@requence/event-sourcing 1.0.4 → 1.1.0

package/src/createCheckpointApi.ts

@@ -1,7 +1,7 @@
 import z from 'zod/v4'
 
 import type { LoadEvents } from './createEventStore.ts'
-import { ValidationError } from './errors.ts'
+import { CheckpointConcurrencyError, ValidationError } from './errors.ts'
 import type {
   BaseOutputEvent,
   MaybePromise,
@@ -13,6 +13,7 @@ const checkpointSchema = z.object({
   type: z.enum(['projection', 'processManager']),
   name: z.string(),
   metadata: z.record(z.string(), z.any()),
+  version: z.int(),
 })
 
 export type Checkpoint = z.output<typeof checkpointSchema>
@@ -26,7 +27,19 @@ export type CheckpointMethods = {
     type: 'projection' | 'processManager',
     name: string,
   ) => MaybePromise<void>
-  upsert: (checkpoint: Checkpoint) => MaybePromise<void>
+  /**
+   * Persist a checkpoint using optimistic concurrency control.
+   *
+   * The write must only succeed if the currently stored version equals
+   * `expectedVersion` (or, when `expectedVersion` is `null`, if no checkpoint
+   * exists yet). `checkpoint.version` holds the version to store on success.
+   * Return `true` when the write was applied and `false` when it was rejected
+   * because another writer had advanced the checkpoint in the meantime.
+   */
+  upsert: (
+    checkpoint: Checkpoint,
+    expectedVersion: number | null,
+  ) => MaybePromise<boolean>
 }
 
 export function createCheckpointApi(
@@ -39,18 +52,81 @@ export function createCheckpointApi(
     applyAfter?: (event: BaseOutputEvent) => MaybePromise<void>
   },
 ) {
+  // In-memory view of the persisted checkpoint version. `null` means "no
+  // checkpoint has been written yet". It is kept in sync with the store on
+  // every load/upsert so optimistic-concurrency writes can detect when another
+  // instance has advanced the same checkpoint.
+  let version: number | null = null
+
   const api = {
     relatedStreamEvents: params.relatedStreamEvents,
     async clear() {
       await params.delete(params.type, params.name)
+      version = null
     },
-    async upsert(event: BaseOutputEvent, metadata: Record<string, any> = {}) {
-      await params.upsert({
-        lastEventPosition: event.position,
-        type: params.type,
-        name: params.name,
-        metadata,
-      })
+    /**
+     * Load the persisted checkpoint and sync the local version. Returns the
+     * raw checkpoint (or `null`), so callers can rehydrate their own state
+     * (e.g. a process manager reloading its folded state) from it.
+     */
+    async load() {
+      const checkpoint = await params.get(params.type, params.name)
+      version = checkpoint?.version ?? null
+      return checkpoint ?? null
+    },
+    /**
+     * Persist the checkpoint position (and optional metadata) for the given
+     * event.
+     *
+     * - `'cas'` (compare-and-swap): the write must land on top of the exact
+     *   version we last observed. If another writer advanced the checkpoint,
+     *   the local version is refreshed and a {@link CheckpointConcurrencyError}
+     *   is thrown so the caller can re-fold its state and retry. Used for
+     *   process managers that fold state into the checkpoint.
+     * - `'monotonic'` (default): retries on conflict, skipping the write once
+     *   the stored position already covers this event. Safe for cursors with
+     *   no derived state (projections, stateless/after-effect writes).
+     */
+    async upsert(
+      event: BaseOutputEvent,
+      metadata: Record<string, any> = {},
+      mode: 'cas' | 'monotonic' = 'monotonic',
+    ) {
+      while (true) {
+        const expectedVersion = version
+        const nextVersion = (expectedVersion ?? -1) + 1
+        const committed = await params.upsert(
+          {
+            lastEventPosition: event.position,
+            type: params.type,
+            name: params.name,
+            metadata,
+            version: nextVersion,
+          },
+          expectedVersion,
+        )
+
+        if (committed) {
+          version = nextVersion
+          return
+        }
+
+        // Another writer advanced this checkpoint. Refresh our view of it.
+        const current = await api.load()
+
+        if (mode === 'cas') {
+          throw new CheckpointConcurrencyError(
+            params.type,
+            params.name,
+            expectedVersion,
+          )
+        }
+
+        // monotonic: the stored cursor already covers this event, nothing to do.
+        if (current && current.lastEventPosition >= event.position) {
+          return
+        }
+      }
     },
     async rehydrated(
       options: {
@@ -59,7 +135,7 @@ export function createCheckpointApi(
         onProgress?: (index: number, event: BaseOutputEvent) => void
       } = {},
     ) {
-      const checkpoint = await params.get(params.type, params.name)
+      const checkpoint = await api.load()
       let startPosition = 0
       if (checkpoint) {
         const result = checkpointSchema.safeParse(checkpoint)

package/src/createProcessManager.ts

@@ -7,6 +7,7 @@ import {
 } from './createCheckpointApi.ts'
 import type { LoadEvents, OnProgress } from './createEventStore.ts'
 import {
+  CheckpointConcurrencyError,
   ProcessManagerEventHandlerExecutionError,
   RefreshingSkipError,
 } from './errors.ts'
@@ -180,39 +181,75 @@ export function buildProcessManagerCreator(params: {
       const runner = (async () => {
         await unlocked
         const refreshing = isRefreshing()
-        await withProcessManagerInfo(
-          {
-            name,
-            event,
-          },
-          async () => {
-            try {
-              await handler(event, { refreshing })
-            } catch (error) {
-              if (error instanceof RefreshingSkipError) {
-                if (refreshing) {
-                  return
+        // Fold state into the process-manager checkpoint with optimistic
+        // concurrency control. Only the stateful `on<Event>` fold needs
+        // compare-and-swap — after-effects and stateless managers persist a
+        // plain cursor, which is safe to write monotonically. When a concurrent
+        // instance advances the checkpoint between our read and write, reload
+        // the latest state and re-apply this event on top of it.
+        const useCas = hasState && !after && !hydrating && !refreshing
+        while (true) {
+          const currentHandler = after
+            ? createAfterEffects(state)[`after${event.type}`]
+            : createEventHandlers(state)[`on${event.type}`]
+          await withProcessManagerInfo(
+            {
+              name,
+              event,
+            },
+            async () => {
+              try {
+                await currentHandler!(event, { refreshing })
+              } catch (error) {
+                if (error instanceof RefreshingSkipError) {
+                  if (refreshing) {
+                    return
+                  }
+
+                  throw new Error(
+                    'RefreshingSkipError should never be thrown outside refresh',
+                  )
                 }
 
-                throw new Error(
-                  'RefreshingSkipError should never be thrown outside refresh',
-                )
-              }
+                if (!(error instanceof Error)) {
+                  throw error
+                }
 
-              if (!(error instanceof Error)) {
-                throw error
+                throw new ProcessManagerEventHandlerExecutionError(
+                  name,
+                  after ? `after${event.type}` : `on${event.type}`,
+                  event,
+                  error,
+                )
               }
+            },
+          )
 
-              throw new ProcessManagerEventHandlerExecutionError(
-                name,
-                after ? `after${event.type}` : `on${event.type}`,
-                event,
-                error,
-              )
+          try {
+            await checkpointApi.upsert(
+              event,
+              { state },
+              useCas ? 'cas' : 'monotonic',
+            )
+            break
+          } catch (error) {
+            if (!(error instanceof CheckpointConcurrencyError)) {
+              throw error
             }
-          },
-        )
-        await checkpointApi.upsert(event, { state })
+
+            // A concurrent writer advanced the checkpoint. Reload the latest
+            // folded state (and version) and re-apply this event on top of it.
+            // This event is emitted only by this instance, so it is never
+            // already part of the reloaded state — we must always re-fold it
+            // (do not skip on position: events are processed out of global
+            // order across instances).
+            const checkpoint = await checkpointApi.load()
+            state =
+              checkpoint?.metadata?.state != null
+                ? clone(checkpoint.metadata.state)
+                : clone(initialState)
+          }
+        }
       })()
 
       if (exclusive) {
@@ -243,12 +280,14 @@ export function buildProcessManagerCreator(params: {
       },
       async beginSession() {
         if (!hasState) return
-        const checkpoint = await params.checkpoint.get(
-          'processManager',
-          name,
-        )
+        // Load through the checkpoint API so the local version is synced with
+        // the store; the subsequent fold relies on it for compare-and-swap.
+        const checkpoint = await checkpointApi.load()
         if (checkpoint) {
-          state = checkpoint.metadata?.state ?? clone(initialState)
+          state =
+            checkpoint.metadata?.state != null
+              ? clone(checkpoint.metadata.state)
+              : clone(initialState)
           lastEventPosition = checkpoint.lastEventPosition
         } else {
           state = clone(initialState)

package/src/drizzle/index.ts

@@ -258,22 +258,36 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
       }
     },
     checkpoint: {
-      async upsert(checkpoint) {
-        await db()
+      async upsert(checkpoint, expectedVersion) {
+        const metadata = superjson.stringify(checkpoint.metadata)
+        // Compare-and-swap: on an existing row the DO UPDATE only fires when
+        // the stored version still matches `expectedVersion`. A `null`
+        // expectation means "insert only" — if the row already exists the
+        // guard fails and no row is returned, signalling a conflict.
+        const committed = await db()
           .insert(checkpoints)
           .values({
             lastEventPosition: checkpoint.lastEventPosition,
             name: checkpoint.name,
             type: checkpoint.type,
-            metadata: superjson.stringify(checkpoint.metadata),
+            metadata,
+            version: checkpoint.version,
           })
           .onConflictDoUpdate({
             target: [checkpoints.type, checkpoints.name],
             set: {
               lastEventPosition: checkpoint.lastEventPosition,
-              metadata: superjson.stringify(checkpoint.metadata),
+              metadata,
+              version: checkpoint.version,
             },
+            setWhere:
+              expectedVersion === null
+                ? sql`false`
+                : eq(checkpoints.version, expectedVersion),
           })
+          .returning({ version: checkpoints.version })
+
+        return committed.length > 0
       },
       async get(type, name) {
         const [checkpoint] = await db()
@@ -282,6 +296,7 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
             name: checkpoints.name,
             lastEventPosition: checkpoints.lastEventPosition,
             metadata: checkpoints.metadata,
+            version: checkpoints.version,
           })
           .from(checkpoints)
           .where(and(eq(checkpoints.type, type), eq(checkpoints.name, name)))

package/src/drizzle/postgres.ts

@@ -99,6 +99,9 @@ export const checkpoints = eventSourcing.table(
     name: text().notNull(),
     lastEventPosition: bigint({ mode: 'number' }).notNull(),
     metadata: text().notNull(),
+    // Optimistic-concurrency guard: bumped on every write so concurrent
+    // instances can detect when they raced on the same checkpoint.
+    version: bigint({ mode: 'number' }).notNull().default(0),
   },
   (table) => [
     unique().on(table.type, table.name),

package/src/errors.ts

@@ -14,6 +14,18 @@ export class ConcurrencyError extends Error {
   }
 }
 
+export class CheckpointConcurrencyError extends Error {
+  constructor(
+    public readonly checkpointType: 'projection' | 'processManager',
+    public readonly name: string,
+    public readonly expectedVersion: number | null,
+  ) {
+    super(
+      `Concurrency error on ${checkpointType} checkpoint "${name}": expected version ${expectedVersion}, but it was modified by another writer`,
+    )
+  }
+}
+
 export class ValidationError extends Error {
   constructor(
     message: string,

package/src/memory/index.ts

@@ -139,7 +139,7 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
           }
         }
       },
-      upsert(checkpoint) {
+      upsert(checkpoint, expectedVersion) {
         let persisted: Checkpoint | undefined
         for (const c of checkpoints) {
           if (c.type === checkpoint.type && c.name === checkpoint.name) {
@@ -149,11 +149,19 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
         }
 
         if (persisted) {
+          // Compare-and-swap: reject the write when another writer advanced the
+          // checkpoint, or when the caller expected to create a fresh one.
+          if (expectedVersion === null || persisted.version !== expectedVersion) {
+            return false
+          }
           persisted.lastEventPosition = checkpoint.lastEventPosition
           persisted.metadata = checkpoint.metadata
+          persisted.version = checkpoint.version
         } else {
-          checkpoints.add(checkpoint)
+          checkpoints.add({ ...checkpoint })
         }
+
+        return true
       },
       delete(type, name) {
         for (const checkpoint of checkpoints) {

package/src/tests/processManagerMultiInstance.spec.ts

@@ -88,7 +88,7 @@ function createSharedDatabase() {
           if (cp.type === type && cp.name === name) return cp
         }
       },
-      upsert(checkpoint: Checkpoint) {
+      upsert(checkpoint: Checkpoint, expectedVersion: number | null) {
         let persisted: Checkpoint | undefined
         for (const c of checkpoints) {
           if (c.type === checkpoint.type && c.name === checkpoint.name) {
@@ -97,11 +97,20 @@ function createSharedDatabase() {
           }
         }
         if (persisted) {
+          // Optimistic-concurrency guard — reject stale writes.
+          if (
+            expectedVersion === null ||
+            persisted.version !== expectedVersion
+          ) {
+            return false
+          }
           persisted.lastEventPosition = checkpoint.lastEventPosition
           persisted.metadata = checkpoint.metadata
+          persisted.version = checkpoint.version
         } else {
-          checkpoints.add(checkpoint)
+          checkpoints.add({ ...checkpoint })
         }
+        return true
       },
       delete(type: string, name: string) {
         for (const cp of checkpoints) {
@@ -123,6 +132,9 @@ function createInstance(
   sharedDb: ReturnType<typeof createSharedDatabase>,
   opts?: {
     onEventsEmitted?: (events: BaseOutputEvent[]) => MaybePromise<void>
+    // Hook invoked before every checkpoint write — lets a test pause one
+    // instance mid-flight to force a concurrent-write interleaving.
+    beforeCheckpointUpsert?: () => MaybePromise<void>
   },
 ) {
   const aggregate = createAggregateRoot('counters')
@@ -135,6 +147,14 @@ function createInstance(
       },
     }))
 
+  const checkpoint = {
+    ...sharedDb.checkpoint,
+    async upsert(cp: Checkpoint, expectedVersion: number | null) {
+      await opts?.beforeCheckpointUpsert?.()
+      return sharedDb.checkpoint.upsert(cp, expectedVersion)
+    },
+  }
+
   const eventStore = createEventStore({
     aggregateRoots: [aggregate],
     autoInit: false,
@@ -145,7 +165,7 @@ function createInstance(
       return appended
     },
     loadEvents: sharedDb.loadEvents.bind(sharedDb),
-    checkpoint: sharedDb.checkpoint,
+    checkpoint,
   })
 
   return { aggregate, eventStore }
@@ -211,4 +231,67 @@ describe('ProcessManager Multi-Instance', () => {
     // Instance A also sees the correct state (loaded from shared checkpoint)
     expect(await pmA.state()).toEqual({ total: 15 })
   })
+
+  it('does not lose updates when two instances fold state concurrently', async () => {
+    const sharedDb = createSharedDatabase()
+
+    // Gate instance A's checkpoint write so we can deterministically force the
+    // race: A reads the (empty) checkpoint and folds its event, then parks
+    // right before persisting. While it is parked, B reads the same empty
+    // checkpoint, folds its own event and commits. When A is released its write
+    // is now stale — without optimistic concurrency it would clobber B's
+    // update and lose it.
+    const aAtGate = Promise.withResolvers<void>()
+    const releaseA = Promise.withResolvers<void>()
+    let aParked = false
+
+    const instanceA = createInstance(sharedDb, {
+      async beforeCheckpointUpsert() {
+        if (!aParked) {
+          aParked = true
+          aAtGate.resolve()
+          await releaseA.promise
+        }
+      },
+    })
+    const pmA = instanceA.eventStore
+      .createProcessManager('counter-pm')
+      .withState({ total: 0 })
+      .withEventHandlers((state) => ({
+        async onCounterIncremented({ payload }) {
+          state.total += payload.amount
+        },
+      }))
+    await instanceA.eventStore.init()
+    await instanceA.eventStore.isReady()
+
+    const instanceB = createInstance(sharedDb)
+    const pmB = instanceB.eventStore
+      .createProcessManager('counter-pm')
+      .withState({ total: 0 })
+      .withEventHandlers((state) => ({
+        async onCounterIncremented({ payload }) {
+          state.total += payload.amount
+        },
+      }))
+    await instanceB.eventStore.init()
+    await instanceB.eventStore.isReady()
+
+    // A starts processing but parks before persisting its checkpoint.
+    const aSettled = instanceA.aggregate.newStream().increment(10).settled()
+    await aAtGate.promise
+
+    // B reads the still-empty checkpoint and commits { total: 5 }.
+    await instanceB.aggregate.newStream().increment(5).settled()
+
+    // Release A — its stale write must be rejected, forcing it to reload B's
+    // state and re-fold on top of it.
+    releaseA.resolve()
+    await aSettled
+
+    const checkpoint = sharedDb.checkpoint.get('processManager', 'counter-pm')!
+    expect(checkpoint.metadata).toEqual({ state: { total: 15 } })
+    expect(await pmA.state()).toEqual({ total: 15 })
+    expect(await pmB.state()).toEqual({ total: 15 })
+  })
 })

package/src/tests/setup.ts

@@ -142,7 +142,7 @@ export function setupEventStore<const Root extends AnyAggregateRoot>(
           }
         }
       },
-      upsert(checkpoint) {
+      upsert(checkpoint, expectedVersion) {
         let persistedCheckpoint: Checkpoint | undefined
         for (const c of pseudoCheckpointStore) {
           if (c.type === checkpoint.type && c.name === checkpoint.name) {
@@ -152,10 +152,20 @@ export function setupEventStore<const Root extends AnyAggregateRoot>(
         }
 
         if (persistedCheckpoint) {
+          if (
+            expectedVersion === null ||
+            persistedCheckpoint.version !== expectedVersion
+          ) {
+            return false
+          }
           persistedCheckpoint.lastEventPosition = checkpoint.lastEventPosition
+          persistedCheckpoint.metadata = checkpoint.metadata
+          persistedCheckpoint.version = checkpoint.version
         } else {
-          pseudoCheckpointStore.add(checkpoint)
+          pseudoCheckpointStore.add({ ...checkpoint })
         }
+
+        return true
       },
       delete(type, name) {
         for (const checkpoint of pseudoCheckpointStore) {

package/dist/chunk-8x4bedr4.js.map

@@ -1,10 +0,0 @@
-{
-  "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  beginSession: () => Promise<void>\n  endSession: () => 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 sessionActive = false\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 beginSession() {\n        if (!hasState) return\n        const checkpoint = await params.checkpoint.get(\n          'processManager',\n          name,\n        )\n        if (checkpoint) {\n          state = checkpoint.metadata?.state ?? clone(initialState)\n          lastEventPosition = checkpoint.lastEventPosition\n        } else {\n          state = clone(initialState)\n          lastEventPosition = -1\n        }\n        sessionActive = true\n      },\n      endSession() {\n        if (!hasState) return\n        state = null\n        sessionActive = false\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        if (!sessionActive && hasState) {\n          const checkpoint = await params.checkpoint.get(\n            'processManager',\n            name,\n          )\n          return checkpoint?.metadata?.state ?? clone(initialState)\n        }\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        // Release state after hydration — it will be loaded\n        // from the checkpoint on the next beginSession call\n        state = null\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": "973C14BE668A8E0964756E2164756E21",
-  "names": []
-}

package/dist/chunk-qdczt68t.js.map

@@ -1,10 +0,0 @@
-{
-  "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-zf3x573k.js.map

@@ -1,10 +0,0 @@
-{
-  "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.ts'\n\nconst checkpointSchema = z.object({\n  lastEventPosition: z.int(),\n  type: z.enum(['projection', 'processManager']),\n  name: z.string(),\n  metadata: z.record(z.string(), z.any()),\n})\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": []
-}