@requence/event-sourcing 0.0.1 → 1.0.1

package/dist/chunk-ty9bhdvx.js

@@ -0,0 +1,53 @@
+// src/lock.ts
+import { Mutex } from "async-mutex";
+function lock(defaultTtl = 5000) {
+  const locks = new Map;
+  return async (key) => {
+    const k = Array.isArray(key) ? key.join(":") : key;
+    if (!locks.has(k)) {
+      locks.set(k, new Mutex);
+    }
+    const mutex = locks.get(k);
+    const releaseMutex = await mutex.acquire();
+    let isReleased = false;
+    let timer;
+    const startTimer = (ttl) => {
+      timer = setTimeout(() => {
+        if (!isReleased) {
+          console.warn("lock ttl expired for key", k);
+          isReleased = true;
+          releaseMutex();
+          if (!mutex.isLocked()) {
+            locks.delete(k);
+          }
+        }
+      }, ttl);
+    };
+    startTimer(defaultTtl);
+    return {
+      async extend(ttl) {
+        if (isReleased) {
+          return false;
+        }
+        clearTimeout(timer);
+        startTimer(ttl ?? defaultTtl / 2);
+        return true;
+      },
+      async release() {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        clearTimeout(timer);
+        releaseMutex();
+        if (!mutex.isLocked()) {
+          locks.delete(k);
+        }
+      }
+    };
+  };
+}
+
+export { lock };
+
+//# debugId=1272FCF41F0B661064756E2164756E21

package/dist/chunk-ty9bhdvx.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/lock.ts"],
+  "sourcesContent": [
+    "import { Mutex } from 'async-mutex'\n\nexport default function lock(defaultTtl = 5000) {\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      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\nexport type LockCreator = ReturnType<typeof lock>\n"
+  ],
+  "mappings": ";AAAA;AAEA,SAAwB,IAAI,CAAC,aAAa,MAAM;AAAA,EAC9C,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,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": "1272FCF41F0B661064756E2164756E21",
+  "names": []
+}

package/dist/chunk-wmz6a1jk.js

@@ -0,0 +1,233 @@
+import {
+  createEventListener
+} from "./chunk-24xjphpk.js";
+import {
+  lock
+} from "./chunk-ty9bhdvx.js";
+import {
+  createTransaction
+} from "./chunk-gq80tgvf.js";
+import {
+  unwrapEvent,
+  wrappedEventBuilder
+} from "./chunk-z388cd25.js";
+import {
+  buildProjectionCreator
+} from "./chunk-ncpk70p4.js";
+import {
+  buildProcessManagerCreator
+} from "./chunk-m07vf8q9.js";
+import {
+  withRefreshing
+} from "./chunk-9psg50cb.js";
+
+// src/createEventStore.ts
+function createEventStore(params) {
+  const transaction = createTransaction();
+  const { promise: initialized, resolve: resolveInitialized } = Promise.withResolvers();
+  const projections = new Map;
+  const processManagers = new Map;
+  const eventListeners = new Map;
+  const aggregatRootsByEvents = new Map;
+  let allReplaying = false;
+  let initializing = false;
+  const assertInitializing = () => {
+    if (!initializing && params.autoInit === false) {
+      throw new Error("Cannot emit events because the event store is not initialized. Set autoInit to true, or explicitly call .init() before emitting events.");
+    }
+  };
+  let exclusiveEmitEventsChain = Promise.resolve();
+  const emitEvents = async (events) => {
+    exclusiveEmitEventsChain = exclusiveEmitEventsChain.then(async () => {
+      for (const event of events) {
+        await Promise.all([
+          ...processManagers.values(),
+          ...projections.values(),
+          ...eventListeners.values()
+        ].map((listener) => listener.apply(event)));
+      }
+      for (const event of events) {
+        await Promise.all([...processManagers.values(), ...eventListeners.values()].map((processManager) => processManager.applyAfter(event)));
+      }
+    });
+    return exclusiveEmitEventsChain;
+  };
+  const loadEvents = (select, range) => {
+    assertInitializing();
+    return params.loadEvents(select, range);
+  };
+  let exclusiveAppendEventsChain = initialized;
+  const appendEvents = async (streamId, events, expectedVersion) => {
+    assertInitializing();
+    exclusiveAppendEventsChain = exclusiveAppendEventsChain.then(async () => {
+      if (events.length === 0) {
+        return [];
+      }
+      await new Promise((resolve) => setImmediate(resolve));
+      const processedEvents = events.map((rawEvent) => {
+        const event = structuredClone(rawEvent);
+        if (params.postProcessEvent) {
+          const wrappedEvent = wrappedEventBuilder(event);
+          const { aggregateRoot } = aggregatRootsByEvents.get(event.type);
+          const processedEvent = unwrapEvent(params.postProcessEvent(wrappedEvent, aggregateRoot));
+          Object.assign(event, processedEvent);
+        }
+        return event;
+      });
+      return params.appendEvents(streamId, processedEvents, expectedVersion);
+    });
+    return exclusiveAppendEventsChain;
+  };
+  for (const aggregateRoot of params.aggregateRoots) {
+    aggregateRoot.eventTypes.forEach((eventType) => {
+      aggregatRootsByEvents.set(eventType, {
+        aggregateRoot,
+        eventType
+      });
+    });
+    aggregateRoot.linkEventStore(loadEvents, appendEvents, emitEvents, transaction, params.lock ?? lock(5000), params.aggregateRootSnapshot);
+  }
+  const baseCreateProjection = buildProjectionCreator({
+    loadEvents,
+    checkpoint: params.checkpoint,
+    snapshot: params.projectionSnapshot,
+    onReplay: params.onProjectionReplay
+  });
+  const baseCreateProcessManager = buildProcessManagerCreator({
+    loadEvents,
+    checkpoint: params.checkpoint,
+    onRefresh: params.onProcessManagerRefresh
+  });
+  const getRelatedStreamEvents = (handlers) => {
+    const relatedStreamEvents = new Map;
+    for (const handlerName of Object.keys(handlers)) {
+      const sanitizedHandlerName = handlerName.replace(/^(on|after)/, "");
+      if (!aggregatRootsByEvents.has(sanitizedHandlerName)) {
+        throw new Error(`event handler ${handlerName} has no corresponding event in any aggregate root`);
+      }
+      const {
+        aggregateRoot: { type: aggregateRootName },
+        eventType
+      } = aggregatRootsByEvents.get(sanitizedHandlerName);
+      if (!relatedStreamEvents.has(aggregateRootName)) {
+        relatedStreamEvents.set(aggregateRootName, new Set);
+      }
+      relatedStreamEvents.get(aggregateRootName).add(eventType);
+    }
+    return Array.from(relatedStreamEvents, ([stream, events]) => ({
+      stream,
+      events: Array.from(events)
+    }));
+  };
+  const initialize = async () => {
+    initializing = true;
+    await Promise.all(projections.values().map((projection) => projection.init(true)));
+    await Promise.all(processManagers.values().map((processManager) => processManager.init(true)));
+    resolveInitialized();
+  };
+  setImmediate(() => {
+    if (allReplaying || params.autoInit === false) {
+      return;
+    }
+    initialize();
+  });
+  const api = {
+    createProjection(name) {
+      if (projections.has(name)) {
+        throw new Error(`Projection ${name} is already registered`);
+      }
+      const api2 = baseCreateProjection(name);
+      const internalApi = api2;
+      internalApi.setRelatedStreamEvents((handlers) => getRelatedStreamEvents(handlers));
+      projections.set(name, internalApi);
+      if (initializing) {
+        internalApi.init(true);
+      }
+      return api2;
+    },
+    createProcessManager(name) {
+      if (processManagers.has(name)) {
+        throw new Error(`Process Manager ${name} is already registered`);
+      }
+      const api2 = baseCreateProcessManager(name);
+      const internalApi = api2;
+      internalApi.setRelatedStreamEvents((handlers) => getRelatedStreamEvents(handlers));
+      processManagers.set(name, internalApi);
+      if (initializing) {
+        internalApi.init(true);
+      }
+      return api2;
+    },
+    createEventListener(name) {
+      if (eventListeners.has(name)) {
+        throw new Error(`Event Listener ${name} is already registered`);
+      }
+      const api2 = createEventListener(name);
+      const internalApi = api2;
+      eventListeners.set(name, internalApi);
+      return api2;
+    },
+    async isReady() {
+      await initialized;
+      await Promise.all([
+        ...projections.values().map((projection) => projection.isReady()),
+        ...processManagers.values().map((projection) => projection.isReady())
+      ]);
+    },
+    async rebuild() {
+      allReplaying = true;
+      initializing = true;
+      const replayProjections = Array.from(projections.values()).filter((projection) => projection.canReplay());
+      const replayProcessManagers = Array.from(processManagers.values()).filter((processManager) => processManager.hasState());
+      await Promise.all([
+        ...replayProjections.map((projection) => projection.init(false)),
+        ...replayProcessManagers.map((projection) => projection.init(false)),
+        ...replayProjections.map((projection) => projection.beginReplay()),
+        ...replayProcessManagers.map((processManager) => processManager.beginRefresh())
+      ]);
+      await withRefreshing(async () => {
+        let index = 0;
+        for await (const event of loadEvents(null)) {
+          index++;
+          await Promise.all([
+            ...replayProjections.map((projection) => projection.progressReplay(index, event)),
+            ...replayProcessManagers.map((processManager) => processManager.progressRefresh(index, event, false)),
+            ...Array.from(eventListeners.values(), (listener) => listener.apply(event))
+          ]);
+          await Promise.all([
+            ...replayProcessManagers.map((processManager) => processManager.progressRefresh(index, event, true)),
+            ...Array.from(eventListeners.values(), (listener) => listener.applyAfter(event))
+          ]);
+        }
+      });
+      await Promise.all([
+        ...replayProjections.map((projection) => projection.endReplay()),
+        ...replayProcessManagers.map((processManager) => processManager.endRefresh())
+      ]);
+      await Promise.all(projections.values().map(async (projection) => {
+        if (!projection.canReplay()) {
+          await projection.init(true);
+        }
+      }));
+      resolveInitialized();
+    },
+    async init() {
+      if (initializing) {
+        return api;
+      }
+      await initialize();
+      return api;
+    },
+    getAggregateRoot(type) {
+      return params.aggregateRoots.find((aggregateRoot) => aggregateRoot.type === type);
+    },
+    async transaction(handler) {
+      return transaction.run(handler);
+    }
+  };
+  return api;
+}
+
+export { createEventStore };
+
+//# debugId=7493A3991CE6299464756E2164756E21

package/dist/chunk-wmz6a1jk.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/createEventStore.ts"],
+  "sourcesContent": [
+    "import type {\n  AggregateRootApi,\n  AggregateRootSnapshotMethods,\n  AnyAggregateRoot,\n  InternalAggregateRootApi,\n} from './createAggregateRoot.ts'\nimport type { CheckpointMethods } from './createCheckpointApi.ts'\nimport {\n  type EventListenerApi,\n  type InternalEventListener,\n  createEventListener,\n} from './createEventListener.ts'\nimport {\n  type InternalProcessManager,\n  type ProcessManagerApi,\n  buildProcessManagerCreator,\n} from './createProcessManager.ts'\nimport {\n  type InternalProjection,\n  type ProjectionApi,\n  type ProjectionApiWithSnapshots,\n  type ProjectionSnapshotMethods,\n  buildProjectionCreator,\n} from './createProjection.ts'\nimport lock, { type LockCreator } from './lock.ts'\nimport { withRefreshing } from './refresh.ts'\nimport createTransaction from './transaction.ts'\nimport type {\n  BaseInputEvent,\n  BaseOutputEvent,\n  EventHandlers,\n  EventTemplate,\n  MaybePromise,\n  Stream,\n  StreamEvents,\n  StreamId,\n  StreamIdEvents,\n} from './utilityTypes.js'\nimport {\n  type WrappedEvent,\n  unwrapEvent,\n  wrappedEventBuilder,\n} from './wrappedEventBuilder.ts'\n\nexport type LoadEvents = (\n  select:\n    | Stream\n    | StreamId\n    | Stream[]\n    | StreamId[]\n    | StreamEvents\n    | StreamEvents[]\n    | StreamIdEvents\n    | StreamIdEvents[]\n    | null,\n  range?: { from: number; to?: number },\n) => AsyncGenerator<BaseOutputEvent>\n\ntype AppendEvents = (\n  streamId: StreamId,\n  events: BaseInputEvent[],\n  expectedVersion: number,\n) => MaybePromise<BaseOutputEvent[]>\n\nexport type InternalAppendEvents = (\n  streamId: StreamId,\n  events: BaseInputEvent[],\n  expectedVersion: number,\n) => MaybePromise<BaseOutputEvent[]>\n\nexport type EmitEvents = (events: BaseOutputEvent[]) => Promise<void>\n\nexport type EventsFromRoot<Root> =\n  Root extends Omit<AggregateRootApi<any, any, infer E>, any> ? E : never\n\nexport type OnProgress = {\n  begin?: (projectionName: string) => void\n  progress?: (\n    projectionName: string,\n    index: number,\n    event: BaseOutputEvent,\n  ) => void\n  end?: (projectionName: string) => void\n}\n\ninterface BaseEventStoreParams<Root extends AnyAggregateRoot> {\n  loadEvents: LoadEvents\n  appendEvents: AppendEvents\n  aggregateRoots: Root[]\n  checkpoint: CheckpointMethods\n  lock?: LockCreator\n  projectionSnapshot?: ProjectionSnapshotMethods\n  onProjectionReplay?: OnProgress\n  onProcessManagerRefresh?: OnProgress\n  autoInit?: boolean\n}\n\nexport interface EventStoreParamsWithAggregateRootSnapshots<\n  Root extends AnyAggregateRoot,\n> extends BaseEventStoreParams<Root> {\n  aggregateRootSnapshot: AggregateRootSnapshotMethods\n  postProcessEvent?: (\n    event: WrappedEvent<EventsFromRoot<Root>>,\n    aggregateRoot: Root,\n  ) => WrappedEvent\n}\n\nexport interface EventStoreParamsWithoutAggregateRootSnapshots<\n  Root extends AnyAggregateRoot,\n> extends BaseEventStoreParams<Root> {\n  aggregateRoots: Root[]\n  aggregateRootSnapshot?: never\n  postProcessEvent?: (\n    event: WrappedEvent<EventsFromRoot<Root>>,\n    aggregateRoot: Root,\n  ) => WrappedEvent\n}\n\nexport type EventStore<\n  Event extends EventTemplate,\n  Root extends AnyAggregateRoot,\n  SupportsProjectionSnapshots = boolean,\n> = {\n  createProjection(\n    name: string,\n  ): SupportsProjectionSnapshots extends true\n    ? ProjectionApiWithSnapshots<Event>\n    : ProjectionApi<Event>\n  createProcessManager(name: string): ProcessManagerApi<never, Event>\n  createEventListener(name: string): EventListenerApi<Event>\n  rebuild: () => Promise<void>\n  isReady: () => Promise<void>\n  init: () => Promise<EventStore<Event, Root, SupportsProjectionSnapshots>>\n  getAggregateRoot<S extends Root['type']>(\n    type: S,\n  ): Root extends { type: S } ? Root : never\n  transaction<T extends () => any>(handler: T): Promise<Awaited<ReturnType<T>>>\n}\n\nexport function createEventStore<const Root extends AnyAggregateRoot>(\n  params: EventStoreParamsWithoutAggregateRootSnapshots<Root>,\n): EventStore<EventsFromRoot<Root>, Root, false>\nexport function createEventStore<const Root extends AnyAggregateRoot>(\n  params: EventStoreParamsWithAggregateRootSnapshots<Root>,\n): EventStore<EventsFromRoot<Root>, Root, true>\nexport function createEventStore<const Root extends AnyAggregateRoot>(\n  params:\n    | EventStoreParamsWithoutAggregateRootSnapshots<Root>\n    | EventStoreParamsWithAggregateRootSnapshots<Root>,\n) {\n  const transaction = createTransaction()\n  const { promise: initialized, resolve: resolveInitialized } =\n    Promise.withResolvers<void>()\n  const projections = new Map<string, InternalProjection>()\n  const processManagers = new Map<string, InternalProcessManager>()\n  const eventListeners = new Map<string, InternalEventListener>()\n  const aggregatRootsByEvents = new Map<\n    string,\n    { aggregateRoot: InternalAggregateRootApi; eventType: string }\n  >()\n\n  let allReplaying = false\n  let initializing = false\n\n  const assertInitializing = () => {\n    if (!initializing && params.autoInit === false) {\n      throw new Error(\n        'Cannot emit events because the event store is not initialized. Set autoInit to true, or explicitly call .init() before emitting events.',\n      )\n    }\n  }\n\n  let exclusiveEmitEventsChain: Promise<any> = Promise.resolve()\n  const emitEvents: EmitEvents = async (events) => {\n    exclusiveEmitEventsChain = exclusiveEmitEventsChain.then(async () => {\n      for (const event of events) {\n        await Promise.all(\n          [\n            ...processManagers.values(),\n            ...projections.values(),\n            ...eventListeners.values(),\n          ].map((listener) => listener.apply(event)),\n        )\n      }\n\n      for (const event of events) {\n        await Promise.all(\n          [...processManagers.values(), ...eventListeners.values()].map(\n            (processManager) => processManager.applyAfter(event),\n          ),\n        )\n      }\n    })\n\n    return exclusiveEmitEventsChain\n  }\n\n  const loadEvents: LoadEvents = (select, range) => {\n    assertInitializing()\n    return params.loadEvents(select, range)\n  }\n\n  let exclusiveAppendEventsChain: Promise<any> = initialized\n  const appendEvents: InternalAppendEvents = async (\n    streamId,\n    events,\n    expectedVersion,\n  ) => {\n    assertInitializing()\n    exclusiveAppendEventsChain = exclusiveAppendEventsChain.then(async () => {\n      if (events.length === 0) {\n        return []\n      }\n      await new Promise((resolve) => setImmediate(resolve)) // edge case for sync setup, see 'can execute after effect' test\n\n      const processedEvents = events.map((rawEvent) => {\n        const event = structuredClone(rawEvent)\n        if (params.postProcessEvent) {\n          const wrappedEvent = wrappedEventBuilder(event) as WrappedEvent<any>\n          const { aggregateRoot } = aggregatRootsByEvents.get(event.type)!\n          const processedEvent = unwrapEvent(\n            params.postProcessEvent(\n              wrappedEvent,\n              aggregateRoot as unknown as Root,\n            ),\n          )\n          Object.assign(event, processedEvent)\n        }\n\n        return event\n      })\n\n      return params.appendEvents(streamId, processedEvents, expectedVersion)\n    })\n\n    return exclusiveAppendEventsChain\n  }\n\n  for (const aggregateRoot of params.aggregateRoots as unknown as InternalAggregateRootApi[]) {\n    aggregateRoot.eventTypes.forEach((eventType) => {\n      aggregatRootsByEvents.set(eventType, {\n        aggregateRoot,\n        eventType,\n      })\n    })\n\n    aggregateRoot.linkEventStore(\n      loadEvents,\n      appendEvents,\n      emitEvents,\n      transaction,\n      params.lock ?? lock(5000),\n      params.aggregateRootSnapshot,\n    )\n  }\n\n  const baseCreateProjection = buildProjectionCreator({\n    loadEvents,\n    checkpoint: params.checkpoint,\n    snapshot: params.projectionSnapshot,\n    onReplay: params.onProjectionReplay,\n  })\n\n  const baseCreateProcessManager = buildProcessManagerCreator({\n    loadEvents,\n    checkpoint: params.checkpoint,\n    onRefresh: params.onProcessManagerRefresh,\n  })\n\n  const getRelatedStreamEvents = (\n    handlers: EventHandlers<any>,\n  ): StreamEvents[] => {\n    const relatedStreamEvents = new Map<string, Set<string>>()\n    for (const handlerName of Object.keys(handlers)) {\n      const sanitizedHandlerName = handlerName.replace(/^(on|after)/, '')\n      if (!aggregatRootsByEvents.has(sanitizedHandlerName)) {\n        throw new Error(\n          `event handler ${handlerName} has no corresponding event in any aggregate root`,\n        )\n      }\n      const {\n        aggregateRoot: { type: aggregateRootName },\n        eventType,\n      } = aggregatRootsByEvents.get(sanitizedHandlerName)!\n      if (!relatedStreamEvents.has(aggregateRootName)) {\n        relatedStreamEvents.set(aggregateRootName, new Set())\n      }\n      relatedStreamEvents.get(aggregateRootName)!.add(eventType)\n    }\n\n    return Array.from(relatedStreamEvents, ([stream, events]) => ({\n      stream,\n      events: Array.from(events),\n    }))\n  }\n\n  const initialize = async () => {\n    initializing = true\n    await Promise.all(\n      projections.values().map((projection) => projection.init(true)),\n    )\n    await Promise.all(\n      processManagers\n        .values()\n        .map((processManager) => processManager.init(true)),\n    )\n    resolveInitialized()\n  }\n  setImmediate(() => {\n    if (allReplaying || params.autoInit === false) {\n      return\n    }\n\n    initialize()\n  })\n\n  const api = {\n    createProjection(name) {\n      if (projections.has(name)) {\n        throw new Error(`Projection ${name} is already registered`)\n      }\n      const api = baseCreateProjection(name)\n      const internalApi = api as unknown as InternalProjection\n      internalApi.setRelatedStreamEvents((handlers) =>\n        getRelatedStreamEvents(handlers),\n      )\n      projections.set(name, internalApi)\n      if (initializing) {\n        internalApi.init(true)\n      }\n      return api\n    },\n    createProcessManager(name) {\n      if (processManagers.has(name)) {\n        throw new Error(`Process Manager ${name} is already registered`)\n      }\n      const api = baseCreateProcessManager(name)\n\n      const internalApi = api as unknown as InternalProcessManager\n      internalApi.setRelatedStreamEvents((handlers) =>\n        getRelatedStreamEvents(handlers),\n      )\n      processManagers.set(name, internalApi)\n      if (initializing) {\n        internalApi.init(true)\n      }\n      return api\n    },\n    createEventListener(name) {\n      if (eventListeners.has(name)) {\n        throw new Error(`Event Listener ${name} is already registered`)\n      }\n\n      const api = createEventListener(name)\n\n      const internalApi = api as unknown as InternalEventListener\n      eventListeners.set(name, internalApi)\n      return api\n    },\n    async isReady() {\n      await initialized\n      await Promise.all([\n        ...projections.values().map((projection) => projection.isReady()),\n        ...processManagers.values().map((projection) => projection.isReady()),\n      ])\n    },\n    async rebuild() {\n      allReplaying = true\n      initializing = true\n      const replayProjections = Array.from(projections.values()).filter(\n        (projection) => projection.canReplay(),\n      )\n      const replayProcessManagers = Array.from(processManagers.values()).filter(\n        (processManager) => processManager.hasState(),\n      )\n\n      await Promise.all([\n        ...replayProjections.map((projection) => projection.init(false)),\n        ...replayProcessManagers.map((projection) => projection.init(false)),\n        ...replayProjections.map((projection) => projection.beginReplay()),\n        ...replayProcessManagers.map((processManager) =>\n          processManager.beginRefresh(),\n        ),\n      ])\n\n      await withRefreshing(async () => {\n        let index = 0\n        for await (const event of loadEvents(null)) {\n          index++\n          await Promise.all([\n            ...replayProjections.map((projection) =>\n              projection.progressReplay(index, event),\n            ),\n            ...replayProcessManagers.map((processManager) =>\n              processManager.progressRefresh(index, event, false),\n            ),\n            ...Array.from(eventListeners.values(), (listener) =>\n              listener.apply(event),\n            ),\n          ])\n          await Promise.all([\n            ...replayProcessManagers.map((processManager) =>\n              processManager.progressRefresh(index, event, true),\n            ),\n            ...Array.from(eventListeners.values(), (listener) =>\n              listener.applyAfter(event),\n            ),\n          ])\n        }\n      })\n\n      await Promise.all([\n        ...replayProjections.map((projection) => projection.endReplay()),\n        ...replayProcessManagers.map((processManager) =>\n          processManager.endRefresh(),\n        ),\n      ])\n\n      await Promise.all(\n        projections.values().map(async (projection) => {\n          if (!projection.canReplay()) {\n            await projection.init(true)\n          }\n        }),\n      )\n      resolveInitialized()\n    },\n    async init() {\n      if (initializing) {\n        return api\n      }\n      await initialize()\n      return api\n    },\n    getAggregateRoot(type) {\n      return params.aggregateRoots.find(\n        (aggregateRoot) => aggregateRoot.type === type,\n      ) as any\n    },\n    async transaction(handler) {\n      return transaction.run(handler)\n    },\n  } as EventStore<any, Root>\n\n  return api\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "7493A3991CE6299464756E2164756E21",
+  "names": []
+}

package/dist/chunk-x90g388y.js

@@ -0,0 +1,22 @@
+import {
+  ReplaySkipError
+} from "./chunk-qdczt68t.js";
+
+// src/replay.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var replayStore = new AsyncLocalStorage;
+function isReplaying() {
+  return replayStore.getStore() ?? false;
+}
+function withReplaying(handler) {
+  return replayStore.run(true, handler);
+}
+function skipReplay() {
+  if (isReplaying()) {
+    throw new ReplaySkipError;
+  }
+}
+
+export { isReplaying, withReplaying, skipReplay };
+
+//# debugId=54300463139EC0AC64756E2164756E21

package/dist/chunk-x90g388y.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/replay.ts"],
+  "sourcesContent": [
+    "import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport { ReplaySkipError } from './errors.ts'\n\nconst replayStore = new AsyncLocalStorage<boolean>()\n\nexport function isReplaying() {\n  return replayStore.getStore() ?? false\n}\n\nexport function withReplaying<T extends () => any>(handler: T) {\n  return replayStore.run(true, handler)\n}\n\nexport function skipReplay() {\n  if (isReplaying()) {\n    throw new ReplaySkipError()\n  }\n}\n"
+  ],
+  "mappings": ";;;;;AAAA;AAIA,IAAM,cAAc,IAAI;AAEjB,SAAS,WAAW,GAAG;AAAA,EAC5B,OAAO,YAAY,SAAS,KAAK;AAAA;AAG5B,SAAS,aAAkC,CAAC,SAAY;AAAA,EAC7D,OAAO,YAAY,IAAI,MAAM,OAAO;AAAA;AAG/B,SAAS,UAAU,GAAG;AAAA,EAC3B,IAAI,YAAY,GAAG;AAAA,IACjB,MAAM,IAAI;AAAA,EACZ;AAAA;",
+  "debugId": "54300463139EC0AC64756E2164756E21",
+  "names": []
+}

package/dist/chunk-z388cd25.js

@@ -0,0 +1,91 @@
+// src/wrappedEventBuilder.ts
+var eventInternalsSymbol = Symbol.for("event-internals");
+function getInternals(event) {
+  return event[eventInternalsSymbol];
+}
+function unwrapEvent(event) {
+  return getInternals(event).event;
+}
+async function handleEventError(event, error) {
+  await getInternals(event).errorHandler?.(error);
+}
+function wrappedEventBuilder(type, payload) {
+  let errorHandler;
+  const event = typeof type === "string" ? {
+    type,
+    payload: payload ?? null
+  } : type;
+  return {
+    withCausationId(causationId) {
+      if (causationId) {
+        event.causationId = causationId;
+      }
+      return this;
+    },
+    withDefaultCausationId(causationId) {
+      if (causationId && !event.causationId) {
+        event.causationId = causationId;
+      }
+      return this;
+    },
+    withCorrelationId(correlationId) {
+      if (correlationId) {
+        event.correlationId = correlationId;
+      }
+      return this;
+    },
+    withDefaultCorrelationId(correlationId) {
+      if (correlationId && !event.correlationId) {
+        event.correlationId = correlationId;
+      }
+      return this;
+    },
+    withActorId(actorId) {
+      if (actorId) {
+        event.actorId = actorId;
+      }
+      return this;
+    },
+    withDefaultActorId(actorId) {
+      if (actorId && !event.actorId) {
+        event.actorId = actorId;
+      }
+      return this;
+    },
+    withMetadata(metadata) {
+      if (metadata) {
+        event.metadata = metadata;
+      }
+      return this;
+    },
+    withDefaultMetadata(metadata) {
+      if (metadata && !event.metadata) {
+        event.metadata = metadata;
+      }
+      return this;
+    },
+    withAdditionalMetadata(metadata) {
+      if (!metadata) {
+        return this;
+      }
+      if (!event.metadata) {
+        event.metadata = metadata;
+      } else {
+        event.metadata = Object.assign(event.metadata, metadata);
+      }
+      return this;
+    },
+    onValidationError(handler) {
+      errorHandler = handler;
+      return this;
+    },
+    get [eventInternalsSymbol]() {
+      return { event, errorHandler };
+    },
+    type
+  };
+}
+
+export { unwrapEvent, handleEventError, wrappedEventBuilder };
+
+//# debugId=D64CAD086572911164756E2164756E21

package/dist/chunk-z388cd25.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/wrappedEventBuilder.ts"],
+  "sourcesContent": [
+    "import type { z } from 'zod/v4'\n\nimport type { EventValidationError } from './errors.ts'\nimport type {\n  BaseInputEvent,\n  EventTemplate,\n  Max,\n  MaybePromise,\n} from './utilityTypes.js'\n\nexport type WrappedEvent<E extends EventTemplate = EventTemplate> = {\n  withCausationId(causationId: string | null | undefined): WrappedEvent<E>\n  withDefaultCausationId(\n    causationId: string | null | undefined,\n  ): WrappedEvent<E>\n  withCorrelationId(correlationId: string | null | undefined): WrappedEvent<E>\n  withDefaultCorrelationId(\n    correlationId: string | null | undefined,\n  ): WrappedEvent<E>\n  withActorId(actorId: string | null | undefined): WrappedEvent<E>\n  withDefaultActorId(actorId: string | null | undefined): WrappedEvent<E>\n  withMetadata(\n    metadata: Record<string, any> | null | undefined,\n  ): WrappedEvent<E>\n  withDefaultMetadata(\n    metadata: Record<string, any> | null | undefined,\n  ): WrappedEvent<E>\n  withAdditionalMetadata(\n    metadata: Record<string, any> | null | undefined,\n  ): WrappedEvent<E>\n  onValidationError(\n    errorHandler: (error: EventValidationError) => MaybePromise<void>,\n  ): WrappedEvent<E>\n  readonly type: string\n}\n\nconst eventInternalsSymbol = Symbol.for('event-internals')\n\nfunction getInternals(event: WrappedEvent) {\n  return (event as any)[eventInternalsSymbol] as {\n    event: Omit<BaseInputEvent, 'schemaVersion'>\n    errorHandler?: (error: EventValidationError) => MaybePromise<void>\n  }\n}\n\nexport function unwrapEvent<E extends EventTemplate = EventTemplate>(\n  event: WrappedEvent<E>,\n) {\n  return getInternals(event).event as {\n    [K in E as K['type']]: Omit<\n      BaseInputEvent<K['type'], z.output<K['schema']>>,\n      'schemaVersion'\n    >\n  }[E['type']]\n}\n\nexport async function handleEventError(\n  event: WrappedEvent,\n  error: EventValidationError,\n) {\n  await getInternals(event).errorHandler?.(error)\n}\n\ntype LatestSchema<\n  Event extends EventTemplate,\n  LatestVersion = Max<Event['version']>,\n  Schema = Event extends { version: LatestVersion } ? Event['schema'] : never,\n> = LatestVersion extends number ? z.input<Schema> : never\n\ntype EventMap<T extends EventTemplate> = {\n  [K in T as K['type']]: LatestSchema<K>\n}\n\nexport type WrappedEventBuilder<Event extends EventTemplate> = {\n  <\n    Type extends Event['type'],\n    LatestVersion = Max<\n      Event extends { type: Type } ? Event['version'] : never\n    >,\n    Schema = Event extends { type: Type; version: LatestVersion }\n      ? Event['schema']\n      : never,\n  >(\n    ...args: z.input<Schema> extends null\n      ? [type: Type, payload?: null]\n      : [type: Type, payload: z.input<Schema>]\n  ): WrappedEvent\n  $inferPayload: EventMap<Event>\n}\n\nexport function wrappedEventBuilder(\n  type: string,\n  payload: unknown,\n): WrappedEvent\nexport function wrappedEventBuilder(event: BaseInputEvent): WrappedEvent\nexport function wrappedEventBuilder(\n  type: string | BaseInputEvent,\n  payload?: unknown,\n): WrappedEvent {\n  let errorHandler: (error: EventValidationError) => MaybePromise<void>\n  const event: Omit<BaseInputEvent, 'schemaVersion'> =\n    typeof type === 'string'\n      ? {\n          type,\n          payload: payload ?? null,\n        }\n      : type\n\n  return {\n    withCausationId(causationId) {\n      if (causationId) {\n        event.causationId = causationId\n      }\n      return this\n    },\n    withDefaultCausationId(causationId) {\n      if (causationId && !event.causationId) {\n        event.causationId = causationId\n      }\n      return this\n    },\n    withCorrelationId(correlationId) {\n      if (correlationId) {\n        event.correlationId = correlationId\n      }\n      return this\n    },\n    withDefaultCorrelationId(correlationId) {\n      if (correlationId && !event.correlationId) {\n        event.correlationId = correlationId\n      }\n      return this\n    },\n    withActorId(actorId) {\n      if (actorId) {\n        event.actorId = actorId\n      }\n      return this\n    },\n    withDefaultActorId(actorId) {\n      if (actorId && !event.actorId) {\n        event.actorId = actorId\n      }\n      return this\n    },\n    withMetadata(metadata) {\n      if (metadata) {\n        event.metadata = metadata\n      }\n      return this\n    },\n    withDefaultMetadata(metadata) {\n      if (metadata && !event.metadata) {\n        event.metadata = metadata\n      }\n      return this\n    },\n    withAdditionalMetadata(metadata) {\n      if (!metadata) {\n        return this\n      }\n      if (!event.metadata) {\n        event.metadata = metadata\n      } else {\n        event.metadata = Object.assign(event.metadata, metadata)\n      }\n\n      return this\n    },\n    onValidationError(handler) {\n      errorHandler = handler\n      return this\n    },\n\n    get [eventInternalsSymbol]() {\n      return { event, errorHandler }\n    },\n\n    type,\n  } as WrappedEvent\n}\n"
+  ],
+  "mappings": ";AAoCA,IAAM,uBAAuB,OAAO,IAAI,iBAAiB;AAEzD,SAAS,YAAY,CAAC,OAAqB;AAAA,EACzC,OAAQ,MAAc;AAAA;AAMjB,SAAS,WAAoD,CAClE,OACA;AAAA,EACA,OAAO,aAAa,KAAK,EAAE;AAAA;AAQ7B,eAAsB,gBAAgB,CACpC,OACA,OACA;AAAA,EACA,MAAM,aAAa,KAAK,EAAE,eAAe,KAAK;AAAA;AAmCzC,SAAS,mBAAmB,CACjC,MACA,SACc;AAAA,EACd,IAAI;AAAA,EACJ,MAAM,QACJ,OAAO,SAAS,WACZ;AAAA,IACE;AAAA,IACA,SAAS,WAAW;AAAA,EACtB,IACA;AAAA,EAEN,OAAO;AAAA,IACL,eAAe,CAAC,aAAa;AAAA,MAC3B,IAAI,aAAa;AAAA,QACf,MAAM,cAAc;AAAA,MACtB;AAAA,MACA,OAAO;AAAA;AAAA,IAET,sBAAsB,CAAC,aAAa;AAAA,MAClC,IAAI,eAAe,CAAC,MAAM,aAAa;AAAA,QACrC,MAAM,cAAc;AAAA,MACtB;AAAA,MACA,OAAO;AAAA;AAAA,IAET,iBAAiB,CAAC,eAAe;AAAA,MAC/B,IAAI,eAAe;AAAA,QACjB,MAAM,gBAAgB;AAAA,MACxB;AAAA,MACA,OAAO;AAAA;AAAA,IAET,wBAAwB,CAAC,eAAe;AAAA,MACtC,IAAI,iBAAiB,CAAC,MAAM,eAAe;AAAA,QACzC,MAAM,gBAAgB;AAAA,MACxB;AAAA,MACA,OAAO;AAAA;AAAA,IAET,WAAW,CAAC,SAAS;AAAA,MACnB,IAAI,SAAS;AAAA,QACX,MAAM,UAAU;AAAA,MAClB;AAAA,MACA,OAAO;AAAA;AAAA,IAET,kBAAkB,CAAC,SAAS;AAAA,MAC1B,IAAI,WAAW,CAAC,MAAM,SAAS;AAAA,QAC7B,MAAM,UAAU;AAAA,MAClB;AAAA,MACA,OAAO;AAAA;AAAA,IAET,YAAY,CAAC,UAAU;AAAA,MACrB,IAAI,UAAU;AAAA,QACZ,MAAM,WAAW;AAAA,MACnB;AAAA,MACA,OAAO;AAAA;AAAA,IAET,mBAAmB,CAAC,UAAU;AAAA,MAC5B,IAAI,YAAY,CAAC,MAAM,UAAU;AAAA,QAC/B,MAAM,WAAW;AAAA,MACnB;AAAA,MACA,OAAO;AAAA;AAAA,IAET,sBAAsB,CAAC,UAAU;AAAA,MAC/B,IAAI,CAAC,UAAU;AAAA,QACb,OAAO;AAAA,MACT;AAAA,MACA,IAAI,CAAC,MAAM,UAAU;AAAA,QACnB,MAAM,WAAW;AAAA,MACnB,EAAO;AAAA,QACL,MAAM,WAAW,OAAO,OAAO,MAAM,UAAU,QAAQ;AAAA;AAAA,MAGzD,OAAO;AAAA;AAAA,IAET,iBAAiB,CAAC,SAAS;AAAA,MACzB,eAAe;AAAA,MACf,OAAO;AAAA;AAAA,SAGJ,qBAAqB,GAAG;AAAA,MAC3B,OAAO,EAAE,OAAO,aAAa;AAAA;AAAA,IAG/B;AAAA,EACF;AAAA;",
+  "debugId": "D64CAD086572911164756E2164756E21",
+  "names": []
+}

package/dist/chunk-zf3x573k.js

@@ -0,0 +1,65 @@
+import {
+  ValidationError
+} from "./chunk-qdczt68t.js";
+
+// src/createCheckpointApi.ts
+import z from "zod/v4";
+var checkpointSchema = z.object({
+  lastEventPosition: z.int(),
+  type: z.enum(["projection", "processManager"]),
+  name: z.string(),
+  metadata: z.record(z.string(), z.any())
+});
+function createCheckpointApi(params) {
+  const api = {
+    relatedStreamEvents: params.relatedStreamEvents,
+    async clear() {
+      await params.delete(params.type, params.name);
+    },
+    async upsert(event, metadata = {}) {
+      await params.upsert({
+        lastEventPosition: event.position,
+        type: params.type,
+        name: params.name,
+        metadata
+      });
+    },
+    async rehydrated(options = {}) {
+      const checkpoint = await params.get(params.type, params.name);
+      let startPosition = 0;
+      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);
+        }
+        startPosition = checkpoint.lastEventPosition + 1;
+        options.onMetadata?.(checkpoint.metadata);
+      }
+      const events = params.loadEvents(params.relatedStreamEvents, {
+        from: startPosition
+      });
+      let index = 0;
+      let lastEvent = null;
+      for await (const event of events) {
+        lastEvent = event;
+        await params.apply(event);
+        index++;
+        options.onProgress?.(index, event);
+      }
+      if (!lastEvent) {
+        return;
+      }
+      if (params.applyAfter) {
+        for await (const event of events) {
+          await params.applyAfter(event);
+        }
+      }
+      await api.upsert(lastEvent, options.getMetadata?.());
+    }
+  };
+  return api;
+}
+
+export { createCheckpointApi };
+
+//# debugId=EDA59BA1E9DE8B8764756E2164756E21

package/dist/chunk-zf3x573k.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/createCheckpointApi.ts"],
+  "sourcesContent": [
+    "import z from 'zod/v4'\n\nimport type { LoadEvents } from './createEventStore.ts'\nimport { ValidationError } from './errors.ts'\nimport type {\n  BaseOutputEvent,\n  MaybePromise,\n  StreamEvents,\n} from './utilityTypes.js'\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})\n\nexport type Checkpoint = z.output<typeof checkpointSchema>\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  upsert: (checkpoint: Checkpoint) => MaybePromise<void>\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  const api = {\n    relatedStreamEvents: params.relatedStreamEvents,\n    async clear() {\n      await params.delete(params.type, params.name)\n    },\n    async upsert(event: BaseOutputEvent, metadata: Record<string, any> = {}) {\n      await params.upsert({\n        lastEventPosition: event.position,\n        type: params.type,\n        name: params.name,\n        metadata,\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 params.get(params.type, params.name)\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": ";;;;;AAAA;AAUA,IAAM,mBAAmB,EAAE,OAAO;AAAA,EAChC,mBAAmB,EAAE,IAAI;AAAA,EACzB,MAAM,EAAE,KAAK,CAAC,cAAc,gBAAgB,CAAC;AAAA,EAC7C,MAAM,EAAE,OAAO;AAAA,EACf,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,IAAI,CAAC;AACxC,CAAC;AAgBM,SAAS,mBAAmB,CACjC,QAQA;AAAA,EACA,MAAM,MAAM;AAAA,IACV,qBAAqB,OAAO;AAAA,SACtB,MAAK,GAAG;AAAA,MACZ,MAAM,OAAO,OAAO,OAAO,MAAM,OAAO,IAAI;AAAA;AAAA,SAExC,OAAM,CAAC,OAAwB,WAAgC,CAAC,GAAG;AAAA,MACvE,MAAM,OAAO,OAAO;AAAA,QAClB,mBAAmB,MAAM;AAAA,QACzB,MAAM,OAAO;AAAA,QACb,MAAM,OAAO;AAAA,QACb;AAAA,MACF,CAAC;AAAA;AAAA,SAEG,WAAU,CACd,UAII,CAAC,GACL;AAAA,MACA,MAAM,aAAa,MAAM,OAAO,IAAI,OAAO,MAAM,OAAO,IAAI;AAAA,MAC5D,IAAI,gBAAgB;AAAA,MACpB,IAAI,YAAY;AAAA,QACd,MAAM,SAAS,iBAAiB,UAAU,UAAU;AAAA,QACpD,IAAI,CAAC,OAAO,SAAS;AAAA,UACnB,MAAM,IAAI,gBACR,yBAAyB,OAAO,QAAQ,OAAO,oCAC/C,OAAO,KACT;AAAA,QACF;AAAA,QACA,gBAAgB,WAAW,oBAAoB;AAAA,QAC/C,QAAQ,aAAa,WAAW,QAAQ;AAAA,MAC1C;AAAA,MAEA,MAAM,SAAS,OAAO,WAAW,OAAO,qBAAqB;AAAA,QAC3D,MAAM;AAAA,MACR,CAAC;AAAA,MAED,IAAI,QAAQ;AAAA,MACZ,IAAI,YAAoC;AAAA,MACxC,iBAAiB,SAAS,QAAQ;AAAA,QAChC,YAAY;AAAA,QACZ,MAAM,OAAO,MAAM,KAAK;AAAA,QACxB;AAAA,QACA,QAAQ,aAAa,OAAO,KAAK;AAAA,MACnC;AAAA,MAEA,IAAI,CAAC,WAAW;AAAA,QACd;AAAA,MACF;AAAA,MAEA,IAAI,OAAO,YAAY;AAAA,QACrB,iBAAiB,SAAS,QAAQ;AAAA,UAChC,MAAM,OAAO,WAAW,KAAK;AAAA,QAC/B;AAAA,MACF;AAAA,MAEA,MAAM,IAAI,OAAO,WAAW,QAAQ,cAAc,CAAC;AAAA;AAAA,EAEvD;AAAA,EAEA,OAAO;AAAA;",
+  "debugId": "EDA59BA1E9DE8B8764756E2164756E21",
+  "names": []
+}