experimental-a2 0.3.0 → 0.4.0

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

@@ -1,19 +1,11 @@
-//#region src/log.d.ts
-/**
- * The A2Log interface — the storage contract every log backend
- * implements. See specs/a2-implementation.md §2–3.
- *
- * This is the whole storage contract: append, read, dispatch claims,
- * failure markers, snapshots, and the live stream. Recovery
- * needs nothing extra — the armed queue message is its own state, and
- * the log is the only thing it consults.
- */
+import { c as PresencePatch } from "./contract-jIfaR085.js";
+//#region src/store.d.ts
 /** A stored event, as the public API exposes it. */
 type Event = {
   id: string;
   type: string;
   payload: unknown;
-  /** Position in the session's log, from 1. */
+  /** Position in the session's event log, from 1. */
   index: number;
   sessionId: string;
   createdAt: Date;
@@ -26,7 +18,7 @@ type EventCause = {
   batchSize?: number;
 };
 /**
- * What the log stores: immutable event history, including its causal edge,
+ * What the store persists: immutable event history, including its causal edge,
  * plus derived dispatch and failure bookkeeping. The bookkeeping is disposable;
  * the event and its cause are not.
  */
@@ -75,6 +67,21 @@ type StoredSessionSummary = {
   firstEventAt: Date;
   updatedAt: Date;
 };
+/**
+ * One live presence value, as `A2Store.presence.read` returns it. The
+ * row is the LWW unit — one participant's one field. `at` is the
+ * sender's stamp, the LWW comparator. `expiresAt` is the storage's
+ * own clock at the applied set plus its `ttlMs` — never derived from
+ * the sender stamp; a row is live strictly before it.
+ */
+type PresenceRow = {
+  participant: string;
+  field: string;
+  value: unknown;
+  seen: number;
+  at: Date;
+  expiresAt: Date;
+};
 /** Metadata for the latest cached fold of one reducer. */
 type StoredSnapshot = {
   reducerName: string;
@@ -82,7 +89,7 @@ type StoredSnapshot = {
   updatedAt: Date;
 };
 /** One consistent cache-plus-tail read for a reducer fold. */
-type LogStateRead = {
+type StoreStateRead = {
   /** The latest cached fold for this reducer, if one exists. */
   snapshot: {
     index: number;
@@ -96,22 +103,37 @@ type StoredSessionPage = {
   /** Opaque backend cursor; null means there is no next page. */
   cursor: string | null;
 };
+type StoredEventPage = {
+  events: StoredEvent[];
+  /** Fixed inclusive log frontier shared by every page in one inspection. */
+  throughIndex: number;
+};
 /**
- * Optional read-only administration implemented by A2's shipped logs.
- * It is separate from the correctness contract so custom logs do not
+ * Optional read-only administration implemented by A2's shipped stores.
+ * It is separate from the correctness contract so custom stores do not
  * need to expose storage-wide discovery merely to process events.
  */
-type A2LogInspection = {
+type A2StoreInspection = {
   listSessions(options: {
     /** Storage namespace prefix, including the contract separator. */
     prefix: string;
     cursor?: string;
     limit: number;
   }): Promise<StoredSessionPage>;
+  /**
+   * A bounded event page for read-only administration. The first page captures
+   * `throughIndex`; callers pass it back so concurrent appends cannot extend a
+   * walk indefinitely. Optional for custom stores; A2 falls back to `read()`.
+   */
+  readEvents?(sessionId: string, options: {
+    afterIndex: number;
+    throughIndex?: number;
+    limit: number;
+  }): Promise<StoredEventPage>;
   listSnapshots(sessionId: string): Promise<StoredSnapshot[]>;
 };
 /** The result of atomically claiming every currently eligible event. */
-type LogClaimAvailableResult = {
+type StoreClaimAvailableResult = {
   outcome: "claimed";
   events: StoredEvent[];
 } | {
@@ -127,12 +149,19 @@ type CompleteAttemptResult = {
 } | {
   outcome: "superseded";
 };
+/** The result of one claim-renewal heartbeat, both lists in append order. */
+type RenewClaimsResult = {
+  /** Listed claims that remain owned by the holder. */
+  renewed: number[];
+  /** Listed claims whose event a newer attempt has durably taken. */
+  superseded: number[];
+};
 /** The result of atomically recording a caught handler failure. */
 type FailAttemptResult = {
   outcome: "failed" | "dead_lettered" | "superseded";
   failureCount: number;
 };
-/** Input to `A2Log.append` — already validated by the machine. */
+/** Input to `A2Store.append` — already validated by the machine. */
 type AppendEvent = {
   type: string;
   payload: unknown;
@@ -145,12 +174,12 @@ type AppendEvent = {
   /** Internal hint: settle this event in the append transaction; no handler is registered. */
   settled?: true;
 };
-/** A handler-returned event with the deterministic id recovery requires. */
+/** A handler-returned event with the deterministic id retries require. */
 type ReturnedEvent = AppendEvent & {
   id: string;
 };
 /** The rows written by an append and the session's pending state. */
-type LogAppendResult = {
+type StoreAppendResult = {
   events: StoredEvent[];
   /** Whether the session contains an event without a completion marker. */
   hasPending: boolean;
@@ -165,7 +194,7 @@ type Clock = {
 };
 /** An injectable id source for generated event ids. */
 type IdSource = () => string;
-interface A2Log {
+interface A2Store {
   /**
    * Accepts a batch; the batch is atomic — one transaction, consecutive
    * `index`es, all-or-nothing. The idempotency key covers the whole
@@ -178,17 +207,27 @@ interface A2Log {
    * operation, with no dispatch claim or `processedByAttempt`. The result's
    * `hasPending` reflects the whole session in the same atomic operation,
    * including older events and idempotent retries.
+   *
+   * An event carrying `cause` is a handler append, fenced by attempt
+   * currency: accept it only while `cause.attempt` is still the parent
+   * event's latest attempt and the parent is not dead-lettered; otherwise
+   * throw `A2Error('SUPERSEDED_ATTEMPT')` and write nothing. The check is
+   * part of this atomic operation and must serialize against a concurrent
+   * `claimAvailable` — an unlocked read of the parent admits write skew.
+   * The idempotent-replay path runs first, so a batch whose ids all exist
+   * replays regardless of the current attempt.
    */
-  append(sessionId: string, events: AppendEvent[]): Promise<LogAppendResult>;
-  /** Events for one session, oldest first. */
+  append(sessionId: string, events: AppendEvent[]): Promise<StoreAppendResult>;
+  /** Events for one session, oldest first. Bounds form `(afterIndex, throughIndex]`. */
   read(sessionId: string, opts?: {
     afterIndex?: number;
+    throughIndex?: number;
   }): Promise<StoredEvent[]>;
   /**
    * Atomically claims every eligible pending event. Unlaned events are all
    * independently eligible. Within a lane, only the lowest-index unfinished
    * event is eligible. A live claim produces `busy` only when it is the sole
-   * remaining obstacle to actionable work. Claimed events are returned in log
+   * remaining obstacle to actionable work. Claimed events are returned in event-log
    * order. Excluded rows remain lane barriers.
    */
   claimAvailable(options: {
@@ -197,19 +236,26 @@ interface A2Log {
     ttlMs: number;
     expiresAtMs?: number;
     excludeIndexes?: readonly number[];
-  }): Promise<LogClaimAvailableResult>;
+  }): Promise<StoreClaimAvailableResult>;
   /**
-   * Renews the listed live claims still owned by `holder`. Missing, expired,
-   * completed, failed, or superseded claims are omitted from the result. The
-   * renewed indexes are returned in log order.
+   * Renews the listed live claims still owned by `holder`. Each listed claim
+   * carries the attempt ordinal the holder owns. `renewed` lists the claims
+   * that remain owned after the operation; `superseded` lists the claims
+   * whose event's `attemptCount` has durably passed the listed attempt. An
+   * expired claim no successor has taken appears in neither list — its
+   * attempt may still complete (`completeAttempt` is the fence), so it is
+   * not reported as lost. Renewal never revives an expired claim.
    */
   renewClaims(options: {
     sessionId: string;
     holder: string;
-    indexes: number[];
+    claims: readonly {
+      index: number;
+      attempt: number;
+    }[];
     ttlMs: number;
     expiresAtMs?: number;
-  }): Promise<number[]>;
+  }): Promise<RenewClaimsResult>;
   /**
    * Atomically completes one current attempt and appends its returned events.
    * Retrying a committed completion with the same attempt and deterministic
@@ -239,25 +285,55 @@ interface A2Log {
    * log. The snapshot is untrusted; core may reject it and issue a full
    * `read()` when its state schema no longer accepts the cached value.
    */
-  readState(sessionId: string, reducerName: string): Promise<LogStateRead>;
+  readState(sessionId: 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
    * (`where up_to_index < excluded.up_to_index`).
    */
   putSnapshot(sessionId: string, reducerName: string, index: number, state: unknown): Promise<void>;
+  /**
+   * Optional ephemeral-plane capability (specs/a2-implementation.md
+   * §15.1) — optional like snapshots are. Values arrive already
+   * validated by core; adapters store them opaquely. Presence never
+   * touches the event log: no index, no history row, no recovery arm.
+   */
+  presence?: {
+    /**
+     * Field-wise last-writer-wins merge of one participant's values:
+     * a field whose existing row has a strictly newer `at` (the
+     * sender's stamp) is left untouched; `null` deletes the row. Every
+     * applied write refreshes that field's expiry to the storage's own
+     * clock plus `ttlMs` — the sender stamp orders writes but never
+     * anchors their lifetime.
+     */
+    set(ns: string, participant: string, values: Record<string, unknown | null>, meta: {
+      seen: number;
+      at: Date;
+      ttlMs: number;
+    }): Promise<void>;
+    /** The current map, pruned of rows at or past their `expiresAt`. */
+    read(ns: string): Promise<PresenceRow[]>;
+    /**
+     * Push-tier patch delivery; present only on backends with a real
+     * broadcast primitive. Without it the backend is the degraded
+     * tier: live feeds surface presence by re-reading on their
+     * existing poll cadence.
+     */
+    subscribe?(ns: string, onPatch: (patch: PresencePatch) => void): () => void;
+  };
   /** Read-only operational data used by `experimental-a2/devtools/server`. */
-  inspect?: A2LogInspection;
+  inspect?: A2StoreInspection;
   /**
-   * A live feed of one session's events, starting after `startAt`
+   * A live feed of one session's events, starting after `startAfter`
    * (exclusive). Transport is the backend's choice — in-process pub/sub,
    * polling, LISTEN/NOTIFY — callers never branch on which. The iterable
    * ends when the consumer calls `return()` (e.g. a disconnecting SSE
    * client) and must deliver events appended after subscription.
    */
   stream(sessionId: string, opts?: {
-    startAt?: number;
+    startAfter?: number;
   }): AsyncIterable<Event>;
 }
 //#endregion
-export { Event as a, IdSource as c, LogStateRead as d, StoredEvent as f, StoredSnapshot as h, Clock as i, LogAppendResult as l, StoredSessionSummary as m, A2LogInspection as n, EventCause as o, StoredSessionPage as p, AppendEvent as r, FailAttemptResult as s, A2Log as t, LogClaimAvailableResult 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 };

package/dist/{log-yJbXUf72.js → store-N8PXxDAS.js}

@@ -1,4 +1,4 @@
-//#region src/log.ts
+//#region src/store.ts
 const SYSTEM_CLOCK = { now: () => /* @__PURE__ */ new Date() };
 const RANDOM_IDS = () => crypto.randomUUID();
 //#endregion

package/dist/store-codec-DTG0Ftek.js

@@ -0,0 +1,8 @@
+//#region src/store-codec.ts
+const decodeReturnedEventIds = (value) => {
+	const decoded = typeof value === "string" ? JSON.parse(value) : value;
+	if (!Array.isArray(decoded) || decoded.some((eventId) => typeof eventId !== "string")) throw new TypeError("stored event has invalid returned event ids");
+	return decoded;
+};
+//#endregion
+export { decodeReturnedEventIds as t };

package/dist/store-memory.d.ts

@@ -0,0 +1,11 @@
+import { c as IdSource, i as Clock, t as A2Store } from "./store-C3sNAaBT.js";
+//#region src/store-memory.d.ts
+type MemoryStoreOptions = {
+  /** Injectable clock — every stored timestamp comes from here. */
+  clock?: Clock;
+  /** Injectable id source for generated event ids. */
+  ids?: IdSource;
+};
+declare function memory(options?: MemoryStoreOptions): A2Store;
+//#endregion
+export { MemoryStoreOptions, memory };

package/dist/{log-memory.js → store-memory.js}

@@ -1,14 +1,8 @@
-import { t as A2Error } from "./errors-BJRMd-h6.js";
-import { t as idempotentReplay } from "./idempotent-replay-BMyHrP0L.js";
-import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./log-yJbXUf72.js";
-//#region src/log-memory.ts
-/**
-* experimental-a2/log-memory — in-memory log backend (the test default).
-*
-* Implements the A2Log interface with zero dependencies. See
-* specs/a2-implementation.md §3 for the contract; the conformance suite
-* in test/conformance is the executable version of it.
-*/
+import { t as A2Error } from "./errors-BQuJpe82.js";
+import { g as nullProtoRecord } from "./internal-aEotMzu_.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
 const toStored = (row) => ({
 	id: row.id,
 	type: row.type,
@@ -50,6 +44,9 @@ function memory(options = {}) {
 	/** Keyed by `${sessionId}\u0000${reducerName}` — a pure cache. */
 	const snapshots = /* @__PURE__ */ new Map();
 	const streamSubscribers = /* @__PURE__ */ new Map();
+	/** ns → participant → field → latest surviving write. */
+	const presenceRows = /* @__PURE__ */ new Map();
+	const presenceSubscribers = /* @__PURE__ */ new Map();
 	const notifyStreams = (sessionId, rows) => {
 		const subs = streamSubscribers.get(sessionId);
 		if (!subs) return;
@@ -173,16 +170,23 @@ function memory(options = {}) {
 				if (existing.length === events.length) return appendResult(sessionId, idempotentReplay(events, existing.map(toStored)));
 				throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`);
 			}
+			const rows = sessions.get(sessionId) ?? [];
+			for (const event of events) {
+				if (!event.cause) continue;
+				const parent = rows[event.cause.index - 1];
+				if (!parent) throw new TypeError(`no event at index ${event.cause.index} in session '${sessionId}'`);
+				if (parent.attemptCount !== event.cause.attempt || parent.failedAt !== null) throw new A2Error("SUPERSEDED_ATTEMPT", `attempt ${event.cause.attempt} no longer owns event ${event.cause.index} in session '${sessionId}'`);
+			}
 			const now = clock.now();
 			const inserted = insert(sessionId, events, now);
 			notifyStreams(sessionId, inserted);
 			return appendResult(sessionId, inserted.map(toStored));
 		},
 		async read(sessionId, opts) {
-			return (sessions.get(sessionId) ?? []).filter((row) => {
-				if (opts?.afterIndex !== void 0 && row.index <= opts.afterIndex) return false;
-				return true;
-			}).map(toStored);
+			const rows = sessions.get(sessionId) ?? [];
+			const start = Math.max(0, opts?.afterIndex ?? 0);
+			const end = Math.max(0, opts?.throughIndex ?? rows.length);
+			return rows.slice(start, end).map(toStored);
 		},
 		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes }) {
 			const claimedAt = clock.now();
@@ -209,16 +213,28 @@ function memory(options = {}) {
 				events: eligible.map((row) => claim(row, holder, claimedAt, expiresAt))
 			};
 		},
-		async renewClaims({ sessionId, holder, indexes, ttlMs, expiresAtMs }) {
+		async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {
 			const now = clock.now();
 			const expiresAt = new Date(expiresAtMs ?? now.getTime() + ttlMs);
-			const requested = new Set(indexes);
+			const requested = new Map(claims.map((c) => [c.index, c.attempt]));
 			const renewed = [];
-			for (const row of sessions.get(sessionId) ?? []) if (requested.has(row.index) && row.processedAt === null && row.failedAt === null && row.claimHolder === holder && row.claimExpiresAt !== null && row.claimExpiresAt > now) {
-				row.claimExpiresAt = new Date(expiresAt);
-				renewed.push(row.index);
+			const superseded = [];
+			for (const row of sessions.get(sessionId) ?? []) {
+				const attempt = requested.get(row.index);
+				if (attempt === void 0) continue;
+				if (row.attemptCount > attempt) {
+					superseded.push(row.index);
+					continue;
+				}
+				if (row.processedAt === null && row.failedAt === null && row.claimHolder === holder && row.claimExpiresAt !== null && row.claimExpiresAt > now) {
+					row.claimExpiresAt = new Date(expiresAt);
+					renewed.push(row.index);
+				}
 			}
-			return renewed;
+			return {
+				renewed,
+				superseded
+			};
 		},
 		async completeAttempt({ sessionId, index, attempt, events }) {
 			const parent = find(sessionId, index);
@@ -309,6 +325,85 @@ function memory(options = {}) {
 				updatedAt: clock.now()
 			});
 		},
+		presence: {
+			async set(ns, participant, values, meta) {
+				let participants = presenceRows.get(ns);
+				if (!participants) {
+					participants = /* @__PURE__ */ new Map();
+					presenceRows.set(ns, participants);
+				}
+				let fields = participants.get(participant);
+				if (!fields) {
+					fields = /* @__PURE__ */ new Map();
+					participants.set(participant, fields);
+				}
+				const expiresAtMs = clock.now().getTime() + meta.ttlMs;
+				const applied = nullProtoRecord();
+				let appliedCount = 0;
+				for (const [field, value] of Object.entries(values)) {
+					const existing = fields.get(field);
+					if (existing && existing.at > meta.at) continue;
+					if (value === null) fields.delete(field);
+					else fields.set(field, {
+						value: structuredClone(value),
+						seen: meta.seen,
+						at: new Date(meta.at),
+						expiresAt: new Date(expiresAtMs)
+					});
+					applied[field] = structuredClone(value);
+					appliedCount += 1;
+				}
+				if (fields.size === 0) participants.delete(participant);
+				if (participants.size === 0) presenceRows.delete(ns);
+				if (appliedCount === 0) return;
+				const subs = presenceSubscribers.get(ns);
+				if (!subs) return;
+				const patch = {
+					participant,
+					values: applied,
+					seen: meta.seen,
+					at: new Date(meta.at)
+				};
+				for (const listener of subs) listener(patch);
+			},
+			async read(ns) {
+				const participants = presenceRows.get(ns);
+				if (!participants) return [];
+				const now = clock.now();
+				const rows = [];
+				for (const [participant, fields] of participants) {
+					for (const [field, entry] of fields) {
+						if (entry.expiresAt <= now) {
+							fields.delete(field);
+							continue;
+						}
+						rows.push({
+							participant,
+							field,
+							value: structuredClone(entry.value),
+							seen: entry.seen,
+							at: new Date(entry.at),
+							expiresAt: new Date(entry.expiresAt)
+						});
+					}
+					if (fields.size === 0) participants.delete(participant);
+				}
+				if (participants.size === 0) presenceRows.delete(ns);
+				return rows;
+			},
+			subscribe(ns, onPatch) {
+				let subs = presenceSubscribers.get(ns);
+				if (!subs) {
+					subs = /* @__PURE__ */ new Set();
+					presenceSubscribers.set(ns, subs);
+				}
+				subs.add(onPatch);
+				return () => {
+					subs.delete(onPatch);
+					if (subs.size === 0) presenceSubscribers.delete(ns);
+				};
+			}
+		},
 		inspect: {
 			async listSessions(inspectionOptions) {
 				const ids = [...sessions.keys()].filter((sessionId) => sessionId.startsWith(inspectionOptions.prefix) && (inspectionOptions.cursor === void 0 || sessionId > inspectionOptions.cursor)).toSorted();
@@ -350,6 +445,14 @@ function memory(options = {}) {
 					cursor: ids.length > visible.length ? visible.at(-1) ?? null : null
 				};
 			},
+			async readEvents(sessionId, pageOptions) {
+				const rows = sessions.get(sessionId) ?? [];
+				const throughIndex = Math.min(pageOptions.throughIndex ?? rows.length, rows.length);
+				return {
+					events: rows.slice(pageOptions.afterIndex, throughIndex).slice(0, pageOptions.limit).map(toStored),
+					throughIndex
+				};
+			},
 			async listSnapshots(sessionId) {
 				const prefix = `${sessionId}\u0000`;
 				return [...snapshots.entries()].filter(([key]) => key.startsWith(prefix)).map(([key, snapshot]) => ({
@@ -360,9 +463,9 @@ function memory(options = {}) {
 			}
 		},
 		stream(sessionId, opts) {
-			const startAt = opts?.startAt ?? 0;
+			const startAfter = opts?.startAfter ?? 0;
 			return { [Symbol.asyncIterator]() {
-				let last = startAt;
+				let last = startAfter;
 				const buffer = [];
 				let wake = null;
 				let closed = false;
@@ -377,7 +480,7 @@ function memory(options = {}) {
 				}
 				subs.add(onRow);
 				const existing = sessions.get(sessionId) ?? [];
-				buffer.unshift(...existing.filter((row) => row.index > startAt));
+				buffer.unshift(...existing.filter((row) => row.index > startAfter));
 				const unsubscribe = () => {
 					subs.delete(onRow);
 					if (subs.size === 0) streamSubscribers.delete(sessionId);

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

@@ -1,8 +1,8 @@
-import { r as POLL_TIMINGS } from "./internal-gCd5qMry.js";
-//#region src/log-polling.ts
+import { i as POLL_TIMINGS } from "./internal-aEotMzu_.js";
+//#region src/store-polling.ts
 /**
 * The shared polling stream — how poll-based backends (sqlite,
-* postgres) implement `A2Log.stream`.
+* postgres) implement `A2Store.stream`.
 *
 * The cadence is activity-adaptive: while events are flowing, polls
 * run at a tight floor (25ms) so streams feel pushed — a token
@@ -38,10 +38,10 @@ const floor = () => Math.min(POLL_TIMINGS.activeFloorMs, POLL_TIMINGS.idleCeilin
 * SSE client), waking any pending sleep immediately.
 */
 function pollingStream(readAfter, options) {
-	const startAt = options.startAt ?? 0;
+	const startAfter = options.startAfter ?? 0;
 	const sleep = options.sleep ?? defaultSleep;
 	return { [Symbol.asyncIterator]() {
-		let last = startAt;
+		let last = startAfter;
 		let buffer = [];
 		let closed = false;
 		let pending = null;

package/dist/{log-postgres.d.ts → store-postgres.d.ts}

@@ -1,5 +1,5 @@
-import { c as IdSource, i as Clock, t as A2Log } from "./log-ldf5g8Cx.js";
-//#region src/log-postgres.d.ts
+import { c as IdSource, i as Clock, t as A2Store } from "./store-C3sNAaBT.js";
+//#region src/store-postgres.d.ts
 /** The result shape this backend reads: just rows. */
 type PostgresQueryResult = {
   rows: Record<string, unknown>[];
@@ -20,7 +20,7 @@ type PostgresClient = {
   connect?(): Promise<PostgresConnection>;
   end?(): Promise<void>;
 };
-type PostgresLogOptions = {
+type PostgresStoreOptions = {
   /** Creates a `pg` Pool lazily (requires the optional peer dep `pg`). */
   connectionString?: string | undefined;
   /** Bring your own client — a `pg` Pool, PGlite, a pooler wrapper. */
@@ -30,11 +30,11 @@ type PostgresLogOptions = {
   /** Injectable id source for generated event ids. */
   ids?: IdSource;
 };
-type PostgresLog = A2Log & {
+type PostgresStore = A2Store & {
   /** End the underlying pool/client (when this backend created it, or
    * the injected client has `end`). */
   close(): Promise<void>;
 };
-declare function postgres(options?: PostgresLogOptions): PostgresLog;
+declare function postgres(options?: PostgresStoreOptions): PostgresStore;
 //#endregion
-export { PostgresClient, PostgresConnection, PostgresLog, PostgresLogOptions, PostgresQueryResult, postgres };
+export { PostgresClient, PostgresConnection, PostgresQueryResult, PostgresStore, PostgresStoreOptions, postgres };