@requence/event-sourcing 1.5.0 → 1.5.1

package/dist/chunk-fpjnk143.js

@@ -0,0 +1,13 @@
+// src/superjson.ts
+import SuperJSON from "superjson";
+var superjson2 = new SuperJSON;
+function extendTypes2(handler) {
+  handler(superjson2);
+}
+function clone2(obj) {
+  return superjson2.deserialize(superjson2.serialize(obj));
+}
+
+export { superjson2, extendTypes2, clone2 };
+
+//# debugId=3B62D845BB126E8B64756E2164756E21

package/dist/{chunk-6q8mr1sg.js.map → chunk-fpjnk143.js.map}

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import SuperJSON from 'superjson'\n\nexport const superjson = new SuperJSON()\n\nexport function extendTypes(handler: (superjson: SuperJSON) => void) {\n  handler(superjson)\n}\n\nexport function clone<T>(obj: T): T {\n  return superjson.deserialize(superjson.serialize(obj))\n}\n"
   ],
-  "mappings": ";AAAA;AAEO,IAAM,YAAY,IAAI;AAEtB,SAAS,WAAW,CAAC,SAAyC;AAAA,EACnE,QAAQ,SAAS;AAAA;AAGZ,SAAS,KAAQ,CAAC,KAAW;AAAA,EAClC,OAAO,UAAU,YAAY,UAAU,UAAU,GAAG,CAAC;AAAA;",
-  "debugId": "97ED416FCC5782E564756E2164756E21",
+  "mappings": ";AAAA;AAEO,IAAM,aAAY,IAAI;AAEtB,SAAS,YAAW,CAAC,SAAyC;AAAA,EACnE,QAAQ,UAAS;AAAA;AAGZ,SAAS,MAAQ,CAAC,KAAW;AAAA,EAClC,OAAO,WAAU,YAAY,WAAU,UAAU,GAAG,CAAC;AAAA;",
+  "debugId": "3B62D845BB126E8B64756E2164756E21",
   "names": []
 }

package/dist/{chunk-8qn1nqnh.js → chunk-fxb9fbvz.js}

@@ -1,6 +1,6 @@
 import {
-  ValidationError
-} from "./chunk-391m4mfp.js";
+  ValidationError2
+} from "./chunk-jw9e0fr0.js";
 
 // src/snapshotGenerator.ts
 import { z } from "zod/v4";
@@ -9,7 +9,7 @@ function createSnapshotGenerator(schemas = [], config = null, applier = null, ca
     async internalApply(snapshot) {
       const result = z.union(schemas.map(({ schema }) => schema)).safeParse(snapshot.state);
       if (!result.success) {
-        throw new ValidationError(`loaded snapshot version ${snapshot.schemaVersion} does not comply with registered schema`, result.error);
+        throw new ValidationError2(`loaded snapshot version ${snapshot.schemaVersion} does not comply with registered schema`, result.error);
       }
       await applier(snapshot);
     },
@@ -20,7 +20,7 @@ function createSnapshotGenerator(schemas = [], config = null, applier = null, ca
       const latestSchema = schemas.slice(1).reduce((latest, schema) => schema.schemaVersion > latest.schemaVersion ? schema : latest, schemas[0]);
       const result = latestSchema.schema.safeParse(await capturer(event));
       if (!result.success) {
-        throw new ValidationError(`generated snapshot does not comply with schema for version ${latestSchema.schemaVersion}`, result.error);
+        throw new ValidationError2(`generated snapshot does not comply with schema for version ${latestSchema.schemaVersion}`, result.error);
       }
       return {
         state: result.data,
@@ -34,11 +34,11 @@ function createSnapshotGenerator(schemas = [], config = null, applier = null, ca
       schemas.push({ schemaVersion: schemaVersion ?? 0, schema });
       return createSnapshotGenerator(schemas, config, null, null);
     },
-    apply(applier2) {
-      return createSnapshotGenerator(schemas, config, applier2, capturer);
+    apply(applier) {
+      return createSnapshotGenerator(schemas, config, applier, capturer);
     },
-    capture(capturer2) {
-      return createSnapshotGenerator(schemas, config, applier, capturer2);
+    capture(capturer) {
+      return createSnapshotGenerator(schemas, config, applier, capturer);
     },
     complete: true
   };
@@ -46,4 +46,4 @@ function createSnapshotGenerator(schemas = [], config = null, applier = null, ca
 
 export { createSnapshotGenerator };
 
-//# debugId=53092F13C54E882C64756E2164756E21
+//# debugId=CB4E2325706333DE64756E2164756E21

package/dist/{chunk-8qn1nqnh.js.map → chunk-fxb9fbvz.js.map}

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import { z } from 'zod/v4'\n\nimport { ValidationError } from './errors.ts'\nimport type {\n  BaseOutputEvent,\n  Keys,\n  Max,\n  MaybePromise,\n  Merge,\n} from './utilityTypes.js'\n\ntype RegisteredSnapshotSchemas = { schemaVersion: number; schema: z.ZodType }\n\ntype LatestSnapshotSchemaInput<\n  T extends RegisteredSnapshotSchemas,\n  M = Max<T['schemaVersion']>,\n> = T extends { schemaVersion: M } ? z.input<T['schema']> : never\n\ntype OutputSnapshot<T extends RegisteredSnapshotSchemas> = T extends {\n  schemaVersion: infer V\n  schema: infer S\n}\n  ? {\n      schemaVersion: V\n      state: z.output<S>\n      createdAt: Date\n    }\n  : never\n\ntype SnapshotApplier<Base, T extends RegisteredSnapshotSchemas> = (\n  snapshot: OutputSnapshot<T> & Base,\n) => MaybePromise<void>\ntype SnapshotCapturer<T extends RegisteredSnapshotSchemas> = (\n  event: BaseOutputEvent,\n) => MaybePromise<LatestSnapshotSchemaInput<T> | undefined | null | void>\n\nexport type SnapshotGenerator<\n  Base,\n  Schemas extends RegisteredSnapshotSchemas = never,\n  Flags extends {\n    every: boolean\n    apply: boolean\n    capture: boolean\n    schema: boolean\n  } = {\n    every: false\n    apply: true\n    capture: true\n    schema: false\n  },\n> = {\n  every(\n    count: number,\n  ): Omit<\n    SnapshotGenerator<Base, Schemas, Merge<Flags, { every: true }>>,\n    Keys<Merge<Flags, { every: true }>>\n  >\n  schema<Schema extends z.ZodType, V extends number = 0>(\n    schema: Schema,\n    schemaVersion?: V,\n  ): Omit<\n    SnapshotGenerator<\n      Base,\n      Schemas | { schemaVersion: V; schema: Schema },\n      Merge<Flags, { apply: false; capture: false }>\n    >,\n    Keys<Merge<Flags, { apply: false; capture: false }>>\n  >\n  apply(\n    applier: SnapshotApplier<Base, Schemas>,\n  ): Omit<\n    SnapshotGenerator<\n      Base,\n      Schemas,\n      Merge<Flags, { apply: true; schema: true }>\n    >,\n    Keys<Merge<Flags, { apply: true; schema: true }>>\n  >\n  capture(\n    capturer: SnapshotCapturer<Schemas>,\n  ): Omit<\n    SnapshotGenerator<\n      Base,\n      Schemas,\n      Merge<Flags, { capture: true; schema: true }>\n    >,\n    Keys<Merge<Flags, { capture: true; schema: true }>>\n  >\n  readonly complete: Flags['schema'] extends true\n    ? Flags['capture'] extends true\n      ? Flags['apply'] extends true\n        ? true\n        : false\n      : false\n    : false\n}\n\nexport type InternalSnapshotGenerator = {\n  internalApply: (snapshot: OutputSnapshot<any>) => Promise<void>\n  internalCapture: (\n    event: BaseOutputEvent,\n    applied: number,\n  ) => Promise<null | { state: any; version: number }>\n}\n\nexport type CompleteSnapshotGenerator = Omit<\n  SnapshotGenerator<\n    any,\n    RegisteredSnapshotSchemas,\n    { every: true; apply: true; capture: true; schema: true }\n  >,\n  'schema' | 'capture' | 'apply' | 'every'\n>\n\nexport default function createSnapshotGenerator<Base>(\n  schemas: Array<RegisteredSnapshotSchemas> = [],\n  config: { every: number } | null = null,\n  applier:\n    | ((snapshot: OutputSnapshot<any>) => MaybePromise<void>)\n    | null = null,\n  capturer: ((event: BaseOutputEvent) => any) | null = null,\n): CompleteSnapshotGenerator {\n  return {\n    async internalApply(snapshot) {\n      const result = z\n        .union(schemas.map(({ schema }) => schema))\n        .safeParse(snapshot.state)\n\n      if (!result.success) {\n        throw new ValidationError(\n          `loaded snapshot version ${snapshot.schemaVersion} does not comply with registered schema`,\n          result.error,\n        )\n      }\n\n      await applier!(snapshot)\n    },\n    async internalCapture(event, applied) {\n      if (!config || applied % config.every !== 0) {\n        return null\n      }\n\n      const latestSchema = schemas\n        .slice(1)\n        .reduce(\n          (latest, schema) =>\n            schema.schemaVersion > latest.schemaVersion ? schema : latest,\n          schemas[0],\n        )\n\n      const result = latestSchema.schema.safeParse(await capturer!(event))\n\n      if (!result.success) {\n        throw new ValidationError(\n          `generated snapshot does not comply with schema for version ${latestSchema.schemaVersion}`,\n          result.error,\n        )\n      }\n\n      return {\n        state: result.data,\n        version: latestSchema.schemaVersion,\n      }\n    },\n    every(count) {\n      return createSnapshotGenerator(\n        schemas,\n        { every: count },\n        applier,\n        capturer,\n      )\n    },\n    schema(schema, schemaVersion) {\n      schemas.push({ schemaVersion: schemaVersion ?? 0, schema })\n      return createSnapshotGenerator(schemas, config, null, null) as any\n    },\n    apply(applier) {\n      return createSnapshotGenerator(schemas, config, applier as any, capturer)\n    },\n    capture(capturer) {\n      return createSnapshotGenerator(schemas, config, applier, capturer as any)\n    },\n    complete: true,\n  } as SnapshotGenerator<\n    Base,\n    RegisteredSnapshotSchemas,\n    { capture: true; apply: true; every: true; schema: true }\n  > &\n    InternalSnapshotGenerator\n}\n"
   ],
-  "mappings": ";;;;;AAAA;AAkHA,SAAwB,uBAA6B,CACnD,UAA4C,CAAC,GAC7C,SAAmC,MACnC,UAEW,MACX,WAAqD,MAC1B;AAAA,EAC3B,OAAO;AAAA,SACC,cAAa,CAAC,UAAU;AAAA,MAC5B,MAAM,SAAS,EACZ,MAAM,QAAQ,IAAI,GAAG,aAAa,MAAM,CAAC,EACzC,UAAU,SAAS,KAAK;AAAA,MAE3B,IAAI,CAAC,OAAO,SAAS;AAAA,QACnB,MAAM,IAAI,gBACR,2BAA2B,SAAS,wDACpC,OAAO,KACT;AAAA,MACF;AAAA,MAEA,MAAM,QAAS,QAAQ;AAAA;AAAA,SAEnB,gBAAe,CAAC,OAAO,SAAS;AAAA,MACpC,IAAI,CAAC,UAAU,UAAU,OAAO,UAAU,GAAG;AAAA,QAC3C,OAAO;AAAA,MACT;AAAA,MAEA,MAAM,eAAe,QAClB,MAAM,CAAC,EACP,OACC,CAAC,QAAQ,WACP,OAAO,gBAAgB,OAAO,gBAAgB,SAAS,QACzD,QAAQ,EACV;AAAA,MAEF,MAAM,SAAS,aAAa,OAAO,UAAU,MAAM,SAAU,KAAK,CAAC;AAAA,MAEnE,IAAI,CAAC,OAAO,SAAS;AAAA,QACnB,MAAM,IAAI,gBACR,8DAA8D,aAAa,iBAC3E,OAAO,KACT;AAAA,MACF;AAAA,MAEA,OAAO;AAAA,QACL,OAAO,OAAO;AAAA,QACd,SAAS,aAAa;AAAA,MACxB;AAAA;AAAA,IAEF,KAAK,CAAC,OAAO;AAAA,MACX,OAAO,wBACL,SACA,EAAE,OAAO,MAAM,GACf,SACA,QACF;AAAA;AAAA,IAEF,MAAM,CAAC,QAAQ,eAAe;AAAA,MAC5B,QAAQ,KAAK,EAAE,eAAe,iBAAiB,GAAG,OAAO,CAAC;AAAA,MAC1D,OAAO,wBAAwB,SAAS,QAAQ,MAAM,IAAI;AAAA;AAAA,IAE5D,KAAK,CAAC,UAAS;AAAA,MACb,OAAO,wBAAwB,SAAS,QAAQ,UAAgB,QAAQ;AAAA;AAAA,IAE1E,OAAO,CAAC,WAAU;AAAA,MAChB,OAAO,wBAAwB,SAAS,QAAQ,SAAS,SAAe;AAAA;AAAA,IAE1E,UAAU;AAAA,EACZ;AAAA;",
-  "debugId": "53092F13C54E882C64756E2164756E21",
+  "mappings": ";;;;;AAAA;AAkHA,SAAwB,uBAA6B,CACnD,UAA4C,CAAC,GAC7C,SAAmC,MACnC,UAEW,MACX,WAAqD,MAC1B;AAAA,EAC3B,OAAO;AAAA,SACC,cAAa,CAAC,UAAU;AAAA,MAC5B,MAAM,SAAS,EACZ,MAAM,QAAQ,IAAI,GAAG,aAAa,MAAM,CAAC,EACzC,UAAU,SAAS,KAAK;AAAA,MAE3B,IAAI,CAAC,OAAO,SAAS;AAAA,QACnB,MAAM,IAAI,iBACR,2BAA2B,SAAS,wDACpC,OAAO,KACT;AAAA,MACF;AAAA,MAEA,MAAM,QAAS,QAAQ;AAAA;AAAA,SAEnB,gBAAe,CAAC,OAAO,SAAS;AAAA,MACpC,IAAI,CAAC,UAAU,UAAU,OAAO,UAAU,GAAG;AAAA,QAC3C,OAAO;AAAA,MACT;AAAA,MAEA,MAAM,eAAe,QAClB,MAAM,CAAC,EACP,OACC,CAAC,QAAQ,WACP,OAAO,gBAAgB,OAAO,gBAAgB,SAAS,QACzD,QAAQ,EACV;AAAA,MAEF,MAAM,SAAS,aAAa,OAAO,UAAU,MAAM,SAAU,KAAK,CAAC;AAAA,MAEnE,IAAI,CAAC,OAAO,SAAS;AAAA,QACnB,MAAM,IAAI,iBACR,8DAA8D,aAAa,iBAC3E,OAAO,KACT;AAAA,MACF;AAAA,MAEA,OAAO;AAAA,QACL,OAAO,OAAO;AAAA,QACd,SAAS,aAAa;AAAA,MACxB;AAAA;AAAA,IAEF,KAAK,CAAC,OAAO;AAAA,MACX,OAAO,wBACL,SACA,EAAE,OAAO,MAAM,GACf,SACA,QACF;AAAA;AAAA,IAEF,MAAM,CAAC,QAAQ,eAAe;AAAA,MAC5B,QAAQ,KAAK,EAAE,eAAe,iBAAiB,GAAG,OAAO,CAAC;AAAA,MAC1D,OAAO,wBAAwB,SAAS,QAAQ,MAAM,IAAI;AAAA;AAAA,IAE5D,KAAK,CAAC,SAAS;AAAA,MACb,OAAO,wBAAwB,SAAS,QAAQ,SAAgB,QAAQ;AAAA;AAAA,IAE1E,OAAO,CAAC,UAAU;AAAA,MAChB,OAAO,wBAAwB,SAAS,QAAQ,SAAS,QAAe;AAAA;AAAA,IAE1E,UAAU;AAAA,EACZ;AAAA;",
+  "debugId": "CB4E2325706333DE64756E2164756E21",
   "names": []
 }

package/dist/chunk-hmvwn02w.js

@@ -0,0 +1,22 @@
+import {
+  RefreshingSkipError2
+} from "./chunk-jw9e0fr0.js";
+
+// src/refresh.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var refreshStore = new AsyncLocalStorage;
+function isRefreshing2() {
+  return refreshStore.getStore() ?? false;
+}
+function withRefreshing2(handler) {
+  return refreshStore.run(true, handler);
+}
+function skipRefreshing2() {
+  if (isRefreshing2()) {
+    throw new RefreshingSkipError2;
+  }
+}
+
+export { isRefreshing2, withRefreshing2, skipRefreshing2 };
+
+//# debugId=67A7F9DE7EDBBD8C64756E2164756E21

package/dist/{chunk-6yrb30rx.js.map → chunk-hmvwn02w.js.map}

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport { RefreshingSkipError } from './errors.ts'\n\nconst refreshStore = new AsyncLocalStorage<boolean>()\n\nexport function isRefreshing() {\n  return refreshStore.getStore() ?? false\n}\n\nexport function withRefreshing<T extends () => any>(handler: T) {\n  return refreshStore.run(true, handler)\n}\n\nexport function skipRefreshing() {\n  if (isRefreshing()) {\n    throw new RefreshingSkipError()\n  }\n}\n"
   ],
-  "mappings": ";;;;;AAAA;AAIA,IAAM,eAAe,IAAI;AAElB,SAAS,YAAY,GAAG;AAAA,EAC7B,OAAO,aAAa,SAAS,KAAK;AAAA;AAG7B,SAAS,cAAmC,CAAC,SAAY;AAAA,EAC9D,OAAO,aAAa,IAAI,MAAM,OAAO;AAAA;AAGhC,SAAS,cAAc,GAAG;AAAA,EAC/B,IAAI,aAAa,GAAG;AAAA,IAClB,MAAM,IAAI;AAAA,EACZ;AAAA;",
-  "debugId": "662B9CB5FCF319E264756E2164756E21",
+  "mappings": ";;;;;AAAA;AAIA,IAAM,eAAe,IAAI;AAElB,SAAS,aAAY,GAAG;AAAA,EAC7B,OAAO,aAAa,SAAS,KAAK;AAAA;AAG7B,SAAS,eAAmC,CAAC,SAAY;AAAA,EAC9D,OAAO,aAAa,IAAI,MAAM,OAAO;AAAA;AAGhC,SAAS,eAAc,GAAG;AAAA,EAC/B,IAAI,cAAa,GAAG;AAAA,IAClB,MAAM,IAAI;AAAA,EACZ;AAAA;",
+  "debugId": "67A7F9DE7EDBBD8C64756E2164756E21",
   "names": []
 }

package/dist/{chunk-ty9bhdvx.js → chunk-j4mwjx07.js}

@@ -1,6 +1,7 @@
 // src/lock.ts
 import { Mutex } from "async-mutex";
-function lock(defaultTtl = 5000) {
+var DEFAULT_LOCK_TTL2 = 5000;
+function lock(defaultTtl = DEFAULT_LOCK_TTL2) {
   const locks = new Map;
   return async (key) => {
     const k = Array.isArray(key) ? key.join(":") : key;
@@ -25,6 +26,7 @@ function lock(defaultTtl = 5000) {
     };
     startTimer(defaultTtl);
     return {
+      ttl: defaultTtl,
       async extend(ttl) {
         if (isReleased) {
           return false;
@@ -48,6 +50,6 @@ function lock(defaultTtl = 5000) {
   };
 }
 
-export { lock };
+export { DEFAULT_LOCK_TTL2, lock };
 
-//# debugId=1272FCF41F0B661064756E2164756E21
+//# debugId=769065B9E0FF5E8F64756E2164756E21

package/dist/chunk-j4mwjx07.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/lock.ts"],
+  "sourcesContent": [
+    "import { Mutex } from 'async-mutex'\n\nexport const DEFAULT_LOCK_TTL = 5000\n\nexport type Lock = {\n  /** Moves the expiry to `ttl` from now (default: half the lock's TTL). */\n  extend(ttl?: number): Promise<boolean>\n  release(): Promise<void>\n  /**\n   * The TTL the lock was taken with. The aggregate root keeps a replay's lock\n   * alive at a quarter of it, and assumes {@link DEFAULT_LOCK_TTL} without it.\n   */\n  ttl?: number\n}\n\nexport type LockCreator = (key: string | string[]) => Promise<Lock>\n\nexport default function lock(defaultTtl = DEFAULT_LOCK_TTL): LockCreator {\n  const locks = new Map<string, Mutex>()\n  return async (key: string | string[]) => {\n    const k = Array.isArray(key) ? key.join(':') : key\n    if (!locks.has(k)) {\n      locks.set(k, new Mutex())\n    }\n\n    const mutex = locks.get(k)!\n\n    const releaseMutex = await mutex.acquire()\n    let isReleased = false\n\n    let timer: ReturnType<typeof setTimeout>\n    const startTimer = (ttl: number) => {\n      timer = setTimeout(() => {\n        if (!isReleased) {\n          console.warn('lock ttl expired for key', k)\n          isReleased = true\n          releaseMutex()\n          if (!mutex.isLocked()) {\n            locks.delete(k)\n          }\n        }\n      }, ttl)\n    }\n\n    startTimer(defaultTtl)\n\n    return {\n      ttl: defaultTtl,\n      async extend(ttl?: number) {\n        if (isReleased) {\n          return false\n        }\n        clearTimeout(timer)\n        startTimer(ttl ?? defaultTtl / 2)\n        return true\n      },\n      async release() {\n        if (isReleased) {\n          return\n        }\n\n        isReleased = true\n        clearTimeout(timer)\n        releaseMutex()\n\n        if (!mutex.isLocked()) {\n          locks.delete(k)\n        }\n      },\n    }\n  }\n}\n"
+  ],
+  "mappings": ";AAAA;AAEO,IAAM,oBAAmB;AAehC,SAAwB,IAAI,CAAC,aAAa,mBAA+B;AAAA,EACvE,MAAM,QAAQ,IAAI;AAAA,EAClB,OAAO,OAAO,QAA2B;AAAA,IACvC,MAAM,IAAI,MAAM,QAAQ,GAAG,IAAI,IAAI,KAAK,GAAG,IAAI;AAAA,IAC/C,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG;AAAA,MACjB,MAAM,IAAI,GAAG,IAAI,KAAO;AAAA,IAC1B;AAAA,IAEA,MAAM,QAAQ,MAAM,IAAI,CAAC;AAAA,IAEzB,MAAM,eAAe,MAAM,MAAM,QAAQ;AAAA,IACzC,IAAI,aAAa;AAAA,IAEjB,IAAI;AAAA,IACJ,MAAM,aAAa,CAAC,QAAgB;AAAA,MAClC,QAAQ,WAAW,MAAM;AAAA,QACvB,IAAI,CAAC,YAAY;AAAA,UACf,QAAQ,KAAK,4BAA4B,CAAC;AAAA,UAC1C,aAAa;AAAA,UACb,aAAa;AAAA,UACb,IAAI,CAAC,MAAM,SAAS,GAAG;AAAA,YACrB,MAAM,OAAO,CAAC;AAAA,UAChB;AAAA,QACF;AAAA,SACC,GAAG;AAAA;AAAA,IAGR,WAAW,UAAU;AAAA,IAErB,OAAO;AAAA,MACL,KAAK;AAAA,WACC,OAAM,CAAC,KAAc;AAAA,QACzB,IAAI,YAAY;AAAA,UACd,OAAO;AAAA,QACT;AAAA,QACA,aAAa,KAAK;AAAA,QAClB,WAAW,OAAO,aAAa,CAAC;AAAA,QAChC,OAAO;AAAA;AAAA,WAEH,QAAO,GAAG;AAAA,QACd,IAAI,YAAY;AAAA,UACd;AAAA,QACF;AAAA,QAEA,aAAa;AAAA,QACb,aAAa,KAAK;AAAA,QAClB,aAAa;AAAA,QAEb,IAAI,CAAC,MAAM,SAAS,GAAG;AAAA,UACrB,MAAM,OAAO,CAAC;AAAA,QAChB;AAAA;AAAA,IAEJ;AAAA;AAAA;",
+  "debugId": "769065B9E0FF5E8F64756E2164756E21",
+  "names": []
+}

package/dist/{chunk-391m4mfp.js → chunk-jw9e0fr0.js}

@@ -1,13 +1,13 @@
 // src/errors.ts
 import z from "zod/v4";
 
-class ConcurrencyError extends Error {
+class ConcurrencyError2 extends Error {
   constructor(streamId, expectedVersion, actualVersion) {
     super(`Concurrency error on ${streamId.stream}(${streamId.id}): expected v${expectedVersion}, actual v${actualVersion}`);
   }
 }
 
-class CheckpointConcurrencyError extends Error {
+class CheckpointConcurrencyError2 extends Error {
   checkpointType;
   name;
   expectedVersion;
@@ -19,7 +19,7 @@ class CheckpointConcurrencyError extends Error {
   }
 }
 
-class ValidationError extends Error {
+class ValidationError2 extends Error {
   zodError;
   constructor(message, zodError) {
     super(`${message}: ${z.prettifyError(zodError)}`);
@@ -27,13 +27,13 @@ class ValidationError extends Error {
   }
 }
 
-class EventValidationError extends ValidationError {
+class EventValidationError2 extends ValidationError2 {
 }
 
-class InfiniteLoopError extends Error {
+class InfiniteLoopError2 extends Error {
 }
 
-class CommandError extends Error {
+class CommandError2 extends Error {
   aggregateRootType;
   commandName;
   streamId;
@@ -47,7 +47,7 @@ class CommandError extends Error {
   }
 }
 
-class ProjectionReplayLoopError extends Error {
+class ProjectionReplayLoopError2 extends Error {
   projection;
   event;
   constructor(message, projection, event) {
@@ -57,13 +57,13 @@ class ProjectionReplayLoopError extends Error {
   }
 }
 
-class RefreshingSkipError extends Error {
+class RefreshingSkipError2 extends Error {
 }
 
-class ReplaySkipError extends Error {
+class ReplaySkipError2 extends Error {
 }
 
-class ProjectionEventHandlerExecutionError extends Error {
+class ProjectionEventHandlerExecutionError2 extends Error {
   projection;
   eventHandler;
   event;
@@ -77,7 +77,7 @@ class ProjectionEventHandlerExecutionError extends Error {
   }
 }
 
-class ProcessManagerEventHandlerExecutionError extends Error {
+class ProcessManagerEventHandlerExecutionError2 extends Error {
   processManager;
   eventHandler;
   event;
@@ -91,6 +91,6 @@ class ProcessManagerEventHandlerExecutionError extends Error {
   }
 }
 
-export { ConcurrencyError, CheckpointConcurrencyError, ValidationError, EventValidationError, InfiniteLoopError, CommandError, ProjectionReplayLoopError, RefreshingSkipError, ReplaySkipError, ProjectionEventHandlerExecutionError, ProcessManagerEventHandlerExecutionError };
+export { ConcurrencyError2, CheckpointConcurrencyError2, ValidationError2, EventValidationError2, InfiniteLoopError2, CommandError2, ProjectionReplayLoopError2, RefreshingSkipError2, ReplaySkipError2, ProjectionEventHandlerExecutionError2, ProcessManagerEventHandlerExecutionError2 };
 
-//# debugId=CD7EE46B2474D0E864756E2164756E21
+//# debugId=42304B5DFE82D88064756E2164756E21

package/dist/{chunk-391m4mfp.js.map → chunk-jw9e0fr0.js.map}

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import z from 'zod/v4'\n\nimport type { BaseOutputEvent, OutputEvent } from './utilityTypes.js'\n\nexport class ConcurrencyError extends Error {\n  constructor(\n    streamId: { stream: string; id: string },\n    expectedVersion: number,\n    actualVersion: number,\n  ) {\n    super(\n      `Concurrency error on ${streamId.stream}(${streamId.id}): expected v${expectedVersion}, actual v${actualVersion}`,\n    )\n  }\n}\n\nexport class CheckpointConcurrencyError extends Error {\n  constructor(\n    public readonly checkpointType: 'projection' | 'processManager',\n    public readonly name: string,\n    public readonly expectedVersion: number | null,\n  ) {\n    super(\n      `Concurrency error on ${checkpointType} checkpoint \"${name}\": expected version ${expectedVersion}, but it was modified by another writer`,\n    )\n  }\n}\n\nexport class ValidationError extends Error {\n  constructor(\n    message: string,\n    public readonly zodError: z.ZodError,\n  ) {\n    super(`${message}: ${z.prettifyError(zodError)}`)\n  }\n}\n\nexport class EventValidationError extends ValidationError {}\n\nexport class InfiniteLoopError extends Error {}\n\nexport class CommandError<T extends Error> extends Error {\n  constructor(\n    public readonly aggregateRootType: string,\n    public readonly commandName: string,\n    public readonly streamId: string,\n    public readonly originalError: T,\n  ) {\n    super(\n      `Error executing command \"${commandName}\" on aggregate root \"${aggregateRootType}\" for stream id \"${streamId}\": ${originalError.message}`,\n    )\n  }\n}\n\nexport class ProjectionReplayLoopError extends Error {\n  constructor(\n    message: string,\n    public readonly projection: { name: string; eventHandler: string },\n    public readonly event: OutputEvent<any>,\n  ) {\n    super(message)\n  }\n}\n\nexport class RefreshingSkipError extends Error {}\n\nexport class ReplaySkipError extends Error {}\n\nexport class ProjectionEventHandlerExecutionError<\n  T extends Error,\n> extends Error {\n  constructor(\n    public readonly projection: string,\n    public readonly eventHandler: string,\n    public readonly event: BaseOutputEvent,\n    public readonly originalError: T,\n  ) {\n    super(\n      `Error execution event handler \"${eventHandler}\" in projection \"${projection}\": ${originalError.message}`,\n    )\n  }\n}\n\nexport class ProcessManagerEventHandlerExecutionError<\n  T extends Error,\n> extends Error {\n  constructor(\n    public readonly processManager: string,\n    public readonly eventHandler: string,\n    public readonly event: BaseOutputEvent,\n    public readonly originalError: T,\n  ) {\n    super(\n      `Error execution event handler \"${eventHandler}\" in process manager \"${processManager}\": ${originalError.message}`,\n    )\n  }\n}\n"
   ],
-  "mappings": ";AAAA;AAAA;AAIO,MAAM,yBAAyB,MAAM;AAAA,EAC1C,WAAW,CACT,UACA,iBACA,eACA;AAAA,IACA,MACE,wBAAwB,SAAS,UAAU,SAAS,kBAAkB,4BAA4B,eACpG;AAAA;AAEJ;AAAA;AAEO,MAAM,mCAAmC,MAAM;AAAA,EAElC;AAAA,EACA;AAAA,EACA;AAAA,EAHlB,WAAW,CACO,gBACA,MACA,iBAChB;AAAA,IACA,MACE,wBAAwB,8BAA8B,2BAA2B,wDACnF;AAAA,IANgB;AAAA,IACA;AAAA,IACA;AAAA;AAMpB;AAAA;AAEO,MAAM,wBAAwB,MAAM;AAAA,EAGvB;AAAA,EAFlB,WAAW,CACT,SACgB,UAChB;AAAA,IACA,MAAM,GAAG,YAAY,EAAE,cAAc,QAAQ,GAAG;AAAA,IAFhC;AAAA;AAIpB;AAAA;AAEO,MAAM,6BAA6B,gBAAgB;AAAC;AAAA;AAEpD,MAAM,0BAA0B,MAAM;AAAC;AAAA;AAEvC,MAAM,qBAAsC,MAAM;AAAA,EAErC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAJlB,WAAW,CACO,mBACA,aACA,UACA,eAChB;AAAA,IACA,MACE,4BAA4B,mCAAmC,qCAAqC,cAAc,cAAc,SAClI;AAAA,IAPgB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAMpB;AAAA;AAEO,MAAM,kCAAkC,MAAM;AAAA,EAGjC;AAAA,EACA;AAAA,EAHlB,WAAW,CACT,SACgB,YACA,OAChB;AAAA,IACA,MAAM,OAAO;AAAA,IAHG;AAAA,IACA;AAAA;AAIpB;AAAA;AAEO,MAAM,4BAA4B,MAAM;AAAC;AAAA;AAEzC,MAAM,wBAAwB,MAAM;AAAC;AAAA;AAErC,MAAM,6CAEH,MAAM;AAAA,EAEI;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAJlB,WAAW,CACO,YACA,cACA,OACA,eAChB;AAAA,IACA,MACE,kCAAkC,gCAAgC,gBAAgB,cAAc,SAClG;AAAA,IAPgB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAMpB;AAAA;AAEO,MAAM,iDAEH,MAAM;AAAA,EAEI;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAJlB,WAAW,CACO,gBACA,cACA,OACA,eAChB;AAAA,IACA,MACE,kCAAkC,qCAAqC,oBAAoB,cAAc,SAC3G;AAAA,IAPgB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAMpB;",
-  "debugId": "CD7EE46B2474D0E864756E2164756E21",
+  "mappings": ";AAAA;AAAA;AAIO,MAAM,0BAAyB,MAAM;AAAA,EAC1C,WAAW,CACT,UACA,iBACA,eACA;AAAA,IACA,MACE,wBAAwB,SAAS,UAAU,SAAS,kBAAkB,4BAA4B,eACpG;AAAA;AAEJ;AAAA;AAEO,MAAM,oCAAmC,MAAM;AAAA,EAElC;AAAA,EACA;AAAA,EACA;AAAA,EAHlB,WAAW,CACO,gBACA,MACA,iBAChB;AAAA,IACA,MACE,wBAAwB,8BAA8B,2BAA2B,wDACnF;AAAA,IANgB;AAAA,IACA;AAAA,IACA;AAAA;AAMpB;AAAA;AAEO,MAAM,yBAAwB,MAAM;AAAA,EAGvB;AAAA,EAFlB,WAAW,CACT,SACgB,UAChB;AAAA,IACA,MAAM,GAAG,YAAY,EAAE,cAAc,QAAQ,GAAG;AAAA,IAFhC;AAAA;AAIpB;AAAA;AAEO,MAAM,8BAA6B,iBAAgB;AAAC;AAAA;AAEpD,MAAM,2BAA0B,MAAM;AAAC;AAAA;AAEvC,MAAM,sBAAsC,MAAM;AAAA,EAErC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAJlB,WAAW,CACO,mBACA,aACA,UACA,eAChB;AAAA,IACA,MACE,4BAA4B,mCAAmC,qCAAqC,cAAc,cAAc,SAClI;AAAA,IAPgB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAMpB;AAAA;AAEO,MAAM,mCAAkC,MAAM;AAAA,EAGjC;AAAA,EACA;AAAA,EAHlB,WAAW,CACT,SACgB,YACA,OAChB;AAAA,IACA,MAAM,OAAO;AAAA,IAHG;AAAA,IACA;AAAA;AAIpB;AAAA;AAEO,MAAM,6BAA4B,MAAM;AAAC;AAAA;AAEzC,MAAM,yBAAwB,MAAM;AAAC;AAAA;AAErC,MAAM,8CAEH,MAAM;AAAA,EAEI;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAJlB,WAAW,CACO,YACA,cACA,OACA,eAChB;AAAA,IACA,MACE,kCAAkC,gCAAgC,gBAAgB,cAAc,SAClG;AAAA,IAPgB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAMpB;AAAA;AAEO,MAAM,kDAEH,MAAM;AAAA,EAEI;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAJlB,WAAW,CACO,gBACA,cACA,OACA,eAChB;AAAA,IACA,MACE,kCAAkC,qCAAqC,oBAAoB,cAAc,SAC3G;AAAA,IAPgB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAMpB;",
+  "debugId": "42304B5DFE82D88064756E2164756E21",
   "names": []
 }

package/dist/chunk-mbxxvskx.js

@@ -0,0 +1,67 @@
+// src/surreal/schema.ts
+var TABLES2 = {
+  events: "events",
+  counters: "event_sourcing_counters",
+  checkpoints: "checkpoints",
+  aggregateRootSnapshots: "aggregate_root_snapshots",
+  projectionSnapshots: "projection_snapshots",
+  projectionAppliedEvents: "projection_applied_events"
+};
+var SCHEMA_STATEMENTS2 = `
+DEFINE TABLE IF NOT EXISTS ${TABLES2.events} SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS position ON ${TABLES2.events} TYPE int;
+DEFINE FIELD IF NOT EXISTS streamId ON ${TABLES2.events} TYPE string;
+DEFINE FIELD IF NOT EXISTS streamType ON ${TABLES2.events} TYPE string;
+DEFINE FIELD IF NOT EXISTS streamVersion ON ${TABLES2.events} TYPE int;
+DEFINE FIELD IF NOT EXISTS type ON ${TABLES2.events} TYPE string;
+DEFINE FIELD IF NOT EXISTS createdAt ON ${TABLES2.events} TYPE datetime DEFAULT time::now();
+DEFINE FIELD IF NOT EXISTS payload ON ${TABLES2.events} TYPE string;
+DEFINE FIELD IF NOT EXISTS metadata ON ${TABLES2.events} TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS causationId ON ${TABLES2.events} TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS correlationId ON ${TABLES2.events} TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS actorId ON ${TABLES2.events} TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS schemaVersion ON ${TABLES2.events} TYPE int;
+DEFINE INDEX IF NOT EXISTS events_stream_unique ON ${TABLES2.events} FIELDS streamId, streamType, streamVersion UNIQUE;
+DEFINE INDEX IF NOT EXISTS events_position ON ${TABLES2.events} FIELDS position UNIQUE;
+
+DEFINE TABLE IF NOT EXISTS ${TABLES2.counters} SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS value ON ${TABLES2.counters} TYPE int;
+
+DEFINE TABLE IF NOT EXISTS ${TABLES2.checkpoints} SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS type ON ${TABLES2.checkpoints} TYPE string;
+DEFINE FIELD IF NOT EXISTS name ON ${TABLES2.checkpoints} TYPE string;
+DEFINE FIELD IF NOT EXISTS lastEventPosition ON ${TABLES2.checkpoints} TYPE int;
+DEFINE FIELD IF NOT EXISTS metadata ON ${TABLES2.checkpoints} TYPE string;
+DEFINE FIELD IF NOT EXISTS version ON ${TABLES2.checkpoints} TYPE int DEFAULT 0;
+
+DEFINE TABLE IF NOT EXISTS ${TABLES2.aggregateRootSnapshots} SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS streamId ON ${TABLES2.aggregateRootSnapshots} TYPE string;
+DEFINE FIELD IF NOT EXISTS streamType ON ${TABLES2.aggregateRootSnapshots} TYPE string;
+DEFINE FIELD IF NOT EXISTS streamVersion ON ${TABLES2.aggregateRootSnapshots} TYPE int;
+DEFINE FIELD IF NOT EXISTS state ON ${TABLES2.aggregateRootSnapshots} TYPE string;
+DEFINE FIELD IF NOT EXISTS metadata ON ${TABLES2.aggregateRootSnapshots} TYPE string;
+DEFINE FIELD IF NOT EXISTS createdAt ON ${TABLES2.aggregateRootSnapshots} TYPE datetime DEFAULT time::now();
+DEFINE FIELD IF NOT EXISTS lastEventPosition ON ${TABLES2.aggregateRootSnapshots} TYPE int;
+DEFINE FIELD IF NOT EXISTS schemaVersion ON ${TABLES2.aggregateRootSnapshots} TYPE int;
+DEFINE INDEX IF NOT EXISTS aggregate_root_snapshots_unique ON ${TABLES2.aggregateRootSnapshots} FIELDS streamType, streamId, streamVersion UNIQUE;
+
+DEFINE TABLE IF NOT EXISTS ${TABLES2.projectionSnapshots} SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS projectionId ON ${TABLES2.projectionSnapshots} TYPE string;
+DEFINE FIELD IF NOT EXISTS projectionType ON ${TABLES2.projectionSnapshots} TYPE string;
+DEFINE FIELD IF NOT EXISTS state ON ${TABLES2.projectionSnapshots} TYPE string;
+DEFINE FIELD IF NOT EXISTS metadata ON ${TABLES2.projectionSnapshots} TYPE string;
+DEFINE FIELD IF NOT EXISTS createdAt ON ${TABLES2.projectionSnapshots} TYPE datetime DEFAULT time::now();
+DEFINE FIELD IF NOT EXISTS lastEventPosition ON ${TABLES2.projectionSnapshots} TYPE int;
+DEFINE FIELD IF NOT EXISTS schemaVersion ON ${TABLES2.projectionSnapshots} TYPE int;
+DEFINE INDEX IF NOT EXISTS projection_snapshots_unique ON ${TABLES2.projectionSnapshots} FIELDS projectionId, projectionType, lastEventPosition UNIQUE;
+
+DEFINE TABLE IF NOT EXISTS ${TABLES2.projectionAppliedEvents} SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS appliedEvents ON ${TABLES2.projectionAppliedEvents} TYPE int;
+`;
+async function initSchema2(database) {
+  await database.query(SCHEMA_STATEMENTS2);
+}
+
+export { TABLES2, SCHEMA_STATEMENTS2, initSchema2 };
+
+//# debugId=D36A3ED0D642495B64756E2164756E21

package/dist/{chunk-ak901ckt.js.map → chunk-mbxxvskx.js.map}

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import type { Surreal } from 'surrealdb'\n\nexport const TABLES = {\n  events: 'events',\n  counters: 'event_sourcing_counters',\n  checkpoints: 'checkpoints',\n  aggregateRootSnapshots: 'aggregate_root_snapshots',\n  projectionSnapshots: 'projection_snapshots',\n  projectionAppliedEvents: 'projection_applied_events',\n} as const\n\n// Idempotent DDL — safe to run on every boot. All tables are SCHEMAFULL, so\n// SurrealDB rejects writes carrying fields that are not defined here.\nexport const SCHEMA_STATEMENTS = `\nDEFINE TABLE IF NOT EXISTS ${TABLES.events} SCHEMAFULL;\nDEFINE FIELD IF NOT EXISTS position ON ${TABLES.events} TYPE int;\nDEFINE FIELD IF NOT EXISTS streamId ON ${TABLES.events} TYPE string;\nDEFINE FIELD IF NOT EXISTS streamType ON ${TABLES.events} TYPE string;\nDEFINE FIELD IF NOT EXISTS streamVersion ON ${TABLES.events} TYPE int;\nDEFINE FIELD IF NOT EXISTS type ON ${TABLES.events} TYPE string;\nDEFINE FIELD IF NOT EXISTS createdAt ON ${TABLES.events} TYPE datetime DEFAULT time::now();\nDEFINE FIELD IF NOT EXISTS payload ON ${TABLES.events} TYPE string;\nDEFINE FIELD IF NOT EXISTS metadata ON ${TABLES.events} TYPE object FLEXIBLE;\nDEFINE FIELD IF NOT EXISTS causationId ON ${TABLES.events} TYPE option<string>;\nDEFINE FIELD IF NOT EXISTS correlationId ON ${TABLES.events} TYPE option<string>;\nDEFINE FIELD IF NOT EXISTS actorId ON ${TABLES.events} TYPE option<string>;\nDEFINE FIELD IF NOT EXISTS schemaVersion ON ${TABLES.events} TYPE int;\nDEFINE INDEX IF NOT EXISTS events_stream_unique ON ${TABLES.events} FIELDS streamId, streamType, streamVersion UNIQUE;\nDEFINE INDEX IF NOT EXISTS events_position ON ${TABLES.events} FIELDS position UNIQUE;\n\nDEFINE TABLE IF NOT EXISTS ${TABLES.counters} SCHEMAFULL;\nDEFINE FIELD IF NOT EXISTS value ON ${TABLES.counters} TYPE int;\n\nDEFINE TABLE IF NOT EXISTS ${TABLES.checkpoints} SCHEMAFULL;\nDEFINE FIELD IF NOT EXISTS type ON ${TABLES.checkpoints} TYPE string;\nDEFINE FIELD IF NOT EXISTS name ON ${TABLES.checkpoints} TYPE string;\nDEFINE FIELD IF NOT EXISTS lastEventPosition ON ${TABLES.checkpoints} TYPE int;\nDEFINE FIELD IF NOT EXISTS metadata ON ${TABLES.checkpoints} TYPE string;\nDEFINE FIELD IF NOT EXISTS version ON ${TABLES.checkpoints} TYPE int DEFAULT 0;\n\nDEFINE TABLE IF NOT EXISTS ${TABLES.aggregateRootSnapshots} SCHEMAFULL;\nDEFINE FIELD IF NOT EXISTS streamId ON ${TABLES.aggregateRootSnapshots} TYPE string;\nDEFINE FIELD IF NOT EXISTS streamType ON ${TABLES.aggregateRootSnapshots} TYPE string;\nDEFINE FIELD IF NOT EXISTS streamVersion ON ${TABLES.aggregateRootSnapshots} TYPE int;\nDEFINE FIELD IF NOT EXISTS state ON ${TABLES.aggregateRootSnapshots} TYPE string;\nDEFINE FIELD IF NOT EXISTS metadata ON ${TABLES.aggregateRootSnapshots} TYPE string;\nDEFINE FIELD IF NOT EXISTS createdAt ON ${TABLES.aggregateRootSnapshots} TYPE datetime DEFAULT time::now();\nDEFINE FIELD IF NOT EXISTS lastEventPosition ON ${TABLES.aggregateRootSnapshots} TYPE int;\nDEFINE FIELD IF NOT EXISTS schemaVersion ON ${TABLES.aggregateRootSnapshots} TYPE int;\nDEFINE INDEX IF NOT EXISTS aggregate_root_snapshots_unique ON ${TABLES.aggregateRootSnapshots} FIELDS streamType, streamId, streamVersion UNIQUE;\n\nDEFINE TABLE IF NOT EXISTS ${TABLES.projectionSnapshots} SCHEMAFULL;\nDEFINE FIELD IF NOT EXISTS projectionId ON ${TABLES.projectionSnapshots} TYPE string;\nDEFINE FIELD IF NOT EXISTS projectionType ON ${TABLES.projectionSnapshots} TYPE string;\nDEFINE FIELD IF NOT EXISTS state ON ${TABLES.projectionSnapshots} TYPE string;\nDEFINE FIELD IF NOT EXISTS metadata ON ${TABLES.projectionSnapshots} TYPE string;\nDEFINE FIELD IF NOT EXISTS createdAt ON ${TABLES.projectionSnapshots} TYPE datetime DEFAULT time::now();\nDEFINE FIELD IF NOT EXISTS lastEventPosition ON ${TABLES.projectionSnapshots} TYPE int;\nDEFINE FIELD IF NOT EXISTS schemaVersion ON ${TABLES.projectionSnapshots} TYPE int;\nDEFINE INDEX IF NOT EXISTS projection_snapshots_unique ON ${TABLES.projectionSnapshots} FIELDS projectionId, projectionType, lastEventPosition UNIQUE;\n\nDEFINE TABLE IF NOT EXISTS ${TABLES.projectionAppliedEvents} SCHEMAFULL;\nDEFINE FIELD IF NOT EXISTS appliedEvents ON ${TABLES.projectionAppliedEvents} TYPE int;\n`\n\nexport async function initSchema(database: Surreal): Promise<void> {\n  await database.query(SCHEMA_STATEMENTS)\n}\n"
   ],
-  "mappings": ";AAEO,IAAM,SAAS;AAAA,EACpB,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,aAAa;AAAA,EACb,wBAAwB;AAAA,EACxB,qBAAqB;AAAA,EACrB,yBAAyB;AAC3B;AAIO,IAAM,oBAAoB;AAAA,6BACJ,OAAO;AAAA,yCACK,OAAO;AAAA,yCACP,OAAO;AAAA,2CACL,OAAO;AAAA,8CACJ,OAAO;AAAA,qCAChB,OAAO;AAAA,0CACF,OAAO;AAAA,wCACT,OAAO;AAAA,yCACN,OAAO;AAAA,4CACJ,OAAO;AAAA,8CACL,OAAO;AAAA,wCACb,OAAO;AAAA,8CACD,OAAO;AAAA,qDACA,OAAO;AAAA,gDACZ,OAAO;AAAA;AAAA,6BAE1B,OAAO;AAAA,sCACE,OAAO;AAAA;AAAA,6BAEhB,OAAO;AAAA,qCACC,OAAO;AAAA,qCACP,OAAO;AAAA,kDACM,OAAO;AAAA,yCAChB,OAAO;AAAA,wCACR,OAAO;AAAA;AAAA,6BAElB,OAAO;AAAA,yCACK,OAAO;AAAA,2CACL,OAAO;AAAA,8CACJ,OAAO;AAAA,sCACf,OAAO;AAAA,yCACJ,OAAO;AAAA,0CACN,OAAO;AAAA,kDACC,OAAO;AAAA,8CACX,OAAO;AAAA,gEACW,OAAO;AAAA;AAAA,6BAE1C,OAAO;AAAA,6CACS,OAAO;AAAA,+CACL,OAAO;AAAA,sCAChB,OAAO;AAAA,yCACJ,OAAO;AAAA,0CACN,OAAO;AAAA,kDACC,OAAO;AAAA,8CACX,OAAO;AAAA,4DACO,OAAO;AAAA;AAAA,6BAEtC,OAAO;AAAA,8CACU,OAAO;AAAA;AAGrD,eAAsB,UAAU,CAAC,UAAkC;AAAA,EACjE,MAAM,SAAS,MAAM,iBAAiB;AAAA;",
-  "debugId": "577B8C27173DD85B64756E2164756E21",
+  "mappings": ";AAEO,IAAM,UAAS;AAAA,EACpB,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,aAAa;AAAA,EACb,wBAAwB;AAAA,EACxB,qBAAqB;AAAA,EACrB,yBAAyB;AAC3B;AAIO,IAAM,qBAAoB;AAAA,6BACJ,QAAO;AAAA,yCACK,QAAO;AAAA,yCACP,QAAO;AAAA,2CACL,QAAO;AAAA,8CACJ,QAAO;AAAA,qCAChB,QAAO;AAAA,0CACF,QAAO;AAAA,wCACT,QAAO;AAAA,yCACN,QAAO;AAAA,4CACJ,QAAO;AAAA,8CACL,QAAO;AAAA,wCACb,QAAO;AAAA,8CACD,QAAO;AAAA,qDACA,QAAO;AAAA,gDACZ,QAAO;AAAA;AAAA,6BAE1B,QAAO;AAAA,sCACE,QAAO;AAAA;AAAA,6BAEhB,QAAO;AAAA,qCACC,QAAO;AAAA,qCACP,QAAO;AAAA,kDACM,QAAO;AAAA,yCAChB,QAAO;AAAA,wCACR,QAAO;AAAA;AAAA,6BAElB,QAAO;AAAA,yCACK,QAAO;AAAA,2CACL,QAAO;AAAA,8CACJ,QAAO;AAAA,sCACf,QAAO;AAAA,yCACJ,QAAO;AAAA,0CACN,QAAO;AAAA,kDACC,QAAO;AAAA,8CACX,QAAO;AAAA,gEACW,QAAO;AAAA;AAAA,6BAE1C,QAAO;AAAA,6CACS,QAAO;AAAA,+CACL,QAAO;AAAA,sCAChB,QAAO;AAAA,yCACJ,QAAO;AAAA,0CACN,QAAO;AAAA,kDACC,QAAO;AAAA,8CACX,QAAO;AAAA,4DACO,QAAO;AAAA;AAAA,6BAEtC,QAAO;AAAA,8CACU,QAAO;AAAA;AAGrD,eAAsB,WAAU,CAAC,UAAkC;AAAA,EACjE,MAAM,SAAS,MAAM,kBAAiB;AAAA;",
+  "debugId": "D36A3ED0D642495B64756E2164756E21",
   "names": []
 }

package/dist/{chunk-3251p253.js → chunk-nrhw3kde.js}

@@ -1,7 +1,7 @@
 import {
-  CheckpointConcurrencyError,
-  ValidationError
-} from "./chunk-391m4mfp.js";
+  CheckpointConcurrencyError2,
+  ValidationError2
+} from "./chunk-jw9e0fr0.js";
 
 // src/createCheckpointApi.ts
 import z from "zod/v4";
@@ -12,7 +12,7 @@ var checkpointSchema = z.object({
   metadata: z.record(z.string(), z.any()),
   version: z.int()
 });
-function createCheckpointApi(params) {
+function createCheckpointApi2(params) {
   let version = null;
   let position = null;
   const api = {
@@ -91,7 +91,7 @@ function createCheckpointApi(params) {
         }
         const current = await api.load();
         if (mode === "cas") {
-          throw new CheckpointConcurrencyError(params.type, params.name, expectedVersion);
+          throw new CheckpointConcurrencyError2(params.type, params.name, expectedVersion);
         }
         if (current && current.lastEventPosition >= event.position) {
           return;
@@ -104,7 +104,7 @@ function createCheckpointApi(params) {
       if (checkpoint) {
         const result = checkpointSchema.safeParse(checkpoint);
         if (!result.success) {
-          throw new ValidationError(`loaded checkpoint for ${params.type} ${params.name} does not comply with schema`, result.error);
+          throw new ValidationError2(`loaded checkpoint for ${params.type} ${params.name} does not comply with schema`, result.error);
         }
         startPosition = checkpoint.lastEventPosition + 1;
         options.onMetadata?.(checkpoint.metadata);
@@ -134,6 +134,6 @@ function createCheckpointApi(params) {
   return api;
 }
 
-export { createCheckpointApi };
+export { createCheckpointApi2 };
 
-//# debugId=695CE154B107C1B964756E2164756E21
+//# debugId=48393861CC2E414464756E2164756E21

package/dist/{chunk-3251p253.js.map → chunk-nrhw3kde.js.map}

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import z from 'zod/v4'\n\nimport type { LoadEvents } from './createEventStore.ts'\nimport { CheckpointConcurrencyError, ValidationError } from './errors.ts'\nimport type {\n  BaseOutputEvent,\n  MaybePromise,\n  StreamEvents,\n} from './utilityTypes.ts'\n\nconst checkpointSchema = z.object({\n  lastEventPosition: z.int(),\n  type: z.enum(['projection', 'processManager']),\n  name: z.string(),\n  metadata: z.record(z.string(), z.any()),\n  version: z.int(),\n})\n\nexport type Checkpoint = z.output<typeof checkpointSchema>\n\n/**\n * The outcome of {@link CheckpointApi.claim}: either this instance owns the\n * event and must run its work, or another instance already has it.\n */\nexport type ClaimResult =\n  | { claimed: false }\n  | { claimed: true; release: () => Promise<void> }\n\nexport type CheckpointMethods = {\n  get: (\n    type: 'projection' | 'processManager',\n    name: string,\n  ) => MaybePromise<Checkpoint | null | undefined>\n  delete: (\n    type: 'projection' | 'processManager',\n    name: string,\n  ) => MaybePromise<void>\n  /**\n   * Persist a checkpoint using optimistic concurrency control.\n   *\n   * The write must only succeed if the currently stored version equals\n   * `expectedVersion` (or, when `expectedVersion` is `null`, if no checkpoint\n   * exists yet). `checkpoint.version` holds the version to store on success.\n   * Return `true` when the write was applied and `false` when it was rejected\n   * because another writer had advanced the checkpoint in the meantime.\n   */\n  upsert: (\n    checkpoint: Checkpoint,\n    expectedVersion: number | null,\n  ) => MaybePromise<boolean>\n}\n\nexport function createCheckpointApi(\n  params: CheckpointMethods & {\n    loadEvents: LoadEvents\n    relatedStreamEvents: StreamEvents[] | null\n    name: string\n    type: 'processManager' | 'projection'\n    apply: (event: BaseOutputEvent) => MaybePromise<void>\n    applyAfter?: (event: BaseOutputEvent) => MaybePromise<void>\n  },\n) {\n  // In-memory view of the persisted checkpoint version. `null` means \"no\n  // checkpoint has been written yet\". It is kept in sync with the store on\n  // every load/upsert so optimistic-concurrency writes can detect when another\n  // instance has advanced the same checkpoint.\n  let version: number | null = null\n  // The position that goes with `version`. Only {@link CheckpointApi.claim}\n  // needs it, to put the cursor back if the work it claimed then fails.\n  let position: number | null = null\n\n  const api = {\n    relatedStreamEvents: params.relatedStreamEvents,\n    async clear() {\n      await params.delete(params.type, params.name)\n      version = null\n      position = null\n    },\n    /**\n     * Load the persisted checkpoint and sync the local version. Returns the\n     * raw checkpoint (or `null`), so callers can rehydrate their own state\n     * (e.g. a process manager reloading its folded state) from it.\n     */\n    async load() {\n      const checkpoint = await params.get(params.type, params.name)\n      version = checkpoint?.version ?? null\n      position = checkpoint?.lastEventPosition ?? null\n      return checkpoint ?? null\n    },\n    /**\n     * Takes ownership of `event` *before* its work runs, so that exactly one\n     * instance does that work.\n     *\n     * Every instance runs its own copy of a projection against shared storage,\n     * and each decides what it has already applied from a cursor only it can\n     * see. Two instances catching up over the same backlog — or one catching up\n     * while the other applies an event it just appended — therefore both reach\n     * the same handler. Writing the cursor first, through the same\n     * compare-and-swap the ordinary write uses, is what breaks the tie: the\n     * loser is told so and skips the event instead of repeating its side\n     * effects.\n     *\n     * Returns `{ claimed: false }` when another writer already covers this\n     * position. On success the caller gets a `release` to call if the work then\n     * fails, which puts the cursor back so the event is picked up again rather\n     * than silently skipped — without it, claiming would turn every failed\n     * handler into a lost event.\n     */\n    async claim(\n      event: BaseOutputEvent,\n      metadata: Record<string, any> = {},\n    ): Promise<ClaimResult> {\n      while (true) {\n        const expectedVersion = version\n        const previousPosition = position\n        const nextVersion = (expectedVersion ?? -1) + 1\n\n        const committed = await params.upsert(\n          {\n            lastEventPosition: event.position,\n            type: params.type,\n            name: params.name,\n            metadata,\n            version: nextVersion,\n          },\n          expectedVersion,\n        )\n\n        if (committed) {\n          version = nextVersion\n          position = event.position\n\n          return {\n            claimed: true,\n            async release() {\n              // Only undo a claim that is still the newest write. Once anything\n              // else has moved the cursor, rewinding it would drop that work.\n              if (version !== nextVersion) {\n                return\n              }\n\n              if (previousPosition === null) {\n                await api.clear()\n                return\n              }\n\n              const restored = await params.upsert(\n                {\n                  lastEventPosition: previousPosition,\n                  type: params.type,\n                  name: params.name,\n                  metadata,\n                  version: nextVersion + 1,\n                },\n                nextVersion,\n              )\n\n              if (restored) {\n                version = nextVersion + 1\n                position = previousPosition\n              }\n            },\n          }\n        }\n\n        // Another writer advanced this checkpoint. Refresh our view of it.\n        const current = await api.load()\n\n        if (current && current.lastEventPosition >= event.position) {\n          return { claimed: false }\n        }\n      }\n    },\n    /**\n     * Persist the checkpoint position (and optional metadata) for the given\n     * event.\n     *\n     * - `'cas'` (compare-and-swap): the write must land on top of the exact\n     *   version we last observed. If another writer advanced the checkpoint,\n     *   the local version is refreshed and a {@link CheckpointConcurrencyError}\n     *   is thrown so the caller can re-fold its state and retry. Used for\n     *   process managers that fold state into the checkpoint.\n     * - `'monotonic'` (default): retries on conflict, skipping the write once\n     *   the stored position already covers this event. Safe for cursors with\n     *   no derived state (projections, stateless/after-effect writes).\n     */\n    async upsert(\n      event: BaseOutputEvent,\n      metadata: Record<string, any> = {},\n      mode: 'cas' | 'monotonic' = 'monotonic',\n    ) {\n      while (true) {\n        const expectedVersion = version\n        const nextVersion = (expectedVersion ?? -1) + 1\n        const committed = await params.upsert(\n          {\n            lastEventPosition: event.position,\n            type: params.type,\n            name: params.name,\n            metadata,\n            version: nextVersion,\n          },\n          expectedVersion,\n        )\n\n        if (committed) {\n          version = nextVersion\n          position = event.position\n          return\n        }\n\n        // Another writer advanced this checkpoint. Refresh our view of it.\n        const current = await api.load()\n\n        if (mode === 'cas') {\n          throw new CheckpointConcurrencyError(\n            params.type,\n            params.name,\n            expectedVersion,\n          )\n        }\n\n        // monotonic: the stored cursor already covers this event, nothing to do.\n        if (current && current.lastEventPosition >= event.position) {\n          return\n        }\n      }\n    },\n    async rehydrated(\n      options: {\n        onMetadata?: (metadata: Record<string, any>) => unknown\n        getMetadata?: () => Record<string, any>\n        onProgress?: (index: number, event: BaseOutputEvent) => void\n      } = {},\n    ) {\n      const checkpoint = await api.load()\n      let startPosition = 0\n      if (checkpoint) {\n        const result = checkpointSchema.safeParse(checkpoint)\n        if (!result.success) {\n          throw new ValidationError(\n            `loaded checkpoint for ${params.type} ${params.name} does not comply with schema`,\n            result.error,\n          )\n        }\n        startPosition = checkpoint.lastEventPosition + 1\n        options.onMetadata?.(checkpoint.metadata)\n      }\n\n      const events = params.loadEvents(params.relatedStreamEvents, {\n        from: startPosition,\n      })\n\n      let index = 0\n      let lastEvent: BaseOutputEvent | null = null\n      for await (const event of events) {\n        lastEvent = event\n        await params.apply(event)\n        index++\n        options.onProgress?.(index, event)\n      }\n\n      if (!lastEvent) {\n        return // up to date\n      }\n\n      if (params.applyAfter) {\n        for await (const event of events) {\n          await params.applyAfter(event)\n        }\n      }\n\n      await api.upsert(lastEvent, options.getMetadata?.())\n    },\n  }\n\n  return api\n}\n\nexport type CheckpointApi = ReturnType<typeof createCheckpointApi>\n"
   ],
-  "mappings": "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",
-  "debugId": "695CE154B107C1B964756E2164756E21",
+  "mappings": "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",
+  "debugId": "48393861CC2E414464756E2164756E21",
   "names": []
 }

package/dist/{chunk-8edc30gz.js → chunk-pcggjrxr.js}

@@ -1,28 +1,28 @@
 import {
-  lock
-} from "./chunk-ty9bhdvx.js";
-import {
-  unwrapEvent,
-  wrappedEventBuilder
-} from "./chunk-z388cd25.js";
+  createEventListener2
+} from "./chunk-06anxtk6.js";
 import {
-  createEventListener
-} from "./chunk-24xjphpk.js";
+  withRefreshing2
+} from "./chunk-hmvwn02w.js";
 import {
-  buildProjectionCreator
-} from "./chunk-zznvzvnv.js";
+  buildProcessManagerCreator2
+} from "./chunk-d6jqbrq2.js";
 import {
-  buildProcessManagerCreator
-} from "./chunk-kqh3q3fj.js";
+  buildProjectionCreator2
+} from "./chunk-2wqpktzp.js";
 import {
-  withRefreshing
-} from "./chunk-6yrb30rx.js";
+  lock
+} from "./chunk-j4mwjx07.js";
 import {
   createTransaction
-} from "./chunk-pc1q4se9.js";
+} from "./chunk-9qtjz725.js";
+import {
+  unwrapEvent2,
+  wrappedEventBuilder2
+} from "./chunk-zkz6ew8c.js";
 
 // src/createEventStore.ts
-function createEventStore(params) {
+function createEventStore2(params) {
   const transaction = createTransaction();
   const { promise: initialized, resolve: resolveInitialized } = Promise.withResolvers();
   const projections = new Map;
@@ -79,9 +79,9 @@ function createEventStore(params) {
       const processedEvents = events.map((rawEvent) => {
         const event = structuredClone(rawEvent);
         if (params.postProcessEvent) {
-          const wrappedEvent = wrappedEventBuilder(event);
+          const wrappedEvent = wrappedEventBuilder2(event);
           const { aggregateRoot } = aggregatRootsByEvents.get(event.type);
-          const processedEvent = unwrapEvent(params.postProcessEvent(wrappedEvent, aggregateRoot));
+          const processedEvent = unwrapEvent2(params.postProcessEvent(wrappedEvent, aggregateRoot));
           Object.assign(event, processedEvent);
         }
         return event;
@@ -104,13 +104,13 @@ function createEventStore(params) {
     });
     aggregateRoot.linkEventStore(loadEvents, appendEvents, emitEvents, transaction, params.lock ?? lock(5000), params.aggregateRootSnapshot);
   }
-  const baseCreateProjection = buildProjectionCreator({
+  const baseCreateProjection = buildProjectionCreator2({
     loadEvents,
     checkpoint: params.checkpoint,
     snapshot: params.projectionSnapshot,
     onReplay: params.onProjectionReplay
   });
-  const baseCreateProcessManager = buildProcessManagerCreator({
+  const baseCreateProcessManager = buildProcessManagerCreator2({
     loadEvents,
     checkpoint: params.checkpoint,
     onRefresh: params.onProcessManagerRefresh
@@ -153,36 +153,36 @@ function createEventStore(params) {
       if (projections.has(name)) {
         throw new Error(`Projection ${name} is already registered`);
       }
-      const api2 = baseCreateProjection(name);
-      const internalApi = api2;
+      const api = baseCreateProjection(name);
+      const internalApi = api;
       internalApi.setRelatedStreamEvents((handlers) => getRelatedStreamEvents(handlers));
       projections.set(name, internalApi);
       if (initializing) {
         internalApi.init(true);
       }
-      return api2;
+      return api;
     },
     createProcessManager(name, options) {
       if (processManagers.has(name)) {
         throw new Error(`Process Manager ${name} is already registered`);
       }
-      const api2 = baseCreateProcessManager(name, options);
-      const internalApi = api2;
+      const api = baseCreateProcessManager(name, options);
+      const internalApi = api;
       internalApi.setRelatedStreamEvents((handlers) => getRelatedStreamEvents(handlers));
       processManagers.set(name, internalApi);
       if (initializing) {
         internalApi.init(true);
       }
-      return api2;
+      return api;
     },
     createEventListener(name) {
       if (eventListeners.has(name)) {
         throw new Error(`Event Listener ${name} is already registered`);
       }
-      const api2 = createEventListener(name);
-      const internalApi = api2;
+      const api = createEventListener2(name);
+      const internalApi = api;
       eventListeners.set(name, internalApi);
-      return api2;
+      return api;
     },
     async isReady() {
       await initialized;
@@ -202,7 +202,7 @@ function createEventStore(params) {
         ...replayProjections.map((projection) => projection.beginReplay()),
         ...replayProcessManagers.map((processManager) => processManager.beginRefresh())
       ]);
-      await withRefreshing(async () => {
+      await withRefreshing2(async () => {
         let index = 0;
         for await (const event of loadEvents(null)) {
           index++;
@@ -245,6 +245,6 @@ function createEventStore(params) {
   return api;
 }
 
-export { createEventStore };
+export { createEventStore2 };
 
-//# debugId=84A22BB56871CDA264756E2164756E21
+//# debugId=45EED805BC72D1C864756E2164756E21