@requence/event-sourcing 0.0.1 → 1.0.0

package/dist/chunk-m07vf8q9.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/createProcessManager.ts"],
+  "sourcesContent": [
+    "import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport {\n  type CheckpointApi,\n  type CheckpointMethods,\n  createCheckpointApi,\n} from './createCheckpointApi.ts'\nimport type { LoadEvents, OnProgress } from './createEventStore.ts'\nimport {\n  ProcessManagerEventHandlerExecutionError,\n  RefreshingSkipError,\n} from './errors.ts'\nimport { isRefreshing, withRefreshing } from './refresh.ts'\nimport { clone } from './superjson.ts'\nimport type {\n  AfterEffectHandlers,\n  BaseOutputEvent,\n  EventHandlers,\n  EventTemplate,\n  Keys,\n  Merge,\n  StreamEvents,\n} from './utilityTypes.js'\n\ntype ProcessManagerInfo = {\n  name: string\n  event: BaseOutputEvent\n}\nconst processManagerInfoStore = new AsyncLocalStorage<ProcessManagerInfo>()\n\nfunction withProcessManagerInfo(\n  info: ProcessManagerInfo,\n  handler: () => Promise<void>,\n) {\n  return processManagerInfoStore.run(info, handler)\n}\n\nexport function getProcessManagerInfo() {\n  return processManagerInfoStore.getStore()\n}\n\nexport function isInsideProcessManager() {\n  return Boolean(getProcessManagerInfo())\n}\n\ntype ProcessManagerEventHandlers<Events extends EventTemplate> = EventHandlers<\n  Events,\n  { refreshing: boolean }\n>\n\ntype ProcessManagerAfterEffectHandlers<Events extends EventTemplate> =\n  AfterEffectHandlers<Events, { refreshing: boolean }>\n\nexport type InternalProcessManager = {\n  apply: (event: BaseOutputEvent) => Promise<void>\n  applyAfter: (event: BaseOutputEvent) => Promise<void>\n  setRelatedStreamEvents: (\n    generateRelatedStreamEvents: (\n      eventHandlers: EventHandlers<EventTemplate>,\n    ) => StreamEvents[],\n  ) => void\n  isReady(): Promise<void>\n  beginRefresh(): Promise<void>\n  progressRefresh(\n    index: number,\n    event: BaseOutputEvent,\n    after: boolean,\n  ): Promise<void>\n  endRefresh(): void\n  init(catchUp: boolean): Promise<void>\n  hasState(): boolean\n}\n\nexport type ProcessManagerApi<\n  State = never,\n  Events extends EventTemplate = never,\n  Flags extends {\n    withState: boolean\n    withEventHandlers: boolean\n    concurrent: boolean\n    withAfterEffects: boolean\n  } = {\n    withState: false\n    withEventHandlers: false\n    concurrent: false\n    withAfterEffects: false\n  },\n> = {\n  withState: <NextState>(\n    state: NextState,\n  ) => Omit<\n    ProcessManagerApi<NextState, Events, Merge<Flags, { withState: true }>>,\n    Keys<Merge<Flags, { withState: true }>>\n  >\n  withEventHandlers: (\n    handlers: [State] extends [never]\n      ? ProcessManagerEventHandlers<Events>\n      : (state: State) => ProcessManagerEventHandlers<Events>,\n  ) => Omit<\n    ProcessManagerApi<State, Events, Merge<Flags, { withEventHandlers: true }>>,\n    Keys<Merge<Flags, { withEventHandlers: true }>>\n  >\n  withAfterEffects: (\n    handlers: [State] extends [never]\n      ? ProcessManagerAfterEffectHandlers<Events>\n      : (state: State) => ProcessManagerAfterEffectHandlers<Events>,\n  ) => Omit<\n    ProcessManagerApi<State, Events, Merge<Flags, { withAfterEffects: true }>>,\n    Keys<Merge<Flags, { withAfterEffects: true }>>\n  >\n  concurrent: () => Omit<\n    ProcessManagerApi<State, Events, Merge<Flags, { concurrent: true }>>,\n    Keys<Merge<Flags, { concurrent: true }>>\n  >\n  isReady(): Promise<void>\n  $inferState: State\n} & (Flags['withState'] extends true\n  ? {\n      refreshState: () => Promise<void>\n      state: () => Promise<State>\n    }\n  : {})\n\nexport function buildProcessManagerCreator(params: {\n  loadEvents: LoadEvents\n  checkpoint: CheckpointMethods\n  onRefresh?: OnProgress\n}) {\n  return (name: string): ProcessManagerApi => {\n    let idle = true\n    let createEventHandlers: (\n      state: any,\n    ) => ProcessManagerEventHandlers<any> = () => ({})\n    let createAfterEffects: (\n      state: any,\n    ) => ProcessManagerAfterEffectHandlers<any> = () => ({})\n\n    let hasState = false\n    let state: any = null\n    let initialState: any = null\n    let exclusive = true\n    let generateRelatedStreamEvents: (\n      eventHandlers: EventHandlers<any>,\n    ) => StreamEvents[]\n    let checkpointApi: CheckpointApi\n    let lastEventPosition = -1\n    const { promise: hydrated, resolve: resolveHydrated } =\n      Promise.withResolvers<void>()\n\n    const locks = new Map<string, Promise<void>>()\n    const apply = async (\n      event: BaseOutputEvent,\n      after: boolean,\n      hydrating = false,\n    ) => {\n      const handler = after\n        ? createAfterEffects(state)[`after${event.type}`]\n        : createEventHandlers(state)[`on${event.type}`]\n\n      if (!handler) {\n        return Promise.resolve()\n      }\n\n      if (hydrating) {\n        lastEventPosition = event.position\n      } else {\n        await hydrated\n        // event was already applied through hydration\n        if (event.position <= lastEventPosition) {\n          return\n        }\n      }\n      const unlocked = !exclusive\n        ? Promise.resolve()\n        : (locks.get(event.streamId)?.catch(() => {}) ?? Promise.resolve())\n\n      const runner = (async () => {\n        await unlocked\n        const refreshing = isRefreshing()\n        await withProcessManagerInfo(\n          {\n            name,\n            event,\n          },\n          async () => {\n            try {\n              await handler(event, { refreshing })\n            } catch (error) {\n              if (error instanceof RefreshingSkipError) {\n                if (refreshing) {\n                  return\n                }\n\n                throw new Error(\n                  'RefreshingSkipError should never be thrown outside refresh',\n                )\n              }\n\n              if (!(error instanceof Error)) {\n                throw error\n              }\n\n              throw new ProcessManagerEventHandlerExecutionError(\n                name,\n                after ? `after${event.type}` : `on${event.type}`,\n                event,\n                error,\n              )\n            }\n          },\n        )\n        await checkpointApi.upsert(event, { state })\n      })()\n\n      if (exclusive) {\n        locks.set(event.streamId, runner)\n\n        runner\n          .finally(() => {\n            if (locks.get(event.streamId) === runner) {\n              locks.delete(event.streamId)\n            }\n          })\n          .catch(() => {})\n        return runner\n      }\n\n      return Promise.resolve()\n    }\n\n    let resolveRefresh: null | (() => void) = null\n\n    const api = {\n      name,\n      hasState() {\n        return hasState\n      },\n      async isReady() {\n        await hydrated\n      },\n      async apply(event) {\n        await apply(event, false)\n      },\n      async applyAfter(event) {\n        await apply(event, true)\n      },\n      withState(nextState) {\n        state = clone(nextState)\n        initialState = clone(nextState)\n        hasState = true\n        return api as any\n      },\n      concurrent() {\n        exclusive = false\n        return api\n      },\n      withEventHandlers(handlers) {\n        createEventHandlers =\n          typeof handlers === 'function' ? (handlers as any) : () => handlers\n\n        return api\n      },\n      withAfterEffects(handlers) {\n        createAfterEffects =\n          typeof handlers === 'function' ? (handlers as any) : () => handlers\n\n        return api\n      },\n      setRelatedStreamEvents(generate) {\n        generateRelatedStreamEvents = generate\n      },\n      async beginRefresh() {\n        params.onRefresh?.begin?.(name)\n        await checkpointApi.clear()\n        lastEventPosition = -1\n        state = initialState\n      },\n      async progressRefresh(index, event, after) {\n        await apply(event, after, true)\n\n        if (\n          !checkpointApi.relatedStreamEvents ||\n          checkpointApi.relatedStreamEvents.some((streamEvent) =>\n            streamEvent.events.includes(event.type),\n          )\n        ) {\n          params.onRefresh?.progress?.(name, index, event)\n        }\n      },\n      endRefresh() {\n        params.onRefresh?.end?.(name)\n        resolveHydrated()\n      },\n      async refreshState() {\n        if (!idle) {\n          await refresh()\n          return\n        }\n        const { promise, resolve } = Promise.withResolvers<void>()\n        resolveRefresh = resolve\n        return promise\n      },\n      async state() {\n        await hydrated\n        return state\n      },\n      async init(catchUp) {\n        idle = false\n        const relatedStreamEvents = generateRelatedStreamEvents({\n          ...createEventHandlers(null),\n          ...createAfterEffects(null),\n        })\n\n        checkpointApi = createCheckpointApi({\n          ...params.checkpoint,\n          name,\n          relatedStreamEvents,\n          type: 'processManager',\n          loadEvents: params.loadEvents,\n          apply: (event) => apply(event, false, true),\n          applyAfter: (event) => apply(event, true, true),\n        })\n\n        if (resolveRefresh) {\n          await refresh()\n          return\n        }\n        if (!catchUp) {\n          return\n        }\n\n        await checkpointApi.rehydrated({\n          getMetadata() {\n            return { state }\n          },\n          onMetadata(metadata) {\n            state = metadata.state ?? state\n          },\n        })\n\n        resolveHydrated()\n      },\n      $inferState: null as never,\n    } as ProcessManagerApi & InternalProcessManager\n\n    async function refresh() {\n      await withRefreshing(async () => {\n        await api.beginRefresh()\n        await checkpointApi.rehydrated({\n          getMetadata() {\n            return { state }\n          },\n          onProgress(index, event) {\n            params.onRefresh?.progress?.(name, index, event)\n          },\n        })\n      })\n      api.endRefresh()\n    }\n\n    return api\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "F1319F7D0A1BF35E64756E2164756E21",
+  "names": []
+}

package/dist/chunk-ncpk70p4.js

@@ -0,0 +1,313 @@
+import {
+  isReplaying,
+  withReplaying
+} from "./chunk-x90g388y.js";
+import {
+  createCheckpointApi
+} from "./chunk-zf3x573k.js";
+import {
+  createSnapshotGenerator
+} from "./chunk-pmfzjavb.js";
+import {
+  ProjectionEventHandlerExecutionError,
+  ProjectionReplayLoopError,
+  ReplaySkipError,
+  ValidationError
+} from "./chunk-qdczt68t.js";
+
+// src/createProjection.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import z from "zod/v4";
+var hydratingStore = new AsyncLocalStorage;
+function isHydrating() {
+  return hydratingStore.getStore() ?? false;
+}
+async function withHydrating(handler) {
+  await hydratingStore.run(true, handler);
+}
+var projectionInfoStore = new AsyncLocalStorage;
+function withProjectionInfo(info, handler) {
+  return projectionInfoStore.run(info, handler);
+}
+function getProjectionInfo() {
+  return projectionInfoStore.getStore();
+}
+function isInsideProjection() {
+  return Boolean(getProjectionInfo());
+}
+var snapshotSchema = z.object({
+  projectionId: z.string(),
+  projectionType: z.string(),
+  lastEventPosition: z.int(),
+  state: z.unknown(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  schemaVersion: z.int(),
+  createdAt: z.date()
+});
+function buildProjectionCreator(params) {
+  return (name) => {
+    let idle = true;
+    let replaying = false;
+    let handlers = {};
+    let globalEventHandler = null;
+    let generateRelatedStreamEvents;
+    let relatedStreamEvents = null;
+    let exclusive = true;
+    let checkpointApi;
+    let lastEventPosition = -1;
+    let replayConfig = null;
+    let snapshotting = null;
+    const { promise: hydrated, resolve: resolveHydrated } = Promise.withResolvers();
+    const locks = new Map;
+    const apply = async (event) => {
+      const handler = handlers[`on${event.type}`];
+      if (!handler && !globalEventHandler) {
+        return Promise.resolve();
+      }
+      if (isHydrating()) {
+        lastEventPosition = event.position;
+      } else {
+        await hydrated;
+        if (event.position <= lastEventPosition) {
+          return;
+        }
+      }
+      const unlocked = !exclusive ? Promise.resolve() : locks.get(event.streamId)?.catch(() => {}) ?? Promise.resolve();
+      const runner = (async () => {
+        await unlocked;
+        await withProjectionInfo({ name, event }, async () => {
+          try {
+            await handler?.(event, {
+              replaying,
+              async replayUntil(position, filterEvents) {
+                if (position >= event.position) {
+                  throw new ProjectionReplayLoopError(`Event handler on${event.type} of projection ${name} tried to replay to the future`, { name, eventHandler: `on${event.type}` }, event);
+                }
+                locks.delete(event.streamId);
+                return api.replayUntil(event.streamId, position, filterEvents);
+              }
+            });
+          } catch (error) {
+            if (error instanceof ReplaySkipError) {
+              if (isReplaying()) {
+                return;
+              }
+              throw new Error("ReplaySkipError should never be thrown outside replay");
+            }
+            if (!(error instanceof Error) || error instanceof ProjectionReplayLoopError) {
+              throw error;
+            }
+            throw new ProjectionEventHandlerExecutionError(name, `on${event.type}`, event, error);
+          }
+          try {
+            await globalEventHandler?.(event);
+          } catch (error) {
+            if (!(error instanceof Error)) {
+              throw error;
+            }
+            throw new ProjectionEventHandlerExecutionError(name, "GLOBAL", event, error);
+          }
+        });
+        if (params.snapshot && snapshotting) {
+          const appliedEvents = await params.snapshot.incrementAppliedCount({
+            projection: name,
+            id: event.streamId
+          });
+          const snapshot = await snapshotting.internalCapture(event, appliedEvents);
+          if (snapshot) {
+            await params.snapshot.put({
+              projectionType: name,
+              projectionId: event.streamId,
+              lastEventPosition: event.position,
+              state: snapshot.state,
+              schemaVersion: snapshot.version,
+              createdAt: new Date
+            });
+          }
+        }
+        await checkpointApi.upsert(event);
+      })();
+      if (exclusive) {
+        locks.set(event.streamId, runner);
+        runner.finally(() => {
+          if (locks.get(event.streamId) === runner) {
+            locks.delete(event.streamId);
+          }
+        }).catch(() => {});
+        return runner;
+      }
+      return Promise.resolve();
+    };
+    let resolveReplay = null;
+    let resolveReplayOne = null;
+    let replayOneStreamId = null;
+    const api = {
+      name: "projection " + name,
+      async isReady() {
+        await hydrated;
+      },
+      withEventHandlers(h) {
+        handlers = h;
+        return api;
+      },
+      withGlobalEventHandler(handler) {
+        globalEventHandler = handler;
+        return api;
+      },
+      concurrent() {
+        exclusive = false;
+        return api;
+      },
+      setRelatedStreamEvents(generate) {
+        generateRelatedStreamEvents = generate;
+      },
+      withReplay(config) {
+        replayConfig = config;
+        return api;
+      },
+      withSnapshots(handler) {
+        snapshotting = handler(createSnapshotGenerator());
+        return api;
+      },
+      async apply(event) {
+        await apply(event);
+      },
+      async replayOne(streamId) {
+        if (!idle) {
+          await replayOne(streamId);
+          return;
+        }
+        const { promise, resolve } = Promise.withResolvers();
+        resolveReplayOne = resolve;
+        replayOneStreamId = streamId;
+        return promise;
+      },
+      async replay() {
+        if (!idle) {
+          await replay();
+          return;
+        }
+        const { promise, resolve } = Promise.withResolvers();
+        resolveReplay = resolve;
+        return promise;
+      },
+      canReplay() {
+        return Boolean(replayConfig);
+      },
+      async beginReplay() {
+        if (!replayConfig?.deleteAll) {
+          throw new Error("this projection does not support replay all. withReplay({ deleteAll }) not implemented.");
+        }
+        lastEventPosition = -1;
+        params.onReplay?.begin?.(name);
+        await params.snapshot?.delete({ projection: name });
+        await replayConfig.deleteAll();
+      },
+      async progressReplay(index, event) {
+        await withReplaying(() => withHydrating(() => apply(event)));
+        if (!checkpointApi.relatedStreamEvents || checkpointApi.relatedStreamEvents.some((streamEvent) => streamEvent.events.includes(event.type))) {
+          params.onReplay?.progress?.(name, index, event);
+        }
+      },
+      endReplay() {
+        params.onReplay?.end?.(name);
+        resolveHydrated();
+      },
+      async replayUntil(id, position, filterEvents = () => true) {
+        let startPosition = 0;
+        if (snapshotting) {
+          await params.snapshot?.delete({ id, projection: name }, position);
+          const snapshot = await params.snapshot?.get({ id, projection: name });
+          if (snapshot) {
+            const result = snapshotSchema.safeParse(snapshot);
+            if (!result.success) {
+              throw new ValidationError("loaded projection snapshot does not comply with schema", result.error);
+            }
+            snapshotting.internalApply(result.data);
+            startPosition = result.data.lastEventPosition + 1;
+          }
+        }
+        const events = params.loadEvents(relatedStreamEvents?.map((relatedStreamEvent) => ({
+          ...relatedStreamEvent,
+          id
+        })) ?? null, {
+          from: startPosition,
+          to: position
+        });
+        replaying = true;
+        await withReplaying(async () => {
+          for await (const event of events) {
+            if (filterEvents(event)) {
+              await apply(event);
+            }
+          }
+        });
+        replaying = false;
+      },
+      async init(catchUp) {
+        idle = false;
+        relatedStreamEvents = globalEventHandler ? null : generateRelatedStreamEvents(handlers);
+        checkpointApi = createCheckpointApi({
+          ...params.checkpoint,
+          name,
+          relatedStreamEvents,
+          type: "projection",
+          loadEvents: params.loadEvents,
+          apply: (event) => withHydrating(() => apply(event))
+        });
+        if (resolveReplay) {
+          await replay();
+          resolveReplay();
+          return;
+        }
+        if (resolveReplayOne && replayOneStreamId) {
+          await replayOne(replayOneStreamId);
+        }
+        if (!catchUp) {
+          return;
+        }
+        await checkpointApi.rehydrated();
+        resolveHydrated();
+        resolveReplayOne?.();
+      }
+    };
+    async function replayOne(id) {
+      if (!replayConfig?.deleteOne) {
+        throw new Error("this projection does not support replay one. withReplay({ deleteOne }) not implemented.");
+      }
+      await params.snapshot?.delete({ id, projection: name });
+      await replayConfig.deleteOne(id);
+      const streamIds = relatedStreamEvents ? relatedStreamEvents.map((relatedStreamEvent) => ({
+        ...relatedStreamEvent,
+        id
+      })) : null;
+      const events = params.loadEvents(streamIds);
+      replaying = true;
+      await withReplaying(async () => {
+        for await (const event of events) {
+          await withHydrating(() => apply(event));
+        }
+      });
+      replaying = false;
+    }
+    async function replay() {
+      await api.beginReplay();
+      const events = params.loadEvents(relatedStreamEvents);
+      let index = 0;
+      replaying = true;
+      await withReplaying(async () => {
+        for await (const event of events) {
+          await api.progressReplay(index, event);
+          index++;
+        }
+      });
+      replaying = false;
+      api.endReplay();
+    }
+    return api;
+  };
+}
+
+export { getProjectionInfo, isInsideProjection, buildProjectionCreator };
+
+//# debugId=B979DBD1EC4FBD5364756E2164756E21

package/dist/chunk-ncpk70p4.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/createProjection.ts"],
+  "sourcesContent": [
+    "import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport z from 'zod/v4'\n\nimport {\n  type CheckpointApi,\n  type CheckpointMethods,\n  createCheckpointApi,\n} from './createCheckpointApi.ts'\nimport type { LoadEvents, OnProgress } from './createEventStore.ts'\nimport {\n  ProjectionEventHandlerExecutionError,\n  ProjectionReplayLoopError,\n  ReplaySkipError,\n  ValidationError,\n} from './errors.ts'\nimport { isReplaying, withReplaying } from './replay.ts'\nimport type {\n  CompleteSnapshotGenerator,\n  InternalSnapshotGenerator,\n  SnapshotGenerator,\n} from './snapshotGenerator.ts'\nimport createSnapshotGenerator from './snapshotGenerator.ts'\nimport type {\n  AllEvents,\n  BaseOutputEvent,\n  EventHandlers,\n  EventTemplate,\n  Keys,\n  MaybePromise,\n  Merge,\n  OutputEvent,\n  StreamEvents,\n} from './utilityTypes.d.ts'\n\nconst hydratingStore = new AsyncLocalStorage<boolean>()\n\nfunction isHydrating() {\n  return hydratingStore.getStore() ?? false\n}\n\nasync function withHydrating(handler: () => Promise<void>) {\n  await hydratingStore.run(true, handler)\n}\n\ntype ProjectionInfo = {\n  name: string\n  event: BaseOutputEvent\n}\nconst projectionInfoStore = new AsyncLocalStorage<ProjectionInfo>()\n\nfunction withProjectionInfo(\n  info: ProjectionInfo,\n  handler: () => Promise<void>,\n) {\n  return projectionInfoStore.run(info, handler)\n}\n\nexport function getProjectionInfo() {\n  return projectionInfoStore.getStore()\n}\n\nexport function isInsideProjection() {\n  return Boolean(getProjectionInfo())\n}\n\ntype ReplayConfig = {\n  deleteOne?: (id: string) => MaybePromise<void>\n  deleteAll?: () => MaybePromise<void>\n}\n\ntype ProjectionEventHandlers<Events extends EventTemplate> = EventHandlers<\n  Events,\n  {\n    replaying: boolean\n    replayUntil: (\n      position: number,\n      filterEvents?: (event: OutputEvent<Events>) => boolean,\n    ) => Promise<void>\n  }\n>\n\ntype ReplayProjection<Events extends EventTemplate> = {\n  replayOne: (streamId: string) => Promise<void>\n  replayUntil: (\n    streamId: string,\n    position: number,\n    filterEvents?: (event: OutputEvent<Events>) => boolean,\n  ) => Promise<void>\n  replay: () => Promise<void>\n}\n\nexport type InternalProjection = {\n  apply: (event: BaseOutputEvent) => Promise<void>\n  setRelatedStreamEvents: (\n    generateRelatedStreamEvents: (\n      eventHandlers: EventHandlers<EventTemplate>,\n    ) => StreamEvents[],\n  ) => void\n  isReady(): Promise<void>\n  canReplay(): boolean\n  beginReplay(): Promise<void>\n  progressReplay(index: number, event: BaseOutputEvent): Promise<void>\n  endReplay(): void\n  init(catchUp: boolean): Promise<void>\n}\n\nexport type ProjectionApi<\n  Events extends EventTemplate = never,\n  RConfig extends ReplayConfig = never,\n  Flags extends {\n    withEventHandlers: boolean\n    withGlobalEventHandler: boolean\n    concurrent: boolean\n    withReplay: boolean\n    withSnapshots: boolean\n  } = {\n    withEventHandlers: false\n    withGlobalEventHandler: false\n    concurrent: false\n    withReplay: false\n    withSnapshots: true\n  },\n> = {\n  withEventHandlers: (\n    handlers: ProjectionEventHandlers<Events>,\n  ) => Omit<\n    ProjectionApi<Events, RConfig, Merge<Flags, { withEventHandlers: true }>>,\n    Keys<Merge<Flags, { withEventHandlers: true }>>\n  >\n  withGlobalEventHandler: (\n    handler: (\n      event: AllEvents<Events>,\n      methods: ReplayProjection<Events>,\n    ) => MaybePromise<void>,\n  ) => Omit<\n    ProjectionApi<\n      Events,\n      RConfig,\n      Merge<Flags, { withGlobalEventHandler: true }>\n    >,\n    Keys<Merge<Flags, { withGlobalEventHandler: true }>>\n  >\n  concurrent: () => Omit<\n    ProjectionApi<Events, RConfig, Merge<Flags, { concurrent: true }>>,\n    Keys<Merge<Flags, { concurrent: true }>>\n  >\n  withReplay: <Config extends ReplayConfig>(\n    config: Config,\n  ) => Omit<\n    ProjectionApi<Events, Config, Merge<Flags, { withReplay: true }>>,\n    Keys<Merge<Flags, { withReplay: true }>>\n  >\n  withSnapshots: (\n    handler: (\n      generator: SnapshotGenerator<Omit<Snapshot, 'schemaVersion' | 'state'>>,\n    ) => CompleteSnapshotGenerator,\n  ) => Omit<\n    ProjectionApi<Events, RConfig, Merge<Flags, { withSnapshots: true }>>,\n    Keys<Merge<Flags, { withSnapshots: true }>>\n  >\n  isReady(): Promise<void>\n} & ('deleteOne' extends keyof RConfig\n  ? Pick<ReplayProjection<Events>, 'replayOne' | 'replayUntil'>\n  : {}) &\n  ('deleteAll' extends keyof RConfig\n    ? Pick<ReplayProjection<Events>, 'replay'>\n    : {})\n\nexport type ProjectionApiWithSnapshots<\n  Events extends EventTemplate = never,\n  RConfig extends ReplayConfig = never,\n  Flags extends {\n    withEventHandlers: boolean\n    withGlobalEventHandler: boolean\n    concurrent: boolean\n    withReplay: boolean\n    withSnapshots: boolean\n  } = {\n    withEventHandlers: false\n    withGlobalEventHandler: false\n    concurrent: false\n    withReplay: false\n    withSnapshots: false\n  },\n> = ProjectionApi<Events, RConfig, Flags>\n\nconst snapshotSchema = z.object({\n  projectionId: z.string(),\n  projectionType: z.string(),\n  lastEventPosition: z.int(),\n  state: z.unknown(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  schemaVersion: z.int(),\n  createdAt: z.date(),\n})\n\nexport type Snapshot = z.output<typeof snapshotSchema>\n\nexport type ProjectionSnapshotMethods = {\n  get: (select: {\n    projection: string\n    id: string\n  }) => MaybePromise<Snapshot | null | undefined>\n  put: (snapshot: Snapshot) => MaybePromise<void>\n  delete: (\n    target: { id?: string; projection: string },\n    fromPosition?: number,\n  ) => MaybePromise<void>\n  incrementAppliedCount: (target: {\n    projection: string\n    id: string\n  }) => MaybePromise<number>\n}\n\nexport function buildProjectionCreator(params: {\n  loadEvents: LoadEvents\n  checkpoint: CheckpointMethods\n  onReplay?: OnProgress\n  snapshot?: ProjectionSnapshotMethods\n}): (name: string) => ProjectionApi {\n  return (name) => {\n    let idle = true\n    let replaying = false\n    let handlers: ProjectionEventHandlers<any> = {}\n    let globalEventHandler:\n      | ((event: BaseOutputEvent) => MaybePromise<void>)\n      | null = null\n    let generateRelatedStreamEvents: (\n      eventHandlers: EventHandlers<any>,\n    ) => StreamEvents[]\n    let relatedStreamEvents: StreamEvents[] | null = null\n    let exclusive = true\n    let checkpointApi: CheckpointApi\n    let lastEventPosition = -1\n\n    let replayConfig: ReplayConfig | null = null\n\n    let snapshotting:\n      | (CompleteSnapshotGenerator & InternalSnapshotGenerator)\n      | null = null\n\n    const { promise: hydrated, resolve: resolveHydrated } =\n      Promise.withResolvers<void>()\n\n    const locks = new Map<string, Promise<void>>()\n    const apply = async (event: BaseOutputEvent) => {\n      const handler = handlers[`on${event.type}`]\n      if (!handler && !globalEventHandler) {\n        return Promise.resolve()\n      }\n\n      if (isHydrating()) {\n        lastEventPosition = event.position\n      } else {\n        await hydrated\n        // event was already applied through hydration\n        if (event.position <= lastEventPosition) {\n          return\n        }\n      }\n\n      const unlocked = !exclusive\n        ? Promise.resolve()\n        : (locks.get(event.streamId)?.catch(() => {}) ?? Promise.resolve())\n\n      const runner = (async () => {\n        await unlocked\n        await withProjectionInfo({ name, event }, async () => {\n          try {\n            await handler?.(event, {\n              replaying,\n              async replayUntil(position, filterEvents) {\n                if (position >= event.position) {\n                  throw new ProjectionReplayLoopError(\n                    `Event handler on${event.type} of projection ${name} tried to replay to the future`,\n                    { name, eventHandler: `on${event.type}` },\n                    event,\n                  )\n                }\n\n                locks.delete(event.streamId)\n                return api.replayUntil(event.streamId, position, filterEvents)\n              },\n            })\n          } catch (error) {\n            if (error instanceof ReplaySkipError) {\n              if (isReplaying()) {\n                return\n              }\n\n              throw new Error(\n                'ReplaySkipError should never be thrown outside replay',\n              )\n            }\n\n            if (\n              !(error instanceof Error) ||\n              error instanceof ProjectionReplayLoopError\n            ) {\n              throw error\n            }\n            throw new ProjectionEventHandlerExecutionError(\n              name,\n              `on${event.type}`,\n              event,\n              error,\n            )\n          }\n          try {\n            await globalEventHandler?.(event)\n          } catch (error) {\n            if (!(error instanceof Error)) {\n              throw error\n            }\n\n            throw new ProjectionEventHandlerExecutionError(\n              name,\n              'GLOBAL',\n              event,\n              error,\n            )\n          }\n        })\n\n        if (params.snapshot && snapshotting) {\n          const appliedEvents = await params.snapshot.incrementAppliedCount({\n            projection: name,\n            id: event.streamId,\n          })\n          const snapshot = await snapshotting.internalCapture(\n            event,\n            appliedEvents,\n          )\n\n          if (snapshot) {\n            await params.snapshot.put({\n              projectionType: name,\n              projectionId: event.streamId,\n              lastEventPosition: event.position,\n              state: snapshot.state,\n              schemaVersion: snapshot.version,\n              createdAt: new Date(),\n            })\n          }\n        }\n\n        await checkpointApi.upsert(event)\n      })()\n\n      if (exclusive) {\n        locks.set(event.streamId, runner)\n\n        runner\n          .finally(() => {\n            if (locks.get(event.streamId) === runner) {\n              locks.delete(event.streamId)\n            }\n          })\n          .catch(() => {})\n        return runner\n      }\n\n      return Promise.resolve()\n    }\n\n    let resolveReplay: null | (() => void) = null\n    let resolveReplayOne: null | (() => void) = null\n    let replayOneStreamId: null | string = null\n\n    const api = {\n      name: 'projection ' + name,\n      async isReady() {\n        await hydrated\n      },\n      withEventHandlers(h) {\n        handlers = h\n        return api\n      },\n      withGlobalEventHandler(handler) {\n        globalEventHandler = handler as any\n        return api\n      },\n      concurrent() {\n        exclusive = false\n        return api\n      },\n      setRelatedStreamEvents(generate) {\n        generateRelatedStreamEvents = generate\n      },\n      withReplay(config) {\n        replayConfig = config\n        return api as any\n      },\n\n      withSnapshots(handler) {\n        snapshotting = handler(createSnapshotGenerator() as any) as any\n        return api\n      },\n\n      async apply(event) {\n        await apply(event)\n      },\n\n      async replayOne(streamId: string) {\n        if (!idle) {\n          await replayOne(streamId)\n          return\n        }\n\n        const { promise, resolve } = Promise.withResolvers<void>()\n        resolveReplayOne = resolve\n        replayOneStreamId = streamId\n        return promise\n      },\n\n      async replay() {\n        if (!idle) {\n          await replay()\n          return\n        }\n        const { promise, resolve } = Promise.withResolvers<void>()\n        resolveReplay = resolve\n        return promise\n      },\n\n      canReplay() {\n        return Boolean(replayConfig)\n      },\n\n      async beginReplay() {\n        if (!replayConfig?.deleteAll) {\n          throw new Error(\n            'this projection does not support replay all. withReplay({ deleteAll }) not implemented.',\n          )\n        }\n\n        lastEventPosition = -1\n        params.onReplay?.begin?.(name)\n        await params.snapshot?.delete({ projection: name })\n        await replayConfig.deleteAll()\n      },\n\n      async progressReplay(index, event) {\n        await withReplaying(() => withHydrating(() => apply(event)))\n        if (\n          !checkpointApi.relatedStreamEvents ||\n          checkpointApi.relatedStreamEvents.some((streamEvent) =>\n            streamEvent.events.includes(event.type),\n          )\n        ) {\n          params.onReplay?.progress?.(name, index, event)\n        }\n      },\n\n      endReplay() {\n        params.onReplay?.end?.(name)\n        resolveHydrated()\n      },\n\n      async replayUntil(id, position, filterEvents = () => true) {\n        let startPosition = 0\n        if (snapshotting) {\n          await params.snapshot?.delete({ id, projection: name }, position)\n          const snapshot = await params.snapshot?.get({ id, projection: name })\n          if (snapshot) {\n            const result = snapshotSchema.safeParse(snapshot)\n\n            if (!result.success) {\n              throw new ValidationError(\n                'loaded projection snapshot does not comply with schema',\n                result.error,\n              )\n            }\n            snapshotting.internalApply(result.data)\n            startPosition = result.data.lastEventPosition + 1\n          }\n        }\n\n        const events = params.loadEvents(\n          relatedStreamEvents?.map((relatedStreamEvent) => ({\n            ...relatedStreamEvent,\n            id,\n          })) ?? null,\n          {\n            from: startPosition,\n            to: position,\n          },\n        )\n\n        replaying = true\n        await withReplaying(async () => {\n          for await (const event of events) {\n            if ((filterEvents as (event: BaseOutputEvent) => boolean)(event)) {\n              await apply(event)\n            }\n          }\n        })\n        replaying = false\n      },\n      async init(catchUp) {\n        idle = false\n        relatedStreamEvents = globalEventHandler\n          ? null\n          : generateRelatedStreamEvents(handlers as EventHandlers<any>)\n        checkpointApi = createCheckpointApi({\n          ...params.checkpoint,\n          name,\n          relatedStreamEvents,\n          type: 'projection',\n          loadEvents: params.loadEvents,\n          apply: (event) => withHydrating(() => apply(event)),\n        })\n\n        if (resolveReplay) {\n          await replay()\n          resolveReplay()\n          return\n        }\n\n        if (resolveReplayOne && replayOneStreamId) {\n          await replayOne(replayOneStreamId)\n        }\n\n        if (!catchUp) {\n          return\n        }\n\n        await checkpointApi.rehydrated()\n        resolveHydrated()\n        resolveReplayOne?.()\n      },\n    } as ProjectionApi & InternalProjection & ReplayProjection<any>\n\n    async function replayOne(id: string) {\n      if (!replayConfig?.deleteOne) {\n        throw new Error(\n          'this projection does not support replay one. withReplay({ deleteOne }) not implemented.',\n        )\n      }\n      await params.snapshot?.delete({ id, projection: name })\n      await replayConfig.deleteOne(id)\n      const streamIds = relatedStreamEvents\n        ? relatedStreamEvents.map((relatedStreamEvent) => ({\n            ...relatedStreamEvent,\n            id,\n          }))\n        : null\n      const events = params.loadEvents(streamIds)\n\n      replaying = true\n      await withReplaying(async () => {\n        for await (const event of events) {\n          await withHydrating(() => apply(event))\n        }\n      })\n      replaying = false\n    }\n\n    async function replay() {\n      await api.beginReplay()\n      const events = params.loadEvents(relatedStreamEvents)\n      let index = 0\n      replaying = true\n      await withReplaying(async () => {\n        for await (const event of events) {\n          await api.progressReplay(index, event)\n          index++\n        }\n      })\n      replaying = false\n      api.endReplay()\n    }\n\n    return api\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "B979DBD1EC4FBD5364756E2164756E21",
+  "names": []
+}

package/dist/chunk-pmfzjavb.js

@@ -0,0 +1,49 @@
+import {
+  ValidationError
+} from "./chunk-qdczt68t.js";
+
+// src/snapshotGenerator.ts
+import { z } from "zod/v4";
+function createSnapshotGenerator(schemas = [], config = null, applier = null, capturer = null) {
+  return {
+    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);
+      }
+      await applier(snapshot);
+    },
+    async internalCapture(event, applied) {
+      if (!config || applied % config.every !== 0) {
+        return null;
+      }
+      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);
+      }
+      return {
+        state: result.data,
+        version: latestSchema.schemaVersion
+      };
+    },
+    every(count) {
+      return createSnapshotGenerator(schemas, { every: count }, applier, capturer);
+    },
+    schema(schema, schemaVersion) {
+      schemas.push({ schemaVersion: schemaVersion ?? 0, schema });
+      return createSnapshotGenerator(schemas, config, null, null);
+    },
+    apply(applier2) {
+      return createSnapshotGenerator(schemas, config, applier2, capturer);
+    },
+    capture(capturer2) {
+      return createSnapshotGenerator(schemas, config, applier, capturer2);
+    },
+    complete: true
+  };
+}
+
+export { createSnapshotGenerator };
+
+//# debugId=53092F13C54E882C64756E2164756E21

package/dist/chunk-pmfzjavb.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/snapshotGenerator.ts"],
+  "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",
+  "names": []
+}

package/dist/chunk-qdczt68t.js

@@ -0,0 +1,84 @@
+// src/errors.ts
+import z from "zod/v4";
+
+class ConcurrencyError extends Error {
+  constructor(streamId, expectedVersion, actualVersion) {
+    super(`Concurrency error on ${streamId.stream}(${streamId.id}): expected v${expectedVersion}, actual v${actualVersion}`);
+  }
+}
+
+class ValidationError extends Error {
+  zodError;
+  constructor(message, zodError) {
+    super(`${message}: ${z.prettifyError(zodError)}`);
+    this.zodError = zodError;
+  }
+}
+
+class EventValidationError extends ValidationError {
+}
+
+class InfiniteLoopError extends Error {
+}
+
+class CommandError extends Error {
+  aggregateRootType;
+  commandName;
+  streamId;
+  originalError;
+  constructor(aggregateRootType, commandName, streamId, originalError) {
+    super(`Error executing command "${commandName}" on aggregate root "${aggregateRootType}" for stream id "${streamId}": ${originalError.message}`);
+    this.aggregateRootType = aggregateRootType;
+    this.commandName = commandName;
+    this.streamId = streamId;
+    this.originalError = originalError;
+  }
+}
+
+class ProjectionReplayLoopError extends Error {
+  projection;
+  event;
+  constructor(message, projection, event) {
+    super(message);
+    this.projection = projection;
+    this.event = event;
+  }
+}
+
+class RefreshingSkipError extends Error {
+}
+
+class ReplaySkipError extends Error {
+}
+
+class ProjectionEventHandlerExecutionError extends Error {
+  projection;
+  eventHandler;
+  event;
+  originalError;
+  constructor(projection, eventHandler, event, originalError) {
+    super(`Error execution event handler "${eventHandler}" in projection "${projection}": ${originalError.message}`);
+    this.projection = projection;
+    this.eventHandler = eventHandler;
+    this.event = event;
+    this.originalError = originalError;
+  }
+}
+
+class ProcessManagerEventHandlerExecutionError extends Error {
+  processManager;
+  eventHandler;
+  event;
+  originalError;
+  constructor(processManager, eventHandler, event, originalError) {
+    super(`Error execution event handler "${eventHandler}" in process manager "${processManager}": ${originalError.message}`);
+    this.processManager = processManager;
+    this.eventHandler = eventHandler;
+    this.event = event;
+    this.originalError = originalError;
+  }
+}
+
+export { ConcurrencyError, ValidationError, EventValidationError, InfiniteLoopError, CommandError, ProjectionReplayLoopError, RefreshingSkipError, ReplaySkipError, ProjectionEventHandlerExecutionError, ProcessManagerEventHandlerExecutionError };
+
+//# debugId=7F0D85CC4F4ACE1E64756E2164756E21

package/dist/chunk-qdczt68t.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/errors.ts"],
+  "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 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,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": "7F0D85CC4F4ACE1E64756E2164756E21",
+  "names": []
+}

package/dist/chunk-tfy01fah.js

@@ -0,0 +1,34 @@
+// src/utils.ts
+async function normalizeArray(result, onItem) {
+  const awaited = await result;
+  if (typeof awaited === "undefined") {
+    return [];
+  }
+  if (typeof awaited[Symbol.asyncIterator] === "function") {
+    const out = [];
+    for await (const item of awaited) {
+      out.push(item);
+      onItem?.(item);
+    }
+    return out;
+  }
+  if (typeof awaited[Symbol.iterator] === "function") {
+    return Array.from(awaited);
+  }
+  return [awaited];
+}
+async function awaitAll(getPromise) {
+  let currentPromise = getPromise();
+  while (true) {
+    await currentPromise;
+    const nextPromise = getPromise();
+    if (nextPromise === currentPromise) {
+      break;
+    }
+    currentPromise = nextPromise;
+  }
+}
+
+export { normalizeArray, awaitAll };
+
+//# debugId=1CEDD25CA17E1B1164756E2164756E21

package/dist/chunk-tfy01fah.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/utils.ts"],
+  "sourcesContent": [
+    "import type { MaybePromise } from './utilityTypes.js'\n\nexport async function normalizeArray<T>(\n  result: MaybePromise<void | T | T[]> | Iterable<T> | AsyncIterable<T>,\n  onItem?: (item: T) => void,\n): Promise<T[]> {\n  const awaited = (await result) as any\n\n  // If it's explicitly void/undefined, normalize to empty array\n  if (typeof awaited === 'undefined') {\n    return []\n  }\n\n  // Async iterable\n  if (typeof awaited[Symbol.asyncIterator] === 'function') {\n    const out: T[] = []\n    for await (const item of awaited as AsyncIterable<T>) {\n      out.push(item)\n      onItem?.(item)\n    }\n    return out\n  }\n\n  // Sync iterable (this also covers arrays)\n  if (typeof awaited[Symbol.iterator] === 'function') {\n    return Array.from(awaited as Iterable<T>)\n  }\n\n  // Plain single value\n  return [awaited as T]\n}\n\nexport async function awaitAll(getPromise: () => Promise<any>) {\n  let currentPromise = getPromise()\n  while (true) {\n    await currentPromise\n    const nextPromise = getPromise()\n    if (nextPromise === currentPromise) {\n      break\n    }\n    currentPromise = nextPromise\n  }\n}\n"
+  ],
+  "mappings": ";AAEA,eAAsB,cAAiB,CACrC,QACA,QACc;AAAA,EACd,MAAM,UAAW,MAAM;AAAA,EAGvB,IAAI,OAAO,YAAY,aAAa;AAAA,IAClC,OAAO,CAAC;AAAA,EACV;AAAA,EAGA,IAAI,OAAO,QAAQ,OAAO,mBAAmB,YAAY;AAAA,IACvD,MAAM,MAAW,CAAC;AAAA,IAClB,iBAAiB,QAAQ,SAA6B;AAAA,MACpD,IAAI,KAAK,IAAI;AAAA,MACb,SAAS,IAAI;AAAA,IACf;AAAA,IACA,OAAO;AAAA,EACT;AAAA,EAGA,IAAI,OAAO,QAAQ,OAAO,cAAc,YAAY;AAAA,IAClD,OAAO,MAAM,KAAK,OAAsB;AAAA,EAC1C;AAAA,EAGA,OAAO,CAAC,OAAY;AAAA;AAGtB,eAAsB,QAAQ,CAAC,YAAgC;AAAA,EAC7D,IAAI,iBAAiB,WAAW;AAAA,EAChC,OAAO,MAAM;AAAA,IACX,MAAM;AAAA,IACN,MAAM,cAAc,WAAW;AAAA,IAC/B,IAAI,gBAAgB,gBAAgB;AAAA,MAClC;AAAA,IACF;AAAA,IACA,iBAAiB;AAAA,EACnB;AAAA;",
+  "debugId": "1CEDD25CA17E1B1164756E2164756E21",
+  "names": []
+}