@requence/event-sourcing 1.0.4 → 1.1.1

package/dist/memory/index.js.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../src/memory/index.ts"],
   "sourcesContent": [
-    "import type { AnyAggregateRoot } from '../createAggregateRoot.ts'\nimport type { Checkpoint } from '../createCheckpointApi.ts'\nimport {\n  type AggregateRootSnapshot,\n  ConcurrencyError,\n  type Event,\n  type ProjectionSnapshot,\n  createEventStore as createBaseEventStore,\n  isStreamEvents,\n  isStreamId,\n} from '../index.ts'\nimport type {\n  EventStore,\n  EventStoreParamsWithAggregateRootSnapshots,\n  EventsFromRoot,\n  OnProgress,\n} from '../createEventStore.ts'\nimport type { BaseOutputEvent, MaybePromise } from '../utilityTypes.js'\n\nexport { createAggregateRoot } from '../index.ts'\n\nexport type OnEventsAppended = (\n  events: BaseOutputEvent[],\n) => MaybePromise<void>\n\ninterface MemoryEventStoreParams<Root extends AnyAggregateRoot> {\n  aggregateRoots: Root[]\n  autoInit?: boolean\n  postProcessEvent?: EventStoreParamsWithAggregateRootSnapshots<Root>['postProcessEvent']\n  onProjectionReplay?: OnProgress\n  onProcessManagerRefresh?: OnProgress\n  onEventsAppended?: OnEventsAppended\n}\n\nexport function createEventStore<const Root extends AnyAggregateRoot>({\n  aggregateRoots,\n  postProcessEvent,\n  onProjectionReplay,\n  onProcessManagerRefresh,\n  onEventsAppended,\n  autoInit,\n}: MemoryEventStoreParams<Root>): EventStore<\n  EventsFromRoot<Root>,\n  Root,\n  true\n> {\n  const events: Event[] = []\n  const checkpoints = new Set<Checkpoint>()\n  const aggregateRootSnapshots = new Map<string, AggregateRootSnapshot>()\n  const projectionSnapshots = new Set<ProjectionSnapshot>()\n  const projectionAppliedCount = new Map<string, number>()\n\n  return createBaseEventStore({\n    aggregateRoots,\n    postProcessEvent,\n    onProjectionReplay,\n    onProcessManagerRefresh,\n    autoInit,\n\n    async *loadEvents(select, range) {\n      let streamTypes: string[] | null = null\n      let streamIds: string[] | null = null\n      let eventTypes: string[] | null = null\n\n      if (select) {\n        const selects = Array.isArray(select) ? select : [select]\n        streamTypes = selects.map((select) => select.stream)\n        streamIds = selects\n          .map((select) => (isStreamId(select) ? select.id : null))\n          .filter(Boolean) as string[]\n        eventTypes = selects.flatMap((select) =>\n          isStreamEvents(select) ? select.events : [],\n        )\n      }\n\n      const filteredEvents = events.filter((event) => {\n        if (streamTypes?.length && !streamTypes.includes(event.streamType)) {\n          return false\n        }\n\n        if (streamIds?.length && !streamIds.includes(event.streamId)) {\n          return false\n        }\n\n        if (eventTypes?.length && !eventTypes.includes(event.type)) {\n          return false\n        }\n\n        if (range?.from && event.position < range.from) {\n          return false\n        }\n\n        if (range?.to && event.position > range.to) {\n          return false\n        }\n\n        return true\n      })\n\n      for (const event of filteredEvents) {\n        yield event\n      }\n    },\n\n    appendEvents({ id, stream }, newEvents, expectedVersion) {\n      const lastEvent = events.findLast(\n        (e) => e.streamId === id && e.streamType === stream,\n      )\n\n      const currentVersion = lastEvent?.streamVersion ?? 0\n\n      if (currentVersion !== expectedVersion) {\n        throw new ConcurrencyError(\n          { id, stream },\n          expectedVersion,\n          currentVersion,\n        )\n      }\n\n      const extendedEvents: Event[] = newEvents.map((event, index) => ({\n        ...event,\n        createdAt: new Date(),\n        position: events.length + index,\n        streamId: id,\n        streamType: stream,\n        streamVersion: expectedVersion + index + 1,\n      }))\n\n      events.push(...extendedEvents)\n      onEventsAppended?.(extendedEvents)\n      return extendedEvents\n    },\n\n    checkpoint: {\n      get(type, name) {\n        for (const checkpoint of checkpoints) {\n          if (checkpoint.type === type && checkpoint.name === name) {\n            return checkpoint\n          }\n        }\n      },\n      upsert(checkpoint) {\n        let persisted: Checkpoint | undefined\n        for (const c of checkpoints) {\n          if (c.type === checkpoint.type && c.name === checkpoint.name) {\n            persisted = c\n            break\n          }\n        }\n\n        if (persisted) {\n          persisted.lastEventPosition = checkpoint.lastEventPosition\n          persisted.metadata = checkpoint.metadata\n        } else {\n          checkpoints.add(checkpoint)\n        }\n      },\n      delete(type, name) {\n        for (const checkpoint of checkpoints) {\n          if (checkpoint.type === type && checkpoint.name === name) {\n            checkpoints.delete(checkpoint)\n          }\n        }\n      },\n    },\n\n    projectionSnapshot: {\n      put(snapshot) {\n        projectionSnapshots.add(snapshot)\n      },\n      get(select) {\n        return Array.from(projectionSnapshots)\n          .toReversed()\n          .find(\n            (snapshot) =>\n              snapshot.projectionId === select.id &&\n              snapshot.projectionType === select.projection,\n          )\n      },\n      delete(target, fromPosition) {\n        for (const snapshot of projectionSnapshots) {\n          if (target.id && snapshot.projectionId !== target.id) {\n            continue\n          }\n\n          if (snapshot.projectionType !== target.projection) {\n            continue\n          }\n\n          if (fromPosition && snapshot.lastEventPosition < fromPosition) {\n            continue\n          }\n\n          projectionSnapshots.delete(snapshot)\n        }\n      },\n      incrementAppliedCount(select) {\n        const key = `${select.projection}-${select.id}`\n        const nextCount = (projectionAppliedCount.get(key) ?? 0) + 1\n        projectionAppliedCount.set(key, nextCount)\n        return nextCount\n      },\n    },\n\n    aggregateRootSnapshot: {\n      put(snapshot) {\n        aggregateRootSnapshots.set(\n          `${snapshot.streamType}:${snapshot.streamId}`,\n          snapshot,\n        )\n      },\n      get(select) {\n        return aggregateRootSnapshots.get(`${select.stream}:${select.id}`)\n      },\n      delete(target, fromStreamVersion) {\n        const key = `${target.stream}:${target.id}`\n        const snapshot = aggregateRootSnapshots.get(key)\n        if (snapshot && snapshot.streamVersion > fromStreamVersion) {\n          aggregateRootSnapshots.delete(key)\n        }\n      },\n    },\n  }) as any\n}\n"
+    "import type { AnyAggregateRoot } from '../createAggregateRoot.ts'\nimport type { Checkpoint } from '../createCheckpointApi.ts'\nimport {\n  type AggregateRootSnapshot,\n  ConcurrencyError,\n  type Event,\n  type ProjectionSnapshot,\n  createEventStore as createBaseEventStore,\n  isStreamEvents,\n  isStreamId,\n} from '../index.ts'\nimport type {\n  EventStore,\n  EventStoreParamsWithAggregateRootSnapshots,\n  EventsFromRoot,\n  OnProgress,\n} from '../createEventStore.ts'\nimport type { LockCreator } from '../lock.ts'\nimport type { BaseOutputEvent, MaybePromise } from '../utilityTypes.js'\n\nexport { createAggregateRoot } from '../index.ts'\n\nexport type OnEventsAppended = (\n  events: BaseOutputEvent[],\n) => MaybePromise<void>\n\ninterface MemoryEventStoreParams<Root extends AnyAggregateRoot> {\n  aggregateRoots: Root[]\n  autoInit?: boolean\n  lock?: LockCreator\n  postProcessEvent?: EventStoreParamsWithAggregateRootSnapshots<Root>['postProcessEvent']\n  onProjectionReplay?: OnProgress\n  onProcessManagerRefresh?: OnProgress\n  onEventsAppended?: OnEventsAppended\n}\n\nexport function createEventStore<const Root extends AnyAggregateRoot>({\n  aggregateRoots,\n  postProcessEvent,\n  onProjectionReplay,\n  onProcessManagerRefresh,\n  onEventsAppended,\n  autoInit,\n  lock,\n}: MemoryEventStoreParams<Root>): EventStore<\n  EventsFromRoot<Root>,\n  Root,\n  true\n> {\n  const events: Event[] = []\n  const checkpoints = new Set<Checkpoint>()\n  const aggregateRootSnapshots = new Map<string, AggregateRootSnapshot>()\n  const projectionSnapshots = new Set<ProjectionSnapshot>()\n  const projectionAppliedCount = new Map<string, number>()\n\n  return createBaseEventStore({\n    aggregateRoots,\n    postProcessEvent,\n    onProjectionReplay,\n    onProcessManagerRefresh,\n    autoInit,\n    lock,\n\n    async *loadEvents(select, range) {\n      let streamTypes: string[] | null = null\n      let streamIds: string[] | null = null\n      let eventTypes: string[] | null = null\n\n      if (select) {\n        const selects = Array.isArray(select) ? select : [select]\n        streamTypes = selects.map((select) => select.stream)\n        streamIds = selects\n          .map((select) => (isStreamId(select) ? select.id : null))\n          .filter(Boolean) as string[]\n        eventTypes = selects.flatMap((select) =>\n          isStreamEvents(select) ? select.events : [],\n        )\n      }\n\n      const filteredEvents = events.filter((event) => {\n        if (streamTypes?.length && !streamTypes.includes(event.streamType)) {\n          return false\n        }\n\n        if (streamIds?.length && !streamIds.includes(event.streamId)) {\n          return false\n        }\n\n        if (eventTypes?.length && !eventTypes.includes(event.type)) {\n          return false\n        }\n\n        if (range?.from && event.position < range.from) {\n          return false\n        }\n\n        if (range?.to && event.position > range.to) {\n          return false\n        }\n\n        return true\n      })\n\n      for (const event of filteredEvents) {\n        yield event\n      }\n    },\n\n    appendEvents({ id, stream }, newEvents, expectedVersion) {\n      const lastEvent = events.findLast(\n        (e) => e.streamId === id && e.streamType === stream,\n      )\n\n      const currentVersion = lastEvent?.streamVersion ?? 0\n\n      if (currentVersion !== expectedVersion) {\n        throw new ConcurrencyError(\n          { id, stream },\n          expectedVersion,\n          currentVersion,\n        )\n      }\n\n      const extendedEvents: Event[] = newEvents.map((event, index) => ({\n        ...event,\n        createdAt: new Date(),\n        position: events.length + index,\n        streamId: id,\n        streamType: stream,\n        streamVersion: expectedVersion + index + 1,\n      }))\n\n      events.push(...extendedEvents)\n      onEventsAppended?.(extendedEvents)\n      return extendedEvents\n    },\n\n    checkpoint: {\n      get(type, name) {\n        for (const checkpoint of checkpoints) {\n          if (checkpoint.type === type && checkpoint.name === name) {\n            return checkpoint\n          }\n        }\n      },\n      upsert(checkpoint, expectedVersion) {\n        let persisted: Checkpoint | undefined\n        for (const c of checkpoints) {\n          if (c.type === checkpoint.type && c.name === checkpoint.name) {\n            persisted = c\n            break\n          }\n        }\n\n        if (persisted) {\n          // Compare-and-swap: reject the write when another writer advanced the\n          // checkpoint, or when the caller expected to create a fresh one.\n          if (expectedVersion === null || persisted.version !== expectedVersion) {\n            return false\n          }\n          persisted.lastEventPosition = checkpoint.lastEventPosition\n          persisted.metadata = checkpoint.metadata\n          persisted.version = checkpoint.version\n        } else {\n          checkpoints.add({ ...checkpoint })\n        }\n\n        return true\n      },\n      delete(type, name) {\n        for (const checkpoint of checkpoints) {\n          if (checkpoint.type === type && checkpoint.name === name) {\n            checkpoints.delete(checkpoint)\n          }\n        }\n      },\n    },\n\n    projectionSnapshot: {\n      put(snapshot) {\n        projectionSnapshots.add(snapshot)\n      },\n      get(select) {\n        return Array.from(projectionSnapshots)\n          .toReversed()\n          .find(\n            (snapshot) =>\n              snapshot.projectionId === select.id &&\n              snapshot.projectionType === select.projection,\n          )\n      },\n      delete(target, fromPosition) {\n        for (const snapshot of projectionSnapshots) {\n          if (target.id && snapshot.projectionId !== target.id) {\n            continue\n          }\n\n          if (snapshot.projectionType !== target.projection) {\n            continue\n          }\n\n          if (fromPosition && snapshot.lastEventPosition < fromPosition) {\n            continue\n          }\n\n          projectionSnapshots.delete(snapshot)\n        }\n      },\n      incrementAppliedCount(select) {\n        const key = `${select.projection}-${select.id}`\n        const nextCount = (projectionAppliedCount.get(key) ?? 0) + 1\n        projectionAppliedCount.set(key, nextCount)\n        return nextCount\n      },\n    },\n\n    aggregateRootSnapshot: {\n      put(snapshot) {\n        aggregateRootSnapshots.set(\n          `${snapshot.streamType}:${snapshot.streamId}`,\n          snapshot,\n        )\n      },\n      get(select) {\n        return aggregateRootSnapshots.get(`${select.stream}:${select.id}`)\n      },\n      delete(target, fromStreamVersion) {\n        const key = `${target.stream}:${target.id}`\n        const snapshot = aggregateRootSnapshots.get(key)\n        if (snapshot && snapshot.streamVersion > fromStreamVersion) {\n          aggregateRootSnapshots.delete(key)\n        }\n      },\n    },\n  }) as any\n}\n"
   ],
-  "mappings": "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",
-  "debugId": "C07C59508B45971C64756E2164756E21",
+  "mappings": "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",
+  "debugId": "44866831ADFEF6FD64756E2164756E21",
   "names": []
 }

package/dist/refresh.js

@@ -2,8 +2,8 @@ import {
   isRefreshing,
   skipRefreshing,
   withRefreshing
-} from "./chunk-9psg50cb.js";
-import"./chunk-qdczt68t.js";
+} from "./chunk-6yrb30rx.js";
+import"./chunk-391m4mfp.js";
 export {
   withRefreshing,
   skipRefreshing,

package/dist/replay.js

@@ -2,8 +2,8 @@ import {
   isReplaying,
   skipReplay,
   withReplaying
-} from "./chunk-x90g388y.js";
-import"./chunk-qdczt68t.js";
+} from "./chunk-2fe8jjdc.js";
+import"./chunk-391m4mfp.js";
 export {
   withReplaying,
   skipReplay,

package/dist/snapshotGenerator.js

@@ -1,7 +1,7 @@
 import {
   createSnapshotGenerator
-} from "./chunk-pmfzjavb.js";
-import"./chunk-qdczt68t.js";
+} from "./chunk-8qn1nqnh.js";
+import"./chunk-391m4mfp.js";
 export {
   createSnapshotGenerator as default
 };

package/dist/tests/setup.d.ts

@@ -45,6 +45,7 @@ export declare function setupEventStore<const Root extends AnyAggregateRoot>(agg
         type: "projection" | "processManager";
         name: string;
         metadata: Record<string, any>;
+        version: number;
     }>;
     pseudoEventStore: Event[];
     pseudoAggregateRootSnapshotStore: Map<string, {

package/dist/tests/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/tests/setup.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAEjE,OAAO,EAGL,KAAK,KAAK,EAMX,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;iBAehB,MAAM;gBAGP,MAAM;;;;;;;;;;;;;IAIvB;AAED,wBAAgB,eAAe,CAAC,KAAK,CAAC,IAAI,SAAS,gBAAgB,EACjE,aAAa,EAAE,IAAI,GAAG,IAAI,EAAE,EAC5B,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,KAAK,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyL9E"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/tests/setup.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAEjE,OAAO,EAGL,KAAK,KAAK,EAMX,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;iBAehB,MAAM;gBAGP,MAAM;;;;;;;;;;;;;IAIvB;AAED,wBAAgB,eAAe,CAAC,KAAK,CAAC,IAAI,SAAS,gBAAgB,EACjE,aAAa,EAAE,IAAI,GAAG,IAAI,EAAE,EAC5B,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,KAAK,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmM9E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@requence/event-sourcing",
-  "version": "1.0.4",
+  "version": "1.1.1",
   "description": "Event sourcing primitives — aggregate roots, projections, process managers, and event listeners",
   "type": "module",
   "sideEffects": false,

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

@@ -31,6 +31,7 @@ import type {
   EventsFromRoot,
   OnProgress,
 } from '../createEventStore.ts'
+import type { LockCreator } from '../lock.ts'
 import { superjson } from '../superjson.ts'
 import type {
   BaseOutputEvent,
@@ -49,6 +50,7 @@ interface DrizzleEventStoreParams<Root extends AnyAggregateRoot> {
   database: PgDatabase<any, any> | (() => PgDatabase<any, any>)
   aggregateRoots: Root[]
   autoInit?: boolean
+  lock?: LockCreator
   postProcessEvent?: EventStoreParamsWithAggregateRootSnapshots<Root>['postProcessEvent']
   onProjectionReplay?: OnProgress
   onProcessManagerRefresh?: OnProgress
@@ -120,6 +122,7 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
   onProcessManagerRefresh,
   onEventsAppended,
   autoInit,
+  lock,
 }: DrizzleEventStoreParams<Root>): EventStore<
   EventsFromRoot<Root>,
   Root,
@@ -133,6 +136,7 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
     onProjectionReplay,
     onProcessManagerRefresh,
     autoInit,
+    lock,
     async *loadEvents(select, range) {
       const conditions = [] as SQL[]
 
@@ -258,22 +262,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 +300,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

@@ -15,6 +15,7 @@ import type {
   EventsFromRoot,
   OnProgress,
 } from '../createEventStore.ts'
+import type { LockCreator } from '../lock.ts'
 import type { BaseOutputEvent, MaybePromise } from '../utilityTypes.js'
 
 export { createAggregateRoot } from '../index.ts'
@@ -26,6 +27,7 @@ export type OnEventsAppended = (
 interface MemoryEventStoreParams<Root extends AnyAggregateRoot> {
   aggregateRoots: Root[]
   autoInit?: boolean
+  lock?: LockCreator
   postProcessEvent?: EventStoreParamsWithAggregateRootSnapshots<Root>['postProcessEvent']
   onProjectionReplay?: OnProgress
   onProcessManagerRefresh?: OnProgress
@@ -39,6 +41,7 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
   onProcessManagerRefresh,
   onEventsAppended,
   autoInit,
+  lock,
 }: MemoryEventStoreParams<Root>): EventStore<
   EventsFromRoot<Root>,
   Root,
@@ -56,6 +59,7 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
     onProjectionReplay,
     onProcessManagerRefresh,
     autoInit,
+    lock,
 
     async *loadEvents(select, range) {
       let streamTypes: string[] | null = null
@@ -139,7 +143,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 +153,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) {