From 000a0dec5dcb4981b09016c9af1fac592e21db6d Mon Sep 17 00:00:00 2001
From: Darren Picard <darren.picard@neofinancial.com>
Date: Sun, 2 Aug 2026 14:05:02 -0600
Subject: [PATCH 1/8] Added bulk datastore processor interface to core-chrono.
 Implementation to follow

---
 packages/chrono-core/src/bulk-datastore.ts    | 54 +++++++++++++++++++
 packages/chrono-core/src/index.ts             |  7 +++
 .../test/unit/bulk-datastore.test.ts          | 54 +++++++++++++++++++
 3 files changed, 115 insertions(+)
 create mode 100644 packages/chrono-core/src/bulk-datastore.ts
 create mode 100644 packages/chrono-core/test/unit/bulk-datastore.test.ts

diff --git a/packages/chrono-core/src/bulk-datastore.ts b/packages/chrono-core/src/bulk-datastore.ts
new file mode 100644
index 0000000..024a3ef
--- /dev/null
+++ b/packages/chrono-core/src/bulk-datastore.ts
@@ -0,0 +1,54 @@
+import type { TaskMappingBase } from './chrono';
+import type { Datastore, Task } from './datastore';
+
+export type ClaimManyInput<TaskKind> = {
+  kind: TaskKind;
+  batchSize: number;
+  claimStaleTimeoutMs: number;
+};
+
+export type RetryManyItem = {
+  taskId: string;
+  retryAt: Date;
+};
+
+export type BulkWriteResult<TaskKind, TaskData> = {
+  succeeded: Task<TaskKind, TaskData>[];
+  failed: { taskId: string; error: unknown }[];
+};
+
+export interface BulkDatastore<TaskMapping extends TaskMappingBase, _DatastoreOptions> {
+  claimMany<TaskKind extends Extract<keyof TaskMapping, string>>(
+    input: ClaimManyInput<TaskKind>,
+  ): Promise<Task<TaskKind, TaskMapping[TaskKind]>[]>;
+
+  completeMany<TaskKind extends keyof TaskMapping>(
+    taskIds: string[],
+  ): Promise<BulkWriteResult<TaskKind, TaskMapping[TaskKind]>>;
+
+  retryMany<TaskKind extends keyof TaskMapping>(
+    items: RetryManyItem[],
+  ): Promise<BulkWriteResult<TaskKind, TaskMapping[TaskKind]>>;
+
+  failMany<TaskKind extends keyof TaskMapping>(
+    taskIds: string[],
+  ): Promise<BulkWriteResult<TaskKind, TaskMapping[TaskKind]>>;
+}
+
+/**
+ * Runtime guard for {@link BulkDatastore} support on a {@link Datastore} instance.
+ */
+export function isBulkDatastore<TaskMapping extends TaskMappingBase, DatastoreOptions>(
+  datastore: Datastore<TaskMapping, DatastoreOptions>,
+): datastore is Datastore<TaskMapping, DatastoreOptions> & BulkDatastore<TaskMapping, DatastoreOptions> {
+  return (
+    'claimMany' in datastore &&
+    typeof datastore.claimMany === 'function' &&
+    'completeMany' in datastore &&
+    typeof datastore.completeMany === 'function' &&
+    'retryMany' in datastore &&
+    typeof datastore.retryMany === 'function' &&
+    'failMany' in datastore &&
+    typeof datastore.failMany === 'function'
+  );
+}
diff --git a/packages/chrono-core/src/index.ts b/packages/chrono-core/src/index.ts
index 7800ca5..454d1f6 100644
--- a/packages/chrono-core/src/index.ts
+++ b/packages/chrono-core/src/index.ts
@@ -1,3 +1,10 @@
+export {
+  type BulkDatastore,
+  type BulkWriteResult,
+  type ClaimManyInput,
+  isBulkDatastore,
+  type RetryManyItem,
+} from './bulk-datastore';
 export {
   Chrono,
   type ChronoHandlerRegistrar,
diff --git a/packages/chrono-core/test/unit/bulk-datastore.test.ts b/packages/chrono-core/test/unit/bulk-datastore.test.ts
new file mode 100644
index 0000000..65733bb
--- /dev/null
+++ b/packages/chrono-core/test/unit/bulk-datastore.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'vitest';
+
+import { type BulkDatastore, isBulkDatastore } from '../../src/bulk-datastore';
+import type { Datastore } from '../../src/datastore';
+
+describe('isBulkDatastore', () => {
+  type TaskMapping = {
+    'test-task': { value: number };
+  };
+  type DatastoreOptions = Record<string, unknown>;
+
+  const baseDatastore = {
+    schedule: async () => {
+      throw new Error('not implemented');
+    },
+    delete: async () => undefined,
+    claim: async () => undefined,
+    retry: async () => {
+      throw new Error('not implemented');
+    },
+    complete: async () => {
+      throw new Error('not implemented');
+    },
+    fail: async () => {
+      throw new Error('not implemented');
+    },
+  } satisfies Datastore<TaskMapping, DatastoreOptions>;
+
+  test('returns false for a datastore without bulk methods', () => {
+    expect(isBulkDatastore(baseDatastore)).toBe(false);
+  });
+
+  test('returns false when only some bulk methods are present', () => {
+    const datastore = {
+      ...baseDatastore,
+      claimMany: async () => [],
+      completeMany: async () => ({ succeeded: [], failed: [] }),
+    };
+
+    expect(isBulkDatastore(datastore)).toBe(false);
+  });
+
+  test('returns true when all bulk methods are present', () => {
+    const datastore = {
+      ...baseDatastore,
+      claimMany: async () => [],
+      completeMany: async () => ({ succeeded: [], failed: [] }),
+      retryMany: async () => ({ succeeded: [], failed: [] }),
+      failMany: async () => ({ succeeded: [], failed: [] }),
+    } satisfies Datastore<TaskMapping, DatastoreOptions> & BulkDatastore<TaskMapping, DatastoreOptions>;
+
+    expect(isBulkDatastore(datastore)).toBe(true);
+  });
+});

From ad0093855af7eee0ef882998c48226acdcf363e5 Mon Sep 17 00:00:00 2001
From: Darren Picard <darren.picard@neofinancial.com>
Date: Sun, 2 Aug 2026 14:41:36 -0600
Subject: [PATCH 2/8] Added mongo implementation for Bulkdatastore + tests

---
 .../test/unit/bulk-datastore.test.ts          |   6 +-
 .../src/chrono-mongo-datastore.ts             | 323 +++++++++++++++++-
 .../test/unit/chrono-mongo-datastore.test.ts  | 263 ++++++++++++++
 3 files changed, 575 insertions(+), 17 deletions(-)

diff --git a/packages/chrono-core/test/unit/bulk-datastore.test.ts b/packages/chrono-core/test/unit/bulk-datastore.test.ts
index 65733bb..0ae2182 100644
--- a/packages/chrono-core/test/unit/bulk-datastore.test.ts
+++ b/packages/chrono-core/test/unit/bulk-datastore.test.ts
@@ -27,7 +27,7 @@ describe('isBulkDatastore', () => {
   } satisfies Datastore<TaskMapping, DatastoreOptions>;
 
   test('returns false for a datastore without bulk methods', () => {
-    expect(isBulkDatastore(baseDatastore)).toBe(false);
+    expect(isBulkDatastore(baseDatastore)).toEqual(false);
   });
 
   test('returns false when only some bulk methods are present', () => {
@@ -37,7 +37,7 @@ describe('isBulkDatastore', () => {
       completeMany: async () => ({ succeeded: [], failed: [] }),
     };
 
-    expect(isBulkDatastore(datastore)).toBe(false);
+    expect(isBulkDatastore(datastore)).toEqual(false);
   });
 
   test('returns true when all bulk methods are present', () => {
@@ -49,6 +49,6 @@ describe('isBulkDatastore', () => {
       failMany: async () => ({ succeeded: [], failed: [] }),
     } satisfies Datastore<TaskMapping, DatastoreOptions> & BulkDatastore<TaskMapping, DatastoreOptions>;
 
-    expect(isBulkDatastore(datastore)).toBe(true);
+    expect(isBulkDatastore(datastore)).toEqual(true);
   });
 });
diff --git a/packages/chrono-mongo-datastore/src/chrono-mongo-datastore.ts b/packages/chrono-mongo-datastore/src/chrono-mongo-datastore.ts
index b32fa85..b2814b5 100644
--- a/packages/chrono-mongo-datastore/src/chrono-mongo-datastore.ts
+++ b/packages/chrono-mongo-datastore/src/chrono-mongo-datastore.ts
@@ -1,8 +1,14 @@
+import { randomUUID } from 'node:crypto';
+
 import {
+  type BulkDatastore,
+  type BulkWriteResult,
+  type ClaimManyInput,
   type ClaimTaskInput,
   type Datastore,
   type DeleteInput,
   type DeleteOptions,
+  type RetryManyItem,
   type ScheduleInput,
   type Task,
   type TaskMappingBase,
@@ -64,10 +70,12 @@ export type MongoDatastoreOptions = {
   session?: ClientSession;
 };
 
-export type TaskDocument<TaskKind, TaskData> = WithId<Omit<Task<TaskKind, TaskData>, 'id'>>;
+export type TaskDocument<TaskKind, TaskData> = WithId<Omit<Task<TaskKind, TaskData>, 'id'>> & {
+  claimBatchId?: string;
+};
 
 export class ChronoMongoDatastore<TaskMapping extends TaskMappingBase>
-  implements Datastore<TaskMapping, MongoDatastoreOptions>
+  implements Datastore<TaskMapping, MongoDatastoreOptions>, BulkDatastore<TaskMapping, MongoDatastoreOptions>
 {
   private config: ChronoMongoDatastoreConfig;
   private database: Db | undefined;
@@ -223,19 +231,11 @@ export class ChronoMongoDatastore<TaskMapping extends TaskMappingBase>
     const now = new Date();
     const collection = await this.collection<TaskKind>();
     const task = await collection.findOneAndUpdate(
-      {
+      this.buildClaimableFilter({
         kind: input.kind,
-        scheduledAt: { $lte: now },
-        $or: [
-          { status: TaskStatus.PENDING },
-          {
-            status: TaskStatus.CLAIMED,
-            claimedAt: {
-              $lte: new Date(now.getTime() - input.claimStaleTimeoutMs),
-            },
-          },
-        ],
-      },
+        now,
+        claimStaleTimeoutMs: input.claimStaleTimeoutMs,
+      }),
       { $set: { status: TaskStatus.CLAIMED, claimedAt: now } },
       {
         sort: { priority: -1, scheduledAt: 1 },
@@ -247,6 +247,217 @@ export class ChronoMongoDatastore<TaskMapping extends TaskMappingBase>
     return task ? this.toObject(task) : undefined;
   }
 
+  async claimMany<TaskKind extends Extract<keyof TaskMapping, string>>(
+    input: ClaimManyInput<TaskKind>,
+  ): Promise<Task<TaskKind, TaskMapping[TaskKind]>[]> {
+    const now = new Date();
+    const claimBatchId = randomUUID();
+    const collection = await this.collection<TaskKind>();
+    const claimableFilter = this.buildClaimableFilter({
+      kind: input.kind,
+      now,
+      claimStaleTimeoutMs: input.claimStaleTimeoutMs,
+    });
+
+    const candidates = await collection
+      .find(claimableFilter)
+      .sort({ priority: -1, scheduledAt: 1 })
+      .limit(input.batchSize)
+      .toArray();
+
+    if (candidates.length === 0) {
+      return [];
+    }
+
+    const candidateIds = candidates.map((document) => document._id);
+
+    await collection.updateMany(
+      {
+        ...claimableFilter,
+        _id: { $in: candidateIds },
+      },
+      { $set: { status: TaskStatus.CLAIMED, claimedAt: now, claimBatchId } },
+    );
+
+    const claimedDocuments = await collection
+      .find({
+        _id: { $in: candidateIds },
+        claimBatchId,
+      })
+      .sort({ priority: -1, scheduledAt: 1 })
+      .toArray();
+
+    return claimedDocuments.map((document) => this.toObject(document));
+  }
+
+  async completeMany<TaskKind extends keyof TaskMapping>(
+    taskIds: string[],
+  ): Promise<BulkWriteResult<TaskKind, TaskMapping[TaskKind]>> {
+    if (taskIds.length === 0) {
+      return { succeeded: [], failed: [] };
+    }
+
+    const now = new Date();
+    const collection = await this.collection<TaskKind>();
+    const { objectIds, invalid } = this.parseTaskIds<TaskKind>(taskIds);
+
+    if (objectIds.length === 0) {
+      return { succeeded: [], failed: invalid };
+    }
+
+    const updateResult = await collection.updateMany(
+      {
+        _id: { $in: objectIds },
+        status: TaskStatus.CLAIMED,
+      },
+      {
+        $set: {
+          status: TaskStatus.COMPLETED,
+          completedAt: now,
+          lastExecutedAt: now,
+        },
+      },
+    );
+
+    return this.buildBulkWriteResultFromUpdate({
+      collection,
+      objectIds,
+      invalid,
+      modifiedCount: updateResult.modifiedCount,
+      resultStatus: TaskStatus.COMPLETED,
+    });
+  }
+
+  async retryMany<TaskKind extends keyof TaskMapping>(
+    items: RetryManyItem[],
+  ): Promise<BulkWriteResult<TaskKind, TaskMapping[TaskKind]>> {
+    if (items.length === 0) {
+      return { succeeded: [], failed: [] };
+    }
+
+    const collection = await this.collection<TaskKind>();
+    const operations: { taskId: string; objectId: ObjectId; retryAt: Date }[] = [];
+    const failed: { taskId: string; error: unknown }[] = [];
+
+    for (const item of items) {
+      if (!ObjectId.isValid(item.taskId)) {
+        failed.push({ taskId: item.taskId, error: new Error(`Invalid task ID ${item.taskId}`) });
+        continue;
+      }
+
+      operations.push({
+        taskId: item.taskId,
+        objectId: new ObjectId(item.taskId),
+        retryAt: item.retryAt,
+      });
+    }
+
+    if (operations.length === 0) {
+      return { succeeded: [], failed };
+    }
+
+    const bulkWriteResult = await collection.bulkWrite(
+      operations.map((operation) => ({
+        updateOne: {
+          filter: { _id: operation.objectId, status: TaskStatus.CLAIMED },
+          update: {
+            $set: {
+              status: TaskStatus.PENDING,
+              scheduledAt: operation.retryAt,
+            },
+            $inc: {
+              retryCount: 1,
+            },
+          },
+        },
+      })),
+      { ordered: false },
+    );
+
+    for (const writeError of bulkWriteResult.getWriteErrors()) {
+      const operation = operations[writeError.index];
+      if (operation) {
+        failed.push({ taskId: operation.taskId, error: writeError });
+      }
+    }
+
+    if (bulkWriteResult.modifiedCount === operations.length && bulkWriteResult.getWriteErrorCount() === 0) {
+      const succeededDocuments = await collection
+        .find({
+          _id: { $in: operations.map((operation) => operation.objectId) },
+        })
+        .toArray();
+
+      return {
+        succeeded: succeededDocuments.map((document) => this.toObject(document)),
+        failed,
+      };
+    }
+
+    const succeededDocuments = await collection
+      .find({
+        _id: { $in: operations.map((operation) => operation.objectId) },
+        status: TaskStatus.PENDING,
+      })
+      .toArray();
+
+    const succeededIds = new Set(succeededDocuments.map((document) => document._id.toHexString()));
+    const failedTaskIds = new Set(failed.map((failure) => failure.taskId));
+
+    for (const operation of operations) {
+      if (failedTaskIds.has(operation.taskId) || succeededIds.has(operation.taskId)) {
+        continue;
+      }
+
+      failed.push({
+        taskId: operation.taskId,
+        error: new Error(`Task with ID ${operation.taskId} not found or not in CLAIMED status`),
+      });
+    }
+
+    return {
+      succeeded: succeededDocuments.map((document) => this.toObject(document)),
+      failed,
+    };
+  }
+
+  async failMany<TaskKind extends keyof TaskMapping>(
+    taskIds: string[],
+  ): Promise<BulkWriteResult<TaskKind, TaskMapping[TaskKind]>> {
+    if (taskIds.length === 0) {
+      return { succeeded: [], failed: [] };
+    }
+
+    const now = new Date();
+    const collection = await this.collection<TaskKind>();
+    const { objectIds, invalid } = this.parseTaskIds<TaskKind>(taskIds);
+
+    if (objectIds.length === 0) {
+      return { succeeded: [], failed: invalid };
+    }
+
+    const updateResult = await collection.updateMany(
+      {
+        _id: { $in: objectIds },
+        status: TaskStatus.CLAIMED,
+      },
+      {
+        $set: {
+          status: TaskStatus.FAILED,
+          lastExecutedAt: now,
+        },
+      },
+    );
+
+    return this.buildBulkWriteResultFromUpdate({
+      collection,
+      objectIds,
+      invalid,
+      modifiedCount: updateResult.modifiedCount,
+      resultStatus: TaskStatus.FAILED,
+    });
+  }
+
   async retry<TaskKind extends keyof TaskMapping>(
     taskId: string,
     retryAt: Date,
@@ -291,6 +502,90 @@ export class ChronoMongoDatastore<TaskMapping extends TaskMappingBase>
     return this.toObject(task);
   }
 
+  private buildClaimableFilter<TaskKind extends Extract<keyof TaskMapping, string>>(input: {
+    kind: TaskKind;
+    now: Date;
+    claimStaleTimeoutMs: number;
+  }) {
+    return {
+      kind: input.kind,
+      scheduledAt: { $lte: input.now },
+      $or: [
+        { status: TaskStatus.PENDING },
+        {
+          status: TaskStatus.CLAIMED,
+          claimedAt: {
+            $lte: new Date(input.now.getTime() - input.claimStaleTimeoutMs),
+          },
+        },
+      ],
+    };
+  }
+
+  private async buildBulkWriteResultFromUpdate<TaskKind extends keyof TaskMapping>(input: {
+    collection: Collection<TaskDocument<TaskKind, TaskMapping[TaskKind]>>;
+    objectIds: ObjectId[];
+    invalid: BulkWriteResult<TaskKind, TaskMapping[TaskKind]>['failed'];
+    modifiedCount: number;
+    resultStatus: TaskStatus;
+  }): Promise<BulkWriteResult<TaskKind, TaskMapping[TaskKind]>> {
+    if (input.modifiedCount === input.objectIds.length) {
+      const succeededDocuments = await input.collection
+        .find({
+          _id: { $in: input.objectIds },
+        })
+        .toArray();
+
+      return {
+        succeeded: succeededDocuments.map((document) => this.toObject(document)),
+        failed: input.invalid,
+      };
+    }
+
+    const succeededDocuments = await input.collection
+      .find({
+        _id: { $in: input.objectIds },
+        status: input.resultStatus,
+      })
+      .toArray();
+
+    const succeededIds = new Set(succeededDocuments.map((document) => document._id.toHexString()));
+    const notClaimedFailed = input.objectIds
+      .filter((objectId) => !succeededIds.has(objectId.toHexString()))
+      .map((objectId) => {
+        const taskId = objectId.toHexString();
+        return {
+          taskId,
+          error: new Error(`Task with ID ${taskId} not found or not in CLAIMED status`),
+        };
+      });
+
+    return {
+      succeeded: succeededDocuments.map((document) => this.toObject(document)),
+      failed: [...input.invalid, ...notClaimedFailed],
+    };
+  }
+
+  private parseTaskIds<TaskKind extends keyof TaskMapping>(
+    taskIds: string[],
+  ): {
+    objectIds: ObjectId[];
+    invalid: BulkWriteResult<TaskKind, TaskMapping[TaskKind]>['failed'];
+  } {
+    const objectIds: ObjectId[] = [];
+    const invalid: BulkWriteResult<TaskKind, TaskMapping[TaskKind]>['failed'] = [];
+
+    for (const taskId of taskIds) {
+      if (ObjectId.isValid(taskId)) {
+        objectIds.push(new ObjectId(taskId));
+      } else {
+        invalid.push({ taskId, error: new Error(`Invalid task ID ${taskId}`) });
+      }
+    }
+
+    return { objectIds, invalid };
+  }
+
   private async updateOrThrow<TaskKind extends keyof TaskMapping>(
     taskId: string,
     update: UpdateFilter<TaskDocument<TaskKind, TaskMapping[TaskKind]>>,
diff --git a/packages/chrono-mongo-datastore/test/unit/chrono-mongo-datastore.test.ts b/packages/chrono-mongo-datastore/test/unit/chrono-mongo-datastore.test.ts
index 3d92e97..d941936 100644
--- a/packages/chrono-mongo-datastore/test/unit/chrono-mongo-datastore.test.ts
+++ b/packages/chrono-mongo-datastore/test/unit/chrono-mongo-datastore.test.ts
@@ -253,6 +253,269 @@ describe('ChronoMongoDatastore', () => {
     });
   });
 
+  describe('claimMany', () => {
+    const input = {
+      kind: 'test' as const,
+      data: { test: 'test' },
+      priority: 1,
+      when: new Date(Date.now() - 1),
+    };
+
+    test('returns an empty array when no tasks are claimable', async () => {
+      const claimedTasks = await dataStore.claimMany({
+        kind: input.kind,
+        batchSize: 10,
+        claimStaleTimeoutMs: TEST_CLAIM_STALE_TIMEOUT_MS,
+      });
+
+      expect(claimedTasks).toEqual([]);
+    });
+
+    test('claims up to batchSize tasks ordered by priority then scheduledAt', async () => {
+      const lowPriorityTask = await dataStore.schedule({
+        ...input,
+        priority: 1,
+        when: new Date(Date.now() - 3_000),
+      });
+      const highPriorityTask = await dataStore.schedule({
+        ...input,
+        priority: 10,
+        when: new Date(Date.now() - 2_000),
+      });
+      await dataStore.schedule({
+        ...input,
+        priority: 1,
+        when: new Date(Date.now() - 1_000),
+      });
+
+      const claimedTasks = await dataStore.claimMany({
+        kind: input.kind,
+        batchSize: 2,
+        claimStaleTimeoutMs: TEST_CLAIM_STALE_TIMEOUT_MS,
+      });
+
+      expect(claimedTasks).toHaveLength(2);
+      expect(claimedTasks[0]?.id).toEqual(highPriorityTask.id);
+      expect(claimedTasks[1]?.id).toEqual(lowPriorityTask.id);
+      expect(claimedTasks.every((task) => task.status === TaskStatus.CLAIMED)).toEqual(true);
+
+      const claimedDocuments = await collection
+        .find({ _id: { $in: claimedTasks.map((task) => new ObjectId(task.id)) } })
+        .toArray();
+
+      expect(claimedDocuments.every((document) => document.claimBatchId)).toEqual(true);
+      expect(new Set(claimedDocuments.map((document) => document.claimBatchId)).size).toEqual(1);
+    });
+
+    test('does not set claimBatchId when using single claim', async () => {
+      const task = await dataStore.schedule(input);
+      await dataStore.claim({
+        kind: input.kind,
+        claimStaleTimeoutMs: TEST_CLAIM_STALE_TIMEOUT_MS,
+      });
+
+      const taskDocument = await collection.findOne({ _id: new ObjectId(task.id) });
+
+      expect(taskDocument?.claimBatchId).toBeUndefined();
+    });
+
+    test('does not double-claim tasks when competing processes call claimMany concurrently', async () => {
+      const taskCount = 10;
+      const scheduledTasks = await Promise.all(
+        Array.from({ length: taskCount }, (_, index) =>
+          dataStore.schedule({
+            ...input,
+            when: new Date(Date.now() - index - 1),
+          }),
+        ),
+      );
+
+      const claimResults = await Promise.all(
+        Array.from({ length: 5 }, () =>
+          dataStore.claimMany({
+            kind: input.kind,
+            batchSize: taskCount,
+            claimStaleTimeoutMs: TEST_CLAIM_STALE_TIMEOUT_MS,
+          }),
+        ),
+      );
+
+      const allClaimedIds = claimResults.flatMap((tasks) => tasks.map((task) => task.id));
+
+      expect(allClaimedIds.length).toEqual(new Set(allClaimedIds).size);
+      expect(new Set(allClaimedIds).size).toEqual(taskCount);
+
+      const claimedDocuments = await collection.find({ status: TaskStatus.CLAIMED }).toArray();
+
+      expect(claimedDocuments).toHaveLength(taskCount);
+      expect(claimedDocuments.map((document) => document._id.toHexString()).sort()).toEqual(
+        scheduledTasks.map((task) => task.id).sort(),
+      );
+    });
+
+    test('splits a small task pool across competing claimMany calls without overlap', async () => {
+      const task1 = await dataStore.schedule({
+        ...input,
+        when: new Date(Date.now() - 2),
+      });
+      const task2 = await dataStore.schedule({
+        ...input,
+        when: new Date(Date.now() - 1),
+      });
+
+      const claimResults = await Promise.all(
+        Array.from({ length: 4 }, () =>
+          dataStore.claimMany({
+            kind: input.kind,
+            batchSize: 2,
+            claimStaleTimeoutMs: TEST_CLAIM_STALE_TIMEOUT_MS,
+          }),
+        ),
+      );
+
+      const allClaimedIds = claimResults.flatMap((tasks) => tasks.map((task) => task.id));
+
+      expect(allClaimedIds.sort()).toEqual([task1.id, task2.id].sort());
+      expect(new Set(allClaimedIds).size).toEqual(allClaimedIds.length);
+
+      const nonEmptyBatches = claimResults.filter((tasks) => tasks.length > 0);
+      const claimBatchIds = await Promise.all(
+        nonEmptyBatches.map(async (tasks) => {
+          const document = await collection.findOne({ _id: new ObjectId(tasks[0]?.id) });
+          return document?.claimBatchId;
+        }),
+      );
+
+      expect(new Set(claimBatchIds).size).toEqual(claimBatchIds.length);
+    });
+  });
+
+  describe('completeMany', () => {
+    test('returns empty result for empty input', async () => {
+      await expect(dataStore.completeMany([])).resolves.toEqual({
+        succeeded: [],
+        failed: [],
+      });
+    });
+
+    test('completes claimed tasks in bulk', async () => {
+      const task = await dataStore.schedule({
+        kind: 'test',
+        data: { test: 'test' },
+        priority: 1,
+        when: new Date(Date.now() - 1),
+      });
+
+      const [claimedTask] = await dataStore.claimMany({
+        kind: 'test',
+        batchSize: 1,
+        claimStaleTimeoutMs: TEST_CLAIM_STALE_TIMEOUT_MS,
+      });
+
+      expect(claimedTask?.id).toEqual(task.id);
+
+      const result = await dataStore.completeMany([task.id]);
+
+      expect(result.failed).toEqual([]);
+      expect(result.succeeded).toEqual([
+        expect.objectContaining({
+          id: task.id,
+          status: TaskStatus.COMPLETED,
+        }),
+      ]);
+    });
+
+    test('reports tasks that are not in CLAIMED status as failed', async () => {
+      const task = await dataStore.schedule({
+        kind: 'test',
+        data: { test: 'test' },
+        priority: 1,
+        when: new Date(),
+      });
+
+      const result = await dataStore.completeMany([task.id]);
+
+      expect(result.succeeded).toEqual([]);
+      expect(result.failed).toEqual([
+        {
+          taskId: task.id,
+          error: expect.any(Error),
+        },
+      ]);
+    });
+  });
+
+  describe('failMany', () => {
+    test('returns empty result for empty input', async () => {
+      await expect(dataStore.failMany([])).resolves.toEqual({
+        succeeded: [],
+        failed: [],
+      });
+    });
+
+    test('fails claimed tasks in bulk', async () => {
+      const task = await dataStore.schedule({
+        kind: 'test',
+        data: { test: 'test' },
+        priority: 1,
+        when: new Date(Date.now() - 1),
+      });
+
+      await dataStore.claimMany({
+        kind: 'test',
+        batchSize: 1,
+        claimStaleTimeoutMs: TEST_CLAIM_STALE_TIMEOUT_MS,
+      });
+
+      const result = await dataStore.failMany([task.id]);
+
+      expect(result.failed).toEqual([]);
+      expect(result.succeeded).toEqual([
+        expect.objectContaining({
+          id: task.id,
+          status: TaskStatus.FAILED,
+        }),
+      ]);
+    });
+  });
+
+  describe('retryMany', () => {
+    test('returns empty result for empty input', async () => {
+      await expect(dataStore.retryMany([])).resolves.toEqual({
+        succeeded: [],
+        failed: [],
+      });
+    });
+
+    test('retries claimed tasks with per-task retryAt values', async () => {
+      const task = await dataStore.schedule({
+        kind: 'test',
+        data: { test: 'test' },
+        priority: 1,
+        when: new Date(Date.now() - 1),
+      });
+
+      await dataStore.claimMany({
+        kind: 'test',
+        batchSize: 1,
+        claimStaleTimeoutMs: TEST_CLAIM_STALE_TIMEOUT_MS,
+      });
+
+      const retryAt = new Date(Date.now() + 60_000);
+      const result = await dataStore.retryMany([{ taskId: task.id, retryAt }]);
+
+      expect(result.failed).toEqual([]);
+      expect(result.succeeded).toEqual([
+        expect.objectContaining({
+          id: task.id,
+          status: TaskStatus.PENDING,
+          scheduledAt: retryAt,
+          retryCount: 1,
+        }),
+      ]);
+    });
+  });
+
   describe('complete', () => {
     test('should allow completing a task before initialize', async () => {
       const task = await dataStore.schedule({

From c42181ec6c67c7efc4777df393af0345aac30075 Mon Sep 17 00:00:00 2001
From: Darren Picard <darren.picard@neofinancial.com>
Date: Sun, 2 Aug 2026 14:57:53 -0600
Subject: [PATCH 3/8] Implement bulk processor and hook up

---
 .../src/processors/bulk-processor.ts          | 258 ++++++++++++++++++
 .../src/processors/create-processor.ts        |  21 +-
 packages/chrono-core/src/processors/index.ts  |   2 +
 .../unit/processor/bulk-processor.test.ts     | 229 ++++++++++++++++
 .../unit/processor/create-processor.test.ts   |  33 ++-
 5 files changed, 540 insertions(+), 3 deletions(-)
 create mode 100644 packages/chrono-core/src/processors/bulk-processor.ts
 create mode 100644 packages/chrono-core/test/unit/processor/bulk-processor.test.ts

diff --git a/packages/chrono-core/src/processors/bulk-processor.ts b/packages/chrono-core/src/processors/bulk-processor.ts
new file mode 100644
index 0000000..e72e287
--- /dev/null
+++ b/packages/chrono-core/src/processors/bulk-processor.ts
@@ -0,0 +1,258 @@
+import { EventEmitter } from 'node:events';
+import { setTimeout } from 'node:timers/promises';
+import type { BackoffStrategy } from '../backoff-strategy';
+import type { BulkDatastore, RetryManyItem } from '../bulk-datastore';
+import type { TaskMappingBase } from '../chrono';
+import type { Datastore, Task } from '../datastore';
+import { promiseWithTimeout } from '../utils/promise-utils';
+import { ProcessorEvents, type ProcessorEventsMap } from './events';
+import type { Processor } from './processor';
+
+const DEFAULT_CONFIG: BulkProcessorConfiguration = {
+  batchSize: 25,
+  claimStaleTimeoutMs: 10_000,
+  taskHandlerTimeoutMs: 5_000,
+  taskHandlerMaxRetries: 5,
+  batchIntervalMs: 5_000,
+  processLoopRetryIntervalMs: 20_000,
+};
+
+export type BulkProcessorConfiguration = {
+  /** The maximum number of tasks to claim per batch. @default 25 */
+  batchSize: number;
+  /** The maximum time a task can be claimed for processing before it will be considered stale and claimed again @default 10000ms */
+  claimStaleTimeoutMs: number;
+  /** The maximum time a task handler can take to complete before it will be considered timed out @default 5000ms */
+  taskHandlerTimeoutMs: number;
+  /** The maximum number of retries for a task handler, before task is marked as failed. @default 5 */
+  taskHandlerMaxRetries: number;
+  /** The interval to wait between each batch processing loop iteration @default 5000ms */
+  batchIntervalMs: number;
+  /** The interval at which the processor will wait before next poll when an unexpected error occurs @default 20000ms */
+  processLoopRetryIntervalMs: number;
+};
+
+const InternalProcessorEvents = { PROCESSOR_LOOP_EXIT: 'processorLoopExit' } as const;
+
+type InternalProcessorEventsMap = {
+  [InternalProcessorEvents.PROCESSOR_LOOP_EXIT]: [];
+};
+
+type BulkDatastoreInstance<TaskMapping extends TaskMappingBase, DatastoreOptions> = Datastore<
+  TaskMapping,
+  DatastoreOptions
+> &
+  BulkDatastore<TaskMapping, DatastoreOptions>;
+
+export class BulkProcessor<
+    TaskKind extends Extract<keyof TaskMapping, string>,
+    TaskMapping extends TaskMappingBase,
+    DatastoreOptions,
+  >
+  extends EventEmitter<ProcessorEventsMap<TaskKind, TaskMapping>>
+  implements Processor<TaskKind, TaskMapping>
+{
+  private config: BulkProcessorConfiguration;
+
+  private exitChannel: EventEmitter<InternalProcessorEventsMap> | undefined;
+  private loopDelayAbortController: AbortController | undefined;
+  private stopRequested = false;
+
+  constructor(
+    private bulkDatastore: BulkDatastoreInstance<TaskMapping, DatastoreOptions>,
+    private taskKind: TaskKind,
+    private handler: (task: Task<TaskKind, TaskMapping[TaskKind]>) => Promise<void>,
+    private backOffStrategy: BackoffStrategy,
+    config?: Partial<BulkProcessorConfiguration>,
+  ) {
+    super();
+
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config,
+    };
+
+    this.validateConfiguration();
+  }
+
+  private validateConfiguration() {
+    if (this.config.taskHandlerTimeoutMs >= this.config.claimStaleTimeoutMs) {
+      throw new Error(
+        `Task handler timeout (${this.config.taskHandlerTimeoutMs}ms) must be less than the claim stale timeout (${this.config.claimStaleTimeoutMs}ms)`,
+      );
+    }
+  }
+
+  async start(): Promise<void> {
+    if (this.stopRequested || this.exitChannel) {
+      return;
+    }
+
+    this.exitChannel = new EventEmitter<InternalProcessorEventsMap>();
+    this.runProcessLoop(this.exitChannel);
+  }
+
+  async stop(): Promise<void> {
+    if (!this.exitChannel) {
+      return;
+    }
+
+    const exitPromise = new Promise((resolve) =>
+      this.exitChannel?.once(InternalProcessorEvents.PROCESSOR_LOOP_EXIT, () => resolve(null)),
+    );
+
+    this.stopRequested = true;
+    this.loopDelayAbortController?.abort();
+
+    await exitPromise;
+  }
+
+  private async abortableDelay(ms: number): Promise<void> {
+    if (this.stopRequested) {
+      return;
+    }
+
+    const abortController = new AbortController();
+    this.loopDelayAbortController = abortController;
+
+    try {
+      await setTimeout(ms, undefined, { signal: abortController.signal });
+    } catch {
+      // Delay aborted during stop.
+    } finally {
+      if (this.loopDelayAbortController === abortController) {
+        this.loopDelayAbortController = undefined;
+      }
+    }
+  }
+
+  private async runProcessLoop(exitChannel: EventEmitter<InternalProcessorEventsMap>): Promise<void> {
+    while (!this.stopRequested) {
+      try {
+        const tasks = await this.bulkDatastore.claimMany({
+          kind: this.taskKind,
+          batchSize: this.config.batchSize,
+          claimStaleTimeoutMs: this.config.claimStaleTimeoutMs,
+        });
+
+        for (const task of tasks) {
+          this.emit(ProcessorEvents.TASK_CLAIMED, { task, claimedAt: task.claimedAt || new Date() });
+        }
+
+        if (tasks.length > 0) {
+          await this.processBatch(tasks);
+        }
+
+        await this.abortableDelay(this.config.batchIntervalMs);
+      } catch (error) {
+        this.emit(ProcessorEvents.UNKNOWN_PROCESSING_ERROR, { error, timestamp: new Date() });
+
+        await this.abortableDelay(this.config.processLoopRetryIntervalMs);
+      }
+    }
+
+    exitChannel.emit(InternalProcessorEvents.PROCESSOR_LOOP_EXIT);
+  }
+
+  private async processBatch(tasks: Task<TaskKind, TaskMapping[TaskKind]>[]) {
+    const startedAt = new Date();
+    const handlerResults = await Promise.allSettled(
+      tasks.map((task) => promiseWithTimeout(this.handler(task), this.config.taskHandlerTimeoutMs)),
+    );
+
+    const completeIds: string[] = [];
+    const retryItems: RetryManyItem[] = [];
+    const failIds: string[] = [];
+    const handlerErrors = new Map<string, unknown>();
+
+    for (const [index, task] of tasks.entries()) {
+      const handlerResult = handlerResults[index];
+
+      if (handlerResult?.status === 'fulfilled') {
+        completeIds.push(task.id);
+        continue;
+      }
+
+      const error = handlerResult?.reason;
+      handlerErrors.set(task.id, error);
+
+      if (task.retryCount >= this.config.taskHandlerMaxRetries) {
+        failIds.push(task.id);
+        continue;
+      }
+
+      const delay = this.backOffStrategy({ retryAttempt: task.retryCount });
+      retryItems.push({
+        taskId: task.id,
+        retryAt: new Date(Date.now() + delay),
+      });
+    }
+
+    const completeResult =
+      completeIds.length > 0
+        ? await this.bulkDatastore.completeMany<TaskKind>(completeIds)
+        : { succeeded: [], failed: [] };
+    const retryResult =
+      retryItems.length > 0 ? await this.bulkDatastore.retryMany<TaskKind>(retryItems) : { succeeded: [], failed: [] };
+    const failResult =
+      failIds.length > 0 ? await this.bulkDatastore.failMany<TaskKind>(failIds) : { succeeded: [], failed: [] };
+
+    const retryAtByTaskId = new Map(retryItems.map((item) => [item.taskId, item.retryAt]));
+
+    for (const task of completeResult.succeeded) {
+      this.emit(ProcessorEvents.TASK_COMPLETED, {
+        task,
+        completedAt: task.completedAt || new Date(),
+        startedAt,
+      });
+    }
+
+    for (const failure of completeResult.failed) {
+      const task = tasks.find((candidate) => candidate.id === failure.taskId);
+      if (!task) {
+        continue;
+      }
+
+      this.emit(ProcessorEvents.TASK_COMPLETION_FAILURE, {
+        task,
+        error: failure.error,
+        failedAt: new Date(),
+      });
+    }
+
+    for (const task of retryResult.succeeded) {
+      const originalTask = tasks.find((candidate) => candidate.id === task.id);
+      if (!originalTask) {
+        continue;
+      }
+
+      this.emit(ProcessorEvents.TASK_RETRY_SCHEDULED, {
+        task,
+        error: handlerErrors.get(task.id),
+        errorAt: startedAt,
+        retryScheduledAt: retryAtByTaskId.get(task.id) || task.scheduledAt,
+      });
+    }
+
+    for (const failure of retryResult.failed) {
+      this.emit(ProcessorEvents.UNKNOWN_PROCESSING_ERROR, { error: failure.error, timestamp: new Date() });
+    }
+
+    for (const task of failResult.succeeded) {
+      const originalTask = tasks.find((candidate) => candidate.id === task.id);
+      if (!originalTask) {
+        continue;
+      }
+
+      this.emit(ProcessorEvents.TASK_FAILED, {
+        task,
+        error: handlerErrors.get(task.id),
+        failedAt: new Date(),
+      });
+    }
+
+    for (const failure of failResult.failed) {
+      this.emit(ProcessorEvents.UNKNOWN_PROCESSING_ERROR, { error: failure.error, timestamp: new Date() });
+    }
+  }
+}
diff --git a/packages/chrono-core/src/processors/create-processor.ts b/packages/chrono-core/src/processors/create-processor.ts
index 5253091..e3258cb 100644
--- a/packages/chrono-core/src/processors/create-processor.ts
+++ b/packages/chrono-core/src/processors/create-processor.ts
@@ -1,6 +1,8 @@
 import type { TaskMappingBase } from '..';
 import { type BackoffStrategyOptions, backoffStrategyFactory } from '../backoff-strategy';
+import { isBulkDatastore } from '../bulk-datastore';
 import type { Datastore, Task } from '../datastore';
+import { BulkProcessor, type BulkProcessorConfiguration } from './bulk-processor';
 import type { Processor } from './processor';
 import { SimpleProcessor, type SimpleProcessorConfiguration } from './simple-processor';
 
@@ -8,7 +10,9 @@ import { SimpleProcessor, type SimpleProcessorConfiguration } from './simple-pro
  * Configuration for the processor. Default to simple processor.
  * @default { type: 'simple' } if no configuration is provided.
  */
-export type ProcessorConfiguration = Partial<SimpleProcessorConfiguration> & { type?: 'simple' };
+export type ProcessorConfiguration =
+  | (Partial<SimpleProcessorConfiguration> & { type?: 'simple' })
+  | (Partial<BulkProcessorConfiguration> & { type: 'bulk' });
 
 export type CreateProcessorInput<
   TaskKind extends keyof TaskMapping,
@@ -28,7 +32,6 @@ export function createProcessor<
   DatastoreOptions,
 >(input: CreateProcessorInput<TaskKind, TaskMapping, DatastoreOptions>): Processor<TaskKind, TaskMapping> {
   const backoffStrategy = backoffStrategyFactory(input.backoffStrategyOptions);
-
   const processorType = input.configuration?.type ?? 'simple';
 
   if (processorType === 'simple') {
@@ -41,6 +44,20 @@ export function createProcessor<
     );
   }
 
+  if (processorType === 'bulk') {
+    if (!isBulkDatastore(input.datastore)) {
+      throw new Error('Bulk processor requires a datastore that implements BulkDatastore');
+    }
+
+    return new BulkProcessor<TaskKind, TaskMapping, DatastoreOptions>(
+      input.datastore,
+      input.kind,
+      input.handler,
+      backoffStrategy,
+      input.configuration,
+    );
+  }
+
   const _unreachable: never = processorType;
 
   throw new Error(`Unknown processor type: ${processorType}`);
diff --git a/packages/chrono-core/src/processors/index.ts b/packages/chrono-core/src/processors/index.ts
index 34ccbcf..127e2a6 100644
--- a/packages/chrono-core/src/processors/index.ts
+++ b/packages/chrono-core/src/processors/index.ts
@@ -1,3 +1,5 @@
+export { BulkProcessor, type BulkProcessorConfiguration } from './bulk-processor';
 export { createProcessor } from './create-processor';
 export { ProcessorEvents, type ProcessorEventsMap } from './events';
 export type { Processor } from './processor';
+export { SimpleProcessor, type SimpleProcessorConfiguration } from './simple-processor';
diff --git a/packages/chrono-core/test/unit/processor/bulk-processor.test.ts b/packages/chrono-core/test/unit/processor/bulk-processor.test.ts
new file mode 100644
index 0000000..0257015
--- /dev/null
+++ b/packages/chrono-core/test/unit/processor/bulk-processor.test.ts
@@ -0,0 +1,229 @@
+import { mock } from 'vitest-mock-extended';
+
+import type { BulkDatastore } from '../../../src/bulk-datastore';
+import type { Datastore } from '../../../src/datastore';
+import { BulkProcessor } from '../../../src/processors/bulk-processor';
+import { ProcessorEvents } from '../../../src/processors/events';
+import { defineTaskFactory } from '../../factories/task.factory';
+
+vi.mock('node:timers/promises', () => ({
+  setTimeout: (ms: number, _value?: unknown, options?: { signal?: AbortSignal }) =>
+    new Promise<void>((resolve, reject) => {
+      if (options?.signal?.aborted) {
+        reject(new Error('Aborted'));
+        return;
+      }
+
+      const timer = setTimeout(resolve, ms);
+
+      options?.signal?.addEventListener('abort', () => {
+        clearTimeout(timer);
+        reject(new Error('Aborted'));
+      });
+    }),
+}));
+
+describe('BulkProcessor', () => {
+  type TaskMapping = {
+    'send-test-task': { foo: string };
+  };
+  type DatastoreOptions = Record<string, unknown>;
+
+  const backoffStrategy = () => 1_000;
+  const handler = vi.fn(async () => Promise.resolve());
+
+  const bulkDatastore = mock<Datastore<TaskMapping, DatastoreOptions> & BulkDatastore<TaskMapping, DatastoreOptions>>();
+  const taskFactory = defineTaskFactory<TaskMapping, 'send-test-task'>('send-test-task', { foo: 'bar' });
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    bulkDatastore.claimMany.mockResolvedValue([]);
+    bulkDatastore.completeMany.mockResolvedValue({ succeeded: [], failed: [] });
+    bulkDatastore.retryMany.mockResolvedValue({ succeeded: [], failed: [] });
+    bulkDatastore.failMany.mockResolvedValue({ succeeded: [], failed: [] });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.resetAllMocks();
+  });
+
+  describe('constructor', () => {
+    test('should throw an error when the task handler timeout is greater than or equal to the claim stale timeout', () => {
+      expect(
+        () =>
+          new BulkProcessor(bulkDatastore, 'send-test-task', handler, backoffStrategy, {
+            taskHandlerTimeoutMs: 10_000,
+            claimStaleTimeoutMs: 10_000,
+          }),
+      ).toThrow('Task handler timeout (10000ms) must be less than the claim stale timeout (10000ms)');
+    });
+
+    test('should create a bulk processor successfully', () => {
+      const processor = new BulkProcessor(bulkDatastore, 'send-test-task', handler, backoffStrategy, {});
+
+      expect(processor).toBeInstanceOf(BulkProcessor);
+    });
+  });
+
+  describe('start', () => {
+    test('should claim batches on batchIntervalMs regardless of whether tasks were returned', async () => {
+      const processor = new BulkProcessor(bulkDatastore, 'send-test-task', handler, backoffStrategy, {
+        batchIntervalMs: 1_000,
+      });
+
+      await processor.start();
+
+      await vi.advanceTimersByTimeAsync(10);
+      expect(bulkDatastore.claimMany).toHaveBeenCalledTimes(1);
+
+      await vi.advanceTimersByTimeAsync(1_000);
+      expect(bulkDatastore.claimMany).toHaveBeenCalledTimes(2);
+
+      const stopPromise = processor.stop();
+      await vi.advanceTimersByTimeAsync(1_000);
+      await stopPromise;
+    });
+
+    test('should abort batchIntervalMs delay when stop is requested', async () => {
+      const processor = new BulkProcessor(bulkDatastore, 'send-test-task', handler, backoffStrategy, {
+        batchIntervalMs: 10_000,
+      });
+
+      await processor.start();
+      await vi.advanceTimersByTimeAsync(10);
+      expect(bulkDatastore.claimMany).toHaveBeenCalledTimes(1);
+
+      const stopPromise = processor.stop();
+      await vi.advanceTimersByTimeAsync(10);
+
+      await expect(stopPromise).resolves.toBeUndefined();
+      expect(bulkDatastore.claimMany).toHaveBeenCalledTimes(1);
+    });
+
+    test('should process a claimed batch and complete successful tasks', async () => {
+      const task = taskFactory.build({ status: 'CLAIMED' });
+      const completedTask = taskFactory.build({ status: 'COMPLETED', id: task.id });
+
+      bulkDatastore.claimMany.mockResolvedValueOnce([task]).mockResolvedValue([]);
+      bulkDatastore.completeMany.mockResolvedValueOnce({ succeeded: [completedTask], failed: [] });
+
+      const completedHandler = vi.fn();
+      const processor = new BulkProcessor(bulkDatastore, 'send-test-task', handler, backoffStrategy, {
+        batchIntervalMs: 1_000,
+        taskHandlerTimeoutMs: 1_000,
+      });
+
+      processor.on(ProcessorEvents.TASK_CLAIMED, completedHandler);
+      processor.on(ProcessorEvents.TASK_COMPLETED, completedHandler);
+
+      await processor.start();
+      await vi.advanceTimersByTimeAsync(10);
+
+      expect(handler).toHaveBeenCalledWith(task);
+      expect(bulkDatastore.completeMany).toHaveBeenCalledWith([task.id]);
+      expect(completedHandler).toHaveBeenCalledTimes(2);
+
+      const stopPromise = processor.stop();
+      await vi.advanceTimersByTimeAsync(1_000);
+      await stopPromise;
+    });
+
+    test('should retry failed handler tasks using retryMany', async () => {
+      const task = taskFactory.build({ status: 'CLAIMED', retryCount: 0 });
+      const retriedTask = taskFactory.build({
+        status: 'PENDING',
+        id: task.id,
+        retryCount: 1,
+        scheduledAt: new Date(Date.now() + 1_000),
+      });
+
+      bulkDatastore.claimMany.mockResolvedValueOnce([task]).mockResolvedValue([]);
+      handler.mockRejectedValueOnce(new Error('handler failed'));
+      bulkDatastore.retryMany.mockResolvedValueOnce({ succeeded: [retriedTask], failed: [] });
+
+      const retryHandler = vi.fn();
+      const processor = new BulkProcessor(bulkDatastore, 'send-test-task', handler, backoffStrategy, {
+        batchIntervalMs: 1_000,
+        taskHandlerTimeoutMs: 1_000,
+      });
+
+      processor.on(ProcessorEvents.TASK_RETRY_SCHEDULED, retryHandler);
+
+      await processor.start();
+      await vi.advanceTimersByTimeAsync(10);
+
+      expect(bulkDatastore.retryMany).toHaveBeenCalledWith([
+        expect.objectContaining({
+          taskId: task.id,
+          retryAt: expect.any(Date),
+        }),
+      ]);
+      expect(retryHandler).toHaveBeenCalledOnce();
+
+      const stopPromise = processor.stop();
+      await vi.advanceTimersByTimeAsync(1_000);
+      await stopPromise;
+    });
+
+    test('should fail tasks that exceed max retries using failMany', async () => {
+      const task = taskFactory.build({ status: 'CLAIMED', retryCount: 5 });
+      const failedTask = taskFactory.build({ status: 'FAILED', id: task.id });
+
+      bulkDatastore.claimMany.mockResolvedValueOnce([task]).mockResolvedValue([]);
+      handler.mockRejectedValueOnce(new Error('handler failed'));
+      bulkDatastore.failMany.mockResolvedValueOnce({ succeeded: [failedTask], failed: [] });
+
+      const failedHandler = vi.fn();
+      const processor = new BulkProcessor(bulkDatastore, 'send-test-task', handler, backoffStrategy, {
+        batchIntervalMs: 1_000,
+        taskHandlerTimeoutMs: 1_000,
+        taskHandlerMaxRetries: 5,
+      });
+
+      processor.on(ProcessorEvents.TASK_FAILED, failedHandler);
+
+      await processor.start();
+      await vi.advanceTimersByTimeAsync(10);
+
+      expect(bulkDatastore.failMany).toHaveBeenCalledWith([task.id]);
+      expect(failedHandler).toHaveBeenCalledOnce();
+
+      const stopPromise = processor.stop();
+      await vi.advanceTimersByTimeAsync(1_000);
+      await stopPromise;
+    });
+
+    test('should emit TASK_COMPLETION_FAILURE when completeMany fails for a task', async () => {
+      const task = taskFactory.build({ status: 'CLAIMED' });
+
+      bulkDatastore.claimMany.mockResolvedValueOnce([task]).mockResolvedValue([]);
+      bulkDatastore.completeMany.mockResolvedValueOnce({
+        succeeded: [],
+        failed: [{ taskId: task.id, error: new Error('write failed') }],
+      });
+
+      const completionFailureHandler = vi.fn();
+      const processor = new BulkProcessor(bulkDatastore, 'send-test-task', handler, backoffStrategy, {
+        batchIntervalMs: 1_000,
+        taskHandlerTimeoutMs: 1_000,
+      });
+
+      processor.on(ProcessorEvents.TASK_COMPLETION_FAILURE, completionFailureHandler);
+
+      await processor.start();
+      await vi.advanceTimersByTimeAsync(10);
+
+      expect(completionFailureHandler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          task,
+          error: expect.any(Error),
+        }),
+      );
+
+      const stopPromise = processor.stop();
+      await vi.advanceTimersByTimeAsync(1_000);
+      await stopPromise;
+    });
+  });
+});
diff --git a/packages/chrono-core/test/unit/processor/create-processor.test.ts b/packages/chrono-core/test/unit/processor/create-processor.test.ts
index d8f6063..7ac3303 100644
--- a/packages/chrono-core/test/unit/processor/create-processor.test.ts
+++ b/packages/chrono-core/test/unit/processor/create-processor.test.ts
@@ -1,6 +1,7 @@
 import { mock } from 'vitest-mock-extended';
-import type { Datastore } from '../../../src';
+import type { BulkDatastore, Datastore } from '../../../src';
 import { createProcessor } from '../../../src/processors';
+import { BulkProcessor } from '../../../src/processors/bulk-processor';
 import type { ProcessorConfiguration } from '../../../src/processors/create-processor';
 import { SimpleProcessor } from '../../../src/processors/simple-processor';
 
@@ -54,4 +55,34 @@ describe('createProcessor', () => {
       }),
     ).toThrow('Unknown processor type: unknown');
   });
+
+  test('should create a bulk processor when type is bulk and datastore supports bulk operations', () => {
+    const bulkDatastore = mock<Datastore<TaskMapping, never> & BulkDatastore<TaskMapping, never>>();
+    Object.assign(bulkDatastore, {
+      claimMany: async () => [],
+      completeMany: async () => ({ succeeded: [], failed: [] }),
+      retryMany: async () => ({ succeeded: [], failed: [] }),
+      failMany: async () => ({ succeeded: [], failed: [] }),
+    });
+
+    const processor = createProcessor({
+      kind: 'test',
+      datastore: bulkDatastore,
+      handler: async () => {},
+      configuration: { type: 'bulk' },
+    });
+
+    expect(processor).toBeInstanceOf(BulkProcessor);
+  });
+
+  test('should throw when type is bulk but datastore does not support bulk operations', () => {
+    expect(() =>
+      createProcessor({
+        kind: 'test',
+        datastore,
+        handler: async () => {},
+        configuration: { type: 'bulk' },
+      }),
+    ).toThrow('Bulk processor requires a datastore that implements BulkDatastore');
+  });
 });

From e44a6273d7502066a010ea78024dac8079480f48 Mon Sep 17 00:00:00 2001
From: Darren Picard <darren.picard@neofinancial.com>
Date: Sun, 2 Aug 2026 15:09:49 -0600
Subject: [PATCH 4/8] Update documentation and test with new compile time
 guards, as well as just general documentation

---
 packages/chrono-core/README.md                | 54 ++++++++++++-
 packages/chrono-core/src/chrono.ts            | 79 ++++++++++++++++---
 packages/chrono-core/src/index.ts             | 13 ++-
 .../src/plugins/chrono-plugin-context.ts      | 23 +++---
 packages/chrono-core/src/plugins/index.ts     |  5 +-
 .../src/plugins/lifecycle-context.ts          |  8 +-
 .../src/plugins/registration-context.ts       | 20 ++++-
 packages/chrono-core/src/processors/index.ts  |  2 +-
 .../types/chrono-bulk-processor.type.test.ts  | 63 +++++++++++++++
 packages/chrono-core/test/unit/chrono.test.ts | 57 ++++++++++++-
 packages/chrono-mongo-datastore/README.md     | 17 ++--
 11 files changed, 300 insertions(+), 41 deletions(-)
 create mode 100644 packages/chrono-core/test/types/chrono-bulk-processor.type.test.ts

diff --git a/packages/chrono-core/README.md b/packages/chrono-core/README.md
index 26600da..dd4c15e 100644
--- a/packages/chrono-core/README.md
+++ b/packages/chrono-core/README.md
@@ -172,13 +172,18 @@ Delay doubles each retry with an optional cap and jitter.
 
 ## Processor Configuration
 
-Each task handler runs on a processor that polls the datastore for tasks. Configure processor behavior via `processorConfiguration`:
+Each task handler runs on a processor that polls the datastore for tasks. Configure processor behavior via `processorConfiguration`.
+
+### Simple processor (default)
+
+Claims and processes one task at a time per worker loop:
 
 ```typescript
 chrono.registerTaskHandler({
   kind: "send-email",
   handler: async (task) => { /* ... */ },
   processorConfiguration: {
+    type: "simple", // optional — this is the default
     maxConcurrency: 5,
     claimIntervalMs: 100,
     taskHandlerTimeoutMs: 30_000,
@@ -187,7 +192,7 @@ chrono.registerTaskHandler({
 });
 ```
 
-### Options
+#### Simple processor options
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
@@ -199,6 +204,37 @@ chrono.registerTaskHandler({
 | `taskHandlerMaxRetries` | `number` | `5` | Maximum number of retries before a task is marked as failed |
 | `processLoopRetryIntervalMs` | `number` | `20000` | Interval in ms before retrying after an unexpected error in the processing loop |
 
+### Bulk processor
+
+Claims and processes tasks in batches. Requires a datastore that implements `BulkDatastore` (for example `ChronoMongoDatastore`):
+
+```typescript
+chrono.registerTaskHandler({
+  kind: "send-email",
+  handler: async (task) => { /* ... */ },
+  processorConfiguration: {
+    type: "bulk",
+    batchSize: 50,
+    batchIntervalMs: 1_000,
+    taskHandlerTimeoutMs: 30_000,
+    taskHandlerMaxRetries: 10,
+  },
+});
+```
+
+`type: "bulk"` is only accepted when the `Chrono` instance was constructed with a bulk-capable datastore. TypeScript will report a compile-time error otherwise; a runtime guard also throws if bulk configuration is used with a non-bulk datastore.
+
+#### Bulk processor options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `batchSize` | `number` | `25` | Maximum number of tasks to claim per batch |
+| `claimStaleTimeoutMs` | `number` | `10000` | Time in ms before a claimed task is considered stale and can be re-claimed |
+| `taskHandlerTimeoutMs` | `number` | `5000` | Maximum time in ms a task handler can run before timing out |
+| `taskHandlerMaxRetries` | `number` | `5` | Maximum number of retries before a task is marked as failed |
+| `batchIntervalMs` | `number` | `5000` | Interval in ms between batch processing loop iterations |
+| `processLoopRetryIntervalMs` | `number` | `20000` | Interval in ms before retrying after an unexpected error in the processing loop |
+
 ## Events
 
 ### Chrono Events
@@ -370,8 +406,20 @@ See the existing implementations for reference:
 | `Task` | Type | Task document type |
 | `TaskMappingBase` | Type | Base type constraint for task mappings |
 | `ScheduleTaskInput` | Type | Input type for `scheduleTask()` |
-| `RegisterTaskHandlerInput` | Type | Input type for `registerTaskHandler()` |
+| `RegisterTaskHandlerInput` | Type | Discriminated union input type for `registerTaskHandler()` (simple or bulk) |
+| `RegisterTaskHandlerSimpleInput` | Type | Simple processor registration input |
+| `RegisterTaskHandlerBulkInput` | Type | Bulk processor registration input (`type: 'bulk'` required) |
 | `RegisterTaskHandlerResponse` | Type | Return type of `registerTaskHandler()` |
+| `ProcessorConfiguration` | Type | Processor configuration union (`simple` \| `bulk`) |
+| `SimpleProcessor` | Class | Simple (single-task) processor implementation |
+| `SimpleProcessorConfiguration` | Type | Configuration for the simple processor |
+| `BulkProcessor` | Class | Bulk (batch) processor implementation |
+| `BulkProcessorConfiguration` | Type | Configuration for the bulk processor |
+| `BulkDatastore` | Interface | Bulk datastore interface (`claimMany`, `completeMany`, etc.) |
+| `isBulkDatastore` | Function | Runtime guard for `BulkDatastore` support |
+| `BulkWriteResult` | Type | Result type for bulk datastore write operations |
+| `ClaimManyInput` | Type | Input type for `claimMany()` |
+| `RetryManyItem` | Type | Input item type for `retryMany()` |
 | `ScheduleInput` | Type | Datastore-level schedule input |
 | `ClaimTaskInput` | Type | Datastore-level claim input |
 | `DeleteInput` | Type | Datastore-level delete input |
diff --git a/packages/chrono-core/src/chrono.ts b/packages/chrono-core/src/chrono.ts
index 7d8a25f..5c80244 100644
--- a/packages/chrono-core/src/chrono.ts
+++ b/packages/chrono-core/src/chrono.ts
@@ -1,13 +1,16 @@
 import { EventEmitter } from 'node:events';
 
 import type { BackoffStrategyOptions } from './backoff-strategy';
+import { type BulkDatastore, isBulkDatastore } from './bulk-datastore';
 import type { Datastore, ScheduleInput, Task } from './datastore';
 import { ChronoEvents, type ChronoEventsMap } from './events';
 import type { ChronoPlugin } from './plugins';
 import { ChronoPluginContext } from './plugins/chrono-plugin-context';
 import { createProcessor, type Processor } from './processors';
+import type { BulkProcessorConfiguration } from './processors/bulk-processor';
 import type { ProcessorConfiguration } from './processors/create-processor';
 import type { ProcessorEventsMap } from './processors/events';
+import type { SimpleProcessorConfiguration } from './processors/simple-processor';
 import { promiseWithTimeout } from './utils/promise-utils';
 
 export type TaskMappingBase = Record<string, unknown>;
@@ -18,17 +21,35 @@ export type ScheduleTaskInput<TaskKind, TaskData, DatastoreOptions> = ScheduleIn
   DatastoreOptions
 >;
 
-export type RegisterTaskHandlerInput<TaskKind, TaskData> = {
+type RegisterTaskHandlerBase<TaskKind, TaskData> = {
   /** The type of task */
   kind: TaskKind;
   /** The handler function to process the task */
   handler: (task: Task<TaskKind, TaskData>) => Promise<void>;
   /** The options for the backoff strategy to use when the task handler fails */
   backoffStrategyOptions?: BackoffStrategyOptions;
-  /** The configuration for the processor to use when processing the task */
-  processorConfiguration?: ProcessorConfiguration;
 };
 
+export type RegisterTaskHandlerSimpleInput<TaskKind, TaskData> = RegisterTaskHandlerBase<TaskKind, TaskData> & {
+  /** The configuration for the simple processor to use when processing the task */
+  processorConfiguration?: Partial<SimpleProcessorConfiguration> & { type?: 'simple' };
+};
+
+export type RegisterTaskHandlerBulkInput<TaskKind, TaskData> = RegisterTaskHandlerBase<TaskKind, TaskData> & {
+  /** The configuration for the bulk processor to use when processing the task */
+  processorConfiguration: Partial<BulkProcessorConfiguration> & { type: 'bulk' };
+};
+
+export type RegisterTaskHandlerInput<TaskKind, TaskData> =
+  | RegisterTaskHandlerSimpleInput<TaskKind, TaskData>
+  | RegisterTaskHandlerBulkInput<TaskKind, TaskData>;
+
+type BulkDatastoreRegistrationCheck<
+  TaskMapping extends TaskMappingBase,
+  DatastoreOptions,
+  DatastoreImpl extends Datastore<TaskMapping, DatastoreOptions>,
+> = DatastoreImpl extends BulkDatastore<TaskMapping, DatastoreOptions> ? unknown : never;
+
 /**
  * Response from registering a task handler.
  * @returns The processor instance that can be used to start and stop the processor.
@@ -63,9 +84,18 @@ export interface ChronoTaskScheduler<TaskMapping extends TaskMappingBase, Datast
  * which is the key property needed to pass a single wide Chrono to multiple
  * narrowly-typed outbox handlers without any casts.
  */
-export interface ChronoHandlerRegistrar<out TaskMapping extends TaskMappingBase> {
+export interface ChronoHandlerRegistrar<
+  TaskMapping extends TaskMappingBase,
+  DatastoreOptions,
+  DatastoreImpl extends Datastore<TaskMapping, DatastoreOptions> = Datastore<TaskMapping, DatastoreOptions>,
+> {
   registerTaskHandler<TaskKind extends Extract<keyof TaskMapping, string>>(
-    input: RegisterTaskHandlerInput<TaskKind, TaskMapping[TaskKind]>,
+    input: RegisterTaskHandlerSimpleInput<TaskKind, TaskMapping[TaskKind]>,
+  ): RegisterTaskHandlerResponse<TaskKind, TaskMapping>;
+
+  registerTaskHandler<TaskKind extends Extract<keyof TaskMapping, string>>(
+    input: RegisterTaskHandlerBulkInput<TaskKind, TaskMapping[TaskKind]> &
+      BulkDatastoreRegistrationCheck<TaskMapping, DatastoreOptions, DatastoreImpl>,
   ): RegisterTaskHandlerResponse<TaskKind, TaskMapping>;
 }
 
@@ -74,18 +104,24 @@ export interface ChronoHandlerRegistrar<out TaskMapping extends TaskMappingBase>
  * @param datastore - The datastore instance to use for storing and retrieving tasks.
  * @returns The Chrono instance that can be used to start and stop the processors as well as receive chrono instance events.
  */
-export class Chrono<TaskMapping extends TaskMappingBase, DatastoreOptions>
+export class Chrono<
+    TaskMapping extends TaskMappingBase,
+    DatastoreOptions,
+    DatastoreImpl extends Datastore<TaskMapping, DatastoreOptions> = Datastore<TaskMapping, DatastoreOptions>,
+  >
   extends EventEmitter<ChronoEventsMap>
-  implements ChronoHandlerRegistrar<TaskMapping>, ChronoTaskScheduler<TaskMapping, DatastoreOptions>
+  implements
+    ChronoHandlerRegistrar<TaskMapping, DatastoreOptions, DatastoreImpl>,
+    ChronoTaskScheduler<TaskMapping, DatastoreOptions>
 {
-  private readonly datastore: Datastore<TaskMapping, DatastoreOptions>;
+  private readonly datastore: DatastoreImpl;
   private readonly processors: Map<keyof TaskMapping, Processor<keyof TaskMapping, TaskMapping>> = new Map();
-  private readonly pluginContexts: ChronoPluginContext<TaskMapping, DatastoreOptions>[] = [];
+  private readonly pluginContexts: ChronoPluginContext<TaskMapping, DatastoreOptions, DatastoreImpl>[] = [];
   private started = false;
 
   readonly exitTimeoutMs = 60_000;
 
-  constructor(datastore: Datastore<TaskMapping, DatastoreOptions>) {
+  constructor(datastore: DatastoreImpl) {
     super();
 
     this.datastore = datastore;
@@ -97,12 +133,16 @@ export class Chrono<TaskMapping extends TaskMappingBase, DatastoreOptions>
    * @param plugin - The plugin to register
    * @returns The plugin's API (if any) for type-safe access to plugin functionality
    */
-  use<PluginAPI>(plugin: ChronoPlugin<TaskMapping, DatastoreOptions, PluginAPI>): PluginAPI {
+  use<PluginAPI>(plugin: ChronoPlugin<TaskMapping, DatastoreOptions, PluginAPI, DatastoreImpl>): PluginAPI {
     if (this.started) {
       throw new Error(`Cannot register plugin "${plugin.name}" after Chrono has started`);
     }
 
-    const context = new ChronoPluginContext<TaskMapping, DatastoreOptions>(this, this.processors, this.datastore);
+    const context = new ChronoPluginContext<TaskMapping, DatastoreOptions, DatastoreImpl>(
+      this,
+      this.processors,
+      this.datastore,
+    );
 
     const api = plugin.register(context);
 
@@ -165,6 +205,15 @@ export class Chrono<TaskMapping extends TaskMappingBase, DatastoreOptions>
     return task;
   }
 
+  public registerTaskHandler<TaskKind extends Extract<keyof TaskMapping, string>>(
+    input: RegisterTaskHandlerSimpleInput<TaskKind, TaskMapping[TaskKind]>,
+  ): RegisterTaskHandlerResponse<TaskKind, TaskMapping>;
+
+  public registerTaskHandler<TaskKind extends Extract<keyof TaskMapping, string>>(
+    input: RegisterTaskHandlerBulkInput<TaskKind, TaskMapping[TaskKind]> &
+      BulkDatastoreRegistrationCheck<TaskMapping, DatastoreOptions, DatastoreImpl>,
+  ): RegisterTaskHandlerResponse<TaskKind, TaskMapping>;
+
   public registerTaskHandler<TaskKind extends Extract<keyof TaskMapping, string>>(
     input: RegisterTaskHandlerInput<TaskKind, TaskMapping[TaskKind]>,
   ): RegisterTaskHandlerResponse<TaskKind, TaskMapping> {
@@ -172,12 +221,16 @@ export class Chrono<TaskMapping extends TaskMappingBase, DatastoreOptions>
       throw new Error('Handler for task kind already exists');
     }
 
+    if (input.processorConfiguration?.type === 'bulk' && !isBulkDatastore(this.datastore)) {
+      throw new Error('Bulk processor requires a datastore that implements BulkDatastore');
+    }
+
     const processor = createProcessor({
       kind: input.kind,
       datastore: this.datastore,
       handler: input.handler,
       backoffStrategyOptions: input.backoffStrategyOptions,
-      configuration: input.processorConfiguration,
+      configuration: input.processorConfiguration satisfies ProcessorConfiguration | undefined,
     });
 
     this.processors.set(input.kind, processor);
diff --git a/packages/chrono-core/src/index.ts b/packages/chrono-core/src/index.ts
index 454d1f6..e0ae466 100644
--- a/packages/chrono-core/src/index.ts
+++ b/packages/chrono-core/src/index.ts
@@ -9,8 +9,10 @@ export {
   Chrono,
   type ChronoHandlerRegistrar,
   type ChronoTaskScheduler,
+  type RegisterTaskHandlerBulkInput,
   type RegisterTaskHandlerInput,
   type RegisterTaskHandlerResponse,
+  type RegisterTaskHandlerSimpleInput,
   type ScheduleTaskInput,
   type TaskMappingBase,
 } from './chrono';
@@ -30,4 +32,13 @@ export type {
   PluginLifecycleContext,
   PluginRegistrationContext,
 } from './plugins';
-export { ProcessorEvents, type ProcessorEventsMap } from './processors';
+export {
+  BulkProcessor,
+  type BulkProcessorConfiguration,
+  createProcessor,
+  type ProcessorConfiguration,
+  ProcessorEvents,
+  type ProcessorEventsMap,
+  SimpleProcessor,
+  type SimpleProcessorConfiguration,
+} from './processors';
diff --git a/packages/chrono-core/src/plugins/chrono-plugin-context.ts b/packages/chrono-core/src/plugins/chrono-plugin-context.ts
index 4116480..afb255b 100644
--- a/packages/chrono-core/src/plugins/chrono-plugin-context.ts
+++ b/packages/chrono-core/src/plugins/chrono-plugin-context.ts
@@ -11,38 +11,41 @@ import type { PluginRegistrationContext } from './registration-context';
  * Provides plugins with access to Chrono methods and manages lifecycle hooks.
  * @internal
  */
-export class ChronoPluginContext<TaskMapping extends TaskMappingBase, DatastoreOptions>
-  implements PluginRegistrationContext<TaskMapping, DatastoreOptions>
+export class ChronoPluginContext<
+  TaskMapping extends TaskMappingBase,
+  DatastoreOptions,
+  DatastoreImpl extends Datastore<TaskMapping, DatastoreOptions> = Datastore<TaskMapping, DatastoreOptions>,
+> implements PluginRegistrationContext<TaskMapping, DatastoreOptions, DatastoreImpl>
 {
   private readonly startHooks: Array<
-    (context: PluginLifecycleContext<TaskMapping, DatastoreOptions>) => Promise<void> | void
+    (context: PluginLifecycleContext<TaskMapping, DatastoreOptions, DatastoreImpl>) => Promise<void> | void
   > = [];
   private readonly stopHooks: Array<
-    (context: PluginLifecycleContext<TaskMapping, DatastoreOptions>) => Promise<void> | void
+    (context: PluginLifecycleContext<TaskMapping, DatastoreOptions, DatastoreImpl>) => Promise<void> | void
   > = [];
 
   readonly hooks = {
     onStart: (
-      handler: (context: PluginLifecycleContext<TaskMapping, DatastoreOptions>) => Promise<void> | void,
+      handler: (context: PluginLifecycleContext<TaskMapping, DatastoreOptions, DatastoreImpl>) => Promise<void> | void,
     ): void => {
       this.startHooks.push(handler);
     },
     onStop: (
-      handler: (context: PluginLifecycleContext<TaskMapping, DatastoreOptions>) => Promise<void> | void,
+      handler: (context: PluginLifecycleContext<TaskMapping, DatastoreOptions, DatastoreImpl>) => Promise<void> | void,
     ): void => {
       this.stopHooks.push(handler);
     },
   };
 
   public readonly chrono: Pick<
-    Chrono<TaskMapping, DatastoreOptions>,
+    Chrono<TaskMapping, DatastoreOptions, DatastoreImpl>,
     'registerTaskHandler' | 'use' | 'scheduleTask' | 'deleteTask'
   >;
 
   constructor(
-    chrono: Chrono<TaskMapping, DatastoreOptions>,
+    chrono: Chrono<TaskMapping, DatastoreOptions, DatastoreImpl>,
     private readonly processors: Map<keyof TaskMapping, Processor<keyof TaskMapping, TaskMapping>>,
-    private readonly datastore: Datastore<TaskMapping, DatastoreOptions>,
+    private readonly datastore: DatastoreImpl,
   ) {
     this.chrono = {
       registerTaskHandler: chrono.registerTaskHandler.bind(chrono),
@@ -55,7 +58,7 @@ export class ChronoPluginContext<TaskMapping extends TaskMappingBase, DatastoreO
   /**
    * Create a lifecycle context for passing to hook handlers.
    */
-  private createLifecycleContext(): PluginLifecycleContext<TaskMapping, DatastoreOptions> {
+  private createLifecycleContext(): PluginLifecycleContext<TaskMapping, DatastoreOptions, DatastoreImpl> {
     return {
       getRegisteredTaskKinds: () => Array.from(this.processors.keys()),
       getDatastore: () => this.datastore,
diff --git a/packages/chrono-core/src/plugins/index.ts b/packages/chrono-core/src/plugins/index.ts
index e4cab86..b8222d4 100644
--- a/packages/chrono-core/src/plugins/index.ts
+++ b/packages/chrono-core/src/plugins/index.ts
@@ -1,4 +1,5 @@
 import type { TaskMappingBase } from '../chrono';
+import type { Datastore } from '../datastore';
 import type { PluginRegistrationContext } from './registration-context';
 
 export type { PluginLifecycleContext } from './lifecycle-context';
@@ -9,11 +10,13 @@ export type { PluginRegistrationContext } from './registration-context';
  * @template TaskMapping - The task type mapping for the Chrono instance
  * @template DatastoreOptions - The datastore options type for the Chrono instance
  * @template PluginAPI - The PluginAPI type returned by the plugin's register function (defaults to void)
+ * @template DatastoreImpl - The concrete datastore implementation used by the Chrono instance
  */
 export interface ChronoPlugin<
   TaskMapping extends TaskMappingBase = TaskMappingBase,
   DatastoreOptions = unknown,
   PluginAPI = void,
+  DatastoreImpl extends Datastore<TaskMapping, DatastoreOptions> = Datastore<TaskMapping, DatastoreOptions>,
 > {
   /** Unique plugin identifier */
   name: string;
@@ -24,5 +27,5 @@ export interface ChronoPlugin<
    * @param context - The plugin registration context providing access to Chrono methods
    * @returns The plugin's public PluginAPI (if any)
    */
-  register(context: PluginRegistrationContext<TaskMapping, DatastoreOptions>): PluginAPI;
+  register(context: PluginRegistrationContext<TaskMapping, DatastoreOptions, DatastoreImpl>): PluginAPI;
 }
diff --git a/packages/chrono-core/src/plugins/lifecycle-context.ts b/packages/chrono-core/src/plugins/lifecycle-context.ts
index 9b1665d..f076e1d 100644
--- a/packages/chrono-core/src/plugins/lifecycle-context.ts
+++ b/packages/chrono-core/src/plugins/lifecycle-context.ts
@@ -7,7 +7,11 @@ import type { ProcessorEventsMap } from '../processors/events';
  * Context passed to plugin lifecycle hooks (onStart, onStop).
  * Provides read-only access to Chrono runtime state.
  */
-export interface PluginLifecycleContext<TaskMapping extends TaskMappingBase, DatastoreOptions = unknown> {
+export interface PluginLifecycleContext<
+  TaskMapping extends TaskMappingBase,
+  DatastoreOptions = unknown,
+  DatastoreImpl extends Datastore<TaskMapping, DatastoreOptions> = Datastore<TaskMapping, DatastoreOptions>,
+> {
   /**
    * Get the list of registered task kinds.
    * @returns An array of all registered task kinds
@@ -18,7 +22,7 @@ export interface PluginLifecycleContext<TaskMapping extends TaskMappingBase, Dat
    * Get the datastore instance.
    * @returns The datastore used by this Chrono instance
    */
-  getDatastore(): Datastore<TaskMapping, DatastoreOptions>;
+  getDatastore(): DatastoreImpl;
 
   /**
    * Get the event emitter for a specific processor by task kind.
diff --git a/packages/chrono-core/src/plugins/registration-context.ts b/packages/chrono-core/src/plugins/registration-context.ts
index 7faf331..c864e1f 100644
--- a/packages/chrono-core/src/plugins/registration-context.ts
+++ b/packages/chrono-core/src/plugins/registration-context.ts
@@ -1,12 +1,20 @@
 import type { Chrono, TaskMappingBase } from '../chrono';
+import type { Datastore } from '../datastore';
 import type { PluginLifecycleContext } from './lifecycle-context';
 
 /**
  * Context passed to plugins during registration.
  * Provides access to Chrono's specific methods and lifecycle hook registration.
  */
-export interface PluginRegistrationContext<TaskMapping extends TaskMappingBase, DatastoreOptions = unknown> {
-  chrono: Pick<Chrono<TaskMapping, DatastoreOptions>, 'use' | 'registerTaskHandler' | 'scheduleTask' | 'deleteTask'>;
+export interface PluginRegistrationContext<
+  TaskMapping extends TaskMappingBase,
+  DatastoreOptions = unknown,
+  DatastoreImpl extends Datastore<TaskMapping, DatastoreOptions> = Datastore<TaskMapping, DatastoreOptions>,
+> {
+  chrono: Pick<
+    Chrono<TaskMapping, DatastoreOptions, DatastoreImpl>,
+    'use' | 'registerTaskHandler' | 'scheduleTask' | 'deleteTask'
+  >;
 
   /** Register lifecycle hooks */
   hooks: {
@@ -15,13 +23,17 @@ export interface PluginRegistrationContext<TaskMapping extends TaskMappingBase,
      * Handlers are executed in registration order (FIFO).
      * @param handler - The handler to call, receiving a lifecycle context
      */
-    onStart(handler: (context: PluginLifecycleContext<TaskMapping, DatastoreOptions>) => Promise<void> | void): void;
+    onStart(
+      handler: (context: PluginLifecycleContext<TaskMapping, DatastoreOptions, DatastoreImpl>) => Promise<void> | void,
+    ): void;
 
     /**
      * Register a handler to be called when Chrono stops.
      * Handlers are executed in reverse registration order (LIFO).
      * @param handler - The handler to call, receiving a lifecycle context
      */
-    onStop(handler: (context: PluginLifecycleContext<TaskMapping, DatastoreOptions>) => Promise<void> | void): void;
+    onStop(
+      handler: (context: PluginLifecycleContext<TaskMapping, DatastoreOptions, DatastoreImpl>) => Promise<void> | void,
+    ): void;
   };
 }
diff --git a/packages/chrono-core/src/processors/index.ts b/packages/chrono-core/src/processors/index.ts
index 127e2a6..509df0f 100644
--- a/packages/chrono-core/src/processors/index.ts
+++ b/packages/chrono-core/src/processors/index.ts
@@ -1,5 +1,5 @@
 export { BulkProcessor, type BulkProcessorConfiguration } from './bulk-processor';
-export { createProcessor } from './create-processor';
+export { createProcessor, type ProcessorConfiguration } from './create-processor';
 export { ProcessorEvents, type ProcessorEventsMap } from './events';
 export type { Processor } from './processor';
 export { SimpleProcessor, type SimpleProcessorConfiguration } from './simple-processor';
diff --git a/packages/chrono-core/test/types/chrono-bulk-processor.type.test.ts b/packages/chrono-core/test/types/chrono-bulk-processor.type.test.ts
new file mode 100644
index 0000000..8c05ffb
--- /dev/null
+++ b/packages/chrono-core/test/types/chrono-bulk-processor.type.test.ts
@@ -0,0 +1,63 @@
+import { expectTypeOf } from 'vitest';
+
+import type { BulkDatastore } from '../../src/bulk-datastore';
+import { Chrono } from '../../src/chrono';
+import type { Datastore } from '../../src/datastore';
+
+type TaskMapping = {
+  'send-test-task': { foo: string };
+};
+
+type DatastoreOptions = Record<string, unknown>;
+
+type BulkDatastoreImpl = Datastore<TaskMapping, DatastoreOptions> & BulkDatastore<TaskMapping, DatastoreOptions>;
+type SimpleDatastoreImpl = Datastore<TaskMapping, DatastoreOptions>;
+
+declare const bulkDatastore: BulkDatastoreImpl;
+declare const simpleDatastore: SimpleDatastoreImpl;
+
+const bulkChrono = new Chrono<TaskMapping, DatastoreOptions, BulkDatastoreImpl>(bulkDatastore);
+const simpleChrono = new Chrono<TaskMapping, DatastoreOptions, SimpleDatastoreImpl>(simpleDatastore);
+
+describe('Chrono bulk processor compile-time guards', () => {
+  test('allows bulk processor registration on bulk-capable datastores', () => {
+    expectTypeOf(
+      bulkChrono.registerTaskHandler({
+        kind: 'send-test-task',
+        handler: async () => {},
+        processorConfiguration: { type: 'bulk', batchSize: 10 },
+      }),
+    ).not.toBeNever();
+  });
+
+  test('allows simple processor registration on any datastore', () => {
+    expectTypeOf(
+      simpleChrono.registerTaskHandler({
+        kind: 'send-test-task',
+        handler: async () => {},
+      }),
+    ).not.toBeNever();
+
+    expectTypeOf(
+      bulkChrono.registerTaskHandler({
+        kind: 'send-test-task',
+        handler: async () => {},
+        processorConfiguration: { type: 'simple' },
+      }),
+    ).not.toBeNever();
+  });
+});
+
+// @ts-expect-error bulk processor registration requires a bulk-capable datastore
+simpleChrono.registerTaskHandler({
+  kind: 'send-test-task',
+  handler: async () => {},
+  processorConfiguration: { type: 'bulk', batchSize: 10 },
+});
+
+// @ts-expect-error batchSize is not valid on simple processor configuration
+simpleChrono.registerTaskHandler({
+  kind: 'send-test-task',
+  handler: async () => {},
+  processorConfiguration: { type: 'simple', batchSize: 10 },
+});
diff --git a/packages/chrono-core/test/unit/chrono.test.ts b/packages/chrono-core/test/unit/chrono.test.ts
index e8aac15..9e3e768 100644
--- a/packages/chrono-core/test/unit/chrono.test.ts
+++ b/packages/chrono-core/test/unit/chrono.test.ts
@@ -1,9 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test, vitest } from 'vitest';
 import { mock } from 'vitest-mock-extended';
 
-import { Chrono } from '../../src/chrono';
+import type { BulkDatastore } from '../../src/bulk-datastore';
+import { Chrono, type RegisterTaskHandlerBulkInput, type RegisterTaskHandlerInput } from '../../src/chrono';
 import type { Datastore } from '../../src/datastore';
 import type { ChronoPlugin } from '../../src/plugins';
+import { BulkProcessor } from '../../src/processors/bulk-processor';
 import { SimpleProcessor } from '../../src/processors/simple-processor';
 import { defineTaskFactory } from '../factories/task.factory';
 
@@ -160,6 +162,59 @@ describe('Chrono', () => {
 
       expect(result).toBeInstanceOf(SimpleProcessor);
     });
+
+    test('registers a bulk task handler when the datastore supports bulk operations', () => {
+      const bulkDatastore = mock<
+        Datastore<TaskMapping, DatastoreOptions> & BulkDatastore<TaskMapping, DatastoreOptions>
+      >();
+      Object.assign(bulkDatastore, {
+        schedule: async () => {
+          throw new Error('not implemented');
+        },
+        delete: async () => undefined,
+        claim: async () => undefined,
+        retry: async () => {
+          throw new Error('not implemented');
+        },
+        complete: async () => {
+          throw new Error('not implemented');
+        },
+        fail: async () => {
+          throw new Error('not implemented');
+        },
+        claimMany: async () => [],
+        completeMany: async () => ({ succeeded: [], failed: [] }),
+        retryMany: async () => ({ succeeded: [], failed: [] }),
+        failMany: async () => ({ succeeded: [], failed: [] }),
+      });
+
+      const bulkChrono = new Chrono<TaskMapping, DatastoreOptions, typeof bulkDatastore>(bulkDatastore);
+
+      const result = bulkChrono.registerTaskHandler({
+        kind: 'send-test-task',
+        handler: vitest.fn(),
+        processorConfiguration: { type: 'bulk', batchSize: 10 },
+      });
+
+      expect(result).toBeInstanceOf(BulkProcessor);
+    });
+
+    test('throws when registering a bulk task handler with a non-bulk datastore', () => {
+      const handler = vitest.fn();
+      const input: RegisterTaskHandlerBulkInput<'send-test-task', TaskData> = {
+        kind: 'send-test-task',
+        handler,
+        processorConfiguration: { type: 'bulk', batchSize: 10 },
+      };
+
+      const registerTaskHandler = chrono.registerTaskHandler.bind(chrono) as (
+        input: RegisterTaskHandlerInput<'send-test-task', TaskData>,
+      ) => ReturnType<Chrono<TaskMapping, DatastoreOptions>['registerTaskHandler']>;
+
+      expect(() => registerTaskHandler(input)).toThrow(
+        'Bulk processor requires a datastore that implements BulkDatastore',
+      );
+    });
   });
 
   describe('use', () => {
diff --git a/packages/chrono-mongo-datastore/README.md b/packages/chrono-mongo-datastore/README.md
index ae43db4..b57048d 100644
--- a/packages/chrono-mongo-datastore/README.md
+++ b/packages/chrono-mongo-datastore/README.md
@@ -81,16 +81,23 @@ const chrono = new Chrono<TaskMapping, MongoDatastoreOptions>(datastore);
 
 // Register task handlers
 chrono.registerTaskHandler({
-  kind: "send-email",
+  kind: "process-payment",
   handler: async (task) => {
-    console.log(`Sending email to ${task.data.to}: "${task.data.subject}"`);
+    console.log(`Processing $${task.data.amount} for user ${task.data.userId}`);
   },
 });
 
+// Optional: use the bulk processor for high-throughput task kinds
 chrono.registerTaskHandler({
-  kind: "process-payment",
+  kind: "send-email",
   handler: async (task) => {
-    console.log(`Processing $${task.data.amount} for user ${task.data.userId}`);
+    console.log(`Sending email to ${task.data.to}: "${task.data.subject}"`);
+  },
+  processorConfiguration: {
+    type: "bulk",
+    batchSize: 50,
+    batchIntervalMs: 1_000,
+    taskHandlerTimeoutMs: 30_000,
   },
 });
 
@@ -257,7 +264,7 @@ Returns the database connection. If the datastore is not yet initialized, behavi
 - `'queue'`: returns a promise that resolves when `initialize()` is called
 - `'throw'`: throws an error immediately
 
-All other methods (`schedule`, `delete`, `claim`, `retry`, `complete`, `fail`) implement the `Datastore` interface from `@neofinancial/chrono`. See the [chrono documentation](https://www.npmjs.com/package/@neofinancial/chrono) for details.
+All other methods (`schedule`, `delete`, `claim`, `retry`, `complete`, `fail`, `claimMany`, `completeMany`, `retryMany`, `failMany`) implement the `Datastore` and `BulkDatastore` interfaces from `@neofinancial/chrono`. See the [chrono documentation](https://www.npmjs.com/package/@neofinancial/chrono) for details.
 
 ### Exported Types
 

From e7880be080f3ec114864d800f15a9734b50c99f8 Mon Sep 17 00:00:00 2001
From: Darren Picard <darren.picard@neofinancial.com>
Date: Sun, 2 Aug 2026 15:34:01 -0600
Subject: [PATCH 5/8] Updated dependencies and switched over to typescript 7

---
 .nvmrc                                        |    2 +-
 biome.json                                    |    4 +-
 .../sample-memory-datastore-app/src/main.ts   |    2 +-
 .../sample-memory-datastore-app/tsconfig.json |    7 +-
 package.json                                  |   16 +-
 packages/chrono-core/test/tsconfig.json       |    3 +-
 packages/chrono-core/tsconfig.json            |    6 -
 .../test/tsconfig.json                        |    1 +
 .../chrono-memory-datastore/tsconfig.json     |    6 -
 .../chrono-mongo-datastore/test/tsconfig.json |    1 +
 packages/chrono-mongo-datastore/tsconfig.json |    6 -
 pnpm-lock.yaml                                | 1728 ++++++++++-------
 tsconfig.base.json                            |    4 +-
 13 files changed, 1067 insertions(+), 719 deletions(-)

diff --git a/.nvmrc b/.nvmrc
index 209e3ef..2bd5a0a 100644
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-20
+22
diff --git a/biome.json b/biome.json
index b0bd2f9..235d603 100644
--- a/biome.json
+++ b/biome.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.4.11/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.5.6/schema.json",
   "vcs": {
     "enabled": false,
     "clientKind": "git",
@@ -20,7 +20,7 @@
   "linter": {
     "enabled": true,
     "rules": {
-      "recommended": true
+      "preset": "recommended"
     }
   },
   "json": {
diff --git a/examples/sample-memory-datastore-app/src/main.ts b/examples/sample-memory-datastore-app/src/main.ts
index a358b17..543dd1b 100644
--- a/examples/sample-memory-datastore-app/src/main.ts
+++ b/examples/sample-memory-datastore-app/src/main.ts
@@ -18,7 +18,7 @@ type TaskMapping = {
  * Consumers only need `ChronoHandlerRegistrar` -- they never see `use()` or
  * `scheduleTask()`, which keeps the type covariant in TaskMapping.
  */
-function registerHandlers(registrar: ChronoHandlerRegistrar<TaskMapping>) {
+function registerHandlers(registrar: ChronoHandlerRegistrar<TaskMapping, DatastoreOptions>) {
   const processor1 = registrar.registerTaskHandler({
     kind: 'async-messaging',
     handler: async (task) => {
diff --git a/examples/sample-memory-datastore-app/tsconfig.json b/examples/sample-memory-datastore-app/tsconfig.json
index 15f576c..78daca7 100644
--- a/examples/sample-memory-datastore-app/tsconfig.json
+++ b/examples/sample-memory-datastore-app/tsconfig.json
@@ -1,11 +1,8 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "baseUrl": "${configDir}/src",
-    "outDir": "${configDir}/build",
-    "paths": {
-      "*": ["*", "node_modules/*", "src/*"]
-    }
+    "rootDir": "./src",
+    "outDir": "./build"
   },
   "include": ["src/**/*"]
 }
diff --git a/package.json b/package.json
index 1ae0564..d1b79b8 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "chrono-monorepo",
   "description": "Monorepo for chrono packages",
   "engines": {
-    "node": ">=20.18.3",
+    "node": ">=22.18.0",
     "pnpm": ">=10.6.2"
   },
   "keywords": [],
@@ -23,16 +23,16 @@
     "publish:alpha": "pnpm i && pnpm build && pnpm publish -r --tag alpha"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.11",
+    "@biomejs/biome": "^2.5.6",
     "@faker-js/faker": "^9.9.0",
-    "@types/node": "^20.19.31",
+    "@types/node": "^22.20.1",
     "fishery": "^2.4.0",
     "husky": "^9.1.7",
-    "lint-staged": "^16.4.0",
+    "lint-staged": "^17.3.0",
     "rimraf": "^6.1.3",
-    "tsdown": "^0.21.7",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.4",
-    "vitest-mock-extended": "^4.0.0"
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
+    "vitest-mock-extended": "^5.1.1"
   }
 }
diff --git a/packages/chrono-core/test/tsconfig.json b/packages/chrono-core/test/tsconfig.json
index a23f82a..b6e5962 100644
--- a/packages/chrono-core/test/tsconfig.json
+++ b/packages/chrono-core/test/tsconfig.json
@@ -1,7 +1,8 @@
 {
   "extends": "../tsconfig.json",
   "compilerOptions": {
+    "rootDir": "..",
     "types": ["vitest/globals", "node"]
   },
-  "include": ["**/*.test.ts"]
+  "include": ["**/*.test.ts", "types/**/*.ts"]
 }
diff --git a/packages/chrono-core/tsconfig.json b/packages/chrono-core/tsconfig.json
index 630a398..bf5a36d 100644
--- a/packages/chrono-core/tsconfig.json
+++ b/packages/chrono-core/tsconfig.json
@@ -1,10 +1,4 @@
 {
   "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": "${configDir}/src",
-    "paths": {
-      "*": ["*", "node_modules/*", "src/*"]
-    }
-  },
   "include": ["src/**/*"]
 }
diff --git a/packages/chrono-memory-datastore/test/tsconfig.json b/packages/chrono-memory-datastore/test/tsconfig.json
index a23f82a..f12a45b 100644
--- a/packages/chrono-memory-datastore/test/tsconfig.json
+++ b/packages/chrono-memory-datastore/test/tsconfig.json
@@ -1,6 +1,7 @@
 {
   "extends": "../tsconfig.json",
   "compilerOptions": {
+    "rootDir": "..",
     "types": ["vitest/globals", "node"]
   },
   "include": ["**/*.test.ts"]
diff --git a/packages/chrono-memory-datastore/tsconfig.json b/packages/chrono-memory-datastore/tsconfig.json
index 630a398..bf5a36d 100644
--- a/packages/chrono-memory-datastore/tsconfig.json
+++ b/packages/chrono-memory-datastore/tsconfig.json
@@ -1,10 +1,4 @@
 {
   "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": "${configDir}/src",
-    "paths": {
-      "*": ["*", "node_modules/*", "src/*"]
-    }
-  },
   "include": ["src/**/*"]
 }
diff --git a/packages/chrono-mongo-datastore/test/tsconfig.json b/packages/chrono-mongo-datastore/test/tsconfig.json
index a23f82a..f12a45b 100644
--- a/packages/chrono-mongo-datastore/test/tsconfig.json
+++ b/packages/chrono-mongo-datastore/test/tsconfig.json
@@ -1,6 +1,7 @@
 {
   "extends": "../tsconfig.json",
   "compilerOptions": {
+    "rootDir": "..",
     "types": ["vitest/globals", "node"]
   },
   "include": ["**/*.test.ts"]
diff --git a/packages/chrono-mongo-datastore/tsconfig.json b/packages/chrono-mongo-datastore/tsconfig.json
index 630a398..bf5a36d 100644
--- a/packages/chrono-mongo-datastore/tsconfig.json
+++ b/packages/chrono-mongo-datastore/tsconfig.json
@@ -1,10 +1,4 @@
 {
   "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": "${configDir}/src",
-    "paths": {
-      "*": ["*", "node_modules/*", "src/*"]
-    }
-  },
   "include": ["src/**/*"]
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9751cf0..fd4c9ef 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -9,14 +9,14 @@ importers:
   .:
     devDependencies:
       '@biomejs/biome':
-        specifier: ^2.4.11
-        version: 2.4.11
+        specifier: ^2.5.6
+        version: 2.5.6
       '@faker-js/faker':
         specifier: ^9.9.0
         version: 9.9.0
       '@types/node':
-        specifier: ^20.19.31
-        version: 20.19.31
+        specifier: ^22.20.1
+        version: 22.20.1
       fishery:
         specifier: ^2.4.0
         version: 2.4.0
@@ -24,23 +24,23 @@ importers:
         specifier: ^9.1.7
         version: 9.1.7
       lint-staged:
-        specifier: ^16.4.0
-        version: 16.4.0
+        specifier: ^17.3.0
+        version: 17.3.0
       rimraf:
         specifier: ^6.1.3
         version: 6.1.3
       tsdown:
-        specifier: ^0.21.7
-        version: 0.21.7(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)(typescript@5.9.3)
+        specifier: ^0.22.14
+        version: 0.22.14(typescript@7.0.2)(unrun@0.2.34(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3))
       typescript:
-        specifier: ^5.9.3
-        version: 5.9.3
+        specifier: ^7.0.2
+        version: 7.0.2
       vitest:
-        specifier: ^4.1.4
-        version: 4.1.4(@types/node@20.19.31)(vite@7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2))
+        specifier: ^4.1.10
+        version: 4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0))
       vitest-mock-extended:
-        specifier: ^4.0.0
-        version: 4.0.0(typescript@5.9.3)(vitest@4.1.4(@types/node@20.19.31)(vite@7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2)))
+        specifier: ^5.1.1
+        version: 5.1.1(typescript@7.0.2)(vitest@4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0)))
 
   examples/sample-memory-datastore-app:
     dependencies:
@@ -74,92 +74,71 @@ importers:
 
 packages:
 
-  '@babel/generator@8.0.0-rc.3':
-    resolution: {integrity: sha512-em37/13/nR320G4jab/nIIHZgc2Wz2y/D39lxnTyxB4/D/omPQncl/lSdlnJY1OhQcRGugTSIF2l/69o31C9dA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-
-  '@babel/helper-string-parser@8.0.0-rc.3':
-    resolution: {integrity: sha512-AmwWFx1m8G/a5cXkxLxTiWl+YEoWuoFLUCwqMlNuWO1tqAYITQAbCRPUkyBHv1VOFgfjVOqEj6L3u15J5ZCzTA==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-
-  '@babel/helper-validator-identifier@8.0.0-rc.3':
-    resolution: {integrity: sha512-8AWCJ2VJJyDFlGBep5GpaaQ9AAaE/FjAcrqI7jyssYhtL7WGV0DOKpJsQqM037xDbpRLHXsY8TwU7zDma7coOw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-
-  '@babel/parser@8.0.0-rc.3':
-    resolution: {integrity: sha512-B20dvP3MfNc/XS5KKCHy/oyWl5IA6Cn9YjXRdDlCjNmUFrjvLXMNUfQq/QUy9fnG2gYkKKcrto2YaF9B32ToOQ==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    hasBin: true
-
-  '@babel/types@8.0.0-rc.3':
-    resolution: {integrity: sha512-mOm5ZrYmphGfqVWoH5YYMTITb3cDXsFgmvFlvkvWDMsR9X8RFnt7a0Wb6yNIdoFsiMO9WjYLq+U/FMtqIYAF8Q==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-
-  '@biomejs/biome@2.4.11':
-    resolution: {integrity: sha512-nWxHX8tf3Opb/qRgZpBbsTOqOodkbrkJ7S+JxJAruxOReaDPPmPuLBAGQ8vigyUgo0QBB+oQltNEAvalLcjggA==}
+  '@biomejs/biome@2.5.6':
+    resolution: {integrity: sha512-lxVNjv7UF6KfhMJfL9gaUHbWdJdHbsAj6OSmwSYNdhRuG67NxNQ4Xdvh3TUxsSK9sBzJBQhEJj3AopmmNJ5pSA==}
     engines: {node: '>=14.21.3'}
     hasBin: true
 
-  '@biomejs/cli-darwin-arm64@2.4.11':
-    resolution: {integrity: sha512-wOt+ed+L2dgZanWyL6i29qlXMc088N11optzpo10peayObBaAshbTcxKUchzEMp9QSY8rh5h6VfAFE3WTS1rqg==}
+  '@biomejs/cli-darwin-arm64@2.5.6':
+    resolution: {integrity: sha512-zMOLZP4oMrjh6m1zcSj1ud2awUPgTuMVbmQhYYWL7J8HwCnbHHBvTm7VBTRuY7epT5bez76IpKYQ11ZAqHFlnw==}
     engines: {node: '>=14.21.3'}
     cpu: [arm64]
     os: [darwin]
 
-  '@biomejs/cli-darwin-x64@2.4.11':
-    resolution: {integrity: sha512-gZ6zR8XmZlExfi/Pz/PffmdpWOQ8Qhy7oBztgkR8/ylSRyLwfRPSadmiVCV8WQ8PoJ2MWUy2fgID9zmtgUUJmw==}
+  '@biomejs/cli-darwin-x64@2.5.6':
+    resolution: {integrity: sha512-JAC1VqzvO7Th5ZplU0G2uGfkZbxEe9uDDektPAhF0JLusoz1w+T4okp2bkykI0bbaO2vslKiRfj4gU43JaGreA==}
     engines: {node: '>=14.21.3'}
     cpu: [x64]
     os: [darwin]
 
-  '@biomejs/cli-linux-arm64-musl@2.4.11':
-    resolution: {integrity: sha512-+Sbo1OAmlegtdwqFE8iOxFIWLh1B3OEgsuZfBpyyN/kWuqZ8dx9ZEes6zVnDMo+zRHF2wLynRVhoQmV7ohxl2Q==}
+  '@biomejs/cli-linux-arm64-musl@2.5.6':
+    resolution: {integrity: sha512-eUa3jeeYvfMt19LBeh6E5PUZpxnTC4JqNWo+EDjTtQjAr2xLGnWaxACtVU1DQqmHYbvThlJzLX+ZsYgrqh2qVw==}
     engines: {node: '>=14.21.3'}
     cpu: [arm64]
     os: [linux]
     libc: [musl]
 
-  '@biomejs/cli-linux-arm64@2.4.11':
-    resolution: {integrity: sha512-avdJaEElXrKceK0va9FkJ4P5ci3N01TGkc6ni3P8l3BElqbOz42Wg2IyX3gbh0ZLEd4HVKEIrmuVu/AMuSeFFA==}
+  '@biomejs/cli-linux-arm64@2.5.6':
+    resolution: {integrity: sha512-6XsYwCFkp5sMxl85ffhgeGpGgs6A7dRYFnkceZ7WVxvycuTnGdD5xa534Z3xfrBQ0JCMK/mujT6ZNPJoghedwg==}
     engines: {node: '>=14.21.3'}
     cpu: [arm64]
     os: [linux]
     libc: [glibc]
 
-  '@biomejs/cli-linux-x64-musl@2.4.11':
-    resolution: {integrity: sha512-bexd2IklK7ZgPhrz6jXzpIL6dEAH9MlJU1xGTrypx+FICxrXUp4CqtwfiuoDKse+UlgAlWtzML3jrMqeEAHEhA==}
+  '@biomejs/cli-linux-x64-musl@2.5.6':
+    resolution: {integrity: sha512-2Vp13QdKysH3HIWLaYLhUUwbK+jbZonJD1K+Lr0d0RO4wH7mkYd43vJixEDm8cUWrowoRz4UUHF1nm9Ae7ym8A==}
     engines: {node: '>=14.21.3'}
     cpu: [x64]
     os: [linux]
     libc: [musl]
 
-  '@biomejs/cli-linux-x64@2.4.11':
-    resolution: {integrity: sha512-TagWV0iomp5LnEnxWFg4nQO+e52Fow349vaX0Q/PIcX6Zhk4GGBgp3qqZ8PVkpC+cuehRctMf3+6+FgQ8jCEFQ==}
+  '@biomejs/cli-linux-x64@2.5.6':
+    resolution: {integrity: sha512-Pop9VXCFUhFTMfFefZ39S+u2rOPyNp5iHlxbZRwXGACHLy2r0jjiRgJHmaEKJzL3SyxlVeGShXhvvElvWowonA==}
     engines: {node: '>=14.21.3'}
     cpu: [x64]
     os: [linux]
     libc: [glibc]
 
-  '@biomejs/cli-win32-arm64@2.4.11':
-    resolution: {integrity: sha512-RJhaTnY8byzxDt4bDVb7AFPHkPcjOPK3xBip4ZRTrN3TEfyhjLRm3r3mqknqydgVTB74XG8l4jMLwEACEeihVg==}
+  '@biomejs/cli-win32-arm64@2.5.6':
+    resolution: {integrity: sha512-tDGshcm6BdkZOCGnTDX0Y8/U4IfBSlnUU7T56nNDuPEfed+aHg+u8G36NB43fJVl0Os6+QURXIE1yuD7AaEofA==}
     engines: {node: '>=14.21.3'}
     cpu: [arm64]
     os: [win32]
 
-  '@biomejs/cli-win32-x64@2.4.11':
-    resolution: {integrity: sha512-A8D3JM/00C2KQgUV3oj8Ba15EHEYwebAGCy5Sf9GAjr5Y3+kJIYOiESoqRDeuRZueuMdCsbLZIUqmPhpYXJE9A==}
+  '@biomejs/cli-win32-x64@2.5.6':
+    resolution: {integrity: sha512-WN05KwXnTO/2J45RQPvzZMXf7tZUIofHoR35xIPfCo7pQ2RFidxI8sfb5mGsaTxdMmEOzHzOPRCdA5/fCpc7xQ==}
     engines: {node: '>=14.21.3'}
     cpu: [x64]
     os: [win32]
 
-  '@emnapi/core@1.9.0':
-    resolution: {integrity: sha512-0DQ98G9ZQZOxfUcQn1waV2yS8aWdZ6kJMbYCJB3oUBecjWYO1fqJ+a1DRfPF3O5JEkwqwP1A9QEN/9mYm2Yd0w==}
+  '@emnapi/core@2.0.0-alpha.3':
+    resolution: {integrity: sha512-AZypUeJ/yByuxyS7BlSNRDOMLMlROYtjYdIAuBmJssVz1UJDSeYxLrdizhXCFYhedC5bqd/ASy8EuNXbVVXp9g==}
 
-  '@emnapi/runtime@1.9.0':
-    resolution: {integrity: sha512-QN75eB0IH2ywSpRpNddCRfQIhmJYBCJ1x5Lb3IscKAL8bMnVAKnRg8dCoXbHzVLLH7P38N2Z3mtulB7W0J0FKw==}
+  '@emnapi/runtime@2.0.0-alpha.3':
+    resolution: {integrity: sha512-hFPAhMUjJD9BSyCANEISPOogeXC9Zo9ZQl7L6vKnaVsMkCtzznaW/naYypeyl0Gv5rYfWYsZbpixTMpjDJzQeA==}
 
-  '@emnapi/wasi-threads@1.2.0':
-    resolution: {integrity: sha512-N10dEJNSsUx41Z6pZsXU8FjPjpBEplgH24sfkmITrBED1/U2Esum9F3lfLrMjKHHjmi557zQn7kR9R+XWXu5Rg==}
+  '@emnapi/wasi-threads@2.0.1':
+    resolution: {integrity: sha512-9DsSk+o5NBX0CCJT8s0EROGSGxjR/tKu6aBTaVyq+SjAEQH4XcdcRxPBRzsBLizTTJ49MJjF+jgu3qnO9GLQcQ==}
 
   '@esbuild/aix-ppc64@0.27.7':
     resolution: {integrity: sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==}
@@ -321,31 +300,32 @@ packages:
     resolution: {integrity: sha512-OEl393iCOoo/z8bMezRlJu+GlRGlsKbUAN7jKB6LhnKoqKve5DXRpalbItIIcwnCjs1k/FOPjFzcA6Qn+H+YbA==}
     engines: {node: '>=18.0.0', npm: '>=9.0.0'}
 
-  '@jridgewell/gen-mapping@0.3.13':
-    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
-
-  '@jridgewell/resolve-uri@3.1.2':
-    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
-    engines: {node: '>=6.0.0'}
-
   '@jridgewell/sourcemap-codec@1.5.5':
     resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
 
-  '@jridgewell/trace-mapping@0.3.31':
-    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
-
   '@mongodb-js/saslprep@1.2.0':
     resolution: {integrity: sha512-+ywrb0AqkfaYuhHs6LxKWgqbh3I72EpEgESCw37o+9qPx9WTCkgDm2B+eMrwehGtHBWHFU4GXvnSCNiFhhausg==}
 
-  '@napi-rs/wasm-runtime@1.1.2':
-    resolution: {integrity: sha512-sNXv5oLJ7ob93xkZ1XnxisYhGYXfaG9f65/ZgYuAu3qt7b3NadcOEhLvx28hv31PgX8SZJRYrAIPQilQmFpLVw==}
+  '@napi-rs/lzma-linux-x64-gnu@1.5.1':
+    resolution: {integrity: sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==}
+    engines: {node: ^22.20 || ^24.12 || >=25}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@napi-rs/wasm-runtime@1.2.2':
+    resolution: {integrity: sha512-JfB4kuJQjaoHuCTseIINHtHWeJnvgEcxjwA5t/Y00ZgaOO1Crz3fjT/p8kT28zA/Caz7oiUMn3d6H2yOVCVwuw==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=23.5.0}
     peerDependencies:
-      '@emnapi/core': ^1.7.1
-      '@emnapi/runtime': ^1.7.1
+      '@emnapi/core': ^1.7.1 || ^2.0.0-alpha.3
+      '@emnapi/runtime': ^1.7.1 || ^2.0.0-alpha.3
 
   '@oxc-project/types@0.122.0':
     resolution: {integrity: sha512-oLAl5kBpV4w69UtFZ9xqcmTi+GENWOcPF7FCrczTiBbmC0ibXxCwyvZGbO39rCVEuLGAZM84DH0pUIyyv/YJzA==}
 
+  '@oxc-project/types@0.142.0':
+    resolution: {integrity: sha512-7W+2q5AKQVU36fkaryontrHn3YDt1RyUYXatw9i5H8ocYe2sPKSFB6eS8WNPeRKiN1qAWWZUPm7gwFzJGrccqQ==}
+
   '@quansync/fs@1.0.0':
     resolution: {integrity: sha512-4TJ3DFtlf1L5LDMaM6CanJ/0lckGNtJcMjQ1NAV6zDmA0tEHKZtxNKin8EgPaVX1YzljbxckyT2tJrpQKAtngQ==}
 
@@ -355,30 +335,60 @@ packages:
     cpu: [arm64]
     os: [android]
 
+  '@rolldown/binding-android-arm64@1.2.1':
+    resolution: {integrity: sha512-02hOeOSryYxVrOIphmLAsqnCJWxwlzFk+pEt/N/i6OgT3lShHO7xGCU5cpgchRDHboAEbSjzgGh+O/u1GswQmA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [android]
+
   '@rolldown/binding-darwin-arm64@1.0.0-rc.12':
     resolution: {integrity: sha512-cFYr6zTG/3PXXF3pUO+umXxt1wkRK/0AYT8lDwuqvRC+LuKYWSAQAQZjCWDQpAH172ZV6ieYrNnFzVVcnSflAg==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [darwin]
 
+  '@rolldown/binding-darwin-arm64@1.2.1':
+    resolution: {integrity: sha512-fMsTOnN0OjFm3CyppWPitKnc8UlliVARUULW6cfU6AIqjdtgmSFWSk9vecHzZduv/yMWIHDlRhM1e8Iff9uAfA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
   '@rolldown/binding-darwin-x64@1.0.0-rc.12':
     resolution: {integrity: sha512-ZCsYknnHzeXYps0lGBz8JrF37GpE9bFVefrlmDrAQhOEi4IOIlcoU1+FwHEtyXGx2VkYAvhu7dyBf75EJQffBw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [darwin]
 
+  '@rolldown/binding-darwin-x64@1.2.1':
+    resolution: {integrity: sha512-1wjKdz/XLGKHaTNHjQveQ/B23TKx4ItAqm1JbyVuvNPc4Ze0Fb48s49TAd/2zcplPl8okE/UbTgmlVfwT7eFeQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
   '@rolldown/binding-freebsd-x64@1.0.0-rc.12':
     resolution: {integrity: sha512-dMLeprcVsyJsKolRXyoTH3NL6qtsT0Y2xeuEA8WQJquWFXkEC4bcu1rLZZSnZRMtAqwtrF/Ib9Ddtpa/Gkge9Q==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [freebsd]
 
+  '@rolldown/binding-freebsd-x64@1.2.1':
+    resolution: {integrity: sha512-Fa0jHR07E7YBN4vOEsbVf2briYNsuOowfLJaXULZM0ldMlaCaj2LJgLMbMe4iacRyZmvR8efFhgR9wKuGclQUg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [freebsd]
+
   '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.12':
     resolution: {integrity: sha512-YqWjAgGC/9M1lz3GR1r1rP79nMgo3mQiiA+Hfo+pvKFK1fAJ1bCi0ZQVh8noOqNacuY1qIcfyVfP6HoyBRZ85Q==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
+  '@rolldown/binding-linux-arm-gnueabihf@1.2.1':
+    resolution: {integrity: sha512-pzkgu1SSHGgRRyRZ4fbmSgmajbVt+epaLP99NDjFft69v/ypfTi6swBMiVdh2EkQ0OSnHE1lZDM7DRGkyAzUpA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
   '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.12':
     resolution: {integrity: sha512-/I5AS4cIroLpslsmzXfwbe5OmWvSsrFuEw3mwvbQ1kDxJ822hFHIx+vsN/TAzNVyepI/j/GSzrtCIwQPeKCLIg==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -386,6 +396,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@rolldown/binding-linux-arm64-gnu@1.2.1':
+    resolution: {integrity: sha512-QI5SEDY8cbiYWHx0VO4vIc3UlS6a32vXHjU8Qy/17adEmZIPuByJg13UEvo9c/UCiUkdcVWY83C+b+JrwnNyUg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
   '@rolldown/binding-linux-arm64-musl@1.0.0-rc.12':
     resolution: {integrity: sha512-V6/wZztnBqlx5hJQqNWwFdxIKN0m38p8Jas+VoSfgH54HSj9tKTt1dZvG6JRHcjh6D7TvrJPWFGaY9UBVOaWPw==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -393,6 +410,13 @@ packages:
     os: [linux]
     libc: [musl]
 
+  '@rolldown/binding-linux-arm64-musl@1.2.1':
+    resolution: {integrity: sha512-Sm41FyCeXqmYcERoYOCbGIL5hNfd8w9LQ7Y61Bev48HkcjaJqV/iiVOaiDxjVTRMS+QKrZmD8cfPt4uMVnvM+A==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
   '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.12':
     resolution: {integrity: sha512-AP3E9BpcUYliZCxa3w5Kwj9OtEVDYK6sVoUzy4vTOJsjPOgdaJZKFmN4oOlX0Wp0RPV2ETfmIra9x1xuayFB7g==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -400,6 +424,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@rolldown/binding-linux-ppc64-gnu@1.2.1':
+    resolution: {integrity: sha512-2x+WhXTGl9yJYPbltW/BSEPTVz9OIWQyER4N+gJEDWkkn904eRcBzELqh/Hf7K0w/ubGbKNMv0ZC+94QK/IFEg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
   '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.12':
     resolution: {integrity: sha512-nWwpvUSPkoFmZo0kQazZYOrT7J5DGOJ/+QHHzjvNlooDZED8oH82Yg67HvehPPLAg5fUff7TfWFHQS8IV1n3og==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -407,6 +438,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@rolldown/binding-linux-s390x-gnu@1.2.1':
+    resolution: {integrity: sha512-eEjmQpuRQayHPWWnywaWHkFT3ToPbP3RYy42VVd/B9aBGDA+Ol25EIWHxKQST3IiWJjikCWUF7KtbfqwZrzVwQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
   '@rolldown/binding-linux-x64-gnu@1.0.0-rc.12':
     resolution: {integrity: sha512-RNrafz5bcwRy+O9e6P8Z/OCAJW/A+qtBczIqVYwTs14pf4iV1/+eKEjdOUta93q2TsT/FI0XYDP3TCky38LMAg==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -414,6 +452,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@rolldown/binding-linux-x64-gnu@1.2.1':
+    resolution: {integrity: sha512-/Orga1fZYkLc/56jBICcHrKchl8Z2UKdDSr3LG9ToWO1lQ6a4Livk9Xz+9WN91zsz5QR3XQz2NNoSDEvP6qadw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
   '@rolldown/binding-linux-x64-musl@1.0.0-rc.12':
     resolution: {integrity: sha512-Jpw/0iwoKWx3LJ2rc1yjFrj+T7iHZn2JDg1Yny1ma0luviFS4mhAIcd1LFNxK3EYu3DHWCps0ydXQ5i/rrJ2ig==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -421,175 +466,207 @@ packages:
     os: [linux]
     libc: [musl]
 
+  '@rolldown/binding-linux-x64-musl@1.2.1':
+    resolution: {integrity: sha512-xxBJRL+0q0Kce7orznGWLuylHDY65vuARXZRpX+hPdv+DqK2c3NlCsVA98tlWzWNEE7yPqA/1NQ5nnCrj49Y5A==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
   '@rolldown/binding-openharmony-arm64@1.0.0-rc.12':
     resolution: {integrity: sha512-vRugONE4yMfVn0+7lUKdKvN4D5YusEiPilaoO2sgUWpCvrncvWgPMzK00ZFFJuiPgLwgFNP5eSiUlv2tfc+lpA==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [openharmony]
 
+  '@rolldown/binding-openharmony-arm64@1.2.1':
+    resolution: {integrity: sha512-M6AdXIXw3s+/8XpKMzdGDEXGS1S7kwUsy+rcTIUIOx5Ge4nXKCtAFHFV9YKkXvGcC5WMoTjAteLzlsQROVI0Yw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [openharmony]
+
   '@rolldown/binding-wasm32-wasi@1.0.0-rc.12':
     resolution: {integrity: sha512-ykGiLr/6kkiHc0XnBfmFJuCjr5ZYKKofkx+chJWDjitX+KsJuAmrzWhwyOMSHzPhzOHOy7u9HlFoa5MoAOJ/Zg==}
     engines: {node: '>=14.0.0'}
     cpu: [wasm32]
 
+  '@rolldown/binding-wasm32-wasi@1.2.1':
+    resolution: {integrity: sha512-/TX0SoRGojHzSAHpfVBbavRVSazg5U3h3Y3VXfcc0cdugq6kxdqw8LPGFiPr+/7gE/60zRcsOY2Vi9b9eT0jww==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=23.5.0}
+
   '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.12':
     resolution: {integrity: sha512-5eOND4duWkwx1AzCxadcOrNeighiLwMInEADT0YM7xeEOOFcovWZCq8dadXgcRHSf3Ulh1kFo/qvzoFiCLOL1Q==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [win32]
 
+  '@rolldown/binding-win32-arm64-msvc@1.2.1':
+    resolution: {integrity: sha512-EvRrivJieyHG+AO9lleZWgq+g0+S7oV2C51yuqlcyU/R9net+sI4Pj0F+lUoP2bEr6TWX3SqFaaS0SzfLxSzkw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
   '@rolldown/binding-win32-x64-msvc@1.0.0-rc.12':
     resolution: {integrity: sha512-PyqoipaswDLAZtot351MLhrlrh6lcZPo2LSYE+VDxbVk24LVKAGOuE4hb8xZQmrPAuEtTZW8E6D2zc5EUZX4Lw==}
     engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [win32]
 
+  '@rolldown/binding-win32-x64-msvc@1.2.1':
+    resolution: {integrity: sha512-Z4eCmn5QJ/5+azF9knpLWKfVd9aidn0mAe9TpJgvBLId9Ax3t0+JVxBmT25Bv7NBbVW1TZyKjQjQReouMeH5UQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
   '@rolldown/pluginutils@1.0.0-rc.12':
     resolution: {integrity: sha512-HHMwmarRKvoFsJorqYlFeFRzXZqCt2ETQlEDOb9aqssrnVBB1/+xgTGtuTrIk5vzLNX1MjMtTf7W9z3tsSbrxw==}
 
-  '@rollup/rollup-android-arm-eabi@4.60.1':
-    resolution: {integrity: sha512-d6FinEBLdIiK+1uACUttJKfgZREXrF0Qc2SmLII7W2AD8FfiZ9Wjd+rD/iRuf5s5dWrr1GgwXCvPqOuDquOowA==}
+  '@rolldown/pluginutils@1.0.1':
+    resolution: {integrity: sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==}
+
+  '@rollup/rollup-android-arm-eabi@4.62.4':
+    resolution: {integrity: sha512-RrPokAb7dmbxFoeO3TloqHyOjgye8RkBhSqmp4aJMIex4c9r46ZstPnleDQOq1t46VOVjwIuwNogIqbodV1Vvg==}
     cpu: [arm]
     os: [android]
 
-  '@rollup/rollup-android-arm64@4.60.1':
-    resolution: {integrity: sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA==}
+  '@rollup/rollup-android-arm64@4.62.4':
+    resolution: {integrity: sha512-JKuJc+pnpks2pjy7L/N3v/cAkZxYlnmuZoD840ldbMI5KDbC4iO9NKwPKYdjYFCMAIIlBzYSFHxIJVYzRo2/8A==}
     cpu: [arm64]
     os: [android]
 
-  '@rollup/rollup-darwin-arm64@4.60.1':
-    resolution: {integrity: sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw==}
+  '@rollup/rollup-darwin-arm64@4.62.4':
+    resolution: {integrity: sha512-krw5uS2STmvJ02x0uTXHbqQNuz+9eZ1iw+qXk9dmW2gvV4jV7O2hEoOnuhFrpOPiel1mBFtqbxYZZtC46hXLOw==}
     cpu: [arm64]
     os: [darwin]
 
-  '@rollup/rollup-darwin-x64@4.60.1':
-    resolution: {integrity: sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew==}
+  '@rollup/rollup-darwin-x64@4.62.4':
+    resolution: {integrity: sha512-wsTxtgApb4PrOsNJIm0FZ1h3WvCC+k9uxLJ4ad75hgoS4NiRes2SoJFlDAyMwiUY8IssDqGcHbXuN0sx1tfF1A==}
     cpu: [x64]
     os: [darwin]
 
-  '@rollup/rollup-freebsd-arm64@4.60.1':
-    resolution: {integrity: sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w==}
+  '@rollup/rollup-freebsd-arm64@4.62.4':
+    resolution: {integrity: sha512-GUOnQlyZe3yAXhWOtOMsn5Qkrv5E5mZXa0thbARWi5Ei2szlVXJFQhddZ4HbAzh8q92w5twp+CQvs/eFanz9YQ==}
     cpu: [arm64]
     os: [freebsd]
 
-  '@rollup/rollup-freebsd-x64@4.60.1':
-    resolution: {integrity: sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g==}
+  '@rollup/rollup-freebsd-x64@4.62.4':
+    resolution: {integrity: sha512-/Y7f3QuxjzPKsjA/rfEDa3+0vXqyjmJ50Ln8dPpCmWkKTrUoWHG1cWhTqaAMLob2m2nESWuC7yGrREz019Ztqg==}
     cpu: [x64]
     os: [freebsd]
 
-  '@rollup/rollup-linux-arm-gnueabihf@4.60.1':
-    resolution: {integrity: sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g==}
+  '@rollup/rollup-linux-arm-gnueabihf@4.62.4':
+    resolution: {integrity: sha512-81wiiX3v7aqy+T+bT61TJ78yJjRquqFFTTbAPt08imfQQzkPIW8t6aJbkTagtCCrXMNc9D66+geqlK7ydLPNqA==}
     cpu: [arm]
     os: [linux]
     libc: [glibc]
 
-  '@rollup/rollup-linux-arm-musleabihf@4.60.1':
-    resolution: {integrity: sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg==}
+  '@rollup/rollup-linux-arm-musleabihf@4.62.4':
+    resolution: {integrity: sha512-9kmDIvNZqdoHOBZgNtpTBeLWYO/LVipM3H/j62P8848/l/VPEQL6N3uxU9pvP1oZAsXyC2MEnFP3ovRjo7WYNQ==}
     cpu: [arm]
     os: [linux]
     libc: [musl]
 
-  '@rollup/rollup-linux-arm64-gnu@4.60.1':
-    resolution: {integrity: sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ==}
+  '@rollup/rollup-linux-arm64-gnu@4.62.4':
+    resolution: {integrity: sha512-CcnXHWnXg69g+DX5VWL3FHts3qMRN2uVEHX+BZvGLdd07/gXkn3ePjYtO1LDJvxkGKVHMclKBRa1QUTH+6toYQ==}
     cpu: [arm64]
     os: [linux]
     libc: [glibc]
 
-  '@rollup/rollup-linux-arm64-musl@4.60.1':
-    resolution: {integrity: sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA==}
+  '@rollup/rollup-linux-arm64-musl@4.62.4':
+    resolution: {integrity: sha512-iFOibiHnTRuhrWLlRsOQFdZJJIa7S8OwkneJr4ocALP16u5yk6lWLINFwhHaEqBFMsKDUZofLkGos7+CPzGB3g==}
     cpu: [arm64]
     os: [linux]
     libc: [musl]
 
-  '@rollup/rollup-linux-loong64-gnu@4.60.1':
-    resolution: {integrity: sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ==}
+  '@rollup/rollup-linux-loong64-gnu@4.62.4':
+    resolution: {integrity: sha512-XnWYMI7euHlb5a871xPja+Gm7DRCFU+FGRrtS2sMq9N8FvqtpagUy6gD4YOemC5MRk9xbh8+jYMEJbigFQwsgA==}
     cpu: [loong64]
     os: [linux]
     libc: [glibc]
 
-  '@rollup/rollup-linux-loong64-musl@4.60.1':
-    resolution: {integrity: sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw==}
+  '@rollup/rollup-linux-loong64-musl@4.62.4':
+    resolution: {integrity: sha512-qGDAlO0U8xedCcsdRm9oaoQY8DAx/QT7uIxJWhCdx0ceIWX783UC9QSYkdpzAe29wNiVfp24+bZdQmn49o45SQ==}
     cpu: [loong64]
     os: [linux]
     libc: [musl]
 
-  '@rollup/rollup-linux-ppc64-gnu@4.60.1':
-    resolution: {integrity: sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw==}
+  '@rollup/rollup-linux-ppc64-gnu@4.62.4':
+    resolution: {integrity: sha512-ru4H6ezD7ysA5EiEK6qkkaEb4modH8CTej6kUy/gQi20u3kB3G7Zn8snXXkeJSCOFKG/rbPPtM/+9Wgas1961w==}
     cpu: [ppc64]
     os: [linux]
     libc: [glibc]
 
-  '@rollup/rollup-linux-ppc64-musl@4.60.1':
-    resolution: {integrity: sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg==}
+  '@rollup/rollup-linux-ppc64-musl@4.62.4':
+    resolution: {integrity: sha512-2W4MO5WQVJnbJaZdvDb9rhBDuFU1nKIepPFpJUBsTh2k1YY2g+ODViaWuyOAjQ5cOP7NvrvLzt3wvHOoiAvc7w==}
     cpu: [ppc64]
     os: [linux]
     libc: [musl]
 
-  '@rollup/rollup-linux-riscv64-gnu@4.60.1':
-    resolution: {integrity: sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg==}
+  '@rollup/rollup-linux-riscv64-gnu@4.62.4':
+    resolution: {integrity: sha512-+fxjfuoAmVMCYV5QyjoIpu0cp5DOiOTeqYFk1AVaxGr+/ravWLX89XfQmptsoWcaVy/TGf2hexzbUOrCQIL1CQ==}
     cpu: [riscv64]
     os: [linux]
     libc: [glibc]
 
-  '@rollup/rollup-linux-riscv64-musl@4.60.1':
-    resolution: {integrity: sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg==}
+  '@rollup/rollup-linux-riscv64-musl@4.62.4':
+    resolution: {integrity: sha512-jTn8JfHGL4djjFxPuM06LmNUJDsst2jeVlsd9OmIH6zc5sC9K6rIuO4YajXatLUpBmBKl6b35ro1QZocLi+tcA==}
     cpu: [riscv64]
     os: [linux]
     libc: [musl]
 
-  '@rollup/rollup-linux-s390x-gnu@4.60.1':
-    resolution: {integrity: sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ==}
+  '@rollup/rollup-linux-s390x-gnu@4.62.4':
+    resolution: {integrity: sha512-oCJCJL4pXsoDcP2QZ+JVlPTIRc6266zsIaeJJsWImmF7HO0W8nb6HuSgZlMWxJwaPf8ehbSw8yo0EUw925hKsA==}
     cpu: [s390x]
     os: [linux]
     libc: [glibc]
 
-  '@rollup/rollup-linux-x64-gnu@4.60.1':
-    resolution: {integrity: sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg==}
+  '@rollup/rollup-linux-x64-gnu@4.62.4':
+    resolution: {integrity: sha512-W69hukhZ3KKNRCaMIEzKvcFye42hh0FE1+YoYaf5+Ikacuftoco6yO/xouz0hc5d5W/s3yBro5jRiuEE/Q5vUw==}
     cpu: [x64]
     os: [linux]
     libc: [glibc]
 
-  '@rollup/rollup-linux-x64-musl@4.60.1':
-    resolution: {integrity: sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w==}
+  '@rollup/rollup-linux-x64-musl@4.62.4':
+    resolution: {integrity: sha512-qiXbGG2jkjXhzXpsFZSR2Xpb8DN/UaxYsbb/STbuR/6fpaDgRmmaq1B/LmtF2wQFOFOSsK2jdE0RZ3a0zHn4QA==}
     cpu: [x64]
     os: [linux]
     libc: [musl]
 
-  '@rollup/rollup-openbsd-x64@4.60.1':
-    resolution: {integrity: sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw==}
+  '@rollup/rollup-openbsd-x64@4.62.4':
+    resolution: {integrity: sha512-nWeM//hxv8mIo6jD7Hu4o48DVmV9pbV6gsKaWU+4NFyqHoPKwrkRiZGLKUhOBk8qNmDmpwFtPKg80Bo/Tn4xiQ==}
     cpu: [x64]
     os: [openbsd]
 
-  '@rollup/rollup-openharmony-arm64@4.60.1':
-    resolution: {integrity: sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA==}
+  '@rollup/rollup-openharmony-arm64@4.62.4':
+    resolution: {integrity: sha512-s62SQ/vgsRSvMwDkOEfTqfgASF0f26ZNaQuTA6Aok5lrikf89yI2W0gFHvZb2Jpgc6N8JnOKZgCK2iciO3CsxQ==}
     cpu: [arm64]
     os: [openharmony]
 
-  '@rollup/rollup-win32-arm64-msvc@4.60.1':
-    resolution: {integrity: sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g==}
+  '@rollup/rollup-win32-arm64-msvc@4.62.4':
+    resolution: {integrity: sha512-J6wGf8TVGbXJq+HH+ttTvrcfNKPbuZecV6KT1B8I18BC5IURUh5kl4Yl5OEP5eFIUoI5BWxCsyYMhFsDx8kekw==}
     cpu: [arm64]
     os: [win32]
 
-  '@rollup/rollup-win32-ia32-msvc@4.60.1':
-    resolution: {integrity: sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg==}
+  '@rollup/rollup-win32-ia32-msvc@4.62.4':
+    resolution: {integrity: sha512-zmfrQd/0wu6oJs8Vq8KwY/YtsKSsLtKe/HwAP4Wqy8LhWjeT55fHRAkOhYQ12wI3ayS4Tt12d5CDRD7N96SAYQ==}
     cpu: [ia32]
     os: [win32]
 
-  '@rollup/rollup-win32-x64-gnu@4.60.1':
-    resolution: {integrity: sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg==}
+  '@rollup/rollup-win32-x64-gnu@4.62.4':
+    resolution: {integrity: sha512-qPzHqdj9rfUD+w79dtE07zi/kFwKyCJqplp5K5ygeLTp7jLpAoc16OAH39HSmRC9UpozaecsleI8uAdEj6v2yw==}
     cpu: [x64]
     os: [win32]
 
-  '@rollup/rollup-win32-x64-msvc@4.60.1':
-    resolution: {integrity: sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ==}
+  '@rollup/rollup-win32-x64-msvc@4.62.4':
+    resolution: {integrity: sha512-zD6NdeWEByGE9QF9vCrlJ5YQB4oq9q91kPZS37Jwj5hOkvR1lTBSpsKhKDw4IJtbQ35LsTS1HD9DZYGKIshU1Q==}
     cpu: [x64]
     os: [win32]
 
   '@standard-schema/spec@1.1.0':
     resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
 
-  '@tybys/wasm-util@0.10.1':
-    resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
+  '@tybys/wasm-util@0.10.3':
+    resolution: {integrity: sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==}
 
   '@types/chai@5.2.3':
     resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
@@ -597,14 +674,11 @@ packages:
   '@types/deep-eql@4.0.2':
     resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
 
-  '@types/estree@1.0.8':
-    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+  '@types/estree@1.0.9':
+    resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
 
-  '@types/jsesc@2.5.1':
-    resolution: {integrity: sha512-9VN+6yxLOPLOav+7PwjZbxiID2bVaeq0ED4qSQmdQTdjnXJSaCVKTR58t15oqH1H5t8Ng2ZX1SabJVoN9Q34bw==}
-
-  '@types/node@20.19.31':
-    resolution: {integrity: sha512-5jsi0wpncvTD33Sh1UCgacK37FFwDn+EG7wCmEvs62fCvBL+n8/76cAYDok21NF6+jaVWIqKwCZyX7Vbu8eB3A==}
+  '@types/node@22.20.1':
+    resolution: {integrity: sha512-EANqOCF9QFyra+4pfxUcX9STKJpCLjMbObVzljIJomAWSnuSIEAvyzEU53GaajbXJEgdh0iEcPL+DGvpUd4k1Q==}
 
   '@types/webidl-conversions@7.0.3':
     resolution: {integrity: sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==}
@@ -612,11 +686,131 @@ packages:
   '@types/whatwg-url@11.0.5':
     resolution: {integrity: sha512-coYR071JRaHa+xoEvvYqvnIHaVqaYrLPbsufM9BF63HkwI5Lgmy2QR8Q5K/lYDYo5AK82wOvSOS0UsLTpTG7uQ==}
 
-  '@vitest/expect@4.1.4':
-    resolution: {integrity: sha512-iPBpra+VDuXmBFI3FMKHSFXp3Gx5HfmSCE8X67Dn+bwephCnQCaB7qWK2ldHa+8ncN8hJU8VTMcxjPpyMkUjww==}
+  '@typescript/typescript-aix-ppc64@7.0.2':
+    resolution: {integrity: sha512-MTKKkWB7p/0E9xi1d1tHtZ5PiLkGEMIq88pK2CubZjOsLtYTLqhgIgi6zepFa+9GHZ6h05NMCkQxGKiPXMxXtQ==}
+    engines: {node: '>=16.20.0'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@typescript/typescript-darwin-arm64@7.0.2':
+    resolution: {integrity: sha512-gowzar9MwS/aRWp6f3a4KUqzRjAZjOsmGNCM6LcTgXum+dBfgsBVMN+AgvOCCbguXyick6LJhpBszxMebJ8syA==}
+    engines: {node: '>=16.20.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@typescript/typescript-darwin-x64@7.0.2':
+    resolution: {integrity: sha512-SZ9xZInqApNlNGc9s0W1VSsktYSOe9cFqNOIqmN1Gs8SmkjKZYFt017G4VwPxASInODuAdbTW7sXiFUf893RgA==}
+    engines: {node: '>=16.20.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@typescript/typescript-freebsd-arm64@7.0.2':
+    resolution: {integrity: sha512-W5NH4y/J0plIIS5b2xvTEkU7JFxyqdMAOgf+Ilhl0vHQXKO5dZoxd+C/jEtq56c4F3wk71RB4BMRQ2XdI+bwYQ==}
+    engines: {node: '>=16.20.0'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@typescript/typescript-freebsd-x64@7.0.2':
+    resolution: {integrity: sha512-UMGDx5sTpzNw3WiPebH7l90IWfJggEd+egHt/q6p7/Cm3zqoV7VxkGXt+3DxPIw8CcmvAB0j3sVVfbhX+M4Tpw==}
+    engines: {node: '>=16.20.0'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@typescript/typescript-linux-arm64@7.0.2':
+    resolution: {integrity: sha512-Qh4eU4/y3yDjnfjjyPYihMj5/ODIlmt+Bzu17OI+fiSRDW57QmU5SiN63exPRNJPKUzcc1INa1NXdrJ+MqHjUQ==}
+    engines: {node: '>=16.20.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@typescript/typescript-linux-arm@7.0.2':
+    resolution: {integrity: sha512-gffT3xPz9sR7j/YJExkyPntrI0P2EP9XbOyWzth2/Gs0RstK+90RBcO0ncXoXy/beYll1SXw846Nf2zdnEz0QQ==}
+    engines: {node: '>=16.20.0'}
+    cpu: [arm]
+    os: [linux]
+
+  '@typescript/typescript-linux-loong64@7.0.2':
+    resolution: {integrity: sha512-uEHck9i8hoAzXPiYRib1O7miOnz23SxIeVl6F4LXox+qov1K35jHcEW6VHKvZI+pyvl7fZEP4MCU5LYvIq1GuQ==}
+    engines: {node: '>=16.20.0'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@typescript/typescript-linux-mips64el@7.0.2':
+    resolution: {integrity: sha512-R4KvAMnE43W5Qeqb0Ly56O3mWMWIAgsMyz36DCaycd5nbg/9kzm0liw3JocfRqyJY0KPmzFjbswozXyW0DnIYA==}
+    engines: {node: '>=16.20.0'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@typescript/typescript-linux-ppc64@7.0.2':
+    resolution: {integrity: sha512-DORx5b3sd/4S7eayxm4FQv+A7CrkUIGRaHiwI8oiHTAI1fAPWhF4J0vAlkC8biAlHSVVwxMQ3tjZ2/DVbnQiiA==}
+    engines: {node: '>=16.20.0'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@typescript/typescript-linux-riscv64@7.0.2':
+    resolution: {integrity: sha512-wf0jqEDOjrPRnKwYRyyJDRo11KMbvMFrU+q4zqKyChODBzvlkbhNQfKvLxQCcwTpdDaXSHZTVuh0JoCrKCUMHQ==}
+    engines: {node: '>=16.20.0'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@typescript/typescript-linux-s390x@7.0.2':
+    resolution: {integrity: sha512-IkwJc3L7yhytWd/ewjyxNDfOmswCm9GWMJT/ue/dU4aZNbwZeYAetq42VyLmsmSjvoX7z74X6ZaYCtzAr0EuGw==}
+    engines: {node: '>=16.20.0'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@typescript/typescript-linux-x64@7.0.2':
+    resolution: {integrity: sha512-EYdf2cNg7rgCWJnxCdJ+F3V39O8ihb37eHAu1LK8oAFizgTQbPOK7zHHXbPt8rX24COqODXeI3sIf0fCXG7H/A==}
+    engines: {node: '>=16.20.0'}
+    cpu: [x64]
+    os: [linux]
+
+  '@typescript/typescript-netbsd-arm64@7.0.2':
+    resolution: {integrity: sha512-+polYF4MF04aPpO5FTkHran9yUQDSXqy5GiSDKpsll5jy3l3+g9QLhpf39T+ePtefhXLOGrLl0QIjkQP6VnelA==}
+    engines: {node: '>=16.20.0'}
+    cpu: [arm64]
+    os: [netbsd]
 
-  '@vitest/mocker@4.1.4':
-    resolution: {integrity: sha512-R9HTZBhW6yCSGbGQnDnH3QHfJxokKN4KB+Yvk9Q1le7eQNYwiCyKxmLmurSpFy6BzJanSLuEUDrD+j97Q+ZLPg==}
+  '@typescript/typescript-netbsd-x64@7.0.2':
+    resolution: {integrity: sha512-8YIT0EHM/3dq10ZOVF/A7pc/YSMtbcecct4rWtexrnSCHOPcpC2KTLXfTCR6vDpnSiY12heNb1GiN/wu+T/FyA==}
+    engines: {node: '>=16.20.0'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@typescript/typescript-openbsd-arm64@7.0.2':
+    resolution: {integrity: sha512-APT8+ClYnuYm1u9+kgGXoMj2VzWzcymwh2gNSQVySHfkRDGOTVkoWLjCmOQSaO+PoqQ57B0flRp9SA+7GnnkzQ==}
+    engines: {node: '>=16.20.0'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@typescript/typescript-openbsd-x64@7.0.2':
+    resolution: {integrity: sha512-yX7s+Q0Dln0Dt9tEzZsAjXXR/+ytBM7AlglaqyeMPxQszJ1JhlJdZ6jLA+IzldHtflX81em7lDao1xXu+aRRkg==}
+    engines: {node: '>=16.20.0'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@typescript/typescript-sunos-x64@7.0.2':
+    resolution: {integrity: sha512-dLJDGaLZ1D4HPQn62u1n8mBDkJREwMsAkCdkwd4Ieqw+x3TUyTsqY0YiBCtE6H6OzzgGk3iuZ3vFWRS+E8/d1g==}
+    engines: {node: '>=16.20.0'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@typescript/typescript-win32-arm64@7.0.2':
+    resolution: {integrity: sha512-Gyl1Vy6OsWesLzmq+EP0Fb7b4Nid5232AvcA2SFcdYreldpNtYFFofPjnt62y9hQy7VTaZp65ICJjuAQRaVcIQ==}
+    engines: {node: '>=16.20.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@typescript/typescript-win32-x64@7.0.2':
+    resolution: {integrity: sha512-0BQ3HkAHHlKLSp1qRvf3SUhGpGsDuhB/jgFw75guyqbxJqEaS0Cw/VFO8i2nHglJUzQCRtMMR/IBAKE3ETMC4g==}
+    engines: {node: '>=16.20.0'}
+    cpu: [x64]
+    os: [win32]
+
+  '@vitest/expect@4.1.10':
+    resolution: {integrity: sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==}
+
+  '@vitest/mocker@4.1.10':
+    resolution: {integrity: sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==}
     peerDependencies:
       msw: ^2.4.9
       vite: ^6.0.0 || ^7.0.0 || ^8.0.0
@@ -626,49 +820,168 @@ packages:
       vite:
         optional: true
 
-  '@vitest/pretty-format@4.1.4':
-    resolution: {integrity: sha512-ddmDHU0gjEUyEVLxtZa7xamrpIefdEETu3nZjWtHeZX4QxqJ7tRxSteHVXJOcr8jhiLoGAhkK4WJ3WqBpjx42A==}
+  '@vitest/pretty-format@4.1.10':
+    resolution: {integrity: sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==}
 
-  '@vitest/runner@4.1.4':
-    resolution: {integrity: sha512-xTp7VZ5aXP5ZJrn15UtJUWlx6qXLnGtF6jNxHepdPHpMfz/aVPx+htHtgcAL2mDXJgKhpoo2e9/hVJsIeFbytQ==}
+  '@vitest/runner@4.1.10':
+    resolution: {integrity: sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg==}
 
-  '@vitest/snapshot@4.1.4':
-    resolution: {integrity: sha512-MCjCFgaS8aZz+m5nTcEcgk/xhWv0rEH4Yl53PPlMXOZ1/Ka2VcZU6CJ+MgYCZbcJvzGhQRjVrGQNZqkGPttIKw==}
+  '@vitest/snapshot@4.1.10':
+    resolution: {integrity: sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw==}
 
-  '@vitest/spy@4.1.4':
-    resolution: {integrity: sha512-XxNdAsKW7C+FLydqFJLb5KhJtl3PGCMmYwFRfhvIgxJvLSXhhVI1zM8f1qD3Zg7RCjTSzDVyct6sghs9UEgBEQ==}
+  '@vitest/spy@4.1.10':
+    resolution: {integrity: sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw==}
 
-  '@vitest/utils@4.1.4':
-    resolution: {integrity: sha512-13QMT+eysM5uVGa1rG4kegGYNp6cnQcsTc67ELFbhNLQO+vgsygtYJx2khvdt4gVQqSSpC/KT5FZZxUpP3Oatw==}
+  '@vitest/utils@4.1.10':
+    resolution: {integrity: sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==}
 
-  agent-base@7.1.3:
-    resolution: {integrity: sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==}
-    engines: {node: '>= 14'}
+  '@yuku-codegen/binding-android-arm64@0.8.3':
+    resolution: {integrity: sha512-/EKnnqwvN7xYoVDhQEIEJTdPDwGW1wkFz/2Eku3ES/IJd4lcQh/OaIDFBmoJKvpe12enrb1TIoYh1fxasGXolA==}
+    cpu: [arm64]
+    os: [android]
 
-  ansi-escapes@7.2.0:
-    resolution: {integrity: sha512-g6LhBsl+GBPRWGWsBtutpzBYuIIdBkLEvad5C/va/74Db018+5TZiyA26cZJAr3Rft5lprVqOIPxf5Vid6tqAw==}
-    engines: {node: '>=18'}
+  '@yuku-codegen/binding-darwin-arm64@0.8.3':
+    resolution: {integrity: sha512-DFAOliF5YIPv3ayNHGOJhIun6Af4kMaL/YXxf8ZtD1qrOIMFnX/AQBhwfvLalhwmmxuGA8AUteaKRHBvdKZFVA==}
+    cpu: [arm64]
+    os: [darwin]
 
-  ansi-regex@6.2.2:
-    resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
-    engines: {node: '>=12'}
+  '@yuku-codegen/binding-darwin-x64@0.8.3':
+    resolution: {integrity: sha512-WlMh4/oEibaTzE9j5Zq8qnsrH4Ii4kWdcDv/Pj2Rb/MYSrKghtg+bxbWpPe/6zJD21p9zZBApQUxl8ECpZOJuQ==}
+    cpu: [x64]
+    os: [darwin]
 
-  ansi-styles@6.2.3:
-    resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==}
-    engines: {node: '>=12'}
+  '@yuku-codegen/binding-freebsd-x64@0.8.3':
+    resolution: {integrity: sha512-hoDOpPP0FTxPSD+6w0Gs4p8iL1yXe6jjIXcdzNxyT1KE6B3JI6O0gTIWQISJ+8QyNpNjIwBb7nHCdRavktJM6A==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@yuku-codegen/binding-linux-arm-gnu@0.8.3':
+    resolution: {integrity: sha512-nNW0GGMJyF04pK4A7Kq7WAYtUWU9uI5ugDAoXl9yHpd3IIZ8UI+zFlM01e+ZGWnQcdxYYLumeRe/EjzZT9bVfQ==}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@yuku-codegen/binding-linux-arm-musl@0.8.3':
+    resolution: {integrity: sha512-/jpxKhO8AV5TmXgT3R2Gv3YctKRUhyDzd5bQw8TiJ3O4z7qerHzoW2kE40fPAO3L434/IZtZbdhr8HuOqiwECA==}
+    cpu: [arm]
+    os: [linux]
+    libc: [musl]
+
+  '@yuku-codegen/binding-linux-arm64-gnu@0.8.3':
+    resolution: {integrity: sha512-CYhLJfnCknabfLvUjsanxC5s3BBtZHUwfzdDL7GcqShIRQh2qqgG7pPfFrFJ6Jp56kkjKXkfluFGn9nnIv0nZg==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@yuku-codegen/binding-linux-arm64-musl@0.8.3':
+    resolution: {integrity: sha512-c6gEdnI0MgA7/rVw6CACMciSbAcxVwLyD/jSBbMLWUeqqbysCNGrGPAHdpSaadpz3W1bd+OdXt9XWjfm66708w==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@yuku-codegen/binding-linux-x64-gnu@0.8.3':
+    resolution: {integrity: sha512-CRVZ9Rw5lIah/PpWeShWv7XiUCMY15N6rZRA2sEZrQvc5Az7Dv9/wsDMa6oBMkfQLXuDkFo4G1QOYyWbebjejg==}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@yuku-codegen/binding-linux-x64-musl@0.8.3':
+    resolution: {integrity: sha512-G12Nhecjmv7OlbCX6Y4HU4wYYePd111kTE+yTjbitnt+P3m8bNegtYG4ZGo4scGTq8cKsLF4xcda1XNzCUA6nQ==}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@yuku-codegen/binding-win32-arm64@0.8.3':
+    resolution: {integrity: sha512-i8bpXWaMlik9DvFl+89emEx3RZFtSd21Vlt0UrnPvUC7h8NGElP2SwQcdcG+pPmihFIYJAoIuJLw7YdQcFcDkA==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@yuku-codegen/binding-win32-x64@0.8.3':
+    resolution: {integrity: sha512-vlYymeTSsx+qxZoNvdl6KehgYDaQC4Sk/9KUnM3V2mriyCwSdhW7lqdpQGl+RLGsDTxyuRGjzGIjgRWk3lohmA==}
+    cpu: [x64]
+    os: [win32]
+
+  '@yuku-parser/binding-android-arm64@0.8.3':
+    resolution: {integrity: sha512-vySYRsMeul9ssvxeHdxgS9ZUIcq7gqljWNqgokjJE0uQWvVvOprihJ6hOsiifVqWsla0BMc3vAFBvNS9QqCw7g==}
+    cpu: [arm64]
+    os: [android]
+
+  '@yuku-parser/binding-darwin-arm64@0.8.3':
+    resolution: {integrity: sha512-+wpB/wqhiZ685Y77I+lj6v9pHSAJ3Y+QMHJmvch0Q0ahIMbNwtKk3s54MhtjCMKO1qpjPbyN/PjuHDg2hbKaVQ==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@yuku-parser/binding-darwin-x64@0.8.3':
+    resolution: {integrity: sha512-jKqiWejj4zVy7pPtEGu4/Ty+pG1h7ooQOXIkm7shKZTSwTU9X8X+eoH11uIeKHZi2SQWV0GhNz0J56eerseysQ==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@yuku-parser/binding-freebsd-x64@0.8.3':
+    resolution: {integrity: sha512-FC7zSwzFzd4z9bsId07CiHLR+Iw6yW/LzIQhL5AUtPUuVXLgEyx0rilgbRUYkl1CT3GJcLpkh63WuPZUSgCDzw==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@yuku-parser/binding-linux-arm-gnu@0.8.3':
+    resolution: {integrity: sha512-So61j88b9/ygDnUPlWCm1EUPw4HSxAyDjrNHKgud5N3aRDQ3kw94nW7TriXbo7GBXID9oBHCMNm1r1Fof/Df5Q==}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@yuku-parser/binding-linux-arm-musl@0.8.3':
+    resolution: {integrity: sha512-Nmnn20yJvSSKL8ZdtqReBRSGCDkSMqR5jEk/Sk/cdIdZmqVD49Z6M7w2GbMjdrxMI1MBPbsWFMMWxa93cd5t5g==}
+    cpu: [arm]
+    os: [linux]
+    libc: [musl]
+
+  '@yuku-parser/binding-linux-arm64-gnu@0.8.3':
+    resolution: {integrity: sha512-Lfgw7AXJ0rxu6BMPGgfc8HLJWEIr8BHhCzcQp/75k+NM90uCLkHlBNqIg/K42KlSvBgAvu9euOvjdswib+4qJA==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@yuku-parser/binding-linux-arm64-musl@0.8.3':
+    resolution: {integrity: sha512-cfRyu87xsJ0tFkHNsnMC4Rq6+xsFJ6i2dc4VAH52d2qLvykEJU/Mdi3ul1O2PyOApX/LoLT3uQZ0fWs3D5XE4w==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@yuku-parser/binding-linux-x64-gnu@0.8.3':
+    resolution: {integrity: sha512-GcQQCUuYxbm6P1n+io/A50rvWKDeWHutIp6rW0ycDOZuEQjOb8hDVgS88+NDyOnd9FfS0/Z6GXopcRFDyKpzOg==}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@yuku-parser/binding-linux-x64-musl@0.8.3':
+    resolution: {integrity: sha512-rMkImBGZzg7GZlj8krYtdiezyjYI4igjKWMut5T65jHyNWFigMQrEpn9mDIBflloW9FKhGE3mN6yTZ/N+4HRwg==}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@yuku-parser/binding-win32-arm64@0.8.3':
+    resolution: {integrity: sha512-/2Pl2cAzCXWxah8FqJapEj/ikpt9cEutEZFCa0hnbfrshkn5+C+aBM3ZDq62d1jsgQjBMmqr5HVhJUA4OAG/Tg==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@yuku-parser/binding-win32-x64@0.8.3':
+    resolution: {integrity: sha512-Ntnvjoan9jnfLhn7Kn3h8j/bhsbVdQSVmKUqFULKtmwImLCJVHOJbLL4qbEJyrOQ7r/FBL1/c/dRvx/AQWzzXg==}
+    cpu: [x64]
+    os: [win32]
 
-  ansis@4.2.0:
-    resolution: {integrity: sha512-HqZ5rWlFjGiV0tDm3UxxgNRqsOTniqoKZu0pIAfh7TZQMGuZK+hH0drySty0si0QXj1ieop4+SkSfPZBPPkHig==}
+  '@yuku-toolchain/types@0.8.3':
+    resolution: {integrity: sha512-9LN3HYs3A9qSPVFunsxlbfwBcUgexti3TmhOzIxB/UH8zFuaHQJXTRDcN17DW6cp1GsyZtiZA7f18uIra36Jag==}
+
+  agent-base@7.1.3:
+    resolution: {integrity: sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==}
+    engines: {node: '>= 14'}
+
+  ansis@4.3.1:
+    resolution: {integrity: sha512-BJ8/l4R5LRE7hW9WdSuGYrLSHi2ynxeFpDFbH0K/CgNeY/tyhk+vO6TYxXC5r5CpUhNVX310xzPsN/H9lCdfOA==}
     engines: {node: '>=14'}
 
   assertion-error@2.0.1:
     resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
     engines: {node: '>=12'}
 
-  ast-kit@3.0.0-beta.1:
-    resolution: {integrity: sha512-trmleAnZ2PxN/loHWVhhx1qeOHSRXq4TDsBBxq3GqeJitfk3+jTQ+v/C1km/KYq9M7wKqCewMh+/NAvVH7m+bw==}
-    engines: {node: '>=20.19.0'}
-
   async-mutex@0.5.0:
     resolution: {integrity: sha512-1A94B18jkJ3DYq284ohPxoXbfTA5HsQ7/Mf4DEhcyLx3Bz27Rh59iScbB6EPiP+B+joue6YCxcMXSbFC1tZKwA==}
 
@@ -682,9 +995,6 @@ packages:
   bare-events@2.5.4:
     resolution: {integrity: sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA==}
 
-  birpc@4.0.0:
-    resolution: {integrity: sha512-LShSxJP0KTmd101b6DRyGBj57LZxSDYWKitQNW/mi8GRMvZb078Uf9+pveax1DrVL89vm7mWe+TovdI/UDOuPw==}
-
   brace-expansion@5.0.4:
     resolution: {integrity: sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==}
     engines: {node: 18 || 20 || >=22}
@@ -708,21 +1018,6 @@ packages:
     resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
     engines: {node: '>=18'}
 
-  cli-cursor@5.0.0:
-    resolution: {integrity: sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==}
-    engines: {node: '>=18'}
-
-  cli-truncate@5.1.1:
-    resolution: {integrity: sha512-SroPvNHxUnk+vIW/dOSfNqdy1sPEFkrTk6TUtqLCnBlo3N7TNYYkzzN7uSD6+jVjrdO4+p8nH7JzH6cIvUem6A==}
-    engines: {node: '>=20'}
-
-  colorette@2.0.20:
-    resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==}
-
-  commander@14.0.3:
-    resolution: {integrity: sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==}
-    engines: {node: '>=20'}
-
   commondir@1.0.1:
     resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}
 
@@ -738,31 +1033,24 @@ packages:
       supports-color:
         optional: true
 
-  defu@6.1.6:
-    resolution: {integrity: sha512-f8mefEW4WIVg4LckePx3mALjQSPQgFlg9U8yaPdlsbdYcHQyj9n2zL2LJEA52smeYxOvmd/nB7TpMtHGMTHcug==}
+  defu@6.1.7:
+    resolution: {integrity: sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==}
 
-  dts-resolver@2.1.3:
-    resolution: {integrity: sha512-bihc7jPC90VrosXNzK0LTE2cuLP6jr0Ro8jk+kMugHReJVLIpHz/xadeq3MhuwyO4TD4OA3L1Q8pBBFRc08Tsw==}
-    engines: {node: '>=20.19.0'}
+  dts-resolver@3.0.0:
+    resolution: {integrity: sha512-1T1f+z+4tl9XD+m+0HBgWoL/nm0bOIffyWaUuUSBlFg/86IWvfx+wjNaO/ybU0AJzG9/Mi5hBUgGV6zCmWEN7Q==}
+    engines: {node: ^22.18.0 || >=24.0.0}
     peerDependencies:
       oxc-resolver: '>=11.0.0'
     peerDependenciesMeta:
       oxc-resolver:
         optional: true
 
-  emoji-regex@10.6.0:
-    resolution: {integrity: sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==}
-
-  empathic@2.0.0:
-    resolution: {integrity: sha512-i6UzDscO/XfAcNYD75CfICkmfLedpyPDdozrLMmQc5ORaQcdMoc21OnlEylMIqI7U8eniKrPMxxtj8k0vhmJhA==}
+  empathic@2.0.1:
+    resolution: {integrity: sha512-YGRs8knHhKHVShLkFET/rWAU8kmHbOV5LwN938RHI0pljAJ1Gf6SzXsSmRaEzcXTtOOmVqJ5+WtQPL5uigY50Q==}
     engines: {node: '>=14'}
 
-  environment@1.1.0:
-    resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==}
-    engines: {node: '>=18'}
-
-  es-module-lexer@2.0.0:
-    resolution: {integrity: sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==}
+  es-module-lexer@2.3.1:
+    resolution: {integrity: sha512-shc1dbU90Yl/xq1QrC7QRtfcwURZuVRfPhZbDoldJ1cn1gzDvBaBWlv0eFolj5+0znnPJz5TXLxsN77X/12KTA==}
 
   esbuild@0.27.7:
     resolution: {integrity: sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==}
@@ -772,11 +1060,8 @@ packages:
   estree-walker@3.0.3:
     resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
 
-  eventemitter3@5.0.4:
-    resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
-
-  expect-type@1.3.0:
-    resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
+  expect-type@1.4.0:
+    resolution: {integrity: sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==}
     engines: {node: '>=12.0.0'}
 
   fast-fifo@1.3.2:
@@ -816,19 +1101,16 @@ packages:
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
 
-  get-east-asian-width@1.4.0:
-    resolution: {integrity: sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q==}
-    engines: {node: '>=18'}
-
-  get-tsconfig@4.13.7:
-    resolution: {integrity: sha512-7tN6rFgBlMgpBML5j8typ92BKFi2sFQvIdpAqLA2beia5avZDrMs0FLZiM5etShWq5irVyGcGMEA1jcDaK7A/Q==}
+  get-tsconfig@5.0.0-beta.5:
+    resolution: {integrity: sha512-/6gFNr0N04nob252sTQxyFLi3eKFRqIg1I87YcqAMT1i6SQrSF6KujUEQrtrjMV0H/eejTCltLdDSTEMzHbnsQ==}
+    engines: {node: '>=20.20.0'}
 
   glob@13.0.6:
     resolution: {integrity: sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==}
     engines: {node: 18 || 20 || >=22}
 
-  hookable@6.1.0:
-    resolution: {integrity: sha512-ZoKZSJgu8voGK2geJS+6YtYjvIzu9AOM/KZXsBxr83uhLL++e9pEv/dlgwgy3dvHg06kTz6JOh1hk3C8Ceiymw==}
+  hookable@6.1.1:
+    resolution: {integrity: sha512-U9LYDy1CwhMCnprUfeAZWZGByVbhd54hwepegYTK7Pi5NvqEj63ifz5z+xukznehT7i6NIZRu89Ay1AZmRsLEQ==}
 
   https-proxy-agent@7.0.6:
     resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==}
@@ -839,32 +1121,19 @@ packages:
     engines: {node: '>=18'}
     hasBin: true
 
-  import-without-cache@0.2.5:
-    resolution: {integrity: sha512-B6Lc2s6yApwnD2/pMzFh/d5AVjdsDXjgkeJ766FmFuJELIGHNycKRj+l3A39yZPM4CchqNCB4RITEAYB1KUM6A==}
-    engines: {node: '>=20.19.0'}
-
-  is-fullwidth-code-point@5.1.0:
-    resolution: {integrity: sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==}
-    engines: {node: '>=18'}
+  import-without-cache@0.4.0:
+    resolution: {integrity: sha512-NkJQA7oZ4YHQhd2+H3BoRFKF3d/XNsiKpHZCQEMH9pDX27hQQLsTyOocyRgaIVtf8gHX3Nt3LPkR4e5EdtPAGQ==}
+    engines: {node: ^22.18.0 || >=24.0.0}
 
   jiti@2.6.1:
     resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
     hasBin: true
 
-  jsesc@3.1.0:
-    resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
-    engines: {node: '>=6'}
-    hasBin: true
-
-  lint-staged@16.4.0:
-    resolution: {integrity: sha512-lBWt8hujh/Cjysw5GYVmZpFHXDCgZzhrOm8vbcUdobADZNOK/bRshr2kM3DfgrrtR1DQhfupW9gnIXOfiFi+bw==}
-    engines: {node: '>=20.17'}
+  lint-staged@17.3.0:
+    resolution: {integrity: sha512-woZS3vNe3UKqBaLPvbLOtKRY4tLANpWQhom12MGWqC8Mh1lCOO+WgSwmX2amjJAqTY9BkXYW87fCUH5H9Ph6xw==}
+    engines: {node: '>=22.22.1'}
     hasBin: true
 
-  listr2@9.0.5:
-    resolution: {integrity: sha512-ME4Fb83LgEgwNw96RKNvKV4VTLuXfoKudAmm2lP8Kk87KaMK0/Xrx/aAkMWmT8mDb+3MlFDspfbCs7adjRxA2g==}
-    engines: {node: '>=20.0.0'}
-
   locate-path@5.0.0:
     resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
     engines: {node: '>=8'}
@@ -872,10 +1141,6 @@ packages:
   lodash.mergewith@4.6.2:
     resolution: {integrity: sha512-GK3g5RPZWTRSeLSpgP8Xhra+pnjBC56q9FZYe1d5RN3TJ35dbkGy3YqBSMbyCrlbi+CM9Z3Jk5yTL7RCsqboyQ==}
 
-  log-update@6.1.0:
-    resolution: {integrity: sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==}
-    engines: {node: '>=18'}
-
   lru-cache@11.2.7:
     resolution: {integrity: sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==}
     engines: {node: 20 || >=22}
@@ -890,10 +1155,6 @@ packages:
   memory-pager@1.5.0:
     resolution: {integrity: sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg==}
 
-  mimic-function@5.0.1:
-    resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==}
-    engines: {node: '>=18'}
-
   minimatch@10.2.4:
     resolution: {integrity: sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==}
     engines: {node: 18 || 20 || >=22}
@@ -943,8 +1204,8 @@ packages:
   ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
 
-  nanoid@3.3.11:
-    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+  nanoid@3.3.16:
+    resolution: {integrity: sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==}
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
@@ -952,12 +1213,9 @@ packages:
     resolution: {integrity: sha512-lDcBsjBSMlj3LXH2v/FW3txlh2pYTjmbOXPYJD93HI5EwuLzI11tdHSIpUMmfq/IOsldj4Ps8M8flhm+pCK4Ew==}
     engines: {node: '>=12.22.0'}
 
-  obug@2.1.1:
-    resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==}
-
-  onetime@7.0.0:
-    resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==}
-    engines: {node: '>=18'}
+  obug@2.1.4:
+    resolution: {integrity: sha512-4a+OsYv9UktOJKE+l1A4OufDgdRF9PifWj+tJnHURo/P+WOxpG4GzUFL9qCalmWauao6ogiG+QvnCovwPoyAWA==}
+    engines: {node: '>=12.20.0'}
 
   p-limit@2.3.0:
     resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
@@ -991,20 +1249,16 @@ packages:
   picocolors@1.1.1:
     resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
 
-  picomatch@4.0.3:
-    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
-    engines: {node: '>=12'}
-
-  picomatch@4.0.4:
-    resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==}
+  picomatch@4.0.5:
+    resolution: {integrity: sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==}
     engines: {node: '>=12'}
 
   pkg-dir@4.2.0:
     resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==}
     engines: {node: '>=8'}
 
-  postcss@8.5.9:
-    resolution: {integrity: sha512-7a70Nsot+EMX9fFU3064K/kdHWZqGVY+BADLyXc8Dfv+mTLLVl6JzJpPaCZ2kQL9gIJvKXSLMHhqdRRjwQeFtw==}
+  postcss@8.5.25:
+    resolution: {integrity: sha512-DTPx3RWSSnWyzLxQnlH0rJP+EW5ekl16ZU4/psbIhA0e53kJfdgaN5vKM+xP7yJtXVu+nfdVFmlgFDEKAe4Pyw==}
     engines: {node: ^10 || ^12 || >=14}
 
   punycode@2.3.1:
@@ -1017,32 +1271,25 @@ packages:
   resolve-pkg-maps@1.0.0:
     resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
 
-  restore-cursor@5.1.0:
-    resolution: {integrity: sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==}
-    engines: {node: '>=18'}
-
-  rfdc@1.4.1:
-    resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
-
   rimraf@6.1.3:
     resolution: {integrity: sha512-LKg+Cr2ZF61fkcaK1UdkH2yEBBKnYjTyWzTJT6KNPcSPaiT7HSdhtMXQuN5wkTX0Xu72KQ1l8S42rlmexS2hSA==}
     engines: {node: 20 || >=22}
     hasBin: true
 
-  rolldown-plugin-dts@0.23.2:
-    resolution: {integrity: sha512-PbSqLawLgZBGcOGT3yqWBGn4cX+wh2nt5FuBGdcMHyOhoukmjbhYAl8NT9sE4U38Cm9tqLOIQeOrvzeayM0DLQ==}
-    engines: {node: '>=20.19.0'}
+  rolldown-plugin-dts@0.27.14:
+    resolution: {integrity: sha512-ZvuDDwoIpRK9RPxDXratCpklFO9QZZWndf/sd0VBFb4LEj0jj07UcHK9OCh7V4XiFz2Z89ziyBC2K6tJiDjrbw==}
+    engines: {node: ^22.18.0 || >=24.11.0}
     peerDependencies:
-      '@ts-macro/tsc': ^0.3.6
-      '@typescript/native-preview': '>=7.0.0-dev.20260325.1'
-      rolldown: ^1.0.0-rc.12
-      typescript: ^5.0.0 || ^6.0.0
-      vue-tsc: ~3.2.0
+      '@typescript/native-preview': '*'
+      '@volar/typescript': ~2.4.0
+      rolldown: ^1.0.0
+      typescript: ^5.0.0 || ^6.0.0 || ~7.0.0
+      vue-tsc: ~3.2.0 || ~3.3.0
     peerDependenciesMeta:
-      '@ts-macro/tsc':
-        optional: true
       '@typescript/native-preview':
         optional: true
+      '@volar/typescript':
+        optional: true
       typescript:
         optional: true
       vue-tsc:
@@ -1053,8 +1300,13 @@ packages:
     engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
 
-  rollup@4.60.1:
-    resolution: {integrity: sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w==}
+  rolldown@1.2.1:
+    resolution: {integrity: sha512-4FKJhg8d3OiyQOA6Q1Q0hoFFpW9/OoX+VsHzpECsdsIZoOArrAK90gl59YK/Z+gnDel45bgJZK03ozH/9bCqEw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+
+  rollup@4.62.4:
+    resolution: {integrity: sha512-RXOqwaPsBGjMNMa4sQjDjHieHEZDFoj/Rdr46l2MU5DfEs16wHJPC2RPTPHWhNl+M3aI472LLqFkFKut4SblOg==}
     engines: {node: '>=18.0.0', npm: '>=8.0.0'}
     hasBin: true
 
@@ -1070,14 +1322,6 @@ packages:
   siginfo@2.0.0:
     resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
 
-  signal-exit@4.1.0:
-    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
-    engines: {node: '>=14'}
-
-  slice-ansi@7.1.2:
-    resolution: {integrity: sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==}
-    engines: {node: '>=18'}
-
   source-map-js@1.2.1:
     resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
     engines: {node: '>=0.10.0'}
@@ -1088,8 +1332,8 @@ packages:
   stackback@0.0.2:
     resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
 
-  std-env@4.0.0:
-    resolution: {integrity: sha512-zUMPtQ/HBY3/50VbpkupYHbRroTRZJPRLvreamgErJVys0ceuzMkD44J/QjqhHjOzK42GQ3QZIeFG1OYfOtKqQ==}
+  std-env@4.2.0:
+    resolution: {integrity: sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==}
 
   streamx@2.22.0:
     resolution: {integrity: sha512-sLh1evHOzBy/iWRiR6d1zRcLao4gGZr3C1kzNz4fopCOKJb6xD9ub8Mpi9Mr1R6id5o43S+d93fI48UC5uM9aw==}
@@ -1098,18 +1342,6 @@ packages:
     resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==}
     engines: {node: '>=0.6.19'}
 
-  string-width@7.2.0:
-    resolution: {integrity: sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==}
-    engines: {node: '>=18'}
-
-  string-width@8.1.1:
-    resolution: {integrity: sha512-KpqHIdDL9KwYk22wEOg/VIqYbrnLeSApsKT/bSj6Ez7pn3CftUiLAv2Lccpq1ALcpLV9UX1Ppn92npZWu2w/aw==}
-    engines: {node: '>=20'}
-
-  strip-ansi@7.1.2:
-    resolution: {integrity: sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==}
-    engines: {node: '>=12'}
-
   tar-stream@3.1.7:
     resolution: {integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==}
 
@@ -1119,24 +1351,16 @@ packages:
   tinybench@2.9.0:
     resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
 
-  tinyexec@1.0.4:
-    resolution: {integrity: sha512-u9r3uZC0bdpGOXtlxUIdwf9pkmvhqJdrVCH9fapQtgy/OeTTMZ1nqH7agtvEfmGui6e1XxjcdrlxvxJvc3sMqw==}
-    engines: {node: '>=18'}
-
-  tinyexec@1.1.1:
-    resolution: {integrity: sha512-VKS/ZaQhhkKFMANmAOhhXVoIfBXblQxGX1myCQ2faQrfmobMftXeJPcZGp0gS07ocvGJWDLZGyOZDadDBqYIJg==}
+  tinyexec@1.3.0:
+    resolution: {integrity: sha512-QKAl9m8gWWGHV8jZcPeym6j+XULi6tOf1mT83WYJ4Lk2ytW/uwAWkrP0uFsdoYMdueVJ0qs26wZ+23xeB4ibNQ==}
     engines: {node: '>=18'}
 
-  tinyglobby@0.2.15:
-    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
-    engines: {node: '>=12.0.0'}
-
-  tinyglobby@0.2.16:
-    resolution: {integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==}
+  tinyglobby@0.2.17:
+    resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==}
     engines: {node: '>=12.0.0'}
 
-  tinyrainbow@3.1.0:
-    resolution: {integrity: sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==}
+  tinyrainbow@3.1.1:
+    resolution: {integrity: sha512-yau8yJdTt989Mm0Bd/236QnzEiPf2xLLTqUZRUJOo/3CB078LSwzei343DgtJVmfJKJE3TMINY1u42SQsP6mXw==}
     engines: {node: '>=14.0.0'}
 
   tr46@5.1.0:
@@ -1147,26 +1371,28 @@ packages:
     resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
     hasBin: true
 
-  ts-essentials@10.1.1:
-    resolution: {integrity: sha512-4aTB7KLHKmUvkjNj8V+EdnmuVTiECzn3K+zIbRthumvHu+j44x3w63xpfs0JL3NGIzGXqoQ7AV591xHO+XrOTw==}
+  ts-essentials@10.2.1:
+    resolution: {integrity: sha512-+Id1fRkuir+CsgK2x04/icS2b4V1hQmq7ObzIrDjhN0ozfRYivnP7aaKMVJfLApQm0trjR39A6NIMVchiB9Erw==}
     peerDependencies:
       typescript: '>=4.5.0'
     peerDependenciesMeta:
       typescript:
         optional: true
 
-  tsdown@0.21.7:
-    resolution: {integrity: sha512-ukKIxKQzngkWvOYJAyptudclkm4VQqbjq+9HF5K5qDO8GJsYtMh8gIRwicbnZEnvFPr6mquFwYAVZ8JKt3rY2g==}
-    engines: {node: '>=20.19.0'}
+  tsdown@0.22.14:
+    resolution: {integrity: sha512-ule7Y+fsAN2iZbLDoo7C4KYljFJNJJ+fLshyn+9gozeTspVersWHxwdGB+Dm2hzA38s6muFnUTl0jK3vJm9ifQ==}
+    engines: {node: ^22.18.0 || >=24.11.0}
     hasBin: true
     peerDependencies:
       '@arethetypeswrong/core': ^0.18.1
-      '@tsdown/css': 0.21.7
-      '@tsdown/exe': 0.21.7
+      '@tsdown/css': 0.22.14
+      '@tsdown/exe': 0.22.14
       '@vitejs/devtools': '*'
-      publint: ^0.3.0
-      typescript: ^5.0.0 || ^6.0.0
+      publint: ^0.3.8
+      tsx: '*'
+      typescript: ^5.0.0 || ^6.0.0 || ^7.0.0
       unplugin-unused: ^0.5.0
+      unrun: '*'
     peerDependenciesMeta:
       '@arethetypeswrong/core':
         optional: true
@@ -1178,17 +1404,21 @@ packages:
         optional: true
       publint:
         optional: true
+      tsx:
+        optional: true
       typescript:
         optional: true
       unplugin-unused:
         optional: true
+      unrun:
+        optional: true
 
   tslib@2.8.1:
     resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
-  typescript@5.9.3:
-    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
-    engines: {node: '>=14.17'}
+  typescript@7.0.2:
+    resolution: {integrity: sha512-8FYau96o3NKOhbjKi/qNvG/W5jhzxkbdm5sj9AbZ/5T5sWqn3hJgLfGx27sRKZWTvyzCP8dLRBTf5tBTSRVUNA==}
+    engines: {node: '>=16.20.0'}
     hasBin: true
 
   unconfig-core@7.5.0:
@@ -1207,6 +1437,10 @@ packages:
       synckit:
         optional: true
 
+  verkit@0.3.1:
+    resolution: {integrity: sha512-w2Eo8LSIIoW7qxNBzT7/17k+bh8plXo7G3dHjEIDqPlnluhzaxr9JX8F28VSYEtDvc1/a3WBDih6xNUZseebXg==}
+    engines: {node: '>=18.12.0'}
+
   vite@7.3.1:
     resolution: {integrity: sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -1247,26 +1481,26 @@ packages:
       yaml:
         optional: true
 
-  vitest-mock-extended@4.0.0:
-    resolution: {integrity: sha512-m2FmH8JYfxzZoLsHuhXRY+Pv++a3zd91HYpSz81tpRLEHbtFkEL2QcWvJowucWuNTirzQURKfWbJJSXbYqkTsA==}
+  vitest-mock-extended@5.1.1:
+    resolution: {integrity: sha512-k5Ji2+t4+nsdepXeakCkilyKydtgaULtP0HsjwQGIZsYr5hDTqrwCtC0+Sh0YBKUS7cY/Wxplf7SVjcZstTIMQ==}
     peerDependencies:
-      typescript: 3.x || 4.x || 5.x || 6.x
+      typescript: 3.x || 4.x || 5.x || 6.x || 7.x
       vitest: '>=4.0.0'
 
-  vitest@4.1.4:
-    resolution: {integrity: sha512-tFuJqTxKb8AvfyqMfnavXdzfy3h3sWZRWwfluGbkeR7n0HUev+FmNgZ8SDrRBTVrVCjgH5cA21qGbCffMNtWvg==}
+  vitest@4.1.10:
+    resolution: {integrity: sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw==}
     engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
     hasBin: true
     peerDependencies:
       '@edge-runtime/vm': '*'
       '@opentelemetry/api': ^1.9.0
       '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
-      '@vitest/browser-playwright': 4.1.4
-      '@vitest/browser-preview': 4.1.4
-      '@vitest/browser-webdriverio': 4.1.4
-      '@vitest/coverage-istanbul': 4.1.4
-      '@vitest/coverage-v8': 4.1.4
-      '@vitest/ui': 4.1.4
+      '@vitest/browser-playwright': 4.1.10
+      '@vitest/browser-preview': 4.1.10
+      '@vitest/browser-webdriverio': 4.1.10
+      '@vitest/coverage-istanbul': 4.1.10
+      '@vitest/coverage-v8': 4.1.10
+      '@vitest/ui': 4.1.10
       happy-dom: '*'
       jsdom: '*'
       vite: ^6.0.0 || ^7.0.0 || ^8.0.0
@@ -1307,12 +1541,8 @@ packages:
     engines: {node: '>=8'}
     hasBin: true
 
-  wrap-ansi@9.0.2:
-    resolution: {integrity: sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==}
-    engines: {node: '>=18'}
-
-  yaml@2.8.2:
-    resolution: {integrity: sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==}
+  yaml@2.9.0:
+    resolution: {integrity: sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==}
     engines: {node: '>= 14.6'}
     hasBin: true
 
@@ -1320,77 +1550,64 @@ packages:
     resolution: {integrity: sha512-Ow9nuGZE+qp1u4JIPvg+uCiUr7xGQWdff7JQSk5VGYTAZMDe2q8lxJ10ygv10qmSj031Ty/6FNJpLO4o1Sgc+w==}
     engines: {node: '>=12'}
 
-snapshots:
+  yuku-ast@0.8.3:
+    resolution: {integrity: sha512-8x34yU5uhHUnJXzy2Qvjvec/vE9BzS0/2khVT1MsLmSLO/P8Q1Wp8IxHv+IhD+HMYETk6kherOSvP4JPWw2joQ==}
 
-  '@babel/generator@8.0.0-rc.3':
-    dependencies:
-      '@babel/parser': 8.0.0-rc.3
-      '@babel/types': 8.0.0-rc.3
-      '@jridgewell/gen-mapping': 0.3.13
-      '@jridgewell/trace-mapping': 0.3.31
-      '@types/jsesc': 2.5.1
-      jsesc: 3.1.0
+  yuku-codegen@0.8.3:
+    resolution: {integrity: sha512-okdo5bb+TfebQa4JOjz9QxeT34D6CcBxu8dxaPUdFEKRdLkp+D2Fah2OanepK+XTyPXdmAJzAo9iXvYvZ/5rmg==}
 
-  '@babel/helper-string-parser@8.0.0-rc.3': {}
+  yuku-parser@0.8.3:
+    resolution: {integrity: sha512-KPQcpF9aj77ywlJBIkQWCQ9DObdxnCA8AJdUOmA5CZZx042Xt4+dvbQmPJfWxF3E+KG5dVAZ2fBKuDJ8VsKWgA==}
 
-  '@babel/helper-validator-identifier@8.0.0-rc.3': {}
-
-  '@babel/parser@8.0.0-rc.3':
-    dependencies:
-      '@babel/types': 8.0.0-rc.3
-
-  '@babel/types@8.0.0-rc.3':
-    dependencies:
-      '@babel/helper-string-parser': 8.0.0-rc.3
-      '@babel/helper-validator-identifier': 8.0.0-rc.3
+snapshots:
 
-  '@biomejs/biome@2.4.11':
+  '@biomejs/biome@2.5.6':
     optionalDependencies:
-      '@biomejs/cli-darwin-arm64': 2.4.11
-      '@biomejs/cli-darwin-x64': 2.4.11
-      '@biomejs/cli-linux-arm64': 2.4.11
-      '@biomejs/cli-linux-arm64-musl': 2.4.11
-      '@biomejs/cli-linux-x64': 2.4.11
-      '@biomejs/cli-linux-x64-musl': 2.4.11
-      '@biomejs/cli-win32-arm64': 2.4.11
-      '@biomejs/cli-win32-x64': 2.4.11
+      '@biomejs/cli-darwin-arm64': 2.5.6
+      '@biomejs/cli-darwin-x64': 2.5.6
+      '@biomejs/cli-linux-arm64': 2.5.6
+      '@biomejs/cli-linux-arm64-musl': 2.5.6
+      '@biomejs/cli-linux-x64': 2.5.6
+      '@biomejs/cli-linux-x64-musl': 2.5.6
+      '@biomejs/cli-win32-arm64': 2.5.6
+      '@biomejs/cli-win32-x64': 2.5.6
 
-  '@biomejs/cli-darwin-arm64@2.4.11':
+  '@biomejs/cli-darwin-arm64@2.5.6':
     optional: true
 
-  '@biomejs/cli-darwin-x64@2.4.11':
+  '@biomejs/cli-darwin-x64@2.5.6':
     optional: true
 
-  '@biomejs/cli-linux-arm64-musl@2.4.11':
+  '@biomejs/cli-linux-arm64-musl@2.5.6':
     optional: true
 
-  '@biomejs/cli-linux-arm64@2.4.11':
+  '@biomejs/cli-linux-arm64@2.5.6':
     optional: true
 
-  '@biomejs/cli-linux-x64-musl@2.4.11':
+  '@biomejs/cli-linux-x64-musl@2.5.6':
     optional: true
 
-  '@biomejs/cli-linux-x64@2.4.11':
+  '@biomejs/cli-linux-x64@2.5.6':
     optional: true
 
-  '@biomejs/cli-win32-arm64@2.4.11':
+  '@biomejs/cli-win32-arm64@2.5.6':
     optional: true
 
-  '@biomejs/cli-win32-x64@2.4.11':
+  '@biomejs/cli-win32-x64@2.5.6':
     optional: true
 
-  '@emnapi/core@1.9.0':
+  '@emnapi/core@2.0.0-alpha.3':
     dependencies:
-      '@emnapi/wasi-threads': 1.2.0
+      '@emnapi/wasi-threads': 2.0.1
       tslib: 2.8.1
     optional: true
 
-  '@emnapi/runtime@1.9.0':
+  '@emnapi/runtime@2.0.0-alpha.3':
     dependencies:
       tslib: 2.8.1
     optional: true
 
-  '@emnapi/wasi-threads@1.2.0':
+  '@emnapi/wasi-threads@2.0.1':
     dependencies:
       tslib: 2.8.1
     optional: true
@@ -1475,32 +1692,26 @@ snapshots:
 
   '@faker-js/faker@9.9.0': {}
 
-  '@jridgewell/gen-mapping@0.3.13':
-    dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.5
-      '@jridgewell/trace-mapping': 0.3.31
-
-  '@jridgewell/resolve-uri@3.1.2': {}
-
   '@jridgewell/sourcemap-codec@1.5.5': {}
 
-  '@jridgewell/trace-mapping@0.3.31':
-    dependencies:
-      '@jridgewell/resolve-uri': 3.1.2
-      '@jridgewell/sourcemap-codec': 1.5.5
-
   '@mongodb-js/saslprep@1.2.0':
     dependencies:
       sparse-bitfield: 3.0.3
 
-  '@napi-rs/wasm-runtime@1.1.2(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)':
+  '@napi-rs/lzma-linux-x64-gnu@1.5.1':
+    optional: true
+
+  '@napi-rs/wasm-runtime@1.2.2(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)':
     dependencies:
-      '@emnapi/core': 1.9.0
-      '@emnapi/runtime': 1.9.0
-      '@tybys/wasm-util': 0.10.1
+      '@emnapi/core': 2.0.0-alpha.3
+      '@emnapi/runtime': 2.0.0-alpha.3
+      '@tybys/wasm-util': 0.10.3
+    optional: true
+
+  '@oxc-project/types@0.122.0':
     optional: true
 
-  '@oxc-project/types@0.122.0': {}
+  '@oxc-project/types@0.142.0': {}
 
   '@quansync/fs@1.0.0':
     dependencies:
@@ -1509,133 +1720,185 @@ snapshots:
   '@rolldown/binding-android-arm64@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-android-arm64@1.2.1':
+    optional: true
+
   '@rolldown/binding-darwin-arm64@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-darwin-arm64@1.2.1':
+    optional: true
+
   '@rolldown/binding-darwin-x64@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-darwin-x64@1.2.1':
+    optional: true
+
   '@rolldown/binding-freebsd-x64@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-freebsd-x64@1.2.1':
+    optional: true
+
   '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-linux-arm-gnueabihf@1.2.1':
+    optional: true
+
   '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-linux-arm64-gnu@1.2.1':
+    optional: true
+
   '@rolldown/binding-linux-arm64-musl@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-linux-arm64-musl@1.2.1':
+    optional: true
+
   '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-linux-ppc64-gnu@1.2.1':
+    optional: true
+
   '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-linux-s390x-gnu@1.2.1':
+    optional: true
+
   '@rolldown/binding-linux-x64-gnu@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-linux-x64-gnu@1.2.1':
+    optional: true
+
   '@rolldown/binding-linux-x64-musl@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-linux-x64-musl@1.2.1':
+    optional: true
+
   '@rolldown/binding-openharmony-arm64@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/binding-wasm32-wasi@1.0.0-rc.12(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)':
+  '@rolldown/binding-openharmony-arm64@1.2.1':
+    optional: true
+
+  '@rolldown/binding-wasm32-wasi@1.0.0-rc.12(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)':
     dependencies:
-      '@napi-rs/wasm-runtime': 1.1.2(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)
+      '@napi-rs/wasm-runtime': 1.2.2(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)
     transitivePeerDependencies:
       - '@emnapi/core'
       - '@emnapi/runtime'
     optional: true
 
+  '@rolldown/binding-wasm32-wasi@1.2.1':
+    dependencies:
+      '@emnapi/core': 2.0.0-alpha.3
+      '@emnapi/runtime': 2.0.0-alpha.3
+      '@napi-rs/wasm-runtime': 1.2.2(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)
+    optional: true
+
   '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.12':
     optional: true
 
+  '@rolldown/binding-win32-arm64-msvc@1.2.1':
+    optional: true
+
   '@rolldown/binding-win32-x64-msvc@1.0.0-rc.12':
     optional: true
 
-  '@rolldown/pluginutils@1.0.0-rc.12': {}
+  '@rolldown/binding-win32-x64-msvc@1.2.1':
+    optional: true
+
+  '@rolldown/pluginutils@1.0.0-rc.12':
+    optional: true
 
-  '@rollup/rollup-android-arm-eabi@4.60.1':
+  '@rolldown/pluginutils@1.0.1': {}
+
+  '@rollup/rollup-android-arm-eabi@4.62.4':
     optional: true
 
-  '@rollup/rollup-android-arm64@4.60.1':
+  '@rollup/rollup-android-arm64@4.62.4':
     optional: true
 
-  '@rollup/rollup-darwin-arm64@4.60.1':
+  '@rollup/rollup-darwin-arm64@4.62.4':
     optional: true
 
-  '@rollup/rollup-darwin-x64@4.60.1':
+  '@rollup/rollup-darwin-x64@4.62.4':
     optional: true
 
-  '@rollup/rollup-freebsd-arm64@4.60.1':
+  '@rollup/rollup-freebsd-arm64@4.62.4':
     optional: true
 
-  '@rollup/rollup-freebsd-x64@4.60.1':
+  '@rollup/rollup-freebsd-x64@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-arm-gnueabihf@4.60.1':
+  '@rollup/rollup-linux-arm-gnueabihf@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-arm-musleabihf@4.60.1':
+  '@rollup/rollup-linux-arm-musleabihf@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-arm64-gnu@4.60.1':
+  '@rollup/rollup-linux-arm64-gnu@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-arm64-musl@4.60.1':
+  '@rollup/rollup-linux-arm64-musl@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-loong64-gnu@4.60.1':
+  '@rollup/rollup-linux-loong64-gnu@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-loong64-musl@4.60.1':
+  '@rollup/rollup-linux-loong64-musl@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-ppc64-gnu@4.60.1':
+  '@rollup/rollup-linux-ppc64-gnu@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-ppc64-musl@4.60.1':
+  '@rollup/rollup-linux-ppc64-musl@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-riscv64-gnu@4.60.1':
+  '@rollup/rollup-linux-riscv64-gnu@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-riscv64-musl@4.60.1':
+  '@rollup/rollup-linux-riscv64-musl@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-s390x-gnu@4.60.1':
+  '@rollup/rollup-linux-s390x-gnu@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-x64-gnu@4.60.1':
+  '@rollup/rollup-linux-x64-gnu@4.62.4':
     optional: true
 
-  '@rollup/rollup-linux-x64-musl@4.60.1':
+  '@rollup/rollup-linux-x64-musl@4.62.4':
     optional: true
 
-  '@rollup/rollup-openbsd-x64@4.60.1':
+  '@rollup/rollup-openbsd-x64@4.62.4':
     optional: true
 
-  '@rollup/rollup-openharmony-arm64@4.60.1':
+  '@rollup/rollup-openharmony-arm64@4.62.4':
     optional: true
 
-  '@rollup/rollup-win32-arm64-msvc@4.60.1':
+  '@rollup/rollup-win32-arm64-msvc@4.62.4':
     optional: true
 
-  '@rollup/rollup-win32-ia32-msvc@4.60.1':
+  '@rollup/rollup-win32-ia32-msvc@4.62.4':
     optional: true
 
-  '@rollup/rollup-win32-x64-gnu@4.60.1':
+  '@rollup/rollup-win32-x64-gnu@4.62.4':
     optional: true
 
-  '@rollup/rollup-win32-x64-msvc@4.60.1':
+  '@rollup/rollup-win32-x64-msvc@4.62.4':
     optional: true
 
   '@standard-schema/spec@1.1.0': {}
 
-  '@tybys/wasm-util@0.10.1':
+  '@tybys/wasm-util@0.10.3':
     dependencies:
       tslib: 2.8.1
     optional: true
@@ -1647,11 +1910,9 @@ snapshots:
 
   '@types/deep-eql@4.0.2': {}
 
-  '@types/estree@1.0.8': {}
-
-  '@types/jsesc@2.5.1': {}
+  '@types/estree@1.0.9': {}
 
-  '@types/node@20.19.31':
+  '@types/node@22.20.1':
     dependencies:
       undici-types: 6.21.0
 
@@ -1661,66 +1922,186 @@ snapshots:
     dependencies:
       '@types/webidl-conversions': 7.0.3
 
-  '@vitest/expect@4.1.4':
+  '@typescript/typescript-aix-ppc64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-darwin-arm64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-darwin-x64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-freebsd-arm64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-freebsd-x64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-linux-arm64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-linux-arm@7.0.2':
+    optional: true
+
+  '@typescript/typescript-linux-loong64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-linux-mips64el@7.0.2':
+    optional: true
+
+  '@typescript/typescript-linux-ppc64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-linux-riscv64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-linux-s390x@7.0.2':
+    optional: true
+
+  '@typescript/typescript-linux-x64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-netbsd-arm64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-netbsd-x64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-openbsd-arm64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-openbsd-x64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-sunos-x64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-win32-arm64@7.0.2':
+    optional: true
+
+  '@typescript/typescript-win32-x64@7.0.2':
+    optional: true
+
+  '@vitest/expect@4.1.10':
     dependencies:
       '@standard-schema/spec': 1.1.0
       '@types/chai': 5.2.3
-      '@vitest/spy': 4.1.4
-      '@vitest/utils': 4.1.4
+      '@vitest/spy': 4.1.10
+      '@vitest/utils': 4.1.10
       chai: 6.2.2
-      tinyrainbow: 3.1.0
+      tinyrainbow: 3.1.1
 
-  '@vitest/mocker@4.1.4(vite@7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2))':
+  '@vitest/mocker@4.1.10(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0))':
     dependencies:
-      '@vitest/spy': 4.1.4
+      '@vitest/spy': 4.1.10
       estree-walker: 3.0.3
       magic-string: 0.30.21
     optionalDependencies:
-      vite: 7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2)
+      vite: 7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0)
 
-  '@vitest/pretty-format@4.1.4':
+  '@vitest/pretty-format@4.1.10':
     dependencies:
-      tinyrainbow: 3.1.0
+      tinyrainbow: 3.1.1
 
-  '@vitest/runner@4.1.4':
+  '@vitest/runner@4.1.10':
     dependencies:
-      '@vitest/utils': 4.1.4
+      '@vitest/utils': 4.1.10
       pathe: 2.0.3
 
-  '@vitest/snapshot@4.1.4':
+  '@vitest/snapshot@4.1.10':
     dependencies:
-      '@vitest/pretty-format': 4.1.4
-      '@vitest/utils': 4.1.4
+      '@vitest/pretty-format': 4.1.10
+      '@vitest/utils': 4.1.10
       magic-string: 0.30.21
       pathe: 2.0.3
 
-  '@vitest/spy@4.1.4': {}
+  '@vitest/spy@4.1.10': {}
 
-  '@vitest/utils@4.1.4':
+  '@vitest/utils@4.1.10':
     dependencies:
-      '@vitest/pretty-format': 4.1.4
+      '@vitest/pretty-format': 4.1.10
       convert-source-map: 2.0.0
-      tinyrainbow: 3.1.0
+      tinyrainbow: 3.1.1
 
-  agent-base@7.1.3: {}
+  '@yuku-codegen/binding-android-arm64@0.8.3':
+    optional: true
 
-  ansi-escapes@7.2.0:
-    dependencies:
-      environment: 1.1.0
+  '@yuku-codegen/binding-darwin-arm64@0.8.3':
+    optional: true
 
-  ansi-regex@6.2.2: {}
+  '@yuku-codegen/binding-darwin-x64@0.8.3':
+    optional: true
 
-  ansi-styles@6.2.3: {}
+  '@yuku-codegen/binding-freebsd-x64@0.8.3':
+    optional: true
 
-  ansis@4.2.0: {}
+  '@yuku-codegen/binding-linux-arm-gnu@0.8.3':
+    optional: true
 
-  assertion-error@2.0.1: {}
+  '@yuku-codegen/binding-linux-arm-musl@0.8.3':
+    optional: true
 
-  ast-kit@3.0.0-beta.1:
-    dependencies:
-      '@babel/parser': 8.0.0-rc.3
-      estree-walker: 3.0.3
-      pathe: 2.0.3
+  '@yuku-codegen/binding-linux-arm64-gnu@0.8.3':
+    optional: true
+
+  '@yuku-codegen/binding-linux-arm64-musl@0.8.3':
+    optional: true
+
+  '@yuku-codegen/binding-linux-x64-gnu@0.8.3':
+    optional: true
+
+  '@yuku-codegen/binding-linux-x64-musl@0.8.3':
+    optional: true
+
+  '@yuku-codegen/binding-win32-arm64@0.8.3':
+    optional: true
+
+  '@yuku-codegen/binding-win32-x64@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-android-arm64@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-darwin-arm64@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-darwin-x64@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-freebsd-x64@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-linux-arm-gnu@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-linux-arm-musl@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-linux-arm64-gnu@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-linux-arm64-musl@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-linux-x64-gnu@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-linux-x64-musl@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-win32-arm64@0.8.3':
+    optional: true
+
+  '@yuku-parser/binding-win32-x64@0.8.3':
+    optional: true
+
+  '@yuku-toolchain/types@0.8.3': {}
+
+  agent-base@7.1.3: {}
+
+  ansis@4.3.1: {}
+
+  assertion-error@2.0.1: {}
 
   async-mutex@0.5.0:
     dependencies:
@@ -1733,8 +2114,6 @@ snapshots:
   bare-events@2.5.4:
     optional: true
 
-  birpc@4.0.0: {}
-
   brace-expansion@5.0.4:
     dependencies:
       balanced-match: 4.0.4
@@ -1749,19 +2128,6 @@ snapshots:
 
   chai@6.2.2: {}
 
-  cli-cursor@5.0.0:
-    dependencies:
-      restore-cursor: 5.1.0
-
-  cli-truncate@5.1.1:
-    dependencies:
-      slice-ansi: 7.1.2
-      string-width: 8.1.1
-
-  colorette@2.0.20: {}
-
-  commander@14.0.3: {}
-
   commondir@1.0.1: {}
 
   convert-source-map@2.0.0: {}
@@ -1770,17 +2136,13 @@ snapshots:
     dependencies:
       ms: 2.1.3
 
-  defu@6.1.6: {}
-
-  dts-resolver@2.1.3: {}
+  defu@6.1.7: {}
 
-  emoji-regex@10.6.0: {}
+  dts-resolver@3.0.0: {}
 
-  empathic@2.0.0: {}
+  empathic@2.0.1: {}
 
-  environment@1.1.0: {}
-
-  es-module-lexer@2.0.0: {}
+  es-module-lexer@2.3.1: {}
 
   esbuild@0.27.7:
     optionalDependencies:
@@ -1813,17 +2175,15 @@ snapshots:
 
   estree-walker@3.0.3:
     dependencies:
-      '@types/estree': 1.0.8
-
-  eventemitter3@5.0.4: {}
+      '@types/estree': 1.0.9
 
-  expect-type@1.3.0: {}
+  expect-type@1.4.0: {}
 
   fast-fifo@1.3.2: {}
 
-  fdir@6.5.0(picomatch@4.0.4):
+  fdir@6.5.0(picomatch@4.0.5):
     optionalDependencies:
-      picomatch: 4.0.4
+      picomatch: 4.0.5
 
   find-cache-dir@3.3.2:
     dependencies:
@@ -1847,9 +2207,7 @@ snapshots:
   fsevents@2.3.3:
     optional: true
 
-  get-east-asian-width@1.4.0: {}
-
-  get-tsconfig@4.13.7:
+  get-tsconfig@5.0.0-beta.5:
     dependencies:
       resolve-pkg-maps: 1.0.0
 
@@ -1859,7 +2217,7 @@ snapshots:
       minipass: 7.1.3
       path-scurry: 2.0.2
 
-  hookable@6.1.0: {}
+  hookable@6.1.1: {}
 
   https-proxy-agent@7.0.6:
     dependencies:
@@ -1870,34 +2228,18 @@ snapshots:
 
   husky@9.1.7: {}
 
-  import-without-cache@0.2.5: {}
-
-  is-fullwidth-code-point@5.1.0:
-    dependencies:
-      get-east-asian-width: 1.4.0
+  import-without-cache@0.4.0: {}
 
   jiti@2.6.1:
     optional: true
 
-  jsesc@3.1.0: {}
-
-  lint-staged@16.4.0:
+  lint-staged@17.3.0:
     dependencies:
-      commander: 14.0.3
-      listr2: 9.0.5
-      picomatch: 4.0.3
+      picomatch: 4.0.5
       string-argv: 0.3.2
-      tinyexec: 1.0.4
-      yaml: 2.8.2
-
-  listr2@9.0.5:
-    dependencies:
-      cli-truncate: 5.1.1
-      colorette: 2.0.20
-      eventemitter3: 5.0.4
-      log-update: 6.1.0
-      rfdc: 1.4.1
-      wrap-ansi: 9.0.2
+      tinyexec: 1.3.0
+    optionalDependencies:
+      yaml: 2.9.0
 
   locate-path@5.0.0:
     dependencies:
@@ -1905,14 +2247,6 @@ snapshots:
 
   lodash.mergewith@4.6.2: {}
 
-  log-update@6.1.0:
-    dependencies:
-      ansi-escapes: 7.2.0
-      cli-cursor: 5.0.0
-      slice-ansi: 7.1.2
-      strip-ansi: 7.1.2
-      wrap-ansi: 9.0.2
-
   lru-cache@11.2.7: {}
 
   magic-string@0.30.21:
@@ -1925,8 +2259,6 @@ snapshots:
 
   memory-pager@1.5.0: {}
 
-  mimic-function@5.0.1: {}
-
   minimatch@10.2.4:
     dependencies:
       brace-expansion: 5.0.4
@@ -1984,7 +2316,7 @@ snapshots:
 
   ms@2.1.3: {}
 
-  nanoid@3.3.11: {}
+  nanoid@3.3.16: {}
 
   new-find-package-json@2.0.0:
     dependencies:
@@ -1992,11 +2324,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  obug@2.1.1: {}
-
-  onetime@7.0.0:
-    dependencies:
-      mimic-function: 5.0.1
+  obug@2.1.4: {}
 
   p-limit@2.3.0:
     dependencies:
@@ -2023,17 +2351,15 @@ snapshots:
 
   picocolors@1.1.1: {}
 
-  picomatch@4.0.3: {}
-
-  picomatch@4.0.4: {}
+  picomatch@4.0.5: {}
 
   pkg-dir@4.2.0:
     dependencies:
       find-up: 4.1.0
 
-  postcss@8.5.9:
+  postcss@8.5.25:
     dependencies:
-      nanoid: 3.3.11
+      nanoid: 3.3.16
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
@@ -2043,37 +2369,26 @@ snapshots:
 
   resolve-pkg-maps@1.0.0: {}
 
-  restore-cursor@5.1.0:
-    dependencies:
-      onetime: 7.0.0
-      signal-exit: 4.1.0
-
-  rfdc@1.4.1: {}
-
   rimraf@6.1.3:
     dependencies:
       glob: 13.0.6
       package-json-from-dist: 1.0.1
 
-  rolldown-plugin-dts@0.23.2(rolldown@1.0.0-rc.12(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0))(typescript@5.9.3):
-    dependencies:
-      '@babel/generator': 8.0.0-rc.3
-      '@babel/helper-validator-identifier': 8.0.0-rc.3
-      '@babel/parser': 8.0.0-rc.3
-      '@babel/types': 8.0.0-rc.3
-      ast-kit: 3.0.0-beta.1
-      birpc: 4.0.0
-      dts-resolver: 2.1.3
-      get-tsconfig: 4.13.7
-      obug: 2.1.1
-      picomatch: 4.0.4
-      rolldown: 1.0.0-rc.12(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)
+  rolldown-plugin-dts@0.27.14(rolldown@1.2.1)(typescript@7.0.2):
+    dependencies:
+      dts-resolver: 3.0.0
+      get-tsconfig: 5.0.0-beta.5
+      obug: 2.1.4
+      rolldown: 1.2.1
+      yuku-ast: 0.8.3
+      yuku-codegen: 0.8.3
+      yuku-parser: 0.8.3
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 7.0.2
     transitivePeerDependencies:
       - oxc-resolver
 
-  rolldown@1.0.0-rc.12(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0):
+  rolldown@1.0.0-rc.12(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3):
     dependencies:
       '@oxc-project/types': 0.122.0
       '@rolldown/pluginutils': 1.0.0-rc.12
@@ -2090,42 +2405,65 @@ snapshots:
       '@rolldown/binding-linux-x64-gnu': 1.0.0-rc.12
       '@rolldown/binding-linux-x64-musl': 1.0.0-rc.12
       '@rolldown/binding-openharmony-arm64': 1.0.0-rc.12
-      '@rolldown/binding-wasm32-wasi': 1.0.0-rc.12(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)
+      '@rolldown/binding-wasm32-wasi': 1.0.0-rc.12(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)
       '@rolldown/binding-win32-arm64-msvc': 1.0.0-rc.12
       '@rolldown/binding-win32-x64-msvc': 1.0.0-rc.12
     transitivePeerDependencies:
       - '@emnapi/core'
       - '@emnapi/runtime'
+    optional: true
 
-  rollup@4.60.1:
+  rolldown@1.2.1:
     dependencies:
-      '@types/estree': 1.0.8
+      '@oxc-project/types': 0.142.0
+      '@rolldown/pluginutils': 1.0.1
+    optionalDependencies:
+      '@rolldown/binding-android-arm64': 1.2.1
+      '@rolldown/binding-darwin-arm64': 1.2.1
+      '@rolldown/binding-darwin-x64': 1.2.1
+      '@rolldown/binding-freebsd-x64': 1.2.1
+      '@rolldown/binding-linux-arm-gnueabihf': 1.2.1
+      '@rolldown/binding-linux-arm64-gnu': 1.2.1
+      '@rolldown/binding-linux-arm64-musl': 1.2.1
+      '@rolldown/binding-linux-ppc64-gnu': 1.2.1
+      '@rolldown/binding-linux-s390x-gnu': 1.2.1
+      '@rolldown/binding-linux-x64-gnu': 1.2.1
+      '@rolldown/binding-linux-x64-musl': 1.2.1
+      '@rolldown/binding-openharmony-arm64': 1.2.1
+      '@rolldown/binding-wasm32-wasi': 1.2.1
+      '@rolldown/binding-win32-arm64-msvc': 1.2.1
+      '@rolldown/binding-win32-x64-msvc': 1.2.1
+
+  rollup@4.62.4:
+    dependencies:
+      '@types/estree': 1.0.9
     optionalDependencies:
-      '@rollup/rollup-android-arm-eabi': 4.60.1
-      '@rollup/rollup-android-arm64': 4.60.1
-      '@rollup/rollup-darwin-arm64': 4.60.1
-      '@rollup/rollup-darwin-x64': 4.60.1
-      '@rollup/rollup-freebsd-arm64': 4.60.1
-      '@rollup/rollup-freebsd-x64': 4.60.1
-      '@rollup/rollup-linux-arm-gnueabihf': 4.60.1
-      '@rollup/rollup-linux-arm-musleabihf': 4.60.1
-      '@rollup/rollup-linux-arm64-gnu': 4.60.1
-      '@rollup/rollup-linux-arm64-musl': 4.60.1
-      '@rollup/rollup-linux-loong64-gnu': 4.60.1
-      '@rollup/rollup-linux-loong64-musl': 4.60.1
-      '@rollup/rollup-linux-ppc64-gnu': 4.60.1
-      '@rollup/rollup-linux-ppc64-musl': 4.60.1
-      '@rollup/rollup-linux-riscv64-gnu': 4.60.1
-      '@rollup/rollup-linux-riscv64-musl': 4.60.1
-      '@rollup/rollup-linux-s390x-gnu': 4.60.1
-      '@rollup/rollup-linux-x64-gnu': 4.60.1
-      '@rollup/rollup-linux-x64-musl': 4.60.1
-      '@rollup/rollup-openbsd-x64': 4.60.1
-      '@rollup/rollup-openharmony-arm64': 4.60.1
-      '@rollup/rollup-win32-arm64-msvc': 4.60.1
-      '@rollup/rollup-win32-ia32-msvc': 4.60.1
-      '@rollup/rollup-win32-x64-gnu': 4.60.1
-      '@rollup/rollup-win32-x64-msvc': 4.60.1
+      '@napi-rs/lzma-linux-x64-gnu': 1.5.1
+      '@rollup/rollup-android-arm-eabi': 4.62.4
+      '@rollup/rollup-android-arm64': 4.62.4
+      '@rollup/rollup-darwin-arm64': 4.62.4
+      '@rollup/rollup-darwin-x64': 4.62.4
+      '@rollup/rollup-freebsd-arm64': 4.62.4
+      '@rollup/rollup-freebsd-x64': 4.62.4
+      '@rollup/rollup-linux-arm-gnueabihf': 4.62.4
+      '@rollup/rollup-linux-arm-musleabihf': 4.62.4
+      '@rollup/rollup-linux-arm64-gnu': 4.62.4
+      '@rollup/rollup-linux-arm64-musl': 4.62.4
+      '@rollup/rollup-linux-loong64-gnu': 4.62.4
+      '@rollup/rollup-linux-loong64-musl': 4.62.4
+      '@rollup/rollup-linux-ppc64-gnu': 4.62.4
+      '@rollup/rollup-linux-ppc64-musl': 4.62.4
+      '@rollup/rollup-linux-riscv64-gnu': 4.62.4
+      '@rollup/rollup-linux-riscv64-musl': 4.62.4
+      '@rollup/rollup-linux-s390x-gnu': 4.62.4
+      '@rollup/rollup-linux-x64-gnu': 4.62.4
+      '@rollup/rollup-linux-x64-musl': 4.62.4
+      '@rollup/rollup-openbsd-x64': 4.62.4
+      '@rollup/rollup-openharmony-arm64': 4.62.4
+      '@rollup/rollup-win32-arm64-msvc': 4.62.4
+      '@rollup/rollup-win32-ia32-msvc': 4.62.4
+      '@rollup/rollup-win32-x64-gnu': 4.62.4
+      '@rollup/rollup-win32-x64-msvc': 4.62.4
       fsevents: 2.3.3
 
   semver@6.3.1: {}
@@ -2134,13 +2472,6 @@ snapshots:
 
   siginfo@2.0.0: {}
 
-  signal-exit@4.1.0: {}
-
-  slice-ansi@7.1.2:
-    dependencies:
-      ansi-styles: 6.2.3
-      is-fullwidth-code-point: 5.1.0
-
   source-map-js@1.2.1: {}
 
   sparse-bitfield@3.0.3:
@@ -2149,7 +2480,7 @@ snapshots:
 
   stackback@0.0.2: {}
 
-  std-env@4.0.0: {}
+  std-env@4.2.0: {}
 
   streamx@2.22.0:
     dependencies:
@@ -2160,21 +2491,6 @@ snapshots:
 
   string-argv@0.3.2: {}
 
-  string-width@7.2.0:
-    dependencies:
-      emoji-regex: 10.6.0
-      get-east-asian-width: 1.4.0
-      strip-ansi: 7.1.2
-
-  string-width@8.1.1:
-    dependencies:
-      get-east-asian-width: 1.4.0
-      strip-ansi: 7.1.2
-
-  strip-ansi@7.1.2:
-    dependencies:
-      ansi-regex: 6.2.2
-
   tar-stream@3.1.7:
     dependencies:
       b4a: 1.6.7
@@ -2187,21 +2503,14 @@ snapshots:
 
   tinybench@2.9.0: {}
 
-  tinyexec@1.0.4: {}
-
-  tinyexec@1.1.1: {}
-
-  tinyglobby@0.2.15:
-    dependencies:
-      fdir: 6.5.0(picomatch@4.0.4)
-      picomatch: 4.0.4
+  tinyexec@1.3.0: {}
 
-  tinyglobby@0.2.16:
+  tinyglobby@0.2.17:
     dependencies:
-      fdir: 6.5.0(picomatch@4.0.4)
-      picomatch: 4.0.4
+      fdir: 6.5.0(picomatch@4.0.5)
+      picomatch: 4.0.5
 
-  tinyrainbow@3.1.0: {}
+  tinyrainbow@3.1.1: {}
 
   tr46@5.1.0:
     dependencies:
@@ -2209,42 +2518,60 @@ snapshots:
 
   tree-kill@1.2.2: {}
 
-  ts-essentials@10.1.1(typescript@5.9.3):
+  ts-essentials@10.2.1(typescript@7.0.2):
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 7.0.2
 
-  tsdown@0.21.7(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)(typescript@5.9.3):
+  tsdown@0.22.14(typescript@7.0.2)(unrun@0.2.34(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)):
     dependencies:
-      ansis: 4.2.0
+      ansis: 4.3.1
       cac: 7.0.0
-      defu: 6.1.6
-      empathic: 2.0.0
-      hookable: 6.1.0
-      import-without-cache: 0.2.5
-      obug: 2.1.1
-      picomatch: 4.0.4
-      rolldown: 1.0.0-rc.12(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)
-      rolldown-plugin-dts: 0.23.2(rolldown@1.0.0-rc.12(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0))(typescript@5.9.3)
-      semver: 7.7.4
-      tinyexec: 1.0.4
-      tinyglobby: 0.2.15
+      defu: 6.1.7
+      empathic: 2.0.1
+      hookable: 6.1.1
+      import-without-cache: 0.4.0
+      obug: 2.1.4
+      picomatch: 4.0.5
+      rolldown: 1.2.1
+      rolldown-plugin-dts: 0.27.14(rolldown@1.2.1)(typescript@7.0.2)
+      tinyexec: 1.3.0
+      tinyglobby: 0.2.17
       tree-kill: 1.2.2
       unconfig-core: 7.5.0
-      unrun: 0.2.34(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)
+      verkit: 0.3.1
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 7.0.2
+      unrun: 0.2.34(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)
     transitivePeerDependencies:
-      - '@emnapi/core'
-      - '@emnapi/runtime'
-      - '@ts-macro/tsc'
       - '@typescript/native-preview'
+      - '@volar/typescript'
       - oxc-resolver
-      - synckit
       - vue-tsc
 
   tslib@2.8.1: {}
 
-  typescript@5.9.3: {}
+  typescript@7.0.2:
+    optionalDependencies:
+      '@typescript/typescript-aix-ppc64': 7.0.2
+      '@typescript/typescript-darwin-arm64': 7.0.2
+      '@typescript/typescript-darwin-x64': 7.0.2
+      '@typescript/typescript-freebsd-arm64': 7.0.2
+      '@typescript/typescript-freebsd-x64': 7.0.2
+      '@typescript/typescript-linux-arm': 7.0.2
+      '@typescript/typescript-linux-arm64': 7.0.2
+      '@typescript/typescript-linux-loong64': 7.0.2
+      '@typescript/typescript-linux-mips64el': 7.0.2
+      '@typescript/typescript-linux-ppc64': 7.0.2
+      '@typescript/typescript-linux-riscv64': 7.0.2
+      '@typescript/typescript-linux-s390x': 7.0.2
+      '@typescript/typescript-linux-x64': 7.0.2
+      '@typescript/typescript-netbsd-arm64': 7.0.2
+      '@typescript/typescript-netbsd-x64': 7.0.2
+      '@typescript/typescript-openbsd-arm64': 7.0.2
+      '@typescript/typescript-openbsd-x64': 7.0.2
+      '@typescript/typescript-sunos-x64': 7.0.2
+      '@typescript/typescript-win32-arm64': 7.0.2
+      '@typescript/typescript-win32-x64': 7.0.2
 
   unconfig-core@7.5.0:
     dependencies:
@@ -2253,57 +2580,60 @@ snapshots:
 
   undici-types@6.21.0: {}
 
-  unrun@0.2.34(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0):
+  unrun@0.2.34(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3):
     dependencies:
-      rolldown: 1.0.0-rc.12(@emnapi/core@1.9.0)(@emnapi/runtime@1.9.0)
+      rolldown: 1.0.0-rc.12(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)
     transitivePeerDependencies:
       - '@emnapi/core'
       - '@emnapi/runtime'
+    optional: true
+
+  verkit@0.3.1: {}
 
-  vite@7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2):
+  vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0):
     dependencies:
       esbuild: 0.27.7
-      fdir: 6.5.0(picomatch@4.0.4)
-      picomatch: 4.0.4
-      postcss: 8.5.9
-      rollup: 4.60.1
-      tinyglobby: 0.2.16
+      fdir: 6.5.0(picomatch@4.0.5)
+      picomatch: 4.0.5
+      postcss: 8.5.25
+      rollup: 4.62.4
+      tinyglobby: 0.2.17
     optionalDependencies:
-      '@types/node': 20.19.31
+      '@types/node': 22.20.1
       fsevents: 2.3.3
       jiti: 2.6.1
-      yaml: 2.8.2
+      yaml: 2.9.0
 
-  vitest-mock-extended@4.0.0(typescript@5.9.3)(vitest@4.1.4(@types/node@20.19.31)(vite@7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2))):
+  vitest-mock-extended@5.1.1(typescript@7.0.2)(vitest@4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0))):
     dependencies:
-      ts-essentials: 10.1.1(typescript@5.9.3)
-      typescript: 5.9.3
-      vitest: 4.1.4(@types/node@20.19.31)(vite@7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2))
+      ts-essentials: 10.2.1(typescript@7.0.2)
+      typescript: 7.0.2
+      vitest: 4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0))
 
-  vitest@4.1.4(@types/node@20.19.31)(vite@7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2)):
+  vitest@4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0)):
     dependencies:
-      '@vitest/expect': 4.1.4
-      '@vitest/mocker': 4.1.4(vite@7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2))
-      '@vitest/pretty-format': 4.1.4
-      '@vitest/runner': 4.1.4
-      '@vitest/snapshot': 4.1.4
-      '@vitest/spy': 4.1.4
-      '@vitest/utils': 4.1.4
-      es-module-lexer: 2.0.0
-      expect-type: 1.3.0
+      '@vitest/expect': 4.1.10
+      '@vitest/mocker': 4.1.10(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0))
+      '@vitest/pretty-format': 4.1.10
+      '@vitest/runner': 4.1.10
+      '@vitest/snapshot': 4.1.10
+      '@vitest/spy': 4.1.10
+      '@vitest/utils': 4.1.10
+      es-module-lexer: 2.3.1
+      expect-type: 1.4.0
       magic-string: 0.30.21
-      obug: 2.1.1
+      obug: 2.1.4
       pathe: 2.0.3
-      picomatch: 4.0.4
-      std-env: 4.0.0
+      picomatch: 4.0.5
+      std-env: 4.2.0
       tinybench: 2.9.0
-      tinyexec: 1.1.1
-      tinyglobby: 0.2.16
-      tinyrainbow: 3.1.0
-      vite: 7.3.1(@types/node@20.19.31)(jiti@2.6.1)(yaml@2.8.2)
+      tinyexec: 1.3.0
+      tinyglobby: 0.2.17
+      tinyrainbow: 3.1.1
+      vite: 7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0)
       why-is-node-running: 2.3.0
     optionalDependencies:
-      '@types/node': 20.19.31
+      '@types/node': 22.20.1
     transitivePeerDependencies:
       - msw
 
@@ -2319,15 +2649,49 @@ snapshots:
       siginfo: 2.0.0
       stackback: 0.0.2
 
-  wrap-ansi@9.0.2:
-    dependencies:
-      ansi-styles: 6.2.3
-      string-width: 7.2.0
-      strip-ansi: 7.1.2
-
-  yaml@2.8.2: {}
+  yaml@2.9.0:
+    optional: true
 
   yauzl@3.2.0:
     dependencies:
       buffer-crc32: 0.2.13
       pend: 1.2.0
+
+  yuku-ast@0.8.3:
+    dependencies:
+      '@yuku-toolchain/types': 0.8.3
+
+  yuku-codegen@0.8.3:
+    dependencies:
+      '@yuku-toolchain/types': 0.8.3
+    optionalDependencies:
+      '@yuku-codegen/binding-android-arm64': 0.8.3
+      '@yuku-codegen/binding-darwin-arm64': 0.8.3
+      '@yuku-codegen/binding-darwin-x64': 0.8.3
+      '@yuku-codegen/binding-freebsd-x64': 0.8.3
+      '@yuku-codegen/binding-linux-arm-gnu': 0.8.3
+      '@yuku-codegen/binding-linux-arm-musl': 0.8.3
+      '@yuku-codegen/binding-linux-arm64-gnu': 0.8.3
+      '@yuku-codegen/binding-linux-arm64-musl': 0.8.3
+      '@yuku-codegen/binding-linux-x64-gnu': 0.8.3
+      '@yuku-codegen/binding-linux-x64-musl': 0.8.3
+      '@yuku-codegen/binding-win32-arm64': 0.8.3
+      '@yuku-codegen/binding-win32-x64': 0.8.3
+
+  yuku-parser@0.8.3:
+    dependencies:
+      '@yuku-toolchain/types': 0.8.3
+      yuku-ast: 0.8.3
+    optionalDependencies:
+      '@yuku-parser/binding-android-arm64': 0.8.3
+      '@yuku-parser/binding-darwin-arm64': 0.8.3
+      '@yuku-parser/binding-darwin-x64': 0.8.3
+      '@yuku-parser/binding-freebsd-x64': 0.8.3
+      '@yuku-parser/binding-linux-arm-gnu': 0.8.3
+      '@yuku-parser/binding-linux-arm-musl': 0.8.3
+      '@yuku-parser/binding-linux-arm64-gnu': 0.8.3
+      '@yuku-parser/binding-linux-arm64-musl': 0.8.3
+      '@yuku-parser/binding-linux-x64-gnu': 0.8.3
+      '@yuku-parser/binding-linux-x64-musl': 0.8.3
+      '@yuku-parser/binding-win32-arm64': 0.8.3
+      '@yuku-parser/binding-win32-x64': 0.8.3
diff --git a/tsconfig.base.json b/tsconfig.base.json
index bce8f12..da4bd9f 100644
--- a/tsconfig.base.json
+++ b/tsconfig.base.json
@@ -18,6 +18,8 @@
     "module": "NodeNext",
     "moduleResolution": "nodenext",
 
-    "lib": ["es2022"]
+    "lib": ["es2022"],
+
+    "types": ["node"]
   }
 }

From 485c8b45d4595dd430a1f251294117146c49d401 Mon Sep 17 00:00:00 2001
From: Darren Picard <darren.picard@neofinancial.com>
Date: Sun, 2 Aug 2026 15:40:31 -0600
Subject: [PATCH 6/8] Downgrade typescript to 6 as 7 was not working well in
 editor

---
 package.json   |   2 +-
 pnpm-lock.yaml | 237 ++++---------------------------------------------
 2 files changed, 19 insertions(+), 220 deletions(-)

diff --git a/package.json b/package.json
index d1b79b8..0e2122a 100644
--- a/package.json
+++ b/package.json
@@ -31,7 +31,7 @@
     "lint-staged": "^17.3.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.22.14",
-    "typescript": "^7.0.2",
+    "typescript": "^6.0.3",
     "vitest": "^4.1.10",
     "vitest-mock-extended": "^5.1.1"
   }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fd4c9ef..b31f5bb 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -31,16 +31,16 @@ importers:
         version: 6.1.3
       tsdown:
         specifier: ^0.22.14
-        version: 0.22.14(typescript@7.0.2)(unrun@0.2.34(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3))
+        version: 0.22.14(typescript@6.0.3)(unrun@0.2.34(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3))
       typescript:
-        specifier: ^7.0.2
-        version: 7.0.2
+        specifier: ^6.0.3
+        version: 6.0.3
       vitest:
         specifier: ^4.1.10
         version: 4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0))
       vitest-mock-extended:
         specifier: ^5.1.1
-        version: 5.1.1(typescript@7.0.2)(vitest@4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0)))
+        version: 5.1.1(typescript@6.0.3)(vitest@4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0)))
 
   examples/sample-memory-datastore-app:
     dependencies:
@@ -686,126 +686,6 @@ packages:
   '@types/whatwg-url@11.0.5':
     resolution: {integrity: sha512-coYR071JRaHa+xoEvvYqvnIHaVqaYrLPbsufM9BF63HkwI5Lgmy2QR8Q5K/lYDYo5AK82wOvSOS0UsLTpTG7uQ==}
 
-  '@typescript/typescript-aix-ppc64@7.0.2':
-    resolution: {integrity: sha512-MTKKkWB7p/0E9xi1d1tHtZ5PiLkGEMIq88pK2CubZjOsLtYTLqhgIgi6zepFa+9GHZ6h05NMCkQxGKiPXMxXtQ==}
-    engines: {node: '>=16.20.0'}
-    cpu: [ppc64]
-    os: [aix]
-
-  '@typescript/typescript-darwin-arm64@7.0.2':
-    resolution: {integrity: sha512-gowzar9MwS/aRWp6f3a4KUqzRjAZjOsmGNCM6LcTgXum+dBfgsBVMN+AgvOCCbguXyick6LJhpBszxMebJ8syA==}
-    engines: {node: '>=16.20.0'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@typescript/typescript-darwin-x64@7.0.2':
-    resolution: {integrity: sha512-SZ9xZInqApNlNGc9s0W1VSsktYSOe9cFqNOIqmN1Gs8SmkjKZYFt017G4VwPxASInODuAdbTW7sXiFUf893RgA==}
-    engines: {node: '>=16.20.0'}
-    cpu: [x64]
-    os: [darwin]
-
-  '@typescript/typescript-freebsd-arm64@7.0.2':
-    resolution: {integrity: sha512-W5NH4y/J0plIIS5b2xvTEkU7JFxyqdMAOgf+Ilhl0vHQXKO5dZoxd+C/jEtq56c4F3wk71RB4BMRQ2XdI+bwYQ==}
-    engines: {node: '>=16.20.0'}
-    cpu: [arm64]
-    os: [freebsd]
-
-  '@typescript/typescript-freebsd-x64@7.0.2':
-    resolution: {integrity: sha512-UMGDx5sTpzNw3WiPebH7l90IWfJggEd+egHt/q6p7/Cm3zqoV7VxkGXt+3DxPIw8CcmvAB0j3sVVfbhX+M4Tpw==}
-    engines: {node: '>=16.20.0'}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@typescript/typescript-linux-arm64@7.0.2':
-    resolution: {integrity: sha512-Qh4eU4/y3yDjnfjjyPYihMj5/ODIlmt+Bzu17OI+fiSRDW57QmU5SiN63exPRNJPKUzcc1INa1NXdrJ+MqHjUQ==}
-    engines: {node: '>=16.20.0'}
-    cpu: [arm64]
-    os: [linux]
-
-  '@typescript/typescript-linux-arm@7.0.2':
-    resolution: {integrity: sha512-gffT3xPz9sR7j/YJExkyPntrI0P2EP9XbOyWzth2/Gs0RstK+90RBcO0ncXoXy/beYll1SXw846Nf2zdnEz0QQ==}
-    engines: {node: '>=16.20.0'}
-    cpu: [arm]
-    os: [linux]
-
-  '@typescript/typescript-linux-loong64@7.0.2':
-    resolution: {integrity: sha512-uEHck9i8hoAzXPiYRib1O7miOnz23SxIeVl6F4LXox+qov1K35jHcEW6VHKvZI+pyvl7fZEP4MCU5LYvIq1GuQ==}
-    engines: {node: '>=16.20.0'}
-    cpu: [loong64]
-    os: [linux]
-
-  '@typescript/typescript-linux-mips64el@7.0.2':
-    resolution: {integrity: sha512-R4KvAMnE43W5Qeqb0Ly56O3mWMWIAgsMyz36DCaycd5nbg/9kzm0liw3JocfRqyJY0KPmzFjbswozXyW0DnIYA==}
-    engines: {node: '>=16.20.0'}
-    cpu: [mips64el]
-    os: [linux]
-
-  '@typescript/typescript-linux-ppc64@7.0.2':
-    resolution: {integrity: sha512-DORx5b3sd/4S7eayxm4FQv+A7CrkUIGRaHiwI8oiHTAI1fAPWhF4J0vAlkC8biAlHSVVwxMQ3tjZ2/DVbnQiiA==}
-    engines: {node: '>=16.20.0'}
-    cpu: [ppc64]
-    os: [linux]
-
-  '@typescript/typescript-linux-riscv64@7.0.2':
-    resolution: {integrity: sha512-wf0jqEDOjrPRnKwYRyyJDRo11KMbvMFrU+q4zqKyChODBzvlkbhNQfKvLxQCcwTpdDaXSHZTVuh0JoCrKCUMHQ==}
-    engines: {node: '>=16.20.0'}
-    cpu: [riscv64]
-    os: [linux]
-
-  '@typescript/typescript-linux-s390x@7.0.2':
-    resolution: {integrity: sha512-IkwJc3L7yhytWd/ewjyxNDfOmswCm9GWMJT/ue/dU4aZNbwZeYAetq42VyLmsmSjvoX7z74X6ZaYCtzAr0EuGw==}
-    engines: {node: '>=16.20.0'}
-    cpu: [s390x]
-    os: [linux]
-
-  '@typescript/typescript-linux-x64@7.0.2':
-    resolution: {integrity: sha512-EYdf2cNg7rgCWJnxCdJ+F3V39O8ihb37eHAu1LK8oAFizgTQbPOK7zHHXbPt8rX24COqODXeI3sIf0fCXG7H/A==}
-    engines: {node: '>=16.20.0'}
-    cpu: [x64]
-    os: [linux]
-
-  '@typescript/typescript-netbsd-arm64@7.0.2':
-    resolution: {integrity: sha512-+polYF4MF04aPpO5FTkHran9yUQDSXqy5GiSDKpsll5jy3l3+g9QLhpf39T+ePtefhXLOGrLl0QIjkQP6VnelA==}
-    engines: {node: '>=16.20.0'}
-    cpu: [arm64]
-    os: [netbsd]
-
-  '@typescript/typescript-netbsd-x64@7.0.2':
-    resolution: {integrity: sha512-8YIT0EHM/3dq10ZOVF/A7pc/YSMtbcecct4rWtexrnSCHOPcpC2KTLXfTCR6vDpnSiY12heNb1GiN/wu+T/FyA==}
-    engines: {node: '>=16.20.0'}
-    cpu: [x64]
-    os: [netbsd]
-
-  '@typescript/typescript-openbsd-arm64@7.0.2':
-    resolution: {integrity: sha512-APT8+ClYnuYm1u9+kgGXoMj2VzWzcymwh2gNSQVySHfkRDGOTVkoWLjCmOQSaO+PoqQ57B0flRp9SA+7GnnkzQ==}
-    engines: {node: '>=16.20.0'}
-    cpu: [arm64]
-    os: [openbsd]
-
-  '@typescript/typescript-openbsd-x64@7.0.2':
-    resolution: {integrity: sha512-yX7s+Q0Dln0Dt9tEzZsAjXXR/+ytBM7AlglaqyeMPxQszJ1JhlJdZ6jLA+IzldHtflX81em7lDao1xXu+aRRkg==}
-    engines: {node: '>=16.20.0'}
-    cpu: [x64]
-    os: [openbsd]
-
-  '@typescript/typescript-sunos-x64@7.0.2':
-    resolution: {integrity: sha512-dLJDGaLZ1D4HPQn62u1n8mBDkJREwMsAkCdkwd4Ieqw+x3TUyTsqY0YiBCtE6H6OzzgGk3iuZ3vFWRS+E8/d1g==}
-    engines: {node: '>=16.20.0'}
-    cpu: [x64]
-    os: [sunos]
-
-  '@typescript/typescript-win32-arm64@7.0.2':
-    resolution: {integrity: sha512-Gyl1Vy6OsWesLzmq+EP0Fb7b4Nid5232AvcA2SFcdYreldpNtYFFofPjnt62y9hQy7VTaZp65ICJjuAQRaVcIQ==}
-    engines: {node: '>=16.20.0'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@typescript/typescript-win32-x64@7.0.2':
-    resolution: {integrity: sha512-0BQ3HkAHHlKLSp1qRvf3SUhGpGsDuhB/jgFw75guyqbxJqEaS0Cw/VFO8i2nHglJUzQCRtMMR/IBAKE3ETMC4g==}
-    engines: {node: '>=16.20.0'}
-    cpu: [x64]
-    os: [win32]
-
   '@vitest/expect@4.1.10':
     resolution: {integrity: sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==}
 
@@ -1416,9 +1296,9 @@ packages:
   tslib@2.8.1:
     resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
-  typescript@7.0.2:
-    resolution: {integrity: sha512-8FYau96o3NKOhbjKi/qNvG/W5jhzxkbdm5sj9AbZ/5T5sWqn3hJgLfGx27sRKZWTvyzCP8dLRBTf5tBTSRVUNA==}
-    engines: {node: '>=16.20.0'}
+  typescript@6.0.3:
+    resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
+    engines: {node: '>=14.17'}
     hasBin: true
 
   unconfig-core@7.5.0:
@@ -1922,66 +1802,6 @@ snapshots:
     dependencies:
       '@types/webidl-conversions': 7.0.3
 
-  '@typescript/typescript-aix-ppc64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-darwin-arm64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-darwin-x64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-freebsd-arm64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-freebsd-x64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-linux-arm64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-linux-arm@7.0.2':
-    optional: true
-
-  '@typescript/typescript-linux-loong64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-linux-mips64el@7.0.2':
-    optional: true
-
-  '@typescript/typescript-linux-ppc64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-linux-riscv64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-linux-s390x@7.0.2':
-    optional: true
-
-  '@typescript/typescript-linux-x64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-netbsd-arm64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-netbsd-x64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-openbsd-arm64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-openbsd-x64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-sunos-x64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-win32-arm64@7.0.2':
-    optional: true
-
-  '@typescript/typescript-win32-x64@7.0.2':
-    optional: true
-
   '@vitest/expect@4.1.10':
     dependencies:
       '@standard-schema/spec': 1.1.0
@@ -2374,7 +2194,7 @@ snapshots:
       glob: 13.0.6
       package-json-from-dist: 1.0.1
 
-  rolldown-plugin-dts@0.27.14(rolldown@1.2.1)(typescript@7.0.2):
+  rolldown-plugin-dts@0.27.14(rolldown@1.2.1)(typescript@6.0.3):
     dependencies:
       dts-resolver: 3.0.0
       get-tsconfig: 5.0.0-beta.5
@@ -2384,7 +2204,7 @@ snapshots:
       yuku-codegen: 0.8.3
       yuku-parser: 0.8.3
     optionalDependencies:
-      typescript: 7.0.2
+      typescript: 6.0.3
     transitivePeerDependencies:
       - oxc-resolver
 
@@ -2518,11 +2338,11 @@ snapshots:
 
   tree-kill@1.2.2: {}
 
-  ts-essentials@10.2.1(typescript@7.0.2):
+  ts-essentials@10.2.1(typescript@6.0.3):
     optionalDependencies:
-      typescript: 7.0.2
+      typescript: 6.0.3
 
-  tsdown@0.22.14(typescript@7.0.2)(unrun@0.2.34(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)):
+  tsdown@0.22.14(typescript@6.0.3)(unrun@0.2.34(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)):
     dependencies:
       ansis: 4.3.1
       cac: 7.0.0
@@ -2533,14 +2353,14 @@ snapshots:
       obug: 2.1.4
       picomatch: 4.0.5
       rolldown: 1.2.1
-      rolldown-plugin-dts: 0.27.14(rolldown@1.2.1)(typescript@7.0.2)
+      rolldown-plugin-dts: 0.27.14(rolldown@1.2.1)(typescript@6.0.3)
       tinyexec: 1.3.0
       tinyglobby: 0.2.17
       tree-kill: 1.2.2
       unconfig-core: 7.5.0
       verkit: 0.3.1
     optionalDependencies:
-      typescript: 7.0.2
+      typescript: 6.0.3
       unrun: 0.2.34(@emnapi/core@2.0.0-alpha.3)(@emnapi/runtime@2.0.0-alpha.3)
     transitivePeerDependencies:
       - '@typescript/native-preview'
@@ -2550,28 +2370,7 @@ snapshots:
 
   tslib@2.8.1: {}
 
-  typescript@7.0.2:
-    optionalDependencies:
-      '@typescript/typescript-aix-ppc64': 7.0.2
-      '@typescript/typescript-darwin-arm64': 7.0.2
-      '@typescript/typescript-darwin-x64': 7.0.2
-      '@typescript/typescript-freebsd-arm64': 7.0.2
-      '@typescript/typescript-freebsd-x64': 7.0.2
-      '@typescript/typescript-linux-arm': 7.0.2
-      '@typescript/typescript-linux-arm64': 7.0.2
-      '@typescript/typescript-linux-loong64': 7.0.2
-      '@typescript/typescript-linux-mips64el': 7.0.2
-      '@typescript/typescript-linux-ppc64': 7.0.2
-      '@typescript/typescript-linux-riscv64': 7.0.2
-      '@typescript/typescript-linux-s390x': 7.0.2
-      '@typescript/typescript-linux-x64': 7.0.2
-      '@typescript/typescript-netbsd-arm64': 7.0.2
-      '@typescript/typescript-netbsd-x64': 7.0.2
-      '@typescript/typescript-openbsd-arm64': 7.0.2
-      '@typescript/typescript-openbsd-x64': 7.0.2
-      '@typescript/typescript-sunos-x64': 7.0.2
-      '@typescript/typescript-win32-arm64': 7.0.2
-      '@typescript/typescript-win32-x64': 7.0.2
+  typescript@6.0.3: {}
 
   unconfig-core@7.5.0:
     dependencies:
@@ -2604,10 +2403,10 @@ snapshots:
       jiti: 2.6.1
       yaml: 2.9.0
 
-  vitest-mock-extended@5.1.1(typescript@7.0.2)(vitest@4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0))):
+  vitest-mock-extended@5.1.1(typescript@6.0.3)(vitest@4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0))):
     dependencies:
-      ts-essentials: 10.2.1(typescript@7.0.2)
-      typescript: 7.0.2
+      ts-essentials: 10.2.1(typescript@6.0.3)
+      typescript: 6.0.3
       vitest: 4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0))
 
   vitest@4.1.10(@types/node@22.20.1)(vite@7.3.1(@types/node@22.20.1)(jiti@2.6.1)(yaml@2.9.0)):

From 65f7ab4ef53dcef209284aedc6bee8357b701fe4 Mon Sep 17 00:00:00 2001
From: Darren Picard <darren.picard@neofinancial.com>
Date: Sun, 2 Aug 2026 15:57:15 -0600
Subject: [PATCH 7/8] update actions to reflect node versions

---
 .github/workflows/ci.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a4eae52..158c776 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,8 +15,7 @@ jobs:
     timeout-minutes: 10
     strategy:
       matrix:
-        # 22.22.2+ toolcache ships a broken global npm (missing promise-retry); pin until fixed upstream.
-        node-version: [20.x, 22.22.1, 24.x]
+        node-version: [22.x, 24.x, 26.x]
 
     steps:
       - name: Perform source code checkout

From 77c1cfb26c15fef4dcf27079c9e9278e5c65137f Mon Sep 17 00:00:00 2001
From: Darren Picard <darren.picard@neofinancial.com>
Date: Sun, 2 Aug 2026 16:01:27 -0600
Subject: [PATCH 8/8] Addressing wiz vulnerability

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 158c776..16e4b9b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -41,7 +41,7 @@ jobs:
         run: |
           npm install -g npm@11.2.0
           npm install -g pnpm@10.30.0
-          pnpm install
+          pnpm install --ignore-scripts
 
       - name: Build
         run: pnpm run build