experimental-a2 0.4.0 → 0.5.0

package/dist/server.js

@@ -1,2 +1,2 @@
-import { n as deliverSchedulerAppend, t as createServer } from "./server-CcNnFnoW.js";
+import { n as deliverSchedulerAppend, t as createServer } from "./server-C72KOw51.js";
 export { createServer, deliverSchedulerAppend };

package/dist/{store-C3sNAaBT.d.ts → store-DysUkTH3.d.ts}

@@ -286,6 +286,14 @@ interface A2Store {
    * `read()` when its state schema no longer accepts the cached value.
    */
   readState(sessionId: string, reducerName: string): Promise<StoreStateRead>;
+  /**
+   * Optional batched `readState` — one consistent snapshot-plus-tail read
+   * per session id, aligned positionally with the input (duplicates
+   * allowed). Each element has its own frontier; the batch makes no
+   * cross-session consistency claim. Core falls back to parallel
+   * `readState` calls when absent.
+   */
+  readStates?(sessionIds: string[], reducerName: string): Promise<StoreStateRead[]>;
   /**
    * Writes a disposable reducer cache. Guard this operation so a slower
    * concurrent writer can never clobber a further-along snapshot
@@ -336,4 +344,5 @@ interface A2Store {
   }): AsyncIterable<Event>;
 }
 //#endregion
-export { Event as a, IdSource as c, StoreClaimAvailableResult as d, StoreStateRead as f, StoredSnapshot as g, StoredSessionSummary as h, Clock as i, PresenceRow as l, StoredSessionPage as m, A2StoreInspection as n, EventCause as o, StoredEvent as p, AppendEvent as r, FailAttemptResult as s, A2Store as t, StoreAppendResult as u };
+export { Event as a, IdSource as c, StoreClaimAvailableResult as d, StoreStateRead as f, StoredSnapshot as g, StoredSessionSummary as h, Clock as i, PresenceRow as l, StoredSessionPage as m, A2StoreInspection as n, EventCause as o, StoredEvent as p, AppendEvent as r, FailAttemptResult as s, A2Store as t, StoreAppendResult as u };
+//# sourceMappingURL=store-DysUkTH3.d.ts.map

package/dist/store-DysUkTH3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-DysUkTH3.d.ts","names":[],"sources":["../src/store.ts"],"mappings":";;;KAaY;EACV;EACA;EACA;;EAEA;EACA;EACA,WAAW;;;KAID;EACV;EACA;;EAEA;;;;;;;KAQU,cAAc;;EAExB,OAAO;;EAEP;;EAEA,aAAa;;EAEb;;EAEA;;EAEA,gBAAgB;;EAEhB,eAAe;;EAEf;;EAEA;;EAEA,gBAAgB;;EAEhB;;EAEA,cAAc;;EAEd;;EAEA;;EAEA,UAAU;;;KAIA;EACV;EACA;EACA;EACA;;EAEA;;EAEA;EACA,cAAc;EACd,WAAW;;;;;;;;;KAUD;EACV;EACA;EACA;EACA;EACA,IAAI;EACJ,WAAW;;;KAID;EACV;EACA;EACA,WAAW;;;KAID;;EAEV;IAAY;IAAe;;;EAE3B,QAAQ;;KAGE;EACV,UAAU;;EAEV;;KAGU;EACV,QAAQ;;EAER;;;;;;;KAQU;EACV,aAAa;;IAEX;IACA;IACA;MACE,QAAQ;;;;;;EAMZ,YACE,mBACA;IAAW;IAAoB;IAAuB;MACrD,QAAQ;EACX,cAAc,oBAAoB,QAAQ;;;KAIhC;EACN;EAAoB,QAAQ;;EAC5B;EAAiB,SAAS;;EAC1B;;;KAGM;EACR;EAAsB,QAAQ;;EAAoB;;;KAG1C;;EAEV;;EAEA;;;KAIU;EACV;EACA;;;KAIU;EACV;EACA;;EAEA;;EAEA,QAAQ;;EAER;;EAEA;;;KAIU,gBAAgB;EAAgB;;;KAGhC;EACV,QAAQ;;EAER;;;;;;;KAQU;EACV,OAAO;;;KAIG;UAQK;;;;;;;;;;;;;;;;;;;;;;;EAuBf,OAAO,mBAAmB,QAAQ,gBAAgB,QAAQ;;EAG1D,KACE,mBACA;IAAS;IAAqB;MAC7B,QAAQ;;;;;;;;EASX,eAAe;IACb;IACA;IACA;IACA;IACA;MACE,QAAQ;;;;;;;;;;EAWZ,YAAY;IACV;IACA;IACA;MAAmB;MAAe;;IAClC;IACA;MACE,QAAQ;;;;;;EAOZ,gBAAgB;IACd;IACA;IACA;IACA,QAAQ;MACN,QAAQ;;;;;;EAOZ,YAAY;IACV;IACA;IACA;IACA;IACA;MACE,QAAQ;;;;;;;EAQZ,UAAU,mBAAmB,sBAAsB,QAAQ;;;;;;;;EAS3D,YACE,sBACA,sBACC,QAAQ;;;;;;EAOX,YACE,mBACA,qBACA,eACA,iBACC;;;;;;;EAQH;;;;;;;;;IASE,IACE,YACA,qBACA,QAAQ,gCACR;MAAQ;MAAc,IAAI;MAAM;QAC/B;;IAGH,KAAK,aAAa,QAAQ;;;;;;;IAQ1B,WAAW,YAAY,UAAU,OAAO;;;EAI1C,UAAU;;;;;;;;EASV,OACE,mBACA;IAAS;MACR,cAAc"}

package/dist/store-N8PXxDAS.js

@@ -3,3 +3,5 @@ const SYSTEM_CLOCK = { now: () => /* @__PURE__ */ new Date() };
 const RANDOM_IDS = () => crypto.randomUUID();
 //#endregion
 export { SYSTEM_CLOCK as n, RANDOM_IDS as t };
+
+//# sourceMappingURL=store-N8PXxDAS.js.map

package/dist/store-N8PXxDAS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-N8PXxDAS.js","names":[],"sources":["../src/store.ts"],"sourcesContent":["/**\n * The A2Store interface — the storage contract every store backend\n * implements. See specs/a2-implementation.md §2–3.\n *\n * This is the whole storage contract: append, read, dispatch claims,\n * failure markers, snapshots, and the live stream. The scheduler\n * needs nothing extra — the armed queue message is its own state, and\n * the store is the only thing it consults.\n */\n\nimport type { PresencePatch } from './contract.ts'\n\n/** A stored event, as the public API exposes it. */\nexport type Event = {\n  id: string\n  type: string\n  payload: unknown\n  /** Position in the session's event log, from 1. */\n  index: number\n  sessionId: string\n  createdAt: Date\n}\n\n/** The handler dispatch whose append first persisted a child event. */\nexport type EventCause = {\n  index: number\n  attempt: number\n  /** Size of one named handler append, used to reject truncated retries. */\n  batchSize?: number\n}\n\n/**\n * What the store persists: immutable event history, including its causal edge,\n * plus derived dispatch and failure bookkeeping. The bookkeeping is disposable;\n * the event and its cause are not.\n */\nexport type StoredEvent = Event & {\n  /** Same-session handler dispatch that appended this event; null means root. */\n  cause: EventCause | null\n  /** Session-scoped serial execution key resolved when the event is appended. */\n  lane: string | null\n  /** Adapter clock time recorded by append settlement, completion, or manual skip; null while pending. */\n  processedAt: Date | null\n  /** Dispatch attempt that completed this event; null without dispatch or while pending. */\n  processedByAttempt: number | null\n  /** Exact ordered child ids atomically returned by the completing attempt. */\n  returnedEventIds: string[] | null\n  /** Adapter clock time recorded by the first durable dispatch claim. */\n  firstClaimedAt: Date | null\n  /** Adapter clock time recorded by the most recent durable dispatch claim. */\n  lastClaimedAt: Date | null\n  /** Durable dispatch claims, including claims abandoned by hard kills. */\n  attemptCount: number\n  /** Current dispatch holder; null when the event is not claimed. */\n  claimHolder: string | null\n  /** Adapter clock expiry for the current dispatch claim. */\n  claimExpiresAt: Date | null\n  /** Caught handler failures. This alone drives dead-lettering. */\n  failureCount: number\n  /** Adapter clock time recorded by the most recent caught handler failure. */\n  lastFailedAt: Date | null\n  /** Dispatch attempt that produced the most recent caught handler failure. */\n  lastFailedAttempt: number | null\n  /** The last handler failure, stringified. */\n  lastError: string | null\n  /** Adapter clock time recorded when dead-lettered; null otherwise. */\n  failedAt: Date | null\n}\n\n/** Durable, read-only session metadata for administrative inspection. */\nexport type StoredSessionSummary = {\n  sessionId: string\n  eventCount: number\n  pendingCount: number\n  failedCount: number\n  /** Durable dispatch claims across every event in the session. */\n  attemptCount: number\n  /** Caught handler failures across every event in the session. */\n  failureCount: number\n  firstEventAt: Date\n  updatedAt: Date\n}\n\n/**\n * One live presence value, as `A2Store.presence.read` returns it. The\n * row is the LWW unit — one participant's one field. `at` is the\n * sender's stamp, the LWW comparator. `expiresAt` is the storage's\n * own clock at the applied set plus its `ttlMs` — never derived from\n * the sender stamp; a row is live strictly before it.\n */\nexport type PresenceRow = {\n  participant: string\n  field: string\n  value: unknown\n  seen: number\n  at: Date\n  expiresAt: Date\n}\n\n/** Metadata for the latest cached fold of one reducer. */\nexport type StoredSnapshot = {\n  reducerName: string\n  index: number\n  updatedAt: Date\n}\n\n/** One consistent cache-plus-tail read for a reducer fold. */\nexport type StoreStateRead = {\n  /** The latest cached fold for this reducer, if one exists. */\n  snapshot: { index: number; state: unknown } | null\n  /** Immutable events strictly after `snapshot.index`, or the full log on a miss. */\n  events: Event[]\n}\n\nexport type StoredSessionPage = {\n  sessions: StoredSessionSummary[]\n  /** Opaque backend cursor; null means there is no next page. */\n  cursor: string | null\n}\n\nexport type StoredEventPage = {\n  events: StoredEvent[]\n  /** Fixed inclusive log frontier shared by every page in one inspection. */\n  throughIndex: number\n}\n\n/**\n * Optional read-only administration implemented by A2's shipped stores.\n * It is separate from the correctness contract so custom stores do not\n * need to expose storage-wide discovery merely to process events.\n */\nexport type A2StoreInspection = {\n  listSessions(options: {\n    /** Storage namespace prefix, including the contract separator. */\n    prefix: string\n    cursor?: string\n    limit: number\n  }): Promise<StoredSessionPage>\n  /**\n   * A bounded event page for read-only administration. The first page captures\n   * `throughIndex`; callers pass it back so concurrent appends cannot extend a\n   * walk indefinitely. Optional for custom stores; A2 falls back to `read()`.\n   */\n  readEvents?(\n    sessionId: string,\n    options: { afterIndex: number; throughIndex?: number; limit: number },\n  ): Promise<StoredEventPage>\n  listSnapshots(sessionId: string): Promise<StoredSnapshot[]>\n}\n\n/** The result of atomically claiming every currently eligible event. */\nexport type StoreClaimAvailableResult =\n  | { outcome: 'claimed'; events: StoredEvent[] }\n  | { outcome: 'busy'; retryAt: Date }\n  | { outcome: 'settled' }\n\n/** A completion may lose to a newer claim or an earlier completion. */\nexport type CompleteAttemptResult =\n  { outcome: 'completed'; events: StoredEvent[] } | { outcome: 'superseded' }\n\n/** The result of one claim-renewal heartbeat, both lists in append order. */\nexport type RenewClaimsResult = {\n  /** Listed claims that remain owned by the holder. */\n  renewed: number[]\n  /** Listed claims whose event a newer attempt has durably taken. */\n  superseded: number[]\n}\n\n/** The result of atomically recording a caught handler failure. */\nexport type FailAttemptResult = {\n  outcome: 'failed' | 'dead_lettered' | 'superseded'\n  failureCount: number\n}\n\n/** Input to `A2Store.append` — already validated by the machine. */\nexport type AppendEvent = {\n  type: string\n  payload: unknown\n  /** Caller-supplied idempotency key; generated when absent. */\n  id?: string\n  /** Internal causal edge supplied atomically by handler `session.append`. */\n  cause?: EventCause\n  /** Session-scoped serial execution key resolved before persistence. */\n  lane?: string\n  /** Internal hint: settle this event in the append transaction; no handler is registered. */\n  settled?: true\n}\n\n/** A handler-returned event with the deterministic id retries require. */\nexport type ReturnedEvent = AppendEvent & { id: string }\n\n/** The rows written by an append and the session's pending state. */\nexport type StoreAppendResult = {\n  events: StoredEvent[]\n  /** Whether the session contains an event without a completion marker. */\n  hasPending: boolean\n}\n\n/**\n * An injectable clock. Adapters take one so tests can drive claim\n * expiry, failure timestamps, and (later) stuck-session detection\n * deterministically — against real storage, no mocking.\n */\nexport type Clock = {\n  now(): Date\n}\n\n/** An injectable id source for generated event ids. */\nexport type IdSource = () => string\n\nexport const SYSTEM_CLOCK: Clock = {\n  now: () => new Date(),\n}\n\nexport const RANDOM_IDS: IdSource = () => crypto.randomUUID()\n\nexport interface A2Store {\n  /**\n   * Accepts a batch; the batch is atomic — one transaction, consecutive\n   * `index`es, all-or-nothing. The idempotency key covers the whole\n   * operation, not each item: if *every* event's `id` already exists in\n   * this session, this is a retry of a committed batch whose ack was\n   * lost — return the existing rows as success. If only *some* ids\n   * exist, the caller mixed an already-sent batch with fresh events —\n   * always a caller bug — so throw `A2Error('PARTIAL_DUPLICATE_BATCH')`.\n   * Events carrying `settled: true` get `processedAt` in this same atomic\n   * operation, with no dispatch claim or `processedByAttempt`. The result's\n   * `hasPending` reflects the whole session in the same atomic operation,\n   * including older events and idempotent retries.\n   *\n   * An event carrying `cause` is a handler append, fenced by attempt\n   * currency: accept it only while `cause.attempt` is still the parent\n   * event's latest attempt and the parent is not dead-lettered; otherwise\n   * throw `A2Error('SUPERSEDED_ATTEMPT')` and write nothing. The check is\n   * part of this atomic operation and must serialize against a concurrent\n   * `claimAvailable` — an unlocked read of the parent admits write skew.\n   * The idempotent-replay path runs first, so a batch whose ids all exist\n   * replays regardless of the current attempt.\n   */\n  append(sessionId: string, events: AppendEvent[]): Promise<StoreAppendResult>\n\n  /** Events for one session, oldest first. Bounds form `(afterIndex, throughIndex]`. */\n  read(\n    sessionId: string,\n    opts?: { afterIndex?: number; throughIndex?: number },\n  ): Promise<StoredEvent[]>\n\n  /**\n   * Atomically claims every eligible pending event. Unlaned events are all\n   * independently eligible. Within a lane, only the lowest-index unfinished\n   * event is eligible. A live claim produces `busy` only when it is the sole\n   * remaining obstacle to actionable work. Claimed events are returned in event-log\n   * order. Excluded rows remain lane barriers.\n   */\n  claimAvailable(options: {\n    sessionId: string\n    holder: string\n    ttlMs: number\n    expiresAtMs?: number\n    excludeIndexes?: readonly number[]\n  }): Promise<StoreClaimAvailableResult>\n\n  /**\n   * Renews the listed live claims still owned by `holder`. Each listed claim\n   * carries the attempt ordinal the holder owns. `renewed` lists the claims\n   * that remain owned after the operation; `superseded` lists the claims\n   * whose event's `attemptCount` has durably passed the listed attempt. An\n   * expired claim no successor has taken appears in neither list — its\n   * attempt may still complete (`completeAttempt` is the fence), so it is\n   * not reported as lost. Renewal never revives an expired claim.\n   */\n  renewClaims(options: {\n    sessionId: string\n    holder: string\n    claims: readonly { index: number; attempt: number }[]\n    ttlMs: number\n    expiresAtMs?: number\n  }): Promise<RenewClaimsResult>\n\n  /**\n   * Atomically completes one current attempt and appends its returned events.\n   * Retrying a committed completion with the same attempt and deterministic\n   * child ids returns the existing children. A stale attempt never appends.\n   */\n  completeAttempt(options: {\n    sessionId: string\n    index: number\n    attempt: number\n    events: ReturnedEvent[]\n  }): Promise<CompleteAttemptResult>\n\n  /**\n   * Atomically records a caught failure for one claimed attempt. A stale\n   * attempt cannot poison a processed event or a newer dispatch. Accepted\n   * failures record the operation's clock time.\n   */\n  failAttempt(options: {\n    sessionId: string\n    index: number\n    attempt: number\n    error: string\n    maxFailures: number\n  }): Promise<FailAttemptResult>\n\n  /**\n   * Reads a reducer snapshot and its event tail as one consistent adapter\n   * operation. On a cache miss, `snapshot` is null and `events` is the full\n   * log. The snapshot is untrusted; core may reject it and issue a full\n   * `read()` when its state schema no longer accepts the cached value.\n   */\n  readState(sessionId: string, reducerName: string): Promise<StoreStateRead>\n\n  /**\n   * Optional batched `readState` — one consistent snapshot-plus-tail read\n   * per session id, aligned positionally with the input (duplicates\n   * allowed). Each element has its own frontier; the batch makes no\n   * cross-session consistency claim. Core falls back to parallel\n   * `readState` calls when absent.\n   */\n  readStates?(\n    sessionIds: string[],\n    reducerName: string,\n  ): Promise<StoreStateRead[]>\n\n  /**\n   * Writes a disposable reducer cache. Guard this operation so a slower\n   * concurrent writer can never clobber a further-along snapshot\n   * (`where up_to_index < excluded.up_to_index`).\n   */\n  putSnapshot(\n    sessionId: string,\n    reducerName: string,\n    index: number,\n    state: unknown,\n  ): Promise<void>\n\n  /**\n   * Optional ephemeral-plane capability (specs/a2-implementation.md\n   * §15.1) — optional like snapshots are. Values arrive already\n   * validated by core; adapters store them opaquely. Presence never\n   * touches the event log: no index, no history row, no recovery arm.\n   */\n  presence?: {\n    /**\n     * Field-wise last-writer-wins merge of one participant's values:\n     * a field whose existing row has a strictly newer `at` (the\n     * sender's stamp) is left untouched; `null` deletes the row. Every\n     * applied write refreshes that field's expiry to the storage's own\n     * clock plus `ttlMs` — the sender stamp orders writes but never\n     * anchors their lifetime.\n     */\n    set(\n      ns: string,\n      participant: string,\n      values: Record<string, unknown | null>,\n      meta: { seen: number; at: Date; ttlMs: number },\n    ): Promise<void>\n\n    /** The current map, pruned of rows at or past their `expiresAt`. */\n    read(ns: string): Promise<PresenceRow[]>\n\n    /**\n     * Push-tier patch delivery; present only on backends with a real\n     * broadcast primitive. Without it the backend is the degraded\n     * tier: live feeds surface presence by re-reading on their\n     * existing poll cadence.\n     */\n    subscribe?(ns: string, onPatch: (patch: PresencePatch) => void): () => void\n  }\n\n  /** Read-only operational data used by `experimental-a2/devtools/server`. */\n  inspect?: A2StoreInspection\n\n  /**\n   * A live feed of one session's events, starting after `startAfter`\n   * (exclusive). Transport is the backend's choice — in-process pub/sub,\n   * polling, LISTEN/NOTIFY — callers never branch on which. The iterable\n   * ends when the consumer calls `return()` (e.g. a disconnecting SSE\n   * client) and must deliver events appended after subscription.\n   */\n  stream(\n    sessionId: string,\n    opts?: { startAfter?: number },\n  ): AsyncIterable<Event>\n}\n"],"mappings":";AAkNA,MAAa,eAAsB,EACjC,2BAAW,IAAI,KAAK,EACtB;AAEA,MAAa,mBAA6B,OAAO,WAAW"}

package/dist/store-codec-DTG0Ftek.js

@@ -6,3 +6,5 @@ const decodeReturnedEventIds = (value) => {
 };
 //#endregion
 export { decodeReturnedEventIds as t };
+
+//# sourceMappingURL=store-codec-DTG0Ftek.js.map

package/dist/store-codec-DTG0Ftek.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-codec-DTG0Ftek.js","names":[],"sources":["../src/store-codec.ts"],"sourcesContent":["export const decodeReturnedEventIds = (value: unknown): string[] => {\n  const decoded: unknown = typeof value === 'string' ? JSON.parse(value) : value\n  if (\n    !Array.isArray(decoded) ||\n    decoded.some((eventId) => typeof eventId !== 'string')\n  ) {\n    throw new TypeError('stored event has invalid returned event ids')\n  }\n  return decoded\n}\n"],"mappings":";AAAA,MAAa,0BAA0B,UAA6B;CAClE,MAAM,UAAmB,OAAO,UAAU,WAAW,KAAK,MAAM,KAAK,IAAI;CACzE,IACE,CAAC,MAAM,QAAQ,OAAO,KACtB,QAAQ,MAAM,YAAY,OAAO,YAAY,QAAQ,GAErD,MAAM,IAAI,UAAU,6CAA6C;CAEnE,OAAO;AACT"}

package/dist/store-memory.d.ts

@@ -1,4 +1,4 @@
-import { c as IdSource, i as Clock, t as A2Store } from "./store-C3sNAaBT.js";
+import { c as IdSource, i as Clock, t as A2Store } from "./store-DysUkTH3.js";
 //#region src/store-memory.d.ts
 type MemoryStoreOptions = {
   /** Injectable clock — every stored timestamp comes from here. */
@@ -8,4 +8,5 @@ type MemoryStoreOptions = {
 };
 declare function memory(options?: MemoryStoreOptions): A2Store;
 //#endregion
-export { MemoryStoreOptions, memory };
+export { MemoryStoreOptions, memory };
+//# sourceMappingURL=store-memory.d.ts.map

package/dist/store-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-memory.d.ts","names":[],"sources":["../src/store-memory.ts"],"mappings":";;KA2BY;;EAEV,QAAQ;;EAER,MAAM;;iBAyEQ,OAAO,UAAS,qBAA0B"}

package/dist/store-memory.js

@@ -1,5 +1,5 @@
 import { t as A2Error } from "./errors-BQuJpe82.js";
-import { g as nullProtoRecord } from "./internal-aEotMzu_.js";
+import { g as nullProtoRecord } from "./internal-DstsI6Re.js";
 import { t as idempotentReplay } from "./idempotent-replay-DuqEkYA7.js";
 import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS.js";
 //#region src/store-memory.ts
@@ -162,6 +162,18 @@ function memory(options = {}) {
 		}
 		return inserted;
 	};
+	const readStateOf = (sessionId, reducerName) => {
+		const snap = snapshots.get(`${sessionId}\u0000${reducerName}`);
+		const snapshot = snap ? {
+			index: snap.index,
+			state: structuredClone(snap.state)
+		} : null;
+		const afterIndex = snapshot?.index ?? 0;
+		return {
+			snapshot,
+			events: (sessions.get(sessionId) ?? []).filter((row) => row.index > afterIndex).map(toEvent)
+		};
+	};
 	return {
 		async append(sessionId, events) {
 			if (events.length === 0) return appendResult(sessionId, []);
@@ -304,16 +316,10 @@ function memory(options = {}) {
 			};
 		},
 		async readState(sessionId, reducerName) {
-			const snap = snapshots.get(`${sessionId}\u0000${reducerName}`);
-			const snapshot = snap ? {
-				index: snap.index,
-				state: structuredClone(snap.state)
-			} : null;
-			const afterIndex = snapshot?.index ?? 0;
-			return {
-				snapshot,
-				events: (sessions.get(sessionId) ?? []).filter((row) => row.index > afterIndex).map(toEvent)
-			};
+			return readStateOf(sessionId, reducerName);
+		},
+		async readStates(sessionIds, reducerName) {
+			return sessionIds.map((sessionId) => readStateOf(sessionId, reducerName));
 		},
 		async putSnapshot(sessionId, reducerName, index, state) {
 			const key = `${sessionId}\u0000${reducerName}`;
@@ -523,3 +529,5 @@ function memory(options = {}) {
 }
 //#endregion
 export { memory };
+
+//# sourceMappingURL=store-memory.js.map

package/dist/store-memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-memory.js","names":[],"sources":["../src/store-memory.ts"],"sourcesContent":["/**\n * experimental-a2/store-memory — in-memory store backend (the test default).\n *\n * Implements the A2Store interface with zero dependencies. See\n * specs/a2-implementation.md §3 for the contract; the conformance suite\n * in test/conformance is the executable version of it.\n */\n\nimport type { PresencePatch } from './contract.ts'\nimport { A2Error } from './errors.ts'\nimport { idempotentReplay } from './idempotent-replay.ts'\nimport { nullProtoRecord } from './internal.ts'\nimport {\n  RANDOM_IDS,\n  SYSTEM_CLOCK,\n  type A2Store,\n  type AppendEvent,\n  type Clock,\n  type Event,\n  type EventCause,\n  type IdSource,\n  type PresenceRow,\n  type StoredEvent,\n  type StoredSessionSummary,\n  type StoreStateRead,\n} from './store.ts'\n\nexport type MemoryStoreOptions = {\n  /** Injectable clock — every stored timestamp comes from here. */\n  clock?: Clock\n  /** Injectable id source for generated event ids. */\n  ids?: IdSource\n}\n\ntype Row = {\n  id: string\n  type: string\n  payload: unknown\n  index: number\n  sessionId: string\n  createdAt: Date\n  cause: EventCause | null\n  lane: string | null\n  processedAt: Date | null\n  processedByAttempt: number | null\n  returnedEventIds: string[] | null\n  firstClaimedAt: Date | null\n  lastClaimedAt: Date | null\n  attemptCount: number\n  claimHolder: string | null\n  claimExpiresAt: Date | null\n  failureCount: number\n  lastFailedAt: Date | null\n  lastFailedAttempt: number | null\n  lastError: string | null\n  failedAt: Date | null\n}\n\ntype PresenceEntry = {\n  value: unknown\n  seen: number\n  at: Date\n  expiresAt: Date\n}\n\ntype LaneQueue = { rows: Row[]; head: number }\ntype SessionDispatch = {\n  ready: Map<number, Row>\n  lanes: Map<string, LaneQueue>\n}\n\nconst toStored = (row: Row): StoredEvent => ({\n  id: row.id,\n  type: row.type,\n  payload: structuredClone(row.payload),\n  index: row.index,\n  sessionId: row.sessionId,\n  createdAt: new Date(row.createdAt),\n  cause: row.cause ? { ...row.cause } : null,\n  lane: row.lane,\n  processedAt: row.processedAt ? new Date(row.processedAt) : null,\n  processedByAttempt: row.processedByAttempt,\n  returnedEventIds: row.returnedEventIds ? [...row.returnedEventIds] : null,\n  firstClaimedAt: row.firstClaimedAt ? new Date(row.firstClaimedAt) : null,\n  lastClaimedAt: row.lastClaimedAt ? new Date(row.lastClaimedAt) : null,\n  attemptCount: row.attemptCount,\n  claimHolder: row.claimHolder,\n  claimExpiresAt: row.claimExpiresAt ? new Date(row.claimExpiresAt) : null,\n  failureCount: row.failureCount,\n  lastFailedAt: row.lastFailedAt ? new Date(row.lastFailedAt) : null,\n  lastFailedAttempt: row.lastFailedAttempt,\n  lastError: row.lastError,\n  failedAt: row.failedAt ? new Date(row.failedAt) : null,\n})\n\nconst toEvent = (row: Row): Event => ({\n  id: row.id,\n  type: row.type,\n  payload: structuredClone(row.payload),\n  index: row.index,\n  sessionId: row.sessionId,\n  createdAt: new Date(row.createdAt),\n})\n\nexport function memory(options: MemoryStoreOptions = {}): A2Store {\n  const clock = options.clock ?? SYSTEM_CLOCK\n  const generateId = options.ids ?? RANDOM_IDS\n\n  const sessions = new Map<string, Row[]>()\n  const dispatch = new Map<string, SessionDispatch>()\n  /** Global unique index on event ids, like the SQL schema's. */\n  const byEventId = new Map<string, Row>()\n  /** Keyed by `${sessionId}\\u0000${reducerName}` — a pure cache. */\n  const snapshots = new Map<\n    string,\n    { index: number; state: unknown; updatedAt: Date }\n  >()\n  const streamSubscribers = new Map<string, Set<(row: Row) => void>>()\n  /** ns → participant → field → latest surviving write. */\n  const presenceRows = new Map<\n    string,\n    Map<string, Map<string, PresenceEntry>>\n  >()\n  const presenceSubscribers = new Map<\n    string,\n    Set<(patch: PresencePatch) => void>\n  >()\n\n  const notifyStreams = (sessionId: string, rows: Row[]): void => {\n    const subs = streamSubscribers.get(sessionId)\n    if (!subs) return\n    for (const listener of subs) {\n      for (const row of rows) listener(row)\n    }\n  }\n\n  const rowsOf = (sessionId: string): Row[] => {\n    let rows = sessions.get(sessionId)\n    if (!rows) {\n      rows = []\n      sessions.set(sessionId, rows)\n    }\n    return rows\n  }\n\n  const dispatchOf = (sessionId: string): SessionDispatch => {\n    let state = dispatch.get(sessionId)\n    if (!state) {\n      state = { ready: new Map(), lanes: new Map() }\n      dispatch.set(sessionId, state)\n    }\n    return state\n  }\n\n  const enqueue = (sessionId: string, row: Row): void => {\n    if (row.processedAt !== null) return\n    const state = dispatchOf(sessionId)\n    if (row.lane === null) {\n      state.ready.set(row.index, row)\n      return\n    }\n    let queue = state.lanes.get(row.lane)\n    if (!queue) {\n      queue = { rows: [], head: 0 }\n      state.lanes.set(row.lane, queue)\n    }\n    queue.rows.push(row)\n    if (queue.rows.length === 1) state.ready.set(row.index, row)\n  }\n\n  const settle = (sessionId: string, row: Row): void => {\n    const state = dispatchOf(sessionId)\n    state.ready.delete(row.index)\n    if (row.lane === null) return\n    const queue = state.lanes.get(row.lane)!\n    if (queue.rows[queue.head] !== row) return\n    queue.head += 1\n    if (queue.head === queue.rows.length) {\n      state.lanes.delete(row.lane)\n      return\n    }\n    const next = queue.rows[queue.head]!\n    if (next.failedAt === null) state.ready.set(next.index, next)\n  }\n\n  const find = (sessionId: string, index: number): Row => {\n    const row = sessions.get(sessionId)?.[index - 1]\n    if (!row) {\n      throw new TypeError(\n        `no event at index ${index} in session '${sessionId}'`,\n      )\n    }\n    return row\n  }\n\n  const appendResult = (sessionId: string, events: StoredEvent[]) => ({\n    events,\n    hasPending: (sessions.get(sessionId) ?? []).some(\n      (row) => row.processedAt === null,\n    ),\n  })\n\n  const claim = (\n    row: Row,\n    holder: string,\n    now: Date,\n    expiresAt: Date,\n  ): StoredEvent => {\n    row.attemptCount += 1\n    row.firstClaimedAt ??= new Date(now)\n    row.lastClaimedAt = new Date(now)\n    row.claimHolder = holder\n    row.claimExpiresAt = new Date(expiresAt)\n    return toStored(row)\n  }\n\n  const checkBatchIds = (\n    sessionId: string,\n    events: readonly (AppendEvent & { id?: string })[],\n  ): Row[] => {\n    const supplied = events.filter(\n      (candidate): candidate is AppendEvent & { id: string } =>\n        candidate.id !== undefined,\n    )\n    const suppliedIds = new Set(supplied.map((candidate) => candidate.id))\n    if (suppliedIds.size !== supplied.length) {\n      throw new A2Error(\n        'PARTIAL_DUPLICATE_BATCH',\n        'batch contains the same event id more than once',\n      )\n    }\n    const existing = supplied\n      .map((candidate) => byEventId.get(candidate.id))\n      .filter((row): row is Row => row !== undefined)\n    const foreign = existing.find((row) => row.sessionId !== sessionId)\n    if (foreign) {\n      throw new A2Error(\n        'PARTIAL_DUPLICATE_BATCH',\n        `event id '${foreign.id}' already exists in another session`,\n      )\n    }\n    return existing\n  }\n\n  const insert = (\n    sessionId: string,\n    events: readonly AppendEvent[],\n    now: Date,\n    cause?: EventCause,\n  ): Row[] => {\n    const rows = rowsOf(sessionId)\n    const base = rows.length === 0 ? 0 : rows[rows.length - 1]!.index\n    const inserted = events.map((candidate, offset): Row => ({\n      id: candidate.id ?? generateId(),\n      type: candidate.type,\n      payload: structuredClone(candidate.payload),\n      index: base + 1 + offset,\n      sessionId,\n      createdAt: new Date(now),\n      cause: cause\n        ? { ...cause }\n        : candidate.cause\n          ? { ...candidate.cause }\n          : null,\n      lane: candidate.lane ?? null,\n      processedAt: candidate.settled ? new Date(now) : null,\n      processedByAttempt: null,\n      returnedEventIds: null,\n      firstClaimedAt: null,\n      lastClaimedAt: null,\n      attemptCount: 0,\n      claimHolder: null,\n      claimExpiresAt: null,\n      failureCount: 0,\n      lastFailedAt: null,\n      lastFailedAttempt: null,\n      lastError: null,\n      failedAt: null,\n    }))\n    for (const row of inserted) {\n      if (byEventId.has(row.id)) {\n        throw new A2Error(\n          'PARTIAL_DUPLICATE_BATCH',\n          `event id '${row.id}' already exists`,\n        )\n      }\n    }\n    for (const row of inserted) {\n      rows.push(row)\n      byEventId.set(row.id, row)\n      enqueue(sessionId, row)\n    }\n    return inserted\n  }\n\n  const readStateOf = (\n    sessionId: string,\n    reducerName: string,\n  ): StoreStateRead => {\n    const snap = snapshots.get(`${sessionId}\\u0000${reducerName}`)\n    const snapshot = snap\n      ? { index: snap.index, state: structuredClone(snap.state) }\n      : null\n    const afterIndex = snapshot?.index ?? 0\n    return {\n      snapshot,\n      events: (sessions.get(sessionId) ?? [])\n        .filter((row) => row.index > afterIndex)\n        .map(toEvent),\n    }\n  }\n\n  return {\n    async append(sessionId, events) {\n      if (events.length === 0) return appendResult(sessionId, [])\n\n      // Batch-scoped idempotency (a2-implementation.md §3): all ids\n      // already present → lost-ack retry, return the original rows;\n      // some present → the caller mixed sent and fresh events.\n      const existing = checkBatchIds(sessionId, events)\n      if (existing.length > 0) {\n        if (existing.length === events.length) {\n          return appendResult(\n            sessionId,\n            idempotentReplay(events, existing.map(toStored)),\n          )\n        }\n        throw new A2Error(\n          'PARTIAL_DUPLICATE_BATCH',\n          `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`,\n        )\n      }\n\n      // Attempt-currency fence: a fresh handler append commits only while\n      // its causal attempt is still the parent's latest (store.ts `append`).\n      const rows = sessions.get(sessionId) ?? []\n      for (const event of events) {\n        if (!event.cause) continue\n        const parent = rows[event.cause.index - 1]\n        if (!parent) {\n          throw new TypeError(\n            `no event at index ${event.cause.index} in session '${sessionId}'`,\n          )\n        }\n        if (\n          parent.attemptCount !== event.cause.attempt ||\n          parent.failedAt !== null\n        ) {\n          throw new A2Error(\n            'SUPERSEDED_ATTEMPT',\n            `attempt ${event.cause.attempt} no longer owns event ${event.cause.index} in session '${sessionId}'`,\n          )\n        }\n      }\n\n      const now = clock.now()\n      const inserted = insert(sessionId, events, now)\n      notifyStreams(sessionId, inserted)\n      return appendResult(sessionId, inserted.map(toStored))\n    },\n\n    async read(sessionId, opts) {\n      const rows = sessions.get(sessionId) ?? []\n      const start = Math.max(0, opts?.afterIndex ?? 0)\n      const end = Math.max(0, opts?.throughIndex ?? rows.length)\n      return rows.slice(start, end).map(toStored)\n    },\n\n    async claimAvailable({\n      sessionId,\n      holder,\n      ttlMs,\n      expiresAtMs,\n      excludeIndexes,\n    }) {\n      const claimedAt = clock.now()\n      const now = claimedAt.getTime()\n      const expiresAt = new Date(expiresAtMs ?? now + ttlMs)\n      const excluded = new Set(excludeIndexes ?? [])\n      const eligible: Row[] = []\n      let retryAt: Date | null = null\n\n      for (const row of dispatchOf(sessionId).ready.values()) {\n        if (row.failedAt !== null || excluded.has(row.index)) continue\n        if (row.claimExpiresAt && row.claimExpiresAt.getTime() > now) {\n          if (!retryAt || row.claimExpiresAt < retryAt) {\n            retryAt = new Date(row.claimExpiresAt)\n          }\n          continue\n        }\n        eligible.push(row)\n      }\n\n      if (eligible.length === 0) {\n        return retryAt ? { outcome: 'busy', retryAt } : { outcome: 'settled' }\n      }\n      eligible.sort((a, b) => a.index - b.index)\n      return {\n        outcome: 'claimed',\n        events: eligible.map((row) => claim(row, holder, claimedAt, expiresAt)),\n      }\n    },\n\n    async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {\n      const now = clock.now()\n      const expiresAt = new Date(expiresAtMs ?? now.getTime() + ttlMs)\n      const requested = new Map(claims.map((c) => [c.index, c.attempt]))\n      const renewed: number[] = []\n      const superseded: number[] = []\n      for (const row of sessions.get(sessionId) ?? []) {\n        const attempt = requested.get(row.index)\n        if (attempt === undefined) continue\n        if (row.attemptCount > attempt) {\n          superseded.push(row.index)\n          continue\n        }\n        if (\n          row.processedAt === null &&\n          row.failedAt === null &&\n          row.claimHolder === holder &&\n          row.claimExpiresAt !== null &&\n          row.claimExpiresAt > now\n        ) {\n          row.claimExpiresAt = new Date(expiresAt)\n          renewed.push(row.index)\n        }\n      }\n      return { renewed, superseded }\n    },\n\n    async completeAttempt({ sessionId, index, attempt, events }) {\n      const parent = find(sessionId, index)\n      const cause = { index, attempt }\n      if (parent.processedAt !== null) {\n        if (parent.processedByAttempt !== attempt) {\n          return { outcome: 'superseded' }\n        }\n        const requestedIds = events.map((event) => event.id)\n        if (\n          parent.returnedEventIds === null ||\n          parent.returnedEventIds.length !== requestedIds.length ||\n          parent.returnedEventIds.some(\n            (id, offset) => id !== requestedIds[offset],\n          )\n        ) {\n          throw new A2Error(\n            'PARTIAL_DUPLICATE_BATCH',\n            'completed attempt does not match the returned event batch',\n          )\n        }\n        const existing = checkBatchIds(sessionId, events)\n        if (\n          existing.length !== events.length ||\n          existing.some(\n            (row) =>\n              row.cause?.index !== index || row.cause.attempt !== attempt,\n          )\n        ) {\n          throw new A2Error(\n            'PARTIAL_DUPLICATE_BATCH',\n            'completed attempt does not match the returned event batch',\n          )\n        }\n        return {\n          outcome: 'completed',\n          events: idempotentReplay(events, existing.map(toStored)),\n        }\n      }\n      if (\n        parent.attemptCount !== attempt ||\n        parent.failedAt !== null ||\n        parent.claimHolder === null\n      ) {\n        return { outcome: 'superseded' }\n      }\n\n      const existing = checkBatchIds(sessionId, events)\n      if (existing.length > 0) {\n        throw new A2Error(\n          'PARTIAL_DUPLICATE_BATCH',\n          'returned event batch contains already-appended ids',\n        )\n      }\n      const now = clock.now()\n      const inserted = insert(sessionId, events, now, cause)\n      parent.processedAt = new Date(now)\n      parent.processedByAttempt = attempt\n      parent.returnedEventIds = events.map((event) => event.id)\n      parent.claimHolder = null\n      parent.claimExpiresAt = null\n      settle(sessionId, parent)\n      notifyStreams(sessionId, inserted)\n      return { outcome: 'completed', events: inserted.map(toStored) }\n    },\n\n    async failAttempt({ sessionId, index, attempt, error, maxFailures }) {\n      const row = find(sessionId, index)\n      if (\n        row.processedAt ||\n        row.attemptCount !== attempt ||\n        (row.claimHolder === null && row.lastFailedAttempt !== attempt)\n      ) {\n        return { outcome: 'superseded', failureCount: row.failureCount }\n      }\n      if (row.lastFailedAttempt === attempt && row.claimHolder === null) {\n        return {\n          outcome: row.failedAt ? 'dead_lettered' : 'failed',\n          failureCount: row.failureCount,\n        }\n      }\n      if (row.failedAt) {\n        return { outcome: 'dead_lettered', failureCount: row.failureCount }\n      }\n      row.failureCount += 1\n      row.lastError = error\n      const failedAt = clock.now()\n      row.lastFailedAt = new Date(failedAt)\n      row.lastFailedAttempt = attempt\n      row.claimHolder = null\n      row.claimExpiresAt = null\n      if (row.failureCount >= maxFailures) {\n        row.failedAt = new Date(failedAt)\n        dispatchOf(sessionId).ready.delete(row.index)\n        return {\n          outcome: 'dead_lettered',\n          failureCount: row.failureCount,\n        }\n      }\n      return { outcome: 'failed', failureCount: row.failureCount }\n    },\n\n    async readState(sessionId, reducerName) {\n      return readStateOf(sessionId, reducerName)\n    },\n\n    async readStates(sessionIds, reducerName) {\n      return sessionIds.map((sessionId) => readStateOf(sessionId, reducerName))\n    },\n\n    async putSnapshot(sessionId, reducerName, index, state) {\n      const key = `${sessionId}\\u0000${reducerName}`\n      const existing = snapshots.get(key)\n      // Guarded upsert: a slower concurrent writer must never clobber a\n      // further-along snapshot. A lost race costs a few refolded events\n      // next read — never correctness.\n      if (existing && existing.index >= index) return\n      snapshots.set(key, {\n        index,\n        state: structuredClone(state),\n        updatedAt: clock.now(),\n      })\n    },\n\n    presence: {\n      async set(ns, participant, values, meta) {\n        let participants = presenceRows.get(ns)\n        if (!participants) {\n          participants = new Map()\n          presenceRows.set(ns, participants)\n        }\n        let fields = participants.get(participant)\n        if (!fields) {\n          fields = new Map()\n          participants.set(participant, fields)\n        }\n\n        // Expiry anchors on the storage's own clock — the sender's\n        // `at` orders writes but never extends or shortens a lifetime.\n        const expiresAtMs = clock.now().getTime() + meta.ttlMs\n        // Field-keyed and caller-named — null-prototype, like every\n        // presence map (see `nullProtoRecord`).\n        const applied: Record<string, unknown> = nullProtoRecord()\n        let appliedCount = 0\n        for (const [field, value] of Object.entries(values)) {\n          // Field-wise LWW by `at`; ties go to the incoming write, so\n          // same-stamp sets keep set-then-read intuition.\n          const existing = fields.get(field)\n          if (existing && existing.at > meta.at) continue\n          if (value === null) {\n            fields.delete(field)\n          } else {\n            fields.set(field, {\n              value: structuredClone(value),\n              seen: meta.seen,\n              at: new Date(meta.at),\n              expiresAt: new Date(expiresAtMs),\n            })\n          }\n          applied[field] = structuredClone(value)\n          appliedCount += 1\n        }\n        if (fields.size === 0) participants.delete(participant)\n        if (participants.size === 0) presenceRows.delete(ns)\n\n        // Only applied fields broadcast — a losing write repaints nothing,\n        // so subscribers stay consistent with what read() returns.\n        if (appliedCount === 0) return\n        const subs = presenceSubscribers.get(ns)\n        if (!subs) return\n        const patch: PresencePatch = {\n          participant,\n          values: applied,\n          seen: meta.seen,\n          at: new Date(meta.at),\n        }\n        for (const listener of subs) listener(patch)\n      },\n\n      async read(ns) {\n        const participants = presenceRows.get(ns)\n        if (!participants) return []\n        const now = clock.now()\n        const rows: PresenceRow[] = []\n        for (const [participant, fields] of participants) {\n          for (const [field, entry] of fields) {\n            // Expiry is enforced lazily on read — no timers; a silent\n            // participant's rows vanish the next time anyone looks.\n            if (entry.expiresAt <= now) {\n              fields.delete(field)\n              continue\n            }\n            rows.push({\n              participant,\n              field,\n              value: structuredClone(entry.value),\n              seen: entry.seen,\n              at: new Date(entry.at),\n              expiresAt: new Date(entry.expiresAt),\n            })\n          }\n          if (fields.size === 0) participants.delete(participant)\n        }\n        if (participants.size === 0) presenceRows.delete(ns)\n        return rows\n      },\n\n      subscribe(ns, onPatch) {\n        let subs = presenceSubscribers.get(ns)\n        if (!subs) {\n          subs = new Set()\n          presenceSubscribers.set(ns, subs)\n        }\n        subs.add(onPatch)\n        return () => {\n          subs.delete(onPatch)\n          if (subs.size === 0) presenceSubscribers.delete(ns)\n        }\n      },\n    },\n\n    inspect: {\n      async listSessions(inspectionOptions) {\n        const ids = [...sessions.keys()]\n          .filter(\n            (sessionId) =>\n              sessionId.startsWith(inspectionOptions.prefix) &&\n              (inspectionOptions.cursor === undefined ||\n                sessionId > inspectionOptions.cursor),\n          )\n          .toSorted()\n        const visible = ids.slice(0, inspectionOptions.limit)\n        const summaries = visible.map((sessionId): StoredSessionSummary => {\n          const rows = sessions.get(sessionId)!\n          const first = rows[0]!\n          let updatedAt = first.createdAt\n          let pendingCount = 0\n          let failedCount = 0\n          let attemptCount = 0\n          let failureCount = 0\n          for (const row of rows) {\n            attemptCount += row.attemptCount\n            failureCount += row.failureCount\n            if (row.processedAt === null && row.failedAt === null) {\n              pendingCount += 1\n            }\n            if (row.failedAt !== null) failedCount += 1\n            for (const timestamp of [\n              row.createdAt,\n              row.firstClaimedAt,\n              row.lastClaimedAt,\n              row.lastFailedAt,\n              row.processedAt,\n              row.failedAt,\n            ]) {\n              if (timestamp && timestamp > updatedAt) updatedAt = timestamp\n            }\n          }\n          return {\n            sessionId,\n            eventCount: rows.length,\n            pendingCount,\n            failedCount,\n            attemptCount,\n            failureCount,\n            firstEventAt: new Date(first.createdAt),\n            updatedAt: new Date(updatedAt),\n          }\n        })\n        return {\n          sessions: summaries,\n          cursor: ids.length > visible.length ? (visible.at(-1) ?? null) : null,\n        }\n      },\n      async readEvents(sessionId, pageOptions) {\n        const rows = sessions.get(sessionId) ?? []\n        const throughIndex = Math.min(\n          pageOptions.throughIndex ?? rows.length,\n          rows.length,\n        )\n        return {\n          events: rows\n            .slice(pageOptions.afterIndex, throughIndex)\n            .slice(0, pageOptions.limit)\n            .map(toStored),\n          throughIndex,\n        }\n      },\n      async listSnapshots(sessionId) {\n        const prefix = `${sessionId}\\u0000`\n        return [...snapshots.entries()]\n          .filter(([key]) => key.startsWith(prefix))\n          .map(([key, snapshot]) => ({\n            reducerName: key.slice(prefix.length),\n            index: snapshot.index,\n            updatedAt: new Date(snapshot.updatedAt),\n          }))\n          .toSorted((a, b) => a.reducerName.localeCompare(b.reducerName))\n      },\n    },\n\n    stream(sessionId, opts) {\n      const startAfter = opts?.startAfter ?? 0\n      return {\n        [Symbol.asyncIterator](): AsyncIterator<Event> {\n          let last = startAfter\n          const buffer: Row[] = []\n          let wake: (() => void) | null = null\n          let closed = false\n\n          const onRow = (row: Row): void => {\n            buffer.push(row)\n            wake?.()\n          }\n          let subs = streamSubscribers.get(sessionId)\n          if (!subs) {\n            subs = new Set()\n            streamSubscribers.set(sessionId, subs)\n          }\n          subs.add(onRow)\n          // Seed with history — synchronously, in the same tick as the\n          // subscription, so nothing can slip between the two.\n          const existing = sessions.get(sessionId) ?? []\n          buffer.unshift(...existing.filter((row) => row.index > startAfter))\n\n          const unsubscribe = (): void => {\n            subs.delete(onRow)\n            if (subs.size === 0) streamSubscribers.delete(sessionId)\n          }\n\n          return {\n            async next(): Promise<IteratorResult<Event>> {\n              for (;;) {\n                while (buffer.length > 0) {\n                  const row = buffer.shift()!\n                  if (row.index <= last) continue\n                  last = row.index\n                  return { value: toStored(row), done: false }\n                }\n                if (closed) return { value: undefined, done: true }\n                // oxlint-disable-next-line no-await-in-loop -- wait-for-wake\n                await new Promise<void>((resolve) => {\n                  wake = resolve\n                })\n                wake = null\n              }\n            },\n            async return(): Promise<IteratorResult<Event>> {\n              closed = true\n              unsubscribe()\n              wake?.()\n              return { value: undefined, done: true }\n            },\n          }\n        },\n      }\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/{store-polling-DgrrAE3d.js → store-polling-dSeLxzfb.js}

@@ -1,4 +1,4 @@
-import { i as POLL_TIMINGS } from "./internal-aEotMzu_.js";
+import { i as POLL_TIMINGS } from "./internal-DstsI6Re.js";
 //#region src/store-polling.ts
 /**
 * The shared polling stream — how poll-based backends (sqlite,
@@ -82,3 +82,5 @@ function pollingStream(readAfter, options) {
 }
 //#endregion
 export { pollingStream as n, defaultSleep as t };
+
+//# sourceMappingURL=store-polling-dSeLxzfb.js.map

package/dist/store-polling-dSeLxzfb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-polling-dSeLxzfb.js","names":[],"sources":["../src/store-polling.ts"],"sourcesContent":["/**\n * The shared polling stream — how poll-based backends (sqlite,\n * postgres) implement `A2Store.stream`.\n *\n * The cadence is activity-adaptive: while events are flowing, polls\n * run at a tight floor (25ms) so streams feel pushed — a token\n * generation reads smoothly instead of clumping at the idle interval;\n * every empty poll doubles the gap until the idle ceiling. The cadence\n * is owned (POLL_TIMINGS in internal.ts), not a public option: the\n * floor already keeps active streams smooth, so tuning it is a cost\n * decision a2 makes, not one it delegates. Correctness never depends\n * on the cadence — each poll is a catch-up read (`index > last`, in\n * order), so nothing can be missed, only arrive a beat later.\n */\n\nimport { POLL_TIMINGS } from './internal.ts'\nimport type { StoredEvent } from './store.ts'\n\n/** One cancellable sleep — the injection seam for cadence tests. */\nexport type Sleeper = { promise: Promise<void>; cancel: () => void }\n\n/** Unref'd cancellable timer — shared with the redis safety read. */\nexport const defaultSleep = (ms: number): Sleeper => {\n  let timer: ReturnType<typeof setTimeout> | undefined\n  let wake: (() => void) | undefined\n  const promise = new Promise<void>((resolve) => {\n    wake = resolve // assigned synchronously by the executor\n    timer = setTimeout(resolve, ms)\n    // Don't hold the process open for an idle poll.\n    ;(timer as { unref?: () => void }).unref?.()\n  })\n  return {\n    promise,\n    cancel: () => {\n      clearTimeout(timer)\n      wake?.()\n    },\n  }\n}\n\n// Read the seam lazily — tests shrink POLL_TIMINGS in their setup.\nconst ceiling = (): number => POLL_TIMINGS.idleCeilingMs\nconst floor = (): number =>\n  Math.min(POLL_TIMINGS.activeFloorMs, POLL_TIMINGS.idleCeilingMs)\n\nexport type PollingStreamOptions = {\n  /** Deliver events strictly after this index (exclusive). */\n  startAfter?: number\n  /** Injectable sleep — tests assert the cadence without wall-clock waits. */\n  sleep?: (ms: number) => Sleeper\n}\n\n/**\n * Build the `stream()` iterable from a backend's catch-up read. The\n * iterable ends when the consumer calls `return()` (a disconnecting\n * SSE client), waking any pending sleep immediately.\n */\nexport function pollingStream(\n  readAfter: (afterIndex: number) => StoredEvent[] | Promise<StoredEvent[]>,\n  options: PollingStreamOptions,\n): AsyncIterable<StoredEvent> {\n  const startAfter = options.startAfter ?? 0\n  const sleep = options.sleep ?? defaultSleep\n\n  return {\n    [Symbol.asyncIterator](): AsyncIterator<StoredEvent> {\n      let last = startAfter\n      let buffer: StoredEvent[] = []\n      let closed = false\n      let pending: Sleeper | null = null\n      let interval = floor()\n\n      return {\n        async next(): Promise<IteratorResult<StoredEvent>> {\n          for (;;) {\n            if (closed) return { value: undefined, done: true }\n            // oxlint-disable-next-line no-await-in-loop -- poll loop\n            if (buffer.length === 0) buffer = await readAfter(last)\n            const row = buffer.shift()\n            if (row) {\n              // Activity: tighten back to the floor.\n              interval = floor()\n              last = row.index\n              return { value: row, done: false }\n            }\n            // Empty poll: wait, then back off toward the idle ceiling.\n            pending = sleep(interval)\n            // oxlint-disable-next-line no-await-in-loop -- poll loop\n            await pending.promise\n            pending = null\n            interval = Math.min(interval * 2, ceiling())\n          }\n        },\n        async return(): Promise<IteratorResult<StoredEvent>> {\n          closed = true\n          pending?.cancel()\n          return { value: undefined, done: true }\n        },\n      }\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAsBA,MAAa,gBAAgB,OAAwB;CACnD,IAAI;CACJ,IAAI;CAOJ,OAAO;EACL,SAAA,IAPkB,SAAe,YAAY;GAC7C,OAAO;GACP,QAAQ,WAAW,SAAS,EAAE;GAE7B,MAAkC,QAAQ;EAC7C,CAEQ;EACN,cAAc;GACZ,aAAa,KAAK;GAClB,OAAO;EACT;CACF;AACF;AAGA,MAAM,gBAAwB,aAAa;AAC3C,MAAM,cACJ,KAAK,IAAI,aAAa,eAAe,aAAa,aAAa;;;;;;AAcjE,SAAgB,cACd,WACA,SAC4B;CAC5B,MAAM,aAAa,QAAQ,cAAc;CACzC,MAAM,QAAQ,QAAQ,SAAS;CAE/B,OAAO,EACL,CAAC,OAAO,iBAA6C;EACnD,IAAI,OAAO;EACX,IAAI,SAAwB,CAAC;EAC7B,IAAI,SAAS;EACb,IAAI,UAA0B;EAC9B,IAAI,WAAW,MAAM;EAErB,OAAO;GACL,MAAM,OAA6C;IACjD,SAAS;KACP,IAAI,QAAQ,OAAO;MAAE,OAAO,KAAA;MAAW,MAAM;KAAK;KAElD,IAAI,OAAO,WAAW,GAAG,SAAS,MAAM,UAAU,IAAI;KACtD,MAAM,MAAM,OAAO,MAAM;KACzB,IAAI,KAAK;MAEP,WAAW,MAAM;MACjB,OAAO,IAAI;MACX,OAAO;OAAE,OAAO;OAAK,MAAM;MAAM;KACnC;KAEA,UAAU,MAAM,QAAQ;KAExB,MAAM,QAAQ;KACd,UAAU;KACV,WAAW,KAAK,IAAI,WAAW,GAAG,QAAQ,CAAC;IAC7C;GACF;GACA,MAAM,SAA+C;IACnD,SAAS;IACT,SAAS,OAAO;IAChB,OAAO;KAAE,OAAO,KAAA;KAAW,MAAM;IAAK;GACxC;EACF;CACF,EACF;AACF"}

package/dist/store-postgres.d.ts

@@ -1,4 +1,4 @@
-import { c as IdSource, i as Clock, t as A2Store } from "./store-C3sNAaBT.js";
+import { c as IdSource, i as Clock, t as A2Store } from "./store-DysUkTH3.js";
 //#region src/store-postgres.d.ts
 /** The result shape this backend reads: just rows. */
 type PostgresQueryResult = {
@@ -37,4 +37,5 @@ type PostgresStore = A2Store & {
 };
 declare function postgres(options?: PostgresStoreOptions): PostgresStore;
 //#endregion
-export { PostgresClient, PostgresConnection, PostgresQueryResult, PostgresStore, PostgresStoreOptions, postgres };
+export { PostgresClient, PostgresConnection, PostgresQueryResult, PostgresStore, PostgresStoreOptions, postgres };
+//# sourceMappingURL=store-postgres.d.ts.map

package/dist/store-postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-postgres.d.ts","names":[],"sources":["../src/store-postgres.ts"],"mappings":";;;KAqCY;EAAwB,MAAM;;;KAG9B;EACV,MAAM,cAAc,qBAAqB,QAAQ;EACjD;;;;;;;;KASU;EACV,MAAM,cAAc,qBAAqB,QAAQ;EACjD,YAAY,QAAQ;EACpB,QAAQ;;KAGE;;EAEV;;EAEA,SAAS;;EAET,QAAQ;;EAER,MAAM;;KAGI,gBAAgB;;;EAG1B,SAAS;;iBAoLK,SAAS,UAAS,uBAA4B"}

package/dist/store-postgres.js

@@ -1,5 +1,5 @@
 import { t as A2Error } from "./errors-BQuJpe82.js";
-import { n as pollingStream } from "./store-polling-DgrrAE3d.js";
+import { n as pollingStream } from "./store-polling-dSeLxzfb.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 import { t as idempotentReplay } from "./idempotent-replay-DuqEkYA7.js";
 import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS.js";
@@ -633,6 +633,60 @@ function postgres(options = {}) {
 				};
 			});
 		},
+		async readStates(sessionIds, reducerName) {
+			if (sessionIds.length === 0) return [];
+			return wrap(async () => {
+				const { rows } = await (await client()).query(`with snapshot as materialized (
+             select session_id, up_to_index, state
+             from a2_snapshots
+             where session_id = any($1::text[]) and reducer_name = $2
+           )
+           select 0 as row_order, 'snapshot' as row_kind,
+                  snapshot.session_id,
+                  snapshot.up_to_index as snapshot_index,
+                  snapshot.state as snapshot_state,
+                  null::bigint as idx, null::text as event_type,
+                  null::jsonb as payload, null::text as event_id,
+                  null::bigint as created_at
+           from snapshot
+           union all
+           select 1 as row_order, 'event' as row_kind,
+                  event.session_id,
+                  null::bigint as snapshot_index,
+                  null::jsonb as snapshot_state,
+                  event.idx, event.event_type, event.payload,
+                  event.event_id, event.created_at
+           from a2_events event
+           left join snapshot on snapshot.session_id = event.session_id
+           where event.session_id = any($1::text[])
+             and event.idx > coalesce(snapshot.up_to_index, 0)
+           order by row_order, session_id, idx`, [sessionIds, reducerName]);
+				const bySession = /* @__PURE__ */ new Map();
+				const readOf = (sessionId) => {
+					let read = bySession.get(sessionId);
+					if (!read) {
+						read = {
+							snapshot: null,
+							events: []
+						};
+						bySession.set(sessionId, read);
+					}
+					return read;
+				};
+				for (const row of rows) {
+					const read = readOf(row["session_id"]);
+					if (row["row_kind"] === "snapshot") read.snapshot = {
+						index: asNumber(row["snapshot_index"]),
+						state: row["snapshot_state"]
+					};
+					else read.events.push(toEvent(row));
+				}
+				return sessionIds.map((sessionId) => bySession.get(sessionId) ?? {
+					snapshot: null,
+					events: []
+				});
+			});
+		},
 		async putSnapshot(sessionId, reducerName, index, state) {
 			await wrap(async () => {
 				await (await client()).query(`insert into a2_snapshots (session_id, reducer_name, up_to_index, state, updated_at)
@@ -803,3 +857,5 @@ function postgres(options = {}) {
 }
 //#endregion
 export { postgres };
+
+//# sourceMappingURL=store-postgres.js.map

package/dist/store-postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-postgres.js","names":[],"sources":["../src/store-postgres.ts"],"sourcesContent":["/**\n * experimental-a2/store-postgres — postgres store backend (the production path).\n *\n * Implements the A2Store interface over any client that speaks the tiny\n * `PostgresClient` shape below — a `pg` Pool matches it structurally\n * (and is what `connectionString` creates, lazily; `pg` is an optional\n * peer dependency). The conformance suite in test/conformance is the\n * executable contract, run against PGlite (real Postgres, in-process)\n * and against a real server when `TEST_DATABASE_URL` is set.\n *\n * Semantics mirror the sqlite backend: `index` is stored as `idx`,\n * timestamps are epoch milliseconds written from the injected clock —\n * never SQL `now()` — and `stream()` is a poll loop. (A LISTEN/NOTIFY\n * upgrade can land later without any API change; callers never branch\n * on the transport.) Appends serialize per session via\n * `pg_advisory_xact_lock`, so concurrent writers can't race the index\n * assignment.\n */\n\nimport { A2Error } from './errors.ts'\nimport { idempotentReplay } from './idempotent-replay.ts'\nimport { decodeReturnedEventIds } from './store-codec.ts'\nimport { pollingStream } from './store-polling.ts'\nimport { retryableLazy } from './retryable-lazy.ts'\nimport {\n  RANDOM_IDS,\n  SYSTEM_CLOCK,\n  type A2Store,\n  type Clock,\n  type Event,\n  type EventCause,\n  type IdSource,\n  type StoredEvent,\n  type StoreStateRead,\n} from './store.ts'\n\n/** The result shape this backend reads: just rows. */\nexport type PostgresQueryResult = { rows: Record<string, unknown>[] }\n\n/** One checked-out connection — what transactions run on. */\nexport type PostgresConnection = {\n  query(text: string, values?: unknown[]): Promise<PostgresQueryResult>\n  release(): void\n}\n\n/**\n * The minimal client this backend needs. `pg.Pool` matches it\n * structurally; so does PGlite (which has no `connect` — transactions\n * then serialize on an internal mutex, fine for a single-connection\n * client).\n */\nexport type PostgresClient = {\n  query(text: string, values?: unknown[]): Promise<PostgresQueryResult>\n  connect?(): Promise<PostgresConnection>\n  end?(): Promise<void>\n}\n\nexport type PostgresStoreOptions = {\n  /** Creates a `pg` Pool lazily (requires the optional peer dep `pg`). */\n  connectionString?: string | undefined\n  /** Bring your own client — a `pg` Pool, PGlite, a pooler wrapper. */\n  client?: PostgresClient\n  /** Injectable clock — every stored timestamp comes from here. */\n  clock?: Clock\n  /** Injectable id source for generated event ids. */\n  ids?: IdSource\n}\n\nexport type PostgresStore = A2Store & {\n  /** End the underlying pool/client (when this backend created it, or\n   * the injected client has `end`). */\n  close(): Promise<void>\n}\n\nconst SCHEMA = `\ncreate table if not exists a2_events (\n  session_id   text    not null,\n  idx          bigint  not null,\n  event_type   text    not null,\n  payload      jsonb   not null,\n  event_id     text    not null,\n  created_at   bigint  not null,\n  cause        jsonb,\n  lane         text,\n  lane_ready   boolean not null default false,\n  processed_at bigint,\n  processed_by_attempt integer,\n  returned_event_ids jsonb,\n  first_claimed_at bigint,\n  last_claimed_at bigint,\n  attempt_count integer not null default 0,\n  failure_count integer not null default 0,\n  last_failed_at bigint,\n  last_failed_attempt integer,\n  last_error   text,\n  failed_at    bigint,\n  claim_holder text,\n  claim_expires_at bigint,\n  primary key (session_id, idx)\n);\n\ncreate unique index if not exists a2_events_event_id on a2_events (event_id);\ncreate index if not exists a2_events_unprocessed\n  on a2_events (session_id, idx) where processed_at is null;\ncreate index if not exists a2_events_lane_pending\n  on a2_events (session_id, lane, idx) where processed_at is null;\ncreate index if not exists a2_events_dispatch_ready\n  on a2_events (session_id, idx)\n  where lane_ready and processed_at is null and failed_at is null;\ncreate index if not exists a2_events_claim_expiry\n  on a2_events (session_id, claim_expires_at)\n  where lane_ready and processed_at is null and failed_at is null;\n\ncreate table if not exists a2_snapshots (\n  session_id   text   not null,\n  reducer_name text   not null,\n  up_to_index  bigint not null,\n  state        jsonb  not null,\n  updated_at   bigint not null,\n  primary key (session_id, reducer_name)\n);\n\ncreate table if not exists a2_presence (\n  ns          text   not null,\n  participant text   not null,\n  field       text   not null,\n  value       jsonb  not null,\n  seen        bigint not null,\n  at          bigint not null,\n  expires_at  bigint not null,\n  primary key (ns, participant, field)\n);\n`\n\nconst asNumber = (value: unknown): number => Number(value) // bigint columns arrive as strings\n\nconst toDate = (ms: unknown): Date | null =>\n  ms === null || ms === undefined ? null : new Date(asNumber(ms))\n\nconst toCause = (raw: unknown): EventCause | null => {\n  if (raw === null || raw === undefined) return null\n  const value = (typeof raw === 'string' ? JSON.parse(raw) : raw) as {\n    index?: unknown\n    attempt?: unknown\n    batchSize?: unknown\n  }\n  if (\n    !Number.isInteger(value.index) ||\n    Number(value.index) < 1 ||\n    !Number.isInteger(value.attempt) ||\n    Number(value.attempt) < 1\n  ) {\n    throw new TypeError('stored event has an invalid cause')\n  }\n  if (\n    value.batchSize !== undefined &&\n    (!Number.isInteger(value.batchSize) || Number(value.batchSize) < 1)\n  ) {\n    throw new TypeError('stored event has an invalid cause')\n  }\n  return {\n    index: Number(value.index),\n    attempt: Number(value.attempt),\n    ...(value.batchSize === undefined\n      ? {}\n      : { batchSize: Number(value.batchSize) }),\n  }\n}\n\nconst toStored = (row: Record<string, unknown>): StoredEvent => ({\n  id: row['event_id'] as string,\n  type: row['event_type'] as string,\n  payload: row['payload'],\n  index: asNumber(row['idx']),\n  sessionId: row['session_id'] as string,\n  createdAt: new Date(asNumber(row['created_at'])),\n  cause: toCause(row['cause']),\n  lane: (row['lane'] as string | null) ?? null,\n  processedAt: toDate(row['processed_at']),\n  processedByAttempt:\n    row['processed_by_attempt'] === null ||\n    row['processed_by_attempt'] === undefined\n      ? null\n      : asNumber(row['processed_by_attempt']),\n  returnedEventIds:\n    row['returned_event_ids'] === null ||\n    row['returned_event_ids'] === undefined\n      ? null\n      : decodeReturnedEventIds(row['returned_event_ids']),\n  firstClaimedAt: toDate(row['first_claimed_at']),\n  lastClaimedAt: toDate(row['last_claimed_at']),\n  attemptCount: asNumber(row['attempt_count']),\n  failureCount: asNumber(row['failure_count']),\n  lastFailedAt: toDate(row['last_failed_at']),\n  lastFailedAttempt:\n    row['last_failed_attempt'] === null ||\n    row['last_failed_attempt'] === undefined\n      ? null\n      : asNumber(row['last_failed_attempt']),\n  lastError: (row['last_error'] as string | null) ?? null,\n  failedAt: toDate(row['failed_at']),\n  claimHolder: (row['claim_holder'] as string | null) ?? null,\n  claimExpiresAt: toDate(row['claim_expires_at']),\n})\n\nconst toEvent = (row: Record<string, unknown>): Event => ({\n  id: row['event_id'] as string,\n  type: row['event_type'] as string,\n  payload: row['payload'],\n  index: asNumber(row['idx']),\n  sessionId: row['session_id'] as string,\n  createdAt: new Date(asNumber(row['created_at'])),\n})\n\nconst wrap = async <T>(fn: () => Promise<T>): Promise<T> => {\n  try {\n    return await fn()\n  } catch (err) {\n    if (err instanceof A2Error || err instanceof TypeError) throw err\n    throw new A2Error('STORE_UNAVAILABLE', 'postgres store operation failed', {\n      cause: err,\n    })\n  }\n}\n\nconst jsonb = (value: unknown): string => JSON.stringify(value) ?? 'null'\n\nconst initializeSchema = async (client: PostgresClient): Promise<void> => {\n  if (!client.connect) {\n    await client.query(SCHEMA)\n    return\n  }\n\n  const conn = await client.connect()\n  try {\n    await conn.query('begin')\n    // `if not exists` does not serialize concurrent catalog writes. Every\n    // serverless isolate takes the same transaction-scoped lock before DDL.\n    await conn.query(\n      \"select pg_advisory_xact_lock(hashtext('a2:postgres:schema'))\",\n    )\n    await conn.query(SCHEMA)\n    await conn.query('commit')\n  } catch (err) {\n    await conn.query('rollback').catch(() => {})\n    throw err\n  } finally {\n    conn.release()\n  }\n}\n\nexport function postgres(options: PostgresStoreOptions = {}): PostgresStore {\n  const clock = options.clock ?? SYSTEM_CLOCK\n  const generateId = options.ids ?? RANDOM_IDS\n\n  if (!options.client && !options.connectionString) {\n    throw new TypeError(\n      'postgres() needs a connectionString or an injected client',\n    )\n  }\n\n  // Lazy init: the first operation creates the client (dynamic import\n  // of the optional peer dep `pg`) and the schema. Constructing the\n  // backend does no I/O — same contract as every other adapter.\n  const connection = retryableLazy(async () => {\n    let owned: PostgresClient | null = null\n    try {\n      let c = options.client\n      if (!c) {\n        const pg = await import('pg').catch(() => {\n          throw new A2Error(\n            'STORE_NOT_CONFIGURED',\n            \"experimental-a2/store-postgres with a connectionString needs the 'pg' package (optional peer dependency) — install it, or inject a client\",\n          )\n        })\n        c = new pg.default.Pool({\n          connectionString: options.connectionString,\n        }) as unknown as PostgresClient\n        owned = c\n      }\n      await initializeSchema(c)\n      return c\n    } catch (err) {\n      if (owned?.end) await owned.end().catch(() => {})\n      throw err\n    }\n  })\n  const client = connection.get\n\n  // Transactions run on one connection. Pools check one out; a\n  // single-connection client (PGlite) serializes on this mutex instead.\n  let mutex: Promise<unknown> = Promise.resolve()\n  const withTx = async <T>(\n    fn: (query: PostgresConnection['query']) => Promise<T>,\n  ): Promise<T> => {\n    const c = await client()\n    if (c.connect) {\n      const conn = await c.connect()\n      try {\n        await conn.query('begin')\n        const result = await fn((text, values) => conn.query(text, values))\n        await conn.query('commit')\n        return result\n      } catch (err) {\n        await conn.query('rollback').catch(() => {})\n        throw err\n      } finally {\n        conn.release()\n      }\n    }\n    const run = mutex.then(async () => {\n      await c.query('begin')\n      try {\n        const result = await fn((text, values) => c.query(text, values))\n        await c.query('commit')\n        return result\n      } catch (err) {\n        await c.query('rollback').catch(() => {})\n        throw err\n      }\n    })\n    mutex = run.catch(() => {})\n    return run\n  }\n\n  return {\n    async append(sessionId, events) {\n      if (events.length === 0) {\n        return wrap(async () => {\n          const c = await client()\n          const { rows } = await c.query(\n            `select exists(\n               select 1 from a2_events\n               where session_id = $1 and processed_at is null\n             ) as has_pending`,\n            [sessionId],\n          )\n          return {\n            events: [],\n            hasPending: rows[0]?.['has_pending'] === true,\n          }\n        })\n      }\n      return wrap(() =>\n        withTx(async (query) => {\n          // Serialize appends per session — index assignment must not\n          // race across writers. Transaction-scoped, self-releasing.\n          await query('select pg_advisory_xact_lock(hashtext($1))', [sessionId])\n\n          const supplied = events.filter((e) => e.id !== undefined)\n          const suppliedIds = supplied.map((e) => e.id as string)\n          if (new Set(suppliedIds).size !== suppliedIds.length) {\n            throw new A2Error(\n              'PARTIAL_DUPLICATE_BATCH',\n              'batch contains the same event id more than once',\n            )\n          }\n          if (suppliedIds.length > 0) {\n            const { rows: existing } = await query(\n              `select stored.*,\n                      exists(\n                        select 1 from a2_events pending\n                        where pending.session_id = $2\n                          and pending.processed_at is null\n                      ) as session_has_pending\n                 from a2_events stored\n                where stored.event_id = any($1)\n                order by stored.idx`,\n              [suppliedIds, sessionId],\n            )\n            if (existing.length > 0) {\n              const foreign = existing.find(\n                (row) => row['session_id'] !== sessionId,\n              )\n              if (foreign) {\n                throw new A2Error(\n                  'PARTIAL_DUPLICATE_BATCH',\n                  `event id '${String(foreign['event_id'])}' already exists in another session`,\n                )\n              }\n              if (existing.length === events.length) {\n                return {\n                  events: idempotentReplay(events, existing.map(toStored)),\n                  hasPending: existing[0]?.['session_has_pending'] === true,\n                }\n              }\n              throw new A2Error(\n                'PARTIAL_DUPLICATE_BATCH',\n                `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`,\n              )\n            }\n          }\n\n          // Attempt-currency fence: a fresh handler append commits only\n          // while its causal attempt is still the parent's latest\n          // (store.ts `append`). `for update` serializes this read against\n          // a concurrent `claimAvailable` — an unlocked read admits write\n          // skew.\n          const causeIndexes = [\n            ...new Set(\n              events\n                .filter((e) => e.cause !== undefined)\n                .map((e) => e.cause!.index),\n            ),\n          ]\n          if (causeIndexes.length > 0) {\n            const { rows: parents } = await query(\n              `select idx, attempt_count, failed_at from a2_events\n                where session_id = $1 and idx = any($2::bigint[])\n                for update`,\n              [sessionId, causeIndexes],\n            )\n            const byIndex = new Map(\n              parents.map((row) => [asNumber(row['idx']), row]),\n            )\n            for (const e of events) {\n              if (!e.cause) continue\n              const parent = byIndex.get(e.cause.index)\n              if (!parent) {\n                throw new TypeError(\n                  `no event at index ${e.cause.index} in session '${sessionId}'`,\n                )\n              }\n              if (\n                asNumber(parent['attempt_count']) !== e.cause.attempt ||\n                parent['failed_at'] !== null\n              ) {\n                throw new A2Error(\n                  'SUPERSEDED_ATTEMPT',\n                  `attempt ${e.cause.attempt} no longer owns event ${e.cause.index} in session '${sessionId}'`,\n                )\n              }\n            }\n          }\n\n          const { rows: maxRows } = await query(\n            `select coalesce(max(idx), 0) as max,\n                    exists(\n                      select 1 from a2_events pending\n                      where pending.session_id = $1\n                        and pending.processed_at is null\n                    ) as session_has_pending\n               from a2_events\n              where session_id = $1`,\n            [sessionId],\n          )\n          const base = asNumber(maxRows[0]?.['max'])\n          const now = clock.now().getTime()\n          const inserted: StoredEvent[] = []\n          for (let i = 0; i < events.length; i += 1) {\n            const e = events[i]!\n            const id = e.id ?? generateId()\n            const index = base + 1 + i\n            // oxlint-disable-next-line no-await-in-loop -- one tx, ordered inserts\n            await query(\n              `insert into a2_events\n                 (session_id, idx, event_type, payload, event_id, created_at,\n                  cause, lane, lane_ready, processed_at)\n               values (\n                 $1, $2, $3, $4::jsonb, $5, $6, $7::jsonb, $8,\n                 $8::text is null or not exists (\n                   select 1 from a2_events\n                    where session_id = $1 and lane = $8 and processed_at is null\n                 ),\n                 $9\n               )`,\n              [\n                sessionId,\n                index,\n                e.type,\n                jsonb(e.payload),\n                id,\n                now,\n                e.cause ? jsonb(e.cause) : null,\n                e.lane ?? null,\n                e.settled ? now : null,\n              ],\n            )\n            inserted.push({\n              id,\n              type: e.type,\n              payload: structuredClone(e.payload),\n              index,\n              sessionId,\n              createdAt: new Date(now),\n              cause: e.cause ? { ...e.cause } : null,\n              lane: e.lane ?? null,\n              processedAt: e.settled ? new Date(now) : null,\n              processedByAttempt: null,\n              returnedEventIds: null,\n              firstClaimedAt: null,\n              lastClaimedAt: null,\n              attemptCount: 0,\n              failureCount: 0,\n              lastFailedAt: null,\n              lastFailedAttempt: null,\n              lastError: null,\n              failedAt: null,\n              claimHolder: null,\n              claimExpiresAt: null,\n            })\n          }\n          return {\n            events: inserted,\n            hasPending:\n              maxRows[0]?.['session_has_pending'] === true ||\n              events.some((event) => event.settled !== true),\n          }\n        }),\n      )\n    },\n\n    async read(sessionId, opts) {\n      return wrap(async () => {\n        const c = await client()\n        const conditions = ['session_id = $1']\n        const params: unknown[] = [sessionId]\n        if (opts?.afterIndex !== undefined) {\n          params.push(opts.afterIndex)\n          conditions.push(`idx > $${params.length}`)\n        }\n        if (opts?.throughIndex !== undefined) {\n          params.push(opts.throughIndex)\n          conditions.push(`idx <= $${params.length}`)\n        }\n        const { rows } = await c.query(\n          `select * from a2_events where ${conditions.join(' and ')} order by idx`,\n          params,\n        )\n        return rows.map(toStored)\n      })\n    },\n\n    async claimAvailable({\n      sessionId,\n      holder,\n      ttlMs,\n      expiresAtMs,\n      excludeIndexes = [],\n    }) {\n      return wrap(() =>\n        withTx(async (query) => {\n          const now = clock.now().getTime()\n          const expiresAt = expiresAtMs ?? now + ttlMs\n          const { rows } = await query(\n            `with eligible as materialized (\n               select event.idx\n                 from a2_events event\n                where event.session_id = $1\n                  and event.processed_at is null\n                  and event.failed_at is null\n                  and event.lane_ready\n                  and (event.claim_expires_at is null or event.claim_expires_at <= $2)\n                  and not (event.idx = any($5::bigint[]))\n                for update of event\n             )\n             update a2_events claimed set\n               attempt_count = claimed.attempt_count + 1,\n               first_claimed_at = coalesce(claimed.first_claimed_at, $2),\n               last_claimed_at = $2,\n               claim_holder = $3,\n               claim_expires_at = $4\n             from eligible\n             where claimed.session_id = $1 and claimed.idx = eligible.idx\n             returning claimed.*`,\n            [sessionId, now, holder, expiresAt, [...excludeIndexes]],\n          )\n          if (rows.length > 0) {\n            const events = rows\n              .map(toStored)\n              .toSorted((a, b) => a.index - b.index)\n            return { outcome: 'claimed', events }\n          }\n          const { rows: activeRows } = await query(\n            `select min(claim_expires_at) as retry_at\n               from a2_events\n              where session_id = $1\n                and processed_at is null\n                and failed_at is null\n                and lane_ready\n                and claim_expires_at > $2`,\n            [sessionId, now],\n          )\n          const retryAt = activeRows[0]?.['retry_at']\n          return retryAt === null || retryAt === undefined\n            ? { outcome: 'settled' }\n            : { outcome: 'busy', retryAt: new Date(asNumber(retryAt)) }\n        }),\n      )\n    },\n\n    async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {\n      if (claims.length === 0) return { renewed: [], superseded: [] }\n      return wrap(async () => {\n        const c = await client()\n        const now = clock.now().getTime()\n        const expiresAt = expiresAtMs ?? now + ttlMs\n        const indexes = claims.map((claim) => claim.index)\n        const attempts = new Map(\n          claims.map((claim) => [claim.index, claim.attempt]),\n        )\n        const { rows } = await c.query(\n          `with listed as (\n             select idx, attempt\n               from unnest($3::bigint[], $6::int[]) as listed(idx, attempt)\n           ),\n           renewed as (\n             update a2_events event set claim_expires_at = $1\n               from listed\n              where event.session_id = $2\n                and event.idx = listed.idx\n                and event.attempt_count = listed.attempt\n                and event.processed_at is null\n                and event.failed_at is null\n                and event.claim_holder = $4\n                and event.claim_expires_at > $5\n              returning event.idx\n           )\n           select event.idx, event.attempt_count,\n                  exists(select 1 from renewed where renewed.idx = event.idx)\n                    as renewed\n             from a2_events event\n            where event.session_id = $2 and event.idx = any($3::bigint[])`,\n          [\n            expiresAt,\n            sessionId,\n            indexes,\n            holder,\n            now,\n            claims.map((claim) => claim.attempt),\n          ],\n        )\n        const renewed: number[] = []\n        const superseded: number[] = []\n        for (const row of rows) {\n          const index = asNumber(row['idx'])\n          if (row['renewed'] === true) renewed.push(index)\n          else if (\n            asNumber(row['attempt_count']) > (attempts.get(index) ?? 0)\n          ) {\n            superseded.push(index)\n          }\n        }\n        return {\n          renewed: renewed.toSorted((a, b) => a - b),\n          superseded: superseded.toSorted((a, b) => a - b),\n        }\n      })\n    },\n\n    async completeAttempt({ sessionId, index, attempt, events }) {\n      return wrap(() =>\n        withTx(async (query) => {\n          const { rows: parentRows } = await query(\n            `select * from a2_events\n              where session_id = $1 and idx = $2\n              for update`,\n            [sessionId, index],\n          )\n          const parent = parentRows[0]\n          if (!parent) {\n            throw new TypeError(\n              `no event at index ${index} in session '${sessionId}'`,\n            )\n          }\n          const ids = events.map((event) => event.id)\n          if (new Set(ids).size !== ids.length) {\n            throw new A2Error(\n              'PARTIAL_DUPLICATE_BATCH',\n              'returned event batch contains the same event id more than once',\n            )\n          }\n          if (parent['processed_at'] !== null) {\n            if (asNumber(parent['processed_by_attempt']) !== attempt) {\n              return { outcome: 'superseded' }\n            }\n            const returnedIds =\n              parent['returned_event_ids'] === null ||\n              parent['returned_event_ids'] === undefined\n                ? null\n                : decodeReturnedEventIds(parent['returned_event_ids'])\n            if (\n              returnedIds === null ||\n              returnedIds.length !== ids.length ||\n              returnedIds.some((id, offset) => id !== ids[offset])\n            ) {\n              throw new A2Error(\n                'PARTIAL_DUPLICATE_BATCH',\n                'completed attempt does not match the returned event batch',\n              )\n            }\n            if (events.length === 0) {\n              return { outcome: 'completed', events: [] }\n            }\n            const { rows: existing } = await query(\n              `select * from a2_events\n                where event_id = any($1::text[])`,\n              [ids],\n            )\n            const byId = new Map(\n              existing.map((row) => [row['event_id'] as string, row]),\n            )\n            const ordered = ids.map((id) => byId.get(id))\n            if (\n              ordered.some((row) => {\n                const cause = row ? toCause(row['cause']) : null\n                return (\n                  !row ||\n                  row['session_id'] !== sessionId ||\n                  cause?.index !== index ||\n                  cause.attempt !== attempt\n                )\n              })\n            ) {\n              throw new A2Error(\n                'PARTIAL_DUPLICATE_BATCH',\n                'returned event retry does not match the committed batch',\n              )\n            }\n            return {\n              outcome: 'completed',\n              events: idempotentReplay(\n                events,\n                (ordered as Record<string, unknown>[]).map(toStored),\n              ),\n            }\n          }\n          if (\n            asNumber(parent['attempt_count']) !== attempt ||\n            parent['claim_holder'] === null ||\n            parent['claim_holder'] === undefined ||\n            parent['failed_at'] !== null\n          ) {\n            return { outcome: 'superseded' }\n          }\n\n          await query('select pg_advisory_xact_lock(hashtext($1))', [sessionId])\n          if (ids.length > 0) {\n            const { rows: existing } = await query(\n              'select event_id from a2_events where event_id = any($1::text[])',\n              [ids],\n            )\n            if (existing.length > 0) {\n              throw new A2Error(\n                'PARTIAL_DUPLICATE_BATCH',\n                'returned event batch contains an already-appended event id',\n              )\n            }\n          }\n\n          const { rows: maxRows } = await query(\n            'select coalesce(max(idx), 0) as max from a2_events where session_id = $1',\n            [sessionId],\n          )\n          const base = asNumber(maxRows[0]?.['max'])\n          const now = clock.now().getTime()\n          const inserted: StoredEvent[] = []\n          for (let offset = 0; offset < events.length; offset += 1) {\n            const event = events[offset]!\n            const childIndex = base + offset + 1\n            // oxlint-disable-next-line no-await-in-loop -- one tx, ordered inserts\n            const { rows } = await query(\n              `insert into a2_events\n                 (session_id, idx, event_type, payload, event_id, created_at,\n                  cause, lane, lane_ready, processed_at)\n               values (\n                 $1, $2, $3, $4::jsonb, $5, $6, $7::jsonb, $8,\n                 $8::text is null or not exists (\n                   select 1 from a2_events\n                    where session_id = $1 and lane = $8 and processed_at is null\n                 ),\n                 $9\n               )\n               returning *`,\n              [\n                sessionId,\n                childIndex,\n                event.type,\n                jsonb(event.payload),\n                event.id,\n                now,\n                jsonb({ index, attempt }),\n                event.lane ?? null,\n                event.settled ? now : null,\n              ],\n            )\n            inserted.push(toStored(rows[0]!))\n          }\n          await query(\n            `update a2_events set\n               processed_at = $1,\n               processed_by_attempt = $2,\n               returned_event_ids = $5::jsonb,\n               lane_ready = false,\n               claim_holder = null,\n               claim_expires_at = null\n             where session_id = $3 and idx = $4`,\n            [now, attempt, sessionId, index, jsonb(ids)],\n          )\n          const parentLane = (parent['lane'] as string | null) ?? null\n          if (parentLane !== null) {\n            await query(\n              `update a2_events set lane_ready = true\n                where session_id = $1\n                  and idx = (\n                    select idx from a2_events\n                     where session_id = $1 and lane = $2 and processed_at is null\n                     order by idx limit 1\n                  )`,\n              [sessionId, parentLane],\n            )\n          }\n          return { outcome: 'completed', events: inserted }\n        }),\n      )\n    },\n\n    async failAttempt({ sessionId, index, attempt, error, maxFailures }) {\n      return wrap(async () => {\n        const c = await client()\n        const { rows } = await c.query(\n          `with current as materialized (\n             select e.* from a2_events e\n             where e.session_id = $1 and e.idx = $2\n             for update of e\n           ), updated as (\n             update a2_events e set\n               failure_count = e.failure_count + 1,\n               last_error = $4,\n               last_failed_at = $6,\n               last_failed_attempt = $3,\n               failed_at = case\n                 when e.failure_count + 1 >= $5 then $6\n                 else e.failed_at\n               end,\n               claim_holder = null,\n               claim_expires_at = null\n             from current\n             where e.session_id = $1\n               and e.idx = $2\n               and current.processed_at is null\n               and current.failed_at is null\n               and current.attempt_count = $3\n               and current.claim_holder is not null\n             returning e.failure_count, e.failed_at\n           )\n           select case\n             when not exists (select 1 from current) then 'missing'\n             when exists (\n               select 1 from updated where failed_at is not null\n             ) then 'dead_lettered'\n             when exists (select 1 from updated) then 'failed'\n             when exists (\n               select 1 from current\n               where processed_at is not null or attempt_count <> $3\n             ) then 'superseded'\n             when exists (\n               select 1 from current where failed_at is not null\n             ) then 'dead_lettered'\n             when exists (\n               select 1 from current\n                where claim_holder is null and last_failed_attempt = $3\n             ) then 'failed'\n             else 'superseded'\n           end as outcome,\n           coalesce(\n             (select failure_count from updated),\n             (select failure_count from current)\n           ) as failure_count`,\n          [\n            sessionId,\n            index,\n            attempt,\n            error,\n            maxFailures,\n            clock.now().getTime(),\n          ],\n        )\n        const row = rows[0]\n        if (!row || row['outcome'] === 'missing') {\n          throw new TypeError(\n            `no event at index ${index} in session '${sessionId}'`,\n          )\n        }\n        return {\n          outcome: row['outcome'] as 'failed' | 'dead_lettered' | 'superseded',\n          failureCount: asNumber(row['failure_count']),\n        }\n      })\n    },\n\n    async readState(sessionId, reducerName) {\n      return wrap(async () => {\n        const c = await client()\n        const { rows } = await c.query(\n          `with snapshot as materialized (\n             select up_to_index, state\n             from a2_snapshots\n             where session_id = $1 and reducer_name = $2\n           )\n           select 0 as row_order, 'snapshot' as row_kind,\n                  snapshot.up_to_index as snapshot_index,\n                  snapshot.state as snapshot_state,\n                  null::text as session_id, null::bigint as idx,\n                  null::text as event_type, null::jsonb as payload,\n                  null::text as event_id, null::bigint as created_at\n           from snapshot\n           union all\n           select 1 as row_order, 'event' as row_kind,\n                  null::bigint as snapshot_index,\n                  null::jsonb as snapshot_state,\n                  event.session_id, event.idx, event.event_type,\n                  event.payload, event.event_id, event.created_at\n           from a2_events event\n           where event.session_id = $1\n             and event.idx > coalesce((select up_to_index from snapshot), 0)\n           order by row_order, idx`,\n          [sessionId, reducerName],\n        )\n        const snapshot = rows.find((row) => row['row_kind'] === 'snapshot')\n        return {\n          snapshot: snapshot\n            ? {\n                index: asNumber(snapshot['snapshot_index']),\n                state: snapshot['snapshot_state'],\n              }\n            : null,\n          events: rows\n            .filter((row) => row['row_kind'] === 'event')\n            .map(toEvent),\n        }\n      })\n    },\n\n    async readStates(sessionIds, reducerName) {\n      if (sessionIds.length === 0) return []\n      return wrap(async () => {\n        const c = await client()\n        // One statement, one MVCC snapshot — each session's tail is\n        // bounded by the same snapshot row the read returns.\n        const { rows } = await c.query(\n          `with snapshot as materialized (\n             select session_id, up_to_index, state\n             from a2_snapshots\n             where session_id = any($1::text[]) and reducer_name = $2\n           )\n           select 0 as row_order, 'snapshot' as row_kind,\n                  snapshot.session_id,\n                  snapshot.up_to_index as snapshot_index,\n                  snapshot.state as snapshot_state,\n                  null::bigint as idx, null::text as event_type,\n                  null::jsonb as payload, null::text as event_id,\n                  null::bigint as created_at\n           from snapshot\n           union all\n           select 1 as row_order, 'event' as row_kind,\n                  event.session_id,\n                  null::bigint as snapshot_index,\n                  null::jsonb as snapshot_state,\n                  event.idx, event.event_type, event.payload,\n                  event.event_id, event.created_at\n           from a2_events event\n           left join snapshot on snapshot.session_id = event.session_id\n           where event.session_id = any($1::text[])\n             and event.idx > coalesce(snapshot.up_to_index, 0)\n           order by row_order, session_id, idx`,\n          [sessionIds, reducerName],\n        )\n        const bySession = new Map<string, StoreStateRead>()\n        const readOf = (sessionId: string): StoreStateRead => {\n          let read = bySession.get(sessionId)\n          if (!read) {\n            read = { snapshot: null, events: [] }\n            bySession.set(sessionId, read)\n          }\n          return read\n        }\n        for (const row of rows) {\n          const read = readOf(row['session_id'] as string)\n          if (row['row_kind'] === 'snapshot') {\n            read.snapshot = {\n              index: asNumber(row['snapshot_index']),\n              state: row['snapshot_state'],\n            }\n          } else {\n            read.events.push(toEvent(row))\n          }\n        }\n        return sessionIds.map(\n          (sessionId) =>\n            bySession.get(sessionId) ?? { snapshot: null, events: [] },\n        )\n      })\n    },\n\n    async putSnapshot(sessionId, reducerName, index, state) {\n      await wrap(async () => {\n        const c = await client()\n        // Guarded upsert: a slower concurrent writer must never clobber\n        // a further-along snapshot (spec §3).\n        await c.query(\n          `insert into a2_snapshots (session_id, reducer_name, up_to_index, state, updated_at)\n           values ($1, $2, $3, $4::jsonb, $5)\n           on conflict (session_id, reducer_name) do update set\n             up_to_index = excluded.up_to_index,\n             state = excluded.state,\n             updated_at = excluded.updated_at\n           where excluded.up_to_index > a2_snapshots.up_to_index`,\n          [sessionId, reducerName, index, jsonb(state), clock.now().getTime()],\n        )\n      })\n    },\n\n    presence: {\n      async set(ns, participant, values, meta) {\n        const entries = Object.entries(values)\n        if (entries.length === 0) return\n        await wrap(async () => {\n          const c = await client()\n          const atMs = meta.at.getTime()\n          // Expiry anchors on the storage clock — the sender's `at`\n          // orders writes but never anchors their lifetime.\n          const expiresAtMs = clock.now().getTime() + meta.ttlMs\n          for (const [field, value] of entries) {\n            // Field-wise LWW: a stored row with a strictly newer `at`\n            // survives; ties go to the incoming write (memory parity).\n            // oxlint-disable-next-line no-await-in-loop -- independent per-field registers\n            await (value === null\n              ? c.query(\n                  `delete from a2_presence\n                    where ns = $1 and participant = $2 and field = $3\n                      and at <= $4`,\n                  [ns, participant, field, atMs],\n                )\n              : c.query(\n                  `insert into a2_presence\n                     (ns, participant, field, value, seen, at, expires_at)\n                   values ($1, $2, $3, $4::jsonb, $5, $6, $7)\n                   on conflict (ns, participant, field) do update set\n                     value = excluded.value,\n                     seen = excluded.seen,\n                     at = excluded.at,\n                     expires_at = excluded.expires_at\n                   where a2_presence.at <= excluded.at`,\n                  [\n                    ns,\n                    participant,\n                    field,\n                    jsonb(value),\n                    meta.seen,\n                    atMs,\n                    expiresAtMs,\n                  ],\n                ))\n          }\n        })\n      },\n\n      async read(ns) {\n        return wrap(async () => {\n          const c = await client()\n          const now = clock.now().getTime()\n          // Sweep and read share one statement (one snapshot): the\n          // delete is opportunistic cleanup; the filter alone keeps\n          // expired rows out of this result.\n          const { rows } = await c.query(\n            `with swept as (\n               delete from a2_presence\n                where ns = $1 and expires_at <= $2\n             )\n             select participant, field, value, seen, at, expires_at\n               from a2_presence\n              where ns = $1 and expires_at > $2\n              order by participant, field`,\n            [ns, now],\n          )\n          return rows.map((row) => ({\n            participant: row['participant'] as string,\n            field: row['field'] as string,\n            value: row['value'],\n            seen: asNumber(row['seen']),\n            at: new Date(asNumber(row['at'])),\n            expiresAt: new Date(asNumber(row['expires_at'])),\n          }))\n        })\n      },\n    },\n\n    inspect: {\n      async listSessions(inspectionOptions) {\n        return wrap(async () => {\n          const c = await client()\n          const conditions = ['left(session_id, length($1)) = $1']\n          const params: unknown[] = [inspectionOptions.prefix]\n          if (inspectionOptions.cursor !== undefined) {\n            params.push(inspectionOptions.cursor)\n            conditions.push(`session_id > $${params.length}`)\n          }\n          params.push(inspectionOptions.limit + 1)\n          const { rows } = await c.query(\n            `select\n               session_id,\n               count(*) as event_count,\n               count(*) filter (where processed_at is null and failed_at is null) as pending_count,\n               count(*) filter (where failed_at is not null) as failed_count,\n               sum(attempt_count) as attempt_count,\n               sum(failure_count) as failure_count,\n               min(created_at) as first_event_at,\n               max(greatest(\n                 created_at,\n                 coalesce(first_claimed_at, 0),\n                 coalesce(last_claimed_at, 0),\n                 coalesce(last_failed_at, 0),\n                 coalesce(processed_at, 0),\n                 coalesce(failed_at, 0)\n               )) as updated_at\n             from a2_events\n             where ${conditions.join(' and ')}\n             group by session_id\n             order by session_id\n             limit $${params.length}`,\n            params,\n          )\n          const hasMore = rows.length > inspectionOptions.limit\n          const visible = rows.slice(0, inspectionOptions.limit)\n          return {\n            sessions: visible.map((row) => ({\n              sessionId: row['session_id'] as string,\n              eventCount: asNumber(row['event_count']),\n              pendingCount: asNumber(row['pending_count']),\n              failedCount: asNumber(row['failed_count']),\n              attemptCount: asNumber(row['attempt_count']),\n              failureCount: asNumber(row['failure_count']),\n              firstEventAt: new Date(asNumber(row['first_event_at'])),\n              updatedAt: new Date(asNumber(row['updated_at'])),\n            })),\n            cursor: hasMore\n              ? ((visible.at(-1)?.['session_id'] as string | undefined) ?? null)\n              : null,\n          }\n        })\n      },\n      async readEvents(sessionId, pageOptions) {\n        return wrap(async () => {\n          const c = await client()\n          const currentFrontier = asNumber(\n            (\n              await c.query(\n                'select coalesce(max(idx), 0) as frontier from a2_events where session_id = $1',\n                [sessionId],\n              )\n            ).rows[0]?.['frontier'] ?? 0,\n          )\n          const throughIndex = Math.min(\n            pageOptions.throughIndex ?? currentFrontier,\n            currentFrontier,\n          )\n          const { rows } = await c.query(\n            `select * from a2_events\n              where session_id = $1 and idx > $2 and idx <= $3\n              order by idx limit $4`,\n            [\n              sessionId,\n              pageOptions.afterIndex,\n              throughIndex,\n              pageOptions.limit,\n            ],\n          )\n          return { events: rows.map(toStored), throughIndex }\n        })\n      },\n      async listSnapshots(sessionId) {\n        return wrap(async () => {\n          const c = await client()\n          const { rows } = await c.query(\n            `select reducer_name, up_to_index, updated_at\n             from a2_snapshots where session_id = $1 order by reducer_name`,\n            [sessionId],\n          )\n          return rows.map((row) => ({\n            reducerName: row['reducer_name'] as string,\n            index: asNumber(row['up_to_index']),\n            updatedAt: new Date(asNumber(row['updated_at'])),\n          }))\n        })\n      },\n    },\n\n    stream(sessionId, opts) {\n      const readAfter = (afterIndex: number): Promise<StoredEvent[]> =>\n        wrap(async () => {\n          const c = await client()\n          const { rows } = await c.query(\n            'select * from a2_events where session_id = $1 and idx > $2 order by idx',\n            [sessionId, afterIndex],\n          )\n          return rows.map(toStored)\n        })\n      return pollingStream(\n        readAfter,\n        opts?.startAfter !== undefined ? { startAfter: opts.startAfter } : {},\n      )\n    },\n\n    async close() {\n      const current = connection.peek()\n      if (!current) return\n      const c = await current\n      await c.end?.()\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4Df,MAAM,YAAY,UAA2B,OAAO,KAAK;AAEzD,MAAM,UAAU,OACd,OAAO,QAAQ,OAAO,KAAA,IAAY,OAAO,IAAI,KAAK,SAAS,EAAE,CAAC;AAEhE,MAAM,WAAW,QAAoC;CACnD,IAAI,QAAQ,QAAQ,QAAQ,KAAA,GAAW,OAAO;CAC9C,MAAM,QAAS,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAI;CAK3D,IACE,CAAC,OAAO,UAAU,MAAM,KAAK,KAC7B,OAAO,MAAM,KAAK,IAAI,KACtB,CAAC,OAAO,UAAU,MAAM,OAAO,KAC/B,OAAO,MAAM,OAAO,IAAI,GAExB,MAAM,IAAI,UAAU,mCAAmC;CAEzD,IACE,MAAM,cAAc,KAAA,MACnB,CAAC,OAAO,UAAU,MAAM,SAAS,KAAK,OAAO,MAAM,SAAS,IAAI,IAEjE,MAAM,IAAI,UAAU,mCAAmC;CAEzD,OAAO;EACL,OAAO,OAAO,MAAM,KAAK;EACzB,SAAS,OAAO,MAAM,OAAO;EAC7B,GAAI,MAAM,cAAc,KAAA,IACpB,CAAC,IACD,EAAE,WAAW,OAAO,MAAM,SAAS,EAAE;CAC3C;AACF;AAEA,MAAM,YAAY,SAA+C;CAC/D,IAAI,IAAI;CACR,MAAM,IAAI;CACV,SAAS,IAAI;CACb,OAAO,SAAS,IAAI,MAAM;CAC1B,WAAW,IAAI;CACf,WAAW,IAAI,KAAK,SAAS,IAAI,aAAa,CAAC;CAC/C,OAAO,QAAQ,IAAI,QAAQ;CAC3B,MAAO,IAAI,WAA6B;CACxC,aAAa,OAAO,IAAI,eAAe;CACvC,oBACE,IAAI,4BAA4B,QAChC,IAAI,4BAA4B,KAAA,IAC5B,OACA,SAAS,IAAI,uBAAuB;CAC1C,kBACE,IAAI,0BAA0B,QAC9B,IAAI,0BAA0B,KAAA,IAC1B,OACA,uBAAuB,IAAI,qBAAqB;CACtD,gBAAgB,OAAO,IAAI,mBAAmB;CAC9C,eAAe,OAAO,IAAI,kBAAkB;CAC5C,cAAc,SAAS,IAAI,gBAAgB;CAC3C,cAAc,SAAS,IAAI,gBAAgB;CAC3C,cAAc,OAAO,IAAI,iBAAiB;CAC1C,mBACE,IAAI,2BAA2B,QAC/B,IAAI,2BAA2B,KAAA,IAC3B,OACA,SAAS,IAAI,sBAAsB;CACzC,WAAY,IAAI,iBAAmC;CACnD,UAAU,OAAO,IAAI,YAAY;CACjC,aAAc,IAAI,mBAAqC;CACvD,gBAAgB,OAAO,IAAI,mBAAmB;AAChD;AAEA,MAAM,WAAW,SAAyC;CACxD,IAAI,IAAI;CACR,MAAM,IAAI;CACV,SAAS,IAAI;CACb,OAAO,SAAS,IAAI,MAAM;CAC1B,WAAW,IAAI;CACf,WAAW,IAAI,KAAK,SAAS,IAAI,aAAa,CAAC;AACjD;AAEA,MAAM,OAAO,OAAU,OAAqC;CAC1D,IAAI;EACF,OAAO,MAAM,GAAG;CAClB,SAAS,KAAK;EACZ,IAAI,eAAe,WAAW,eAAe,WAAW,MAAM;EAC9D,MAAM,IAAI,QAAQ,qBAAqB,mCAAmC,EACxE,OAAO,IACT,CAAC;CACH;AACF;AAEA,MAAM,SAAS,UAA2B,KAAK,UAAU,KAAK,KAAK;AAEnE,MAAM,mBAAmB,OAAO,WAA0C;CACxE,IAAI,CAAC,OAAO,SAAS;EACnB,MAAM,OAAO,MAAM,MAAM;EACzB;CACF;CAEA,MAAM,OAAO,MAAM,OAAO,QAAQ;CAClC,IAAI;EACF,MAAM,KAAK,MAAM,OAAO;EAGxB,MAAM,KAAK,MACT,8DACF;EACA,MAAM,KAAK,MAAM,MAAM;EACvB,MAAM,KAAK,MAAM,QAAQ;CAC3B,SAAS,KAAK;EACZ,MAAM,KAAK,MAAM,UAAU,CAAC,CAAC,YAAY,CAAC,CAAC;EAC3C,MAAM;CACR,UAAU;EACR,KAAK,QAAQ;CACf;AACF;AAEA,SAAgB,SAAS,UAAgC,CAAC,GAAkB;CAC1E,MAAM,QAAQ,QAAQ,SAAS;CAC/B,MAAM,aAAa,QAAQ,OAAO;CAElC,IAAI,CAAC,QAAQ,UAAU,CAAC,QAAQ,kBAC9B,MAAM,IAAI,UACR,2DACF;CAMF,MAAM,aAAa,cAAc,YAAY;EAC3C,IAAI,QAA+B;EACnC,IAAI;GACF,IAAI,IAAI,QAAQ;GAChB,IAAI,CAAC,GAAG;IAON,IAAI,KAAI,OANS,OAAO,KAAK,CAAC,YAAY;KACxC,MAAM,IAAI,QACR,wBACA,2IACF;IACF,CAAC,GAAA,CACU,QAAQ,KAAK,EACtB,kBAAkB,QAAQ,iBAC5B,CAAC;IACD,QAAQ;GACV;GACA,MAAM,iBAAiB,CAAC;GACxB,OAAO;EACT,SAAS,KAAK;GACZ,IAAI,OAAO,KAAK,MAAM,MAAM,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC;GAChD,MAAM;EACR;CACF,CAAC;CACD,MAAM,SAAS,WAAW;CAI1B,IAAI,QAA0B,QAAQ,QAAQ;CAC9C,MAAM,SAAS,OACb,OACe;EACf,MAAM,IAAI,MAAM,OAAO;EACvB,IAAI,EAAE,SAAS;GACb,MAAM,OAAO,MAAM,EAAE,QAAQ;GAC7B,IAAI;IACF,MAAM,KAAK,MAAM,OAAO;IACxB,MAAM,SAAS,MAAM,IAAI,MAAM,WAAW,KAAK,MAAM,MAAM,MAAM,CAAC;IAClE,MAAM,KAAK,MAAM,QAAQ;IACzB,OAAO;GACT,SAAS,KAAK;IACZ,MAAM,KAAK,MAAM,UAAU,CAAC,CAAC,YAAY,CAAC,CAAC;IAC3C,MAAM;GACR,UAAU;IACR,KAAK,QAAQ;GACf;EACF;EACA,MAAM,MAAM,MAAM,KAAK,YAAY;GACjC,MAAM,EAAE,MAAM,OAAO;GACrB,IAAI;IACF,MAAM,SAAS,MAAM,IAAI,MAAM,WAAW,EAAE,MAAM,MAAM,MAAM,CAAC;IAC/D,MAAM,EAAE,MAAM,QAAQ;IACtB,OAAO;GACT,SAAS,KAAK;IACZ,MAAM,EAAE,MAAM,UAAU,CAAC,CAAC,YAAY,CAAC,CAAC;IACxC,MAAM;GACR;EACF,CAAC;EACD,QAAQ,IAAI,YAAY,CAAC,CAAC;EAC1B,OAAO;CACT;CAEA,OAAO;EACL,MAAM,OAAO,WAAW,QAAQ;GAC9B,IAAI,OAAO,WAAW,GACpB,OAAO,KAAK,YAAY;IAEtB,MAAM,EAAE,SAAS,OAAM,MADP,OAAO,EAAA,CACE,MACvB;;;gCAIA,CAAC,SAAS,CACZ;IACA,OAAO;KACL,QAAQ,CAAC;KACT,YAAY,KAAK,EAAE,GAAG,mBAAmB;IAC3C;GACF,CAAC;GAEH,OAAO,WACL,OAAO,OAAO,UAAU;IAGtB,MAAM,MAAM,8CAA8C,CAAC,SAAS,CAAC;IAGrE,MAAM,cADW,OAAO,QAAQ,MAAM,EAAE,OAAO,KAAA,CACpB,CAAC,CAAC,KAAK,MAAM,EAAE,EAAY;IACtD,IAAI,IAAI,IAAI,WAAW,CAAC,CAAC,SAAS,YAAY,QAC5C,MAAM,IAAI,QACR,2BACA,iDACF;IAEF,IAAI,YAAY,SAAS,GAAG;KAC1B,MAAM,EAAE,MAAM,aAAa,MAAM,MAC/B;;;;;;;;sCASA,CAAC,aAAa,SAAS,CACzB;KACA,IAAI,SAAS,SAAS,GAAG;MACvB,MAAM,UAAU,SAAS,MACtB,QAAQ,IAAI,kBAAkB,SACjC;MACA,IAAI,SACF,MAAM,IAAI,QACR,2BACA,aAAa,OAAO,QAAQ,WAAW,EAAE,oCAC3C;MAEF,IAAI,SAAS,WAAW,OAAO,QAC7B,OAAO;OACL,QAAQ,iBAAiB,QAAQ,SAAS,IAAI,QAAQ,CAAC;OACvD,YAAY,SAAS,EAAE,GAAG,2BAA2B;MACvD;MAEF,MAAM,IAAI,QACR,2BACA,eAAe,SAAS,OAAO,wBAAwB,OAAO,SAAS,SAAS,OAAO,cACzF;KACF;IACF;IAOA,MAAM,eAAe,CACnB,GAAG,IAAI,IACL,OACG,QAAQ,MAAM,EAAE,UAAU,KAAA,CAAS,CAAC,CACpC,KAAK,MAAM,EAAE,MAAO,KAAK,CAC9B,CACF;IACA,IAAI,aAAa,SAAS,GAAG;KAC3B,MAAM,EAAE,MAAM,YAAY,MAAM,MAC9B;;6BAGA,CAAC,WAAW,YAAY,CAC1B;KACA,MAAM,UAAU,IAAI,IAClB,QAAQ,KAAK,QAAQ,CAAC,SAAS,IAAI,MAAM,GAAG,GAAG,CAAC,CAClD;KACA,KAAK,MAAM,KAAK,QAAQ;MACtB,IAAI,CAAC,EAAE,OAAO;MACd,MAAM,SAAS,QAAQ,IAAI,EAAE,MAAM,KAAK;MACxC,IAAI,CAAC,QACH,MAAM,IAAI,UACR,qBAAqB,EAAE,MAAM,MAAM,eAAe,UAAU,EAC9D;MAEF,IACE,SAAS,OAAO,gBAAgB,MAAM,EAAE,MAAM,WAC9C,OAAO,iBAAiB,MAExB,MAAM,IAAI,QACR,sBACA,WAAW,EAAE,MAAM,QAAQ,wBAAwB,EAAE,MAAM,MAAM,eAAe,UAAU,EAC5F;KAEJ;IACF;IAEA,MAAM,EAAE,MAAM,YAAY,MAAM,MAC9B;;;;;;;sCAQA,CAAC,SAAS,CACZ;IACA,MAAM,OAAO,SAAS,QAAQ,EAAE,GAAG,MAAM;IACzC,MAAM,MAAM,MAAM,IAAI,CAAC,CAAC,QAAQ;IAChC,MAAM,WAA0B,CAAC;IACjC,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,GAAG;KACzC,MAAM,IAAI,OAAO;KACjB,MAAM,KAAK,EAAE,MAAM,WAAW;KAC9B,MAAM,QAAQ,OAAO,IAAI;KAEzB,MAAM,MACJ;;;;;;;;;;mBAWA;MACE;MACA;MACA,EAAE;MACF,MAAM,EAAE,OAAO;MACf;MACA;MACA,EAAE,QAAQ,MAAM,EAAE,KAAK,IAAI;MAC3B,EAAE,QAAQ;MACV,EAAE,UAAU,MAAM;KACpB,CACF;KACA,SAAS,KAAK;MACZ;MACA,MAAM,EAAE;MACR,SAAS,gBAAgB,EAAE,OAAO;MAClC;MACA;MACA,WAAW,IAAI,KAAK,GAAG;MACvB,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,IAAI;MAClC,MAAM,EAAE,QAAQ;MAChB,aAAa,EAAE,UAAU,IAAI,KAAK,GAAG,IAAI;MACzC,oBAAoB;MACpB,kBAAkB;MAClB,gBAAgB;MAChB,eAAe;MACf,cAAc;MACd,cAAc;MACd,cAAc;MACd,mBAAmB;MACnB,WAAW;MACX,UAAU;MACV,aAAa;MACb,gBAAgB;KAClB,CAAC;IACH;IACA,OAAO;KACL,QAAQ;KACR,YACE,QAAQ,EAAE,GAAG,2BAA2B,QACxC,OAAO,MAAM,UAAU,MAAM,YAAY,IAAI;IACjD;GACF,CAAC,CACH;EACF;EAEA,MAAM,KAAK,WAAW,MAAM;GAC1B,OAAO,KAAK,YAAY;IACtB,MAAM,IAAI,MAAM,OAAO;IACvB,MAAM,aAAa,CAAC,iBAAiB;IACrC,MAAM,SAAoB,CAAC,SAAS;IACpC,IAAI,MAAM,eAAe,KAAA,GAAW;KAClC,OAAO,KAAK,KAAK,UAAU;KAC3B,WAAW,KAAK,UAAU,OAAO,QAAQ;IAC3C;IACA,IAAI,MAAM,iBAAiB,KAAA,GAAW;KACpC,OAAO,KAAK,KAAK,YAAY;KAC7B,WAAW,KAAK,WAAW,OAAO,QAAQ;IAC5C;IACA,MAAM,EAAE,SAAS,MAAM,EAAE,MACvB,iCAAiC,WAAW,KAAK,OAAO,EAAE,gBAC1D,MACF;IACA,OAAO,KAAK,IAAI,QAAQ;GAC1B,CAAC;EACH;EAEA,MAAM,eAAe,EACnB,WACA,QACA,OACA,aACA,iBAAiB,CAAC,KACjB;GACD,OAAO,WACL,OAAO,OAAO,UAAU;IACtB,MAAM,MAAM,MAAM,IAAI,CAAC,CAAC,QAAQ;IAEhC,MAAM,EAAE,SAAS,MAAM,MACrB;;;;;;;;;;;;;;;;;;;mCAoBA;KAAC;KAAW;KAAK;KAtBD,eAAe,MAAM;KAsBD,CAAC,GAAG,cAAc;IAAC,CACzD;IACA,IAAI,KAAK,SAAS,GAIhB,OAAO;KAAE,SAAS;KAAW,QAHd,KACZ,IAAI,QAAQ,CAAC,CACb,UAAU,GAAG,MAAM,EAAE,QAAQ,EAAE,KACA;IAAE;IAEtC,MAAM,EAAE,MAAM,eAAe,MAAM,MACjC;;;;;;4CAOA,CAAC,WAAW,GAAG,CACjB;IACA,MAAM,UAAU,WAAW,EAAE,GAAG;IAChC,OAAO,YAAY,QAAQ,YAAY,KAAA,IACnC,EAAE,SAAS,UAAU,IACrB;KAAE,SAAS;KAAQ,SAAS,IAAI,KAAK,SAAS,OAAO,CAAC;IAAE;GAC9D,CAAC,CACH;EACF;EAEA,MAAM,YAAY,EAAE,WAAW,QAAQ,QAAQ,OAAO,eAAe;GACnE,IAAI,OAAO,WAAW,GAAG,OAAO;IAAE,SAAS,CAAC;IAAG,YAAY,CAAC;GAAE;GAC9D,OAAO,KAAK,YAAY;IACtB,MAAM,IAAI,MAAM,OAAO;IACvB,MAAM,MAAM,MAAM,IAAI,CAAC,CAAC,QAAQ;IAChC,MAAM,YAAY,eAAe,MAAM;IACvC,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,KAAK;IACjD,MAAM,WAAW,IAAI,IACnB,OAAO,KAAK,UAAU,CAAC,MAAM,OAAO,MAAM,OAAO,CAAC,CACpD;IACA,MAAM,EAAE,SAAS,MAAM,EAAE,MACvB;;;;;;;;;;;;;;;;;;;;4EAqBA;KACE;KACA;KACA;KACA;KACA;KACA,OAAO,KAAK,UAAU,MAAM,OAAO;IACrC,CACF;IACA,MAAM,UAAoB,CAAC;IAC3B,MAAM,aAAuB,CAAC;IAC9B,KAAK,MAAM,OAAO,MAAM;KACtB,MAAM,QAAQ,SAAS,IAAI,MAAM;KACjC,IAAI,IAAI,eAAe,MAAM,QAAQ,KAAK,KAAK;UAC1C,IACH,SAAS,IAAI,gBAAgB,KAAK,SAAS,IAAI,KAAK,KAAK,IAEzD,WAAW,KAAK,KAAK;IAEzB;IACA,OAAO;KACL,SAAS,QAAQ,UAAU,GAAG,MAAM,IAAI,CAAC;KACzC,YAAY,WAAW,UAAU,GAAG,MAAM,IAAI,CAAC;IACjD;GACF,CAAC;EACH;EAEA,MAAM,gBAAgB,EAAE,WAAW,OAAO,SAAS,UAAU;GAC3D,OAAO,WACL,OAAO,OAAO,UAAU;IACtB,MAAM,EAAE,MAAM,eAAe,MAAM,MACjC;;2BAGA,CAAC,WAAW,KAAK,CACnB;IACA,MAAM,SAAS,WAAW;IAC1B,IAAI,CAAC,QACH,MAAM,IAAI,UACR,qBAAqB,MAAM,eAAe,UAAU,EACtD;IAEF,MAAM,MAAM,OAAO,KAAK,UAAU,MAAM,EAAE;IAC1C,IAAI,IAAI,IAAI,GAAG,CAAC,CAAC,SAAS,IAAI,QAC5B,MAAM,IAAI,QACR,2BACA,gEACF;IAEF,IAAI,OAAO,oBAAoB,MAAM;KACnC,IAAI,SAAS,OAAO,uBAAuB,MAAM,SAC/C,OAAO,EAAE,SAAS,aAAa;KAEjC,MAAM,cACJ,OAAO,0BAA0B,QACjC,OAAO,0BAA0B,KAAA,IAC7B,OACA,uBAAuB,OAAO,qBAAqB;KACzD,IACE,gBAAgB,QAChB,YAAY,WAAW,IAAI,UAC3B,YAAY,MAAM,IAAI,WAAW,OAAO,IAAI,OAAO,GAEnD,MAAM,IAAI,QACR,2BACA,2DACF;KAEF,IAAI,OAAO,WAAW,GACpB,OAAO;MAAE,SAAS;MAAa,QAAQ,CAAC;KAAE;KAE5C,MAAM,EAAE,MAAM,aAAa,MAAM,MAC/B;mDAEA,CAAC,GAAG,CACN;KACA,MAAM,OAAO,IAAI,IACf,SAAS,KAAK,QAAQ,CAAC,IAAI,aAAuB,GAAG,CAAC,CACxD;KACA,MAAM,UAAU,IAAI,KAAK,OAAO,KAAK,IAAI,EAAE,CAAC;KAC5C,IACE,QAAQ,MAAM,QAAQ;MACpB,MAAM,QAAQ,MAAM,QAAQ,IAAI,QAAQ,IAAI;MAC5C,OACE,CAAC,OACD,IAAI,kBAAkB,aACtB,OAAO,UAAU,SACjB,MAAM,YAAY;KAEtB,CAAC,GAED,MAAM,IAAI,QACR,2BACA,yDACF;KAEF,OAAO;MACL,SAAS;MACT,QAAQ,iBACN,QACC,QAAsC,IAAI,QAAQ,CACrD;KACF;IACF;IACA,IACE,SAAS,OAAO,gBAAgB,MAAM,WACtC,OAAO,oBAAoB,QAC3B,OAAO,oBAAoB,KAAA,KAC3B,OAAO,iBAAiB,MAExB,OAAO,EAAE,SAAS,aAAa;IAGjC,MAAM,MAAM,8CAA8C,CAAC,SAAS,CAAC;IACrE,IAAI,IAAI,SAAS,GAAG;KAClB,MAAM,EAAE,MAAM,aAAa,MAAM,MAC/B,mEACA,CAAC,GAAG,CACN;KACA,IAAI,SAAS,SAAS,GACpB,MAAM,IAAI,QACR,2BACA,4DACF;IAEJ;IAEA,MAAM,EAAE,MAAM,YAAY,MAAM,MAC9B,4EACA,CAAC,SAAS,CACZ;IACA,MAAM,OAAO,SAAS,QAAQ,EAAE,GAAG,MAAM;IACzC,MAAM,MAAM,MAAM,IAAI,CAAC,CAAC,QAAQ;IAChC,MAAM,WAA0B,CAAC;IACjC,KAAK,IAAI,SAAS,GAAG,SAAS,OAAO,QAAQ,UAAU,GAAG;KACxD,MAAM,QAAQ,OAAO;KAGrB,MAAM,EAAE,SAAS,MAAM,MACrB;;;;;;;;;;;6BAYA;MACE;MAhBe,OAAO,SAAS;MAkB/B,MAAM;MACN,MAAM,MAAM,OAAO;MACnB,MAAM;MACN;MACA,MAAM;OAAE;OAAO;MAAQ,CAAC;MACxB,MAAM,QAAQ;MACd,MAAM,UAAU,MAAM;KACxB,CACF;KACA,SAAS,KAAK,SAAS,KAAK,EAAG,CAAC;IAClC;IACA,MAAM,MACJ;;;;;;;kDAQA;KAAC;KAAK;KAAS;KAAW;KAAO,MAAM,GAAG;IAAC,CAC7C;IACA,MAAM,aAAc,OAAO,WAA6B;IACxD,IAAI,eAAe,MACjB,MAAM,MACJ;;;;;;sBAOA,CAAC,WAAW,UAAU,CACxB;IAEF,OAAO;KAAE,SAAS;KAAa,QAAQ;IAAS;GAClD,CAAC,CACH;EACF;EAEA,MAAM,YAAY,EAAE,WAAW,OAAO,SAAS,OAAO,eAAe;GACnE,OAAO,KAAK,YAAY;IAEtB,MAAM,EAAE,SAAS,OAAM,MADP,OAAO,EAAA,CACE,MACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAgDA;KACE;KACA;KACA;KACA;KACA;KACA,MAAM,IAAI,CAAC,CAAC,QAAQ;IACtB,CACF;IACA,MAAM,MAAM,KAAK;IACjB,IAAI,CAAC,OAAO,IAAI,eAAe,WAC7B,MAAM,IAAI,UACR,qBAAqB,MAAM,eAAe,UAAU,EACtD;IAEF,OAAO;KACL,SAAS,IAAI;KACb,cAAc,SAAS,IAAI,gBAAgB;IAC7C;GACF,CAAC;EACH;EAEA,MAAM,UAAU,WAAW,aAAa;GACtC,OAAO,KAAK,YAAY;IAEtB,MAAM,EAAE,SAAS,OAAM,MADP,OAAO,EAAA,CACE,MACvB;;;;;;;;;;;;;;;;;;;;;qCAsBA,CAAC,WAAW,WAAW,CACzB;IACA,MAAM,WAAW,KAAK,MAAM,QAAQ,IAAI,gBAAgB,UAAU;IAClE,OAAO;KACL,UAAU,WACN;MACE,OAAO,SAAS,SAAS,iBAAiB;MAC1C,OAAO,SAAS;KAClB,IACA;KACJ,QAAQ,KACL,QAAQ,QAAQ,IAAI,gBAAgB,OAAO,CAAC,CAC5C,IAAI,OAAO;IAChB;GACF,CAAC;EACH;EAEA,MAAM,WAAW,YAAY,aAAa;GACxC,IAAI,WAAW,WAAW,GAAG,OAAO,CAAC;GACrC,OAAO,KAAK,YAAY;IAItB,MAAM,EAAE,SAAS,OAAM,MAHP,OAAO,EAAA,CAGE,MACvB;;;;;;;;;;;;;;;;;;;;;;;;iDAyBA,CAAC,YAAY,WAAW,CAC1B;IACA,MAAM,4BAAY,IAAI,IAA4B;IAClD,MAAM,UAAU,cAAsC;KACpD,IAAI,OAAO,UAAU,IAAI,SAAS;KAClC,IAAI,CAAC,MAAM;MACT,OAAO;OAAE,UAAU;OAAM,QAAQ,CAAC;MAAE;MACpC,UAAU,IAAI,WAAW,IAAI;KAC/B;KACA,OAAO;IACT;IACA,KAAK,MAAM,OAAO,MAAM;KACtB,MAAM,OAAO,OAAO,IAAI,aAAuB;KAC/C,IAAI,IAAI,gBAAgB,YACtB,KAAK,WAAW;MACd,OAAO,SAAS,IAAI,iBAAiB;MACrC,OAAO,IAAI;KACb;UAEA,KAAK,OAAO,KAAK,QAAQ,GAAG,CAAC;IAEjC;IACA,OAAO,WAAW,KACf,cACC,UAAU,IAAI,SAAS,KAAK;KAAE,UAAU;KAAM,QAAQ,CAAC;IAAE,CAC7D;GACF,CAAC;EACH;EAEA,MAAM,YAAY,WAAW,aAAa,OAAO,OAAO;GACtD,MAAM,KAAK,YAAY;IAIrB,OAAM,MAHU,OAAO,EAAA,CAGf,MACN;;;;;;mEAOA;KAAC;KAAW;KAAa;KAAO,MAAM,KAAK;KAAG,MAAM,IAAI,CAAC,CAAC,QAAQ;IAAC,CACrE;GACF,CAAC;EACH;EAEA,UAAU;GACR,MAAM,IAAI,IAAI,aAAa,QAAQ,MAAM;IACvC,MAAM,UAAU,OAAO,QAAQ,MAAM;IACrC,IAAI,QAAQ,WAAW,GAAG;IAC1B,MAAM,KAAK,YAAY;KACrB,MAAM,IAAI,MAAM,OAAO;KACvB,MAAM,OAAO,KAAK,GAAG,QAAQ;KAG7B,MAAM,cAAc,MAAM,IAAI,CAAC,CAAC,QAAQ,IAAI,KAAK;KACjD,KAAK,MAAM,CAAC,OAAO,UAAU,SAI3B,OAAO,UAAU,OACb,EAAE,MACA;;qCAGA;MAAC;MAAI;MAAa;MAAO;KAAI,CAC/B,IACA,EAAE,MACA;;;;;;;;yDASA;MACE;MACA;MACA;MACA,MAAM,KAAK;MACX,KAAK;MACL;MACA;KACF,CACF;IAER,CAAC;GACH;GAEA,MAAM,KAAK,IAAI;IACb,OAAO,KAAK,YAAY;KACtB,MAAM,IAAI,MAAM,OAAO;KACvB,MAAM,MAAM,MAAM,IAAI,CAAC,CAAC,QAAQ;KAIhC,MAAM,EAAE,SAAS,MAAM,EAAE,MACvB;;;;;;;4CAQA,CAAC,IAAI,GAAG,CACV;KACA,OAAO,KAAK,KAAK,SAAS;MACxB,aAAa,IAAI;MACjB,OAAO,IAAI;MACX,OAAO,IAAI;MACX,MAAM,SAAS,IAAI,OAAO;MAC1B,IAAI,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC;MAChC,WAAW,IAAI,KAAK,SAAS,IAAI,aAAa,CAAC;KACjD,EAAE;IACJ,CAAC;GACH;EACF;EAEA,SAAS;GACP,MAAM,aAAa,mBAAmB;IACpC,OAAO,KAAK,YAAY;KACtB,MAAM,IAAI,MAAM,OAAO;KACvB,MAAM,aAAa,CAAC,mCAAmC;KACvD,MAAM,SAAoB,CAAC,kBAAkB,MAAM;KACnD,IAAI,kBAAkB,WAAW,KAAA,GAAW;MAC1C,OAAO,KAAK,kBAAkB,MAAM;MACpC,WAAW,KAAK,iBAAiB,OAAO,QAAQ;KAClD;KACA,OAAO,KAAK,kBAAkB,QAAQ,CAAC;KACvC,MAAM,EAAE,SAAS,MAAM,EAAE,MACvB;;;;;;;;;;;;;;;;;qBAiBS,WAAW,KAAK,OAAO,EAAE;;;sBAGxB,OAAO,UACjB,MACF;KACA,MAAM,UAAU,KAAK,SAAS,kBAAkB;KAChD,MAAM,UAAU,KAAK,MAAM,GAAG,kBAAkB,KAAK;KACrD,OAAO;MACL,UAAU,QAAQ,KAAK,SAAS;OAC9B,WAAW,IAAI;OACf,YAAY,SAAS,IAAI,cAAc;OACvC,cAAc,SAAS,IAAI,gBAAgB;OAC3C,aAAa,SAAS,IAAI,eAAe;OACzC,cAAc,SAAS,IAAI,gBAAgB;OAC3C,cAAc,SAAS,IAAI,gBAAgB;OAC3C,cAAc,IAAI,KAAK,SAAS,IAAI,iBAAiB,CAAC;OACtD,WAAW,IAAI,KAAK,SAAS,IAAI,aAAa,CAAC;MACjD,EAAE;MACF,QAAQ,UACF,QAAQ,GAAG,EAAE,CAAC,GAAG,iBAAwC,OAC3D;KACN;IACF,CAAC;GACH;GACA,MAAM,WAAW,WAAW,aAAa;IACvC,OAAO,KAAK,YAAY;KACtB,MAAM,IAAI,MAAM,OAAO;KACvB,MAAM,kBAAkB,UAEpB,MAAM,EAAE,MACN,iFACA,CAAC,SAAS,CACZ,EAAA,CACA,KAAK,EAAE,GAAG,eAAe,CAC7B;KACA,MAAM,eAAe,KAAK,IACxB,YAAY,gBAAgB,iBAC5B,eACF;KACA,MAAM,EAAE,SAAS,MAAM,EAAE,MACvB;;sCAGA;MACE;MACA,YAAY;MACZ;MACA,YAAY;KACd,CACF;KACA,OAAO;MAAE,QAAQ,KAAK,IAAI,QAAQ;MAAG;KAAa;IACpD,CAAC;GACH;GACA,MAAM,cAAc,WAAW;IAC7B,OAAO,KAAK,YAAY;KAEtB,MAAM,EAAE,SAAS,OAAM,MADP,OAAO,EAAA,CACE,MACvB;6EAEA,CAAC,SAAS,CACZ;KACA,OAAO,KAAK,KAAK,SAAS;MACxB,aAAa,IAAI;MACjB,OAAO,SAAS,IAAI,cAAc;MAClC,WAAW,IAAI,KAAK,SAAS,IAAI,aAAa,CAAC;KACjD,EAAE;IACJ,CAAC;GACH;EACF;EAEA,OAAO,WAAW,MAAM;GACtB,MAAM,aAAa,eACjB,KAAK,YAAY;IAEf,MAAM,EAAE,SAAS,OAAM,MADP,OAAO,EAAA,CACE,MACvB,2EACA,CAAC,WAAW,UAAU,CACxB;IACA,OAAO,KAAK,IAAI,QAAQ;GAC1B,CAAC;GACH,OAAO,cACL,WACA,MAAM,eAAe,KAAA,IAAY,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC,CACtE;EACF;EAEA,MAAM,QAAQ;GACZ,MAAM,UAAU,WAAW,KAAK;GAChC,IAAI,CAAC,SAAS;GAEd,OAAM,MADU,QAAA,CACR,MAAM;EAChB;CACF;AACF"}

package/dist/{store-redis-core-DWqx3F47.js → store-redis-core-BFLwz0Wj.js}

@@ -1,5 +1,5 @@
 import { t as A2Error } from "./errors-BQuJpe82.js";
-import { g as nullProtoRecord } from "./internal-aEotMzu_.js";
+import { g as nullProtoRecord } from "./internal-DstsI6Re.js";
 import { t as idempotentReplay } from "./idempotent-replay-DuqEkYA7.js";
 import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
 //#region src/store-redis-core.ts
@@ -1037,3 +1037,5 @@ function createRedisStoreCore(options) {
 }
 //#endregion
 export { createRedisStoreCore as t };
+
+//# sourceMappingURL=store-redis-core-BFLwz0Wj.js.map