@vercel/board 0.16.0 → 0.18.0

package/dist/backend-a2/store-postgres.mjs

@@ -1,5 +1,2853 @@
-import { r as sqlTables } from "../sql-DbiEnqM0.mjs";
-import { postgres as postgres$1 } from "experimental-a2/store-postgres";
+import { n as CLEAR_EVENT_TYPE, o as sessionClearedError, s as supersededAttemptError, t as A2Error } from "../session-clear-wHd5GCpZ-BnKSxReK.mjs";
+import { m as nullProtoRecord, n as NOTIFY_TIMINGS } from "../internal-CvsrprnU-CRY89I-b.mjs";
+import { n as defaultSleep, r as pollingStream } from "../store-polling-BZt2Rf3D-BiEM6_HB.mjs";
+import { r as platformWaitUntil } from "../platform-B4TnJtWu-CwcTyKg2.mjs";
+import { t as retryableLazy } from "../retryable-lazy-DZWmHpii-Bye-W8q7.mjs";
+import { r as sqlTables } from "../sql-U9WTxrwJ.mjs";
+import { a as idleLogCursor, i as idempotentReplay, n as decodeCause, r as decodeReturnedEventIds, t as cursorKeyOf } from "../store-codec-DwrWlgQx-CYxGW0aD.mjs";
+import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "../store-N8PXxDAS-BWBgzBHp.mjs";
+import { t as pollPresence } from "../store-presence-polling-JuAy2Ck2-CYpuK75X.mjs";
+import { createHash } from "node:crypto";
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/store-postgres.js
+const postgresNotificationChannel = ({ kind, sessionId }) => `a2_${kind}_${createHash("md5").update(sessionId).digest("hex")}`;
+function postgresNotifications(createConnection) {
+	const channels = /* @__PURE__ */ new Map();
+	const ending = /* @__PURE__ */ new Set();
+	const end = (connection) => {
+		if (!connection) return;
+		const pending = connection.end().catch(() => {}).finally(() => {
+			ending.delete(pending);
+		});
+		ending.add(pending);
+	};
+	let current;
+	let task;
+	let retry;
+	let delay = 100;
+	let connectedAt = 0;
+	let closed = false;
+	const queues = /* @__PURE__ */ new WeakMap();
+	const query = ({ connection, text }) => {
+		const result = (queues.get(connection) ?? Promise.resolve()).then(() => {
+			if (current !== connection) throw new Error("Postgres listener disconnected");
+			return connection.query(text);
+		});
+		queues.set(connection, result.catch(() => {}));
+		return result;
+	};
+	const fail = ({ connection, error }) => {
+		if (connection !== current) return;
+		current = void 0;
+		end(connection);
+		for (const entry of channels.values()) {
+			entry.listening = false;
+			for (const watcher of entry.watchers) watcher.reject(error);
+		}
+		if (closed || channels.size === 0 || retry) return;
+		if (Date.now() - connectedAt >= NOTIFY_TIMINGS.safetyReadMs) delay = 100;
+		retry = defaultSleep(delay);
+		delay = Math.min(delay * 2, NOTIFY_TIMINGS.safetyReadMs);
+		retry.promise.then(() => {
+			retry = void 0;
+			reconcile();
+		});
+	};
+	const reconcile = () => {
+		if (closed || task || retry || channels.size === 0) return;
+		let attempt;
+		task = (async () => {
+			if (!current) {
+				connectedAt = Date.now();
+				const connection = await createConnection();
+				if (closed || channels.size === 0) {
+					await connection.end();
+					return;
+				}
+				current = connection;
+				attempt = connection;
+				connectedAt = Date.now();
+				connection.onNotification(({ channel, payload }) => {
+					if (current !== connection) return;
+					for (const watcher of channels.get(channel)?.watchers ?? []) watcher.notify(payload ?? "");
+				});
+				connection.onError((error) => fail({
+					connection,
+					error
+				}));
+				connection.onEnd(() => fail({
+					connection,
+					error: /* @__PURE__ */ new Error("Postgres listener disconnected")
+				}));
+				await connection.connect();
+				if (current !== connection) return;
+			}
+			const connection = current;
+			attempt = connection;
+			for (const [channel, entry] of channels) {
+				if (entry.listening) continue;
+				entry.listening = true;
+				entry.ready = query({
+					connection,
+					text: `LISTEN "${channel.replaceAll("\"", "\"\"")}"`
+				});
+				await entry.ready;
+				if (current !== connection) return;
+				for (const watcher of entry.watchers) {
+					watcher.resolve();
+					watcher.notify("");
+				}
+			}
+		})().catch((error) => {
+			if (attempt === current) fail({
+				connection: attempt,
+				error
+			});
+		}).finally(() => {
+			task = void 0;
+			if ([...channels.values()].some((entry) => !entry.listening)) reconcile();
+		});
+	};
+	return {
+		watch({ channel, notify }) {
+			let resolve;
+			let reject;
+			const ready = new Promise((yes, no) => {
+				resolve = yes;
+				reject = no;
+			});
+			const watcher = {
+				notify,
+				resolve,
+				reject
+			};
+			let entry = channels.get(channel);
+			if (!entry) {
+				entry = {
+					listening: false,
+					watchers: /* @__PURE__ */ new Set()
+				};
+				channels.set(channel, entry);
+			}
+			entry.watchers.add(watcher);
+			if (entry.listening) entry.ready?.then(resolve, reject);
+			reconcile();
+			let stopped = false;
+			return {
+				ready,
+				stop() {
+					if (stopped) return;
+					stopped = true;
+					resolve();
+					entry.watchers.delete(watcher);
+					if (entry.watchers.size > 0) return;
+					channels.delete(channel);
+					if (channels.size === 0) {
+						retry?.cancel();
+						const connection = current;
+						current = void 0;
+						end(connection);
+					} else if (entry.listening) {
+						const connection = current;
+						if (connection) query({
+							connection,
+							text: `UNLISTEN "${channel.replaceAll("\"", "\"\"")}"`
+						}).catch((error) => fail({
+							connection,
+							error
+						}));
+					}
+				}
+			};
+		},
+		async close() {
+			closed = true;
+			retry?.cancel();
+			for (const entry of channels.values()) for (const watcher of entry.watchers) watcher.resolve();
+			channels.clear();
+			const connection = current;
+			current = void 0;
+			end(connection);
+			await Promise.all(ending);
+		}
+	};
+}
+/**
+* The Postgres schema contract. A2 never runs DDL in a Postgres database:
+* `sql/postgres/schema.sql`, or the tables in `drizzle-schema.ts` next to it,
+* create
+* the tables, and `notifications.sql` the triggers `listenConnectionString`
+* needs. A store checks nothing up front. A query that finds a table or column
+* missing fails anyway, so the store only turns that failure into one that
+* says what to apply. Missing triggers fail no query, so a listening store
+* looks for them when its listener starts.
+*/
+const PACKAGE = "node_modules/experimental-a2";
+const SEE_DOCS = `See ${PACKAGE}/docs/stores/04-postgres.mdx.`;
+/** Postgres error codes a store that hasn't been set up raises. */
+const UNDEFINED_TABLE = "42P01";
+const UNDEFINED_COLUMN = "42703";
+const UNDEFINED_FUNCTION = "42883";
+/** `a2_batch` refuses to run outside read committed. */
+const BATCH_ISOLATION = "A2002";
+const INSUFFICIENT_PRIVILEGE = "42501";
+/** NUL, which Postgres can't store: in jsonb (`\u0000`), or in text. */
+const UNTRANSLATABLE_CHARACTER = "22P05";
+const CHARACTER_NOT_IN_REPERTOIRE = "22021";
+/** The Postgres error in `error`'s cause chain, for clients that wrap theirs. */
+const postgresError = (error) => {
+	for (let current = error, depth = 0; depth < 5; depth += 1) {
+		if (typeof current !== "object" || current === null) return void 0;
+		const { code, message, cause } = current;
+		if (typeof code === "string" && /^[0-9A-Z]{5}$/.test(code)) return {
+			code,
+			message: typeof message === "string" ? message : code
+		};
+		current = cause;
+	}
+};
+/** Explains a query that failed because A2's tables aren't set up, or on a NUL, or returns `error`. */
+const explainPostgresError = (error) => {
+	const found = postgresError(error);
+	if (found?.code === UNDEFINED_TABLE || found?.code === UNDEFINED_COLUMN || found?.code === UNDEFINED_FUNCTION) return new A2Error("STORE_NOT_CONFIGURED", `${found.message}: A2's tables or its function are missing, or from an earlier release, and A2 doesn't create or change them at runtime. Apply ${PACKAGE}/sql/postgres/schema.sql to this database, or migrate it to the tables in drizzle-schema.ts next to it, with schema.sql's a2_batch function. ${SEE_DOCS}`, { cause: error });
+	if (found?.code === INSUFFICIENT_PRIVILEGE) return new A2Error("STORE_NOT_CONFIGURED", `${found.message}: the role this store connects as needs select, insert, update, and delete on A2's tables, and execute on a2_batch. Create them as that role, or grant it those privileges. ${SEE_DOCS}`, { cause: error });
+	if (found?.code === UNTRANSLATABLE_CHARACTER || found?.code === CHARACTER_NOT_IN_REPERTOIRE) return new A2Error("INVALID_PAYLOAD", `${found.message}: Postgres can't store a NUL character (\\u0000) in text or jsonb, so nothing was written. Remove it before appending.`, { cause: error });
+	if (found?.code === BATCH_ISOLATION) return new A2Error("STORE_NOT_CONFIGURED", `${found.message}: A2 reads what it locks in read committed, Postgres's default, and its connections here default to a stricter level. Set default_transaction_isolation to 'read committed' for the role or database this store connects to. ${SEE_DOCS}`, { cause: error });
+	return error;
+};
+const explained = (promise) => promise.catch((error) => {
+	throw explainPostgresError(error);
+});
+/** `client`, with every query's setup failures explained. */
+const explainingPostgresClient = (client) => ({
+	query: (text, values) => explained(client.query(text, values)),
+	...client.connect && { connect: async () => {
+		const connection = await client.connect();
+		return {
+			query: (text, values) => explained(connection.query(text, values)),
+			release: () => connection.release()
+		};
+	} },
+	...client.end && { end: () => client.end() }
+});
+/** Fails when the triggers `listenConnectionString` listens to are missing. */
+const checkPostgresTriggers = async (client) => {
+	const { rows } = await client.query(`select count(*) as triggers from pg_trigger
+   where (tgname = 'a2_notify_events' and tgrelid = to_regclass('a2_events'))
+      or (tgname = 'a2_notify_presence' and tgrelid = to_regclass('a2_presence'))`);
+	if (Number(rows[0]?.["triggers"]) < 2) throw new A2Error("STORE_NOT_CONFIGURED", `listenConnectionString needs A2's notification triggers, which aren't in this Postgres database. After schema.sql, apply ${PACKAGE}/sql/postgres/notifications.sql to this database. ${SEE_DOCS}`);
+};
+const failure = (error) => error instanceof A2Error ? error : new A2Error("STORE_UNAVAILABLE", "Postgres subscription failed", { cause: error });
+function postgresNotificationScope(load) {
+	const state = {
+		shared: retryableLazy(load),
+		stops: /* @__PURE__ */ new Set(),
+		closed: false
+	};
+	const scope = {
+		watch(options) {
+			let stopped = false;
+			let cancel;
+			const cancelled = new Promise((resolve) => {
+				cancel = resolve;
+			});
+			let subscription;
+			const stop = () => {
+				stopped = true;
+				cancel();
+				subscription?.stop();
+				state.stops.delete(stop);
+			};
+			state.stops.add(stop);
+			return {
+				ready: Promise.race([cancelled, state.shared.get().then(async ({ value }) => {
+					if (stopped || state.closed) return;
+					subscription = value.watch(options);
+					await subscription.ready;
+				})]).catch((error) => {
+					if (!stopped && !state.closed) throw failure(error);
+				}),
+				stop
+			};
+		},
+		stream({ channel, read, startAfter }) {
+			return { [Symbol.asyncIterator]() {
+				let stopped = false;
+				let after = startAfter;
+				let buffer = [];
+				let position = 0;
+				let version = 0;
+				let waiting;
+				let lease;
+				const stop = () => {
+					stopped = true;
+					buffer = [];
+					position = 0;
+					waiting?.cancel();
+					lease?.stop();
+					state.stops.delete(stop);
+				};
+				state.stops.add(stop);
+				return {
+					async next() {
+						try {
+							if (stopped || state.closed) return {
+								done: true,
+								value: void 0
+							};
+							lease ??= scope.watch({
+								channel,
+								notify: () => {
+									version += 1;
+									waiting?.cancel();
+								}
+							});
+							await lease.ready;
+							for (;;) {
+								if (stopped || state.closed) return {
+									done: true,
+									value: void 0
+								};
+								const row = buffer[position];
+								if (row) {
+									after = row.index;
+									buffer[position] = void 0;
+									position += 1;
+									if (position === buffer.length) {
+										buffer = [];
+										position = 0;
+									}
+									return {
+										done: false,
+										value: row
+									};
+								}
+								const before = version;
+								const rows = await read(after);
+								if (stopped || state.closed) return {
+									done: true,
+									value: void 0
+								};
+								buffer = rows;
+								position = 0;
+								if (buffer.length || before !== version) continue;
+								waiting = defaultSleep(NOTIFY_TIMINGS.safetyReadMs);
+								await waiting.promise;
+							}
+						} catch (error) {
+							if (stopped || state.closed) return {
+								done: true,
+								value: void 0
+							};
+							stop();
+							throw failure(error);
+						}
+					},
+					async return() {
+						stop();
+						return {
+							done: true,
+							value: void 0
+						};
+					}
+				};
+			} };
+		},
+		async close() {
+			if (state.closed) return;
+			state.closed = true;
+			for (const stop of state.stops) stop();
+			await (await state.shared.peek()?.catch(() => void 0))?.release();
+		}
+	};
+	return scope;
+}
+function postgresPoolClient(pool) {
+	let timer;
+	let resolve;
+	const finish = () => {
+		clearTimeout(timer);
+		timer = void 0;
+		resolve?.();
+		resolve = void 0;
+	};
+	const keepAlive = () => {
+		const idleTimeout = pool.options.idleTimeoutMillis;
+		if (pool.ending || pool.idleCount === 0 || typeof idleTimeout !== "number" || !Number.isFinite(idleTimeout) || idleTimeout <= 0) return;
+		finish();
+		const pending = new Promise((done) => {
+			resolve = done;
+			timer = setTimeout(finish, idleTimeout + 100);
+			timer.unref();
+		});
+		platformWaitUntil(pending);
+	};
+	pool.on("remove", () => {
+		if (pool.totalCount === 0) finish();
+	});
+	return {
+		async query(text, values) {
+			try {
+				return await pool.query(text, values);
+			} finally {
+				keepAlive();
+			}
+		},
+		async connect() {
+			const client = await pool.connect();
+			return {
+				query: (text, values) => client.query(text, values),
+				release() {
+					try {
+						client.release();
+					} finally {
+						keepAlive();
+					}
+				}
+			};
+		},
+		async end() {
+			try {
+				await pool.end();
+			} finally {
+				finish();
+			}
+		}
+	};
+}
+const registryKey = Symbol.for("experimental-a2.postgres-resources.v3");
+const registry = () => {
+	let value = Reflect.get(globalThis, registryKey);
+	if (!value) {
+		value = {
+			pools: /* @__PURE__ */ new Map(),
+			injected: /* @__PURE__ */ new WeakMap(),
+			listeners: /* @__PURE__ */ new Map(),
+			identities: /* @__PURE__ */ new WeakMap(),
+			nextIdentity: 0
+		};
+		Reflect.set(globalThis, registryKey, value);
+	}
+	return value;
+};
+const acquire = ({ cache, key, create }) => {
+	let entry = cache.get(key);
+	if (!entry) {
+		entry = {
+			value: create(),
+			refs: 0
+		};
+		cache.set(key, entry);
+	}
+	entry.refs += 1;
+	const held = entry;
+	let released = false;
+	return {
+		value: entry.value,
+		async release() {
+			if (released) return;
+			released = true;
+			held.refs -= 1;
+			if (held.refs !== 0) return;
+			if (cache.get(key) === held) cache.delete(key);
+			await held.value.close();
+		}
+	};
+};
+function postgresConnectionKey({ connectionString, defaults }) {
+	const shared = registry();
+	const visited = /* @__PURE__ */ new Set();
+	const identity = (value) => {
+		let id = shared.identities.get(value);
+		if (id === void 0) {
+			id = ++shared.nextIdentity;
+			shared.identities.set(value, id);
+		}
+		return id;
+	};
+	const encode = (value) => {
+		if (typeof value === "function") return ["reference", identity(value)];
+		if (value === null || typeof value !== "object") return [typeof value, String(value)];
+		if (Buffer.isBuffer(value)) return ["buffer", value.toString("base64")];
+		const prototype = Object.getPrototypeOf(value);
+		if (visited.has(value) || prototype !== Object.prototype && prototype !== null && !Array.isArray(value)) return ["reference", identity(value)];
+		visited.add(value);
+		const result = [Array.isArray(value) ? "array" : "object", Object.getOwnPropertyNames(value).toSorted().map((key) => [key, encode(Reflect.get(value, key))])];
+		visited.delete(value);
+		return result;
+	};
+	const environment = Object.keys(process.env).filter((key) => key.startsWith("PG")).toSorted().map((key) => [key, process.env[key]]);
+	return createHash("sha256").update(JSON.stringify([
+		connectionString,
+		environment,
+		encode(defaults)
+	])).digest("hex");
+}
+const queries = (raw) => {
+	let pending = Promise.resolve();
+	const initialized = /* @__PURE__ */ new Map();
+	const exclusive = (fn) => {
+		const result = pending.then(fn);
+		pending = result.catch(() => {});
+		return result;
+	};
+	return {
+		raw,
+		client: raw.connect ? raw : { query: (text, values) => exclusive(() => raw.query(text, values)) },
+		exclusive,
+		initialize({ key, run }) {
+			const existing = initialized.get(key);
+			if (existing) return existing;
+			const attempt = run();
+			initialized.set(key, attempt);
+			attempt.catch(() => {
+				if (initialized.get(key) === attempt) initialized.delete(key);
+			});
+			return attempt;
+		},
+		async close() {
+			await pending;
+			await raw.end?.();
+		}
+	};
+};
+const sharePostgresPool = ({ key, create }) => acquire({
+	cache: registry().pools,
+	key,
+	create: () => queries(create())
+});
+const sharePostgresClient = (client) => acquire({
+	cache: registry().injected,
+	key: client,
+	create: () => queries(client)
+});
+const sharePostgresListener = ({ key, create }) => acquire({
+	cache: registry().listeners,
+	key,
+	create
+});
+/**
+* experimental-a2/store-postgres — postgres store backend (the production path).
+*
+* Implements the A2Store interface over any client that speaks the tiny
+* `PostgresClient` shape below — a `pg` Pool matches it structurally
+* (and is what `connectionString` creates, lazily; `pg` is an optional
+* peer dependency). The conformance suite in test/conformance is the
+* executable contract, run against PGlite (real Postgres, in-process)
+* and against a real server when `TEST_DATABASE_URL` is set.
+*
+* Semantics mirror the sqlite backend: `index` is stored as `idx`,
+* timestamps are epoch milliseconds written from the injected clock —
+* never SQL `now()`, and dispatch state lives on consumer cursors, not on
+* events. Streams poll by default; an optional direct connection enables
+* LISTEN/NOTIFY for events and presence. Appends serialize per session via
+* `pg_advisory_xact_lock`, so concurrent writers can't race the index
+* assignment, and each runs in one round trip (`a2_batch`, below), so the
+* lock is held only while the server runs it.
+*
+* Lock discipline. Completions lock their cursor first, then the session lock
+* when they append, or when their cursor goes idle (`completeAttempt`);
+* everything else that takes the session lock takes it first. Every
+* operation that locks a cursor row locks it only in the exact state it acts
+* on (a head, an attempt). Under the session lock, an append never writes a
+* cursor row that exists: a lane or log cursor's runs are rows keyed by the
+* head each run started at (its epoch), so starting an idle cursor inserts a
+* new run and retires the idle row with `skip locked`. An append therefore
+* never waits on a cursor row, in particular not on one a completion waiting
+* for the session lock holds, or one a clear left behind.
+*/
+const asNumber = (value) => Number(value);
+const asNullableNumber = (value) => value === null || value === void 0 ? null : asNumber(value);
+/**
+* The session's latest clear marker, or 0, as a primary-key subquery. Read
+* it in a statement that runs after the operation's lock: a statement's
+* snapshot starts with the statement, so one that waited for the lock could
+* miss a clear that committed meanwhile.
+*/
+const clearIndexOf = (session) => `coalesce((select clear_index from a2_clears where session_id = ${session}), 0)`;
+/**
+* Whether a served consumer has a cursor with a head in the session. A null
+* `served` array serves every consumer.
+*/
+const pendingIn = (session, served) => `exists(
+     select 1 from a2_cursors pending
+      where pending.session_id = ${session}
+        and pending.head > ${clearIndexOf(session)}
+        and pending.failed_at is null
+        and (${served}::text[] is null or pending.consumer = any(${served}::text[]))
+   )`;
+/** A fresh head's dispatch columns, for `set` clauses. */
+const FRESH_DISPATCH = `
+  attempt_count = 0, first_claimed_at = null, last_claimed_at = null,
+  claim_holder = null, claim_expires_at = null, failure_count = 0,
+  last_failed_at = null, last_failed_attempt = null, last_error = null,
+  failed_at = null`;
+/** The head event's columns a claim, dead letter, or listing joins in, prefixed `e_`. */
+const HEAD_COLUMNS = `
+  event.idx as e_idx, event.event_type as e_event_type,
+  event.payload as e_payload, event.event_id as e_event_id,
+  event.created_at as e_created_at, event.cause as e_cause`;
+const RECLAIM_BATCH = 256;
+/**
+* A cursor run reclaim deletes once the session is cleared through `$2`:
+* one from before the clear, or one a later run of its cursor replaced. A
+* log cursor's last run stays: it records that the consumer counts from the
+* marker.
+*/
+const SUPERSEDED_CURSOR = `
+  cur.session_id = $1 and (
+    (cur.epoch < $2 and cur.kind <> 'log')
+    or ((cur.head is null or cur.head <= $2) and exists (
+      select 1 from a2_cursors later
+       where later.session_id = cur.session_id
+         and later.cursor_key = cur.cursor_key
+         and later.consumer = cur.consumer
+         and later.epoch > cur.epoch
+    ))
+  )`;
+/**
+* A value of `a2_batch`'s one parameter, `$1`: a JSON object the store builds
+* for each call. JSON null reads as SQL null.
+*/
+const param = {
+	text: (key) => `($1->>'${key}')`,
+	bigint: (key) => `($1->>'${key}')::bigint`,
+	int: (key) => `($1->>'${key}')::int`,
+	boolean: (key) => `($1->>'${key}')::boolean`,
+	jsonb: (key) => `nullif($1->'${key}', 'null'::jsonb)`,
+	/** A JSON array of strings as text[], or null when the value isn't an array. */
+	texts: (key) => `(case when jsonb_typeof($1->'${key}') = 'array'
+       then array(select jsonb_array_elements_text($1->'${key}')) end)`
+};
+/** Every batch names its session. */
+const SESSION = param.text("session");
+/**
+* The next event after `after` a log cursor takes, as a scalar subquery:
+* `types` is its JSON array, or null for every type but the clear marker
+* (`clearType`). Each listed type is one probe of `a2_events_types`, so a
+* consumer of rare types never scans the events it skips.
+*/
+const nextLogHead = ({ types, after, clearType = param.text("clearType") }) => `
+  case when ${types} is null then (
+    select event.idx from a2_events event
+     where event.session_id = ${SESSION} and event.idx > ${after}
+       and event.event_type <> ${clearType}
+     order by event.idx limit 1
+  ) else (
+    select min(next.idx)
+      from jsonb_array_elements_text(${types}) as wanted(event_type)
+      cross join lateral (
+        select event.idx from a2_events event
+         where event.session_id = ${SESSION} and event.event_type = wanted.event_type
+           and event.idx > ${after}
+         order by event.idx limit 1
+      ) next
+     where wanted.event_type <> ${clearType}
+  ) end`;
+/** The latest run of `target`'s cursor, as a lateral subquery. */
+const LATEST_RUN = (target) => `
+  select cur.epoch, cur.position, cur.head from a2_cursors cur
+   where cur.session_id = ${SESSION} and cur.cursor_key = ${target}.cursor_key
+     and cur.consumer = ${target}.consumer
+   order by cur.epoch desc limit 1`;
+/**
+* Retires the runs `target` replaces, those idle or superseded by the clear
+* marker `clearIndex`, skipping any another operation holds: a later reclaim
+* deletes those.
+*/
+const RETIRE_RUNS = (target, clearIndex) => `
+  idle as materialized (
+    select cur.ctid from a2_cursors cur
+      join ${target} on cur.cursor_key = ${target}.cursor_key
+       and cur.consumer = ${target}.consumer
+     where cur.session_id = ${SESSION}
+       and (cur.head is null or cur.head <= ${clearIndex})
+     for update of cur skip locked
+  ), retired as (
+    delete from a2_cursors old using idle where old.ctid = idle.ctid
+  )`;
+const toDate = (ms) => ms === null || ms === void 0 ? null : new Date(asNumber(ms));
+const toEvent = (row) => ({
+	id: row["event_id"],
+	type: row["event_type"],
+	payload: row["payload"],
+	index: asNumber(row["idx"]),
+	sessionId: row["session_id"],
+	createdAt: new Date(asNumber(row["created_at"]))
+});
+const toStored = (row) => ({
+	...toEvent(row),
+	cause: decodeCause(row["cause"])
+});
+const toDispatch = (row) => ({
+	consumer: row["consumer"],
+	lane: row["lane"] ?? null,
+	firstClaimedAt: toDate(row["first_claimed_at"]),
+	lastClaimedAt: toDate(row["last_claimed_at"]),
+	attemptCount: asNumber(row["attempt_count"]),
+	claimHolder: row["claim_holder"] ?? null,
+	claimExpiresAt: toDate(row["claim_expires_at"]),
+	failureCount: asNumber(row["failure_count"]),
+	lastFailedAt: toDate(row["last_failed_at"]),
+	lastFailedAttempt: asNullableNumber(row["last_failed_attempt"]),
+	lastError: row["last_error"] ?? null,
+	failedAt: toDate(row["failed_at"])
+});
+const freshDispatch = (consumer, lane) => ({
+	consumer,
+	lane,
+	firstClaimedAt: null,
+	lastClaimedAt: null,
+	attemptCount: 0,
+	claimHolder: null,
+	claimExpiresAt: null,
+	failureCount: 0,
+	lastFailedAt: null,
+	lastFailedAttempt: null,
+	lastError: null,
+	failedAt: null
+});
+/** A cursor row joined with its head event's `e_` columns. */
+const toHead = (row) => ({
+	...toStored({
+		session_id: row["session_id"],
+		idx: row["e_idx"],
+		event_type: row["e_event_type"],
+		payload: row["e_payload"],
+		event_id: row["e_event_id"],
+		created_at: row["e_created_at"],
+		cause: row["e_cause"]
+	}),
+	...toDispatch(row)
+});
+/** A cursor run as `cursors()` reports it, given the session's clear marker. */
+const toCursor = (row, clearIndex) => {
+	const position = asNumber(row["position"]);
+	if (row["kind"] !== "log" || asNumber(row["epoch"]) > clearIndex) return Object.assign(toDispatch(row), {
+		position,
+		head: asNullableNumber(row["head"])
+	});
+	return Object.assign(freshDispatch(row["consumer"], row["lane"]), {
+		position: Math.max(position, clearIndex),
+		head: null
+	});
+};
+const compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const byHead = (a, b) => a.index - b.index || compareText(a.consumer, b.consumer);
+/** Consumer, then lane, with concurrent cursors last by head. */
+const byCursor = (a, b) => compareText(a.consumer, b.consumer) || (a.lane === null ? b.lane === null ? (a.head ?? 0) - (b.head ?? 0) : 1 : b.lane === null ? -1 : compareText(a.lane, b.lane));
+const servedNames = (consumers) => consumers === void 0 ? null : consumers.map((consumer) => consumer.name);
+const wrap = async (fn) => {
+	try {
+		return await fn();
+	} catch (err) {
+		if (err instanceof A2Error || err instanceof TypeError) throw err;
+		throw new A2Error("STORE_UNAVAILABLE", "postgres store operation failed", { cause: err });
+	}
+};
+const jsonb = (value) => JSON.stringify(value) ?? "null";
+const loadPg = async () => import("pg").catch(() => {
+	throw new A2Error("STORE_NOT_CONFIGURED", "Postgres connections created by A2 require the optional 'pg' package");
+});
+const createListener = ({ pg, connectionString }) => postgresNotifications(async () => {
+	const listener = new pg.default.Client({
+		connectionString,
+		application_name: "a2-listener",
+		connectionTimeoutMillis: 1e4
+	});
+	return {
+		connect: () => listener.connect(),
+		query: (text) => listener.query(text),
+		end: () => listener.end(),
+		onNotification: (callback) => {
+			listener.on("notification", callback);
+		},
+		onError: (callback) => {
+			listener.on("error", callback);
+		},
+		onEnd: (callback) => {
+			listener.on("end", callback);
+		}
+	};
+});
+/** A finished or dead head's snapshot pins, and history no pin keeps. */
+const releasePins = async ({ query, sessionId, consumer, cursorKey, index }) => {
+	await query(`delete from a2_snapshot_pins
+      where session_id = $1 and event_index = $2
+        and consumer = $3 and cursor_key = $4`, [
+		sessionId,
+		index,
+		consumer,
+		cursorKey
+	]);
+	await query(`delete from a2_snapshot_history history
+      where history.session_id = $1
+        and not exists (
+          select 1 from a2_snapshot_pins pin
+           where pin.session_id = history.session_id
+             and pin.reducer_name = history.reducer_name
+             and pin.up_to_index = history.up_to_index
+        )`, [sessionId]);
+};
+const lockSession = (query, sessionId) => query("select pg_advisory_xact_lock(hashtext($1))", [sessionId]);
+/** Whether the session has an event at `index`. */
+const hasEvent = async (query, sessionId, index) => (await query("select 1 from a2_events where session_id = $1 and idx = $2", [sessionId, index])).rows.length > 0;
+/**
+* The attempt-currency fence shared by consumer appends and clears, under
+* the session lock. The cursor is read locked (`for share` by an append,
+* `for update` by a clear, which then releases the head): it serializes
+* with every writer of the cursor (claims, completions, failures), so a
+* stale read cannot pass the fence against a takeover committing beside
+* it. The lock is only taken while the head and attempt still match.
+*/
+const assertCurrentCause = async ({ query, sessionId, cause, clearIndex, lock }) => {
+	if (cause.index <= clearIndex) throw supersededAttemptError(sessionId, cause);
+	const { rows } = await query(`select 1 from a2_cursors
+      where session_id = $1 and cursor_key = $2 and consumer = $3
+        and head = $4 and attempt_count = $5 and failed_at is null
+      for ${lock}`, [
+		sessionId,
+		cursorKeyOf(cause.lane, cause.index),
+		cause.consumer,
+		cause.index,
+		cause.attempt
+	]);
+	if (rows.length === 0) throw supersededAttemptError(sessionId, cause);
+};
+const BATCH = "select r from a2_batch($1::text[], $2::jsonb) as r";
+/**
+* Each statement as a batch sends it, whitespace collapsed: a batch sends all
+* its statements on every call. They hold no comments or spaced literals, and
+* they're this module's constants, so the cache stays this size.
+*/
+const compacted = /* @__PURE__ */ new Map();
+const compact = (statement) => {
+	let sent = compacted.get(statement);
+	if (sent === void 0) {
+		if (statement.includes("--")) throw new TypeError("a batch statement holds a comment");
+		sent = statement.replace(/\s+/g, " ").trim();
+		compacted.set(statement, sent);
+	}
+	return sent;
+};
+/** The SQLSTATE `a2_batch` raises an `abort` row with, as its detail. */
+const BATCH_ABORTED = "A2001";
+/** The row an aborted `a2_batch` call raised, from `error` or its cause chain. */
+const abortedBatch = (error) => {
+	for (let current = error, depth = 0; depth < 5; depth += 1) {
+		if (typeof current !== "object" || current === null) return void 0;
+		const { code, detail, cause } = current;
+		if (code === BATCH_ABORTED && typeof detail === "string") return JSON.parse(detail);
+		current = cause;
+	}
+};
+const LOCK_SESSION = `
+  select jsonb_build_object('locked', true)
+    from pg_advisory_xact_lock(hashtext(${SESSION}))`;
+const INDEX = param.bigint("index");
+const CONSUMER = param.text("consumer");
+/**
+* The index before the events this call inserted, the last `count` of the
+* session's: read under the session lock, after the insert.
+*/
+const INSERTED_AFTER = `(
+  select coalesce(max(idx), 0) - ${param.bigint("count")}
+    from a2_events where session_id = ${SESSION})`;
+/**
+* An append's checks, under the session lock: the session's head and pending
+* state, and what its supplied `ids` say. Ids are unique per session. When
+* every event's id belongs to this session already, the batch is a retry: it
+* stops with the committed rows. Some owned aborts, as does scheduled work
+* from at or below the clear marker (`origin`). Rows below the marker own no
+* id.
+*/
+const APPEND_CHECKS = `
+  with boundary as materialized (
+    select coalesce(max(idx), 0) as base,
+           ${clearIndexOf(SESSION)} as clear_index,
+           ${pendingIn(SESSION, param.texts("served"))} as has_pending
+      from a2_events where session_id = ${SESSION}
+  ), owned as materialized (
+    select event.session_id, event.idx, event.event_type, event.payload,
+           event.event_id, event.created_at, event.cause
+      from a2_events event, boundary
+     where event.session_id = ${SESSION}
+       and event.event_id = any(${param.texts("ids")})
+       and event.idx >= boundary.clear_index
+  )
+  select case
+    when (select count(*) from owned) = ${param.bigint("count")} then
+      jsonb_build_object('stop', 'replay',
+        'has_pending', boundary.has_pending,
+        'events', (select jsonb_agg(to_jsonb(owned) order by owned.idx)
+                     from owned))
+    when exists (select 1 from owned) then
+      jsonb_build_object('abort', 'mixed', 'owned',
+        (select count(*) from owned))
+    when ${param.bigint("origin")} <= boundary.clear_index then
+      jsonb_build_object('abort', 'cleared')
+    else jsonb_build_object('base', boundary.base,
+                            'has_pending', boundary.has_pending)
+  end
+  from boundary`;
+/**
+* The attempt-currency fence of a consumer append, under the session lock.
+* Each cause's cursor is read `for share`: that serializes with every writer
+* of the cursor (claims, completions, failures), so a stale read cannot pass
+* the fence against a takeover committing beside it. A row is locked only
+* while its head and attempt still match. The first cause that fails aborts.
+*/
+const FENCE = `
+  with cause as (
+    select * from jsonb_to_recordset($1->'causes')
+      as cause(ord int, consumer text, cursor_key text, idx bigint, attempt int)
+  ), held as materialized (
+    select cause.ord from cause
+      join a2_cursors cur
+        on cur.session_id = ${SESSION} and cur.cursor_key = cause.cursor_key
+       and cur.consumer = cause.consumer and cur.head = cause.idx
+       and cur.attempt_count = cause.attempt and cur.failed_at is null
+     where cause.idx > ${clearIndexOf(SESSION)}
+     for share of cur
+  )
+  select jsonb_build_object('abort', 'superseded', 'ord', cause.ord)
+    from cause where cause.ord not in (select ord from held)
+   order by cause.ord limit 1`;
+/**
+* Frees the `ids` this session's rows below its clear marker hold, so the
+* batch can take them. It never waits on a row: a reclaim deleting one may
+* hold it, and one it skips aborts.
+*/
+const REUSE_IDS = `
+  with stale as materialized (
+    select event.idx from a2_events event
+     where event.session_id = ${SESSION}
+       and event.event_id = any(${param.texts("ids")})
+       and event.idx < ${clearIndexOf(SESSION)}
+     order by event.idx
+     for update skip locked
+  ), deleted as (
+    delete from a2_events event using stale
+     where event.session_id = ${SESSION} and event.idx = stale.idx
+    returning event.idx
+  )
+  select jsonb_build_object('abort', 'held')
+   where (select count(*) from deleted) < (
+     select count(*) from a2_events event
+      where event.session_id = ${SESSION}
+        and event.event_id = any(${param.texts("ids")})
+        and event.idx < ${clearIndexOf(SESSION)})`;
+/** Inserts `events` after the session's head, under the session lock. */
+const INSERT_EVENTS = `
+  with inserted as (
+    insert into a2_events
+      (session_id, idx, event_type, payload, event_id, created_at, cause)
+    select ${SESSION}, base.base + event.ord, event.type,
+           coalesce(event.payload, 'null'::jsonb), event.id,
+           ${param.bigint("now")}, event.cause
+      from (select coalesce(max(idx), 0) as base from a2_events
+             where session_id = ${SESSION}) base,
+           jsonb_to_recordset($1->'events')
+             as event(ord bigint, type text, payload jsonb, id text, cause jsonb)
+    returning 1
+  )
+  select jsonb_build_object('inserted', count(*)) from inserted`;
+/** A cursor for each concurrent target: the event alone. */
+const START_EVENTS = `
+  with started as (
+    insert into a2_cursors
+      (session_id, consumer, cursor_key, epoch, lane, kind, position, head)
+    select ${SESSION}, target.consumer, '#' || target.idx, target.idx, null,
+           'event', target.idx - 1, target.idx
+      from (
+        select single.consumer, ${INSERTED_AFTER} + single.ord as idx
+          from jsonb_to_recordset($1->'singles')
+            as single(consumer text, ord bigint)
+      ) target
+    on conflict do nothing
+    returning 1
+  )
+  select jsonb_build_object('started', count(*)) from started`;
+/** Queues each lane target's event in its lane. */
+const QUEUE_LANES = `
+  with queued as (
+    insert into a2_lane_events (session_id, consumer, lane, idx)
+    select ${SESSION}, queued.consumer, queued.lane,
+           ${INSERTED_AFTER} + queued.ord
+      from jsonb_to_recordset($1->'queued')
+        as queued(consumer text, lane text, ord bigint)
+    on conflict do nothing
+    returning 1
+  )
+  select jsonb_build_object('queued', count(*)) from queued`;
+/**
+* Starts a run for each lane cursor the batch queues work for that has none
+* running: one that is idle, superseded by the clear marker, or new. It starts
+* at the lane's first event in the batch and counts from the marker.
+*/
+const START_LANES = `
+  with boundary as materialized (
+    select ${INSERTED_AFTER} as base, ${clearIndexOf(SESSION)} as clear_index
+  ), target as (
+    select first.consumer, first.cursor_key, first.lane,
+           boundary.base + first.ord as idx
+      from boundary, jsonb_to_recordset($1->'lanes')
+        as first(consumer text, cursor_key text, lane text, ord bigint)
+  ), started as materialized (
+    select target.*, latest.position
+      from target
+      left join lateral (${LATEST_RUN("target")}) latest on true
+     where latest.head is null
+        or latest.head <= (select clear_index from boundary)
+  ), ${RETIRE_RUNS("started", "(select clear_index from boundary)")},
+  inserted as (
+    insert into a2_cursors
+      (session_id, consumer, cursor_key, epoch, lane, kind, position, head)
+    select ${SESSION}, started.consumer, started.cursor_key, started.idx,
+           started.lane, 'lane',
+           greatest(coalesce(started.position, 0),
+                    (select clear_index from boundary)),
+           started.idx
+      from started
+    on conflict do nothing
+    returning 1
+  )
+  select jsonb_build_object('lanes', count(*)) from inserted`;
+/**
+* Starts a run for each served log cursor the batch carries types for that
+* has none running. A missing cursor starts at the batch's first event of its
+* types, or at the beginning of the log with backfill. One that exists starts
+* at the next event it takes after its position: a deployment that does not
+* serve the consumer may have appended some while it was idle. A cursor from
+* before the clear marker counts from it.
+*/
+const WAKE_LOGS = `
+  with boundary as materialized (
+    select ${INSERTED_AFTER} as base, ${clearIndexOf(SESSION)} as clear_index
+  ), target as (
+    select log.consumer, log.cursor_key, log.lane,
+           boundary.base + log.ord as first, log.types, log.backfill
+      from boundary, jsonb_to_recordset($1->'logs')
+        as log(consumer text, cursor_key text, lane text, ord bigint,
+               types jsonb, backfill boolean)
+  ), woken as materialized (
+    select target.*,
+           case when latest.epoch is not null
+                  then greatest(latest.position,
+                                (select clear_index from boundary))
+                when target.backfill then (select clear_index from boundary)
+                else (select base from boundary) end as position,
+           latest.epoch is not null or target.backfill as resumes
+      from target
+      left join lateral (${LATEST_RUN("target")}) latest on true
+     where latest.head is null
+        or latest.head <= (select clear_index from boundary)
+  ), ${RETIRE_RUNS("woken", "(select clear_index from boundary)")}, run as (
+    select woken.*,
+           case when woken.resumes then coalesce(${nextLogHead({
+	types: "woken.types",
+	after: "woken.position"
+})}, woken.first) else woken.first end as head
+      from woken
+  ), inserted as (
+    insert into a2_cursors
+      (session_id, consumer, cursor_key, epoch, lane, kind, position, head,
+       types)
+    select ${SESSION}, run.consumer, run.cursor_key, run.head, run.lane, 'log',
+           run.position, run.head, run.types
+      from run
+    on conflict do nothing
+    returning 1
+  )
+  select jsonb_build_object('logs', count(*)) from inserted`;
+/**
+* The heads a claim may take, up to `through` when there is one, as
+* `from ... where` for `cur`. `for update` makes a claim racing another wait
+* and then re-check the row it waited for.
+*/
+const ELIGIBLE = `
+  from a2_cursors cur
+ where cur.session_id = ${SESSION}
+   and cur.head > ${clearIndexOf(SESSION)}
+   and (${param.bigint("through")} is null
+        or cur.head <= ${param.bigint("through")})
+   and cur.failed_at is null
+   and (${param.texts("served")} is null
+        or cur.consumer = any(${param.texts("served")}))
+   and not exists (
+     select 1 from jsonb_to_recordset($1->'excluded')
+       as skip(consumer text, cursor_key text)
+      where skip.consumer = cur.consumer and skip.cursor_key = cur.cursor_key
+   )`;
+/** A lapsed claim's takeover that spends the last failed attempt dead-letters the head instead. */
+const EXHAUSTED = `(cur.claim_holder is not null
+  and cur.failure_count + 1 >= ${param.int("maxFailures")})`;
+/**
+* Claims every eligible head, returning each with its event. A head the claim
+* waited on may have moved to an event its snapshot predates: that row comes
+* back without one (`e_idx` null), for `claimAvailable` to read. It stops
+* there unless one dead-lettered, whose pins `RELEASE_DEAD` then releases, or
+* none was claimed, for `RETRY_AT`.
+*/
+const CLAIM = `
+  with eligible as materialized (
+    select cur.consumer, cur.cursor_key, cur.epoch
+    ${ELIGIBLE}
+       and (cur.claim_expires_at is null
+            or cur.claim_expires_at <= ${param.bigint("now")})
+     order by cur.head, cur.consumer
+     for update of cur
+  ), claimed as (
+    update a2_cursors cur set
+      attempt_count = cur.attempt_count + 1,
+      failure_count = cur.failure_count
+        + case when cur.claim_holder is null then 0 else 1 end,
+      failed_at = case when ${EXHAUSTED} then ${param.bigint("now")}
+                       else cur.failed_at end,
+      first_claimed_at = case when ${EXHAUSTED} then cur.first_claimed_at
+        else coalesce(cur.first_claimed_at, ${param.bigint("now")}) end,
+      last_claimed_at = case when ${EXHAUSTED} then cur.last_claimed_at
+                             else ${param.bigint("now")} end,
+      claim_holder = case when ${EXHAUSTED} then null
+                          else ${param.text("holder")} end,
+      claim_expires_at = case when ${EXHAUSTED} then null
+                              else ${param.bigint("expiresAt")} end
+      from eligible
+     where cur.session_id = ${SESSION}
+       and cur.cursor_key = eligible.cursor_key
+       and cur.consumer = eligible.consumer
+       and cur.epoch = eligible.epoch
+    returning cur.*
+  ), heads as (
+    select claimed.*, ${HEAD_COLUMNS},
+           ${clearIndexOf(SESSION)} as clear_index,
+           (select coalesce(max(idx), 0) from a2_events
+             where session_id = ${SESSION}) as session_head
+      from claimed
+      left join a2_events event
+        on event.session_id = ${SESSION} and event.idx = claimed.head
+  )
+  select r from (
+    select 0 as ord, to_jsonb(heads) as r from heads
+    union all
+    select 1, jsonb_build_object('stop', 'claimed')
+     where exists (select 1 from heads)
+       and not exists (select 1 from heads where failed_at is not null)
+  ) claim
+  order by ord`;
+/**
+* Releases the pins of the heads dead-lettered at `now`, the claim's among
+* them, in a snapshot after the claim's locks, with the history no other pin
+* keeps.
+*/
+const RELEASE_DEAD = `
+  with dead as materialized (
+    select cur.consumer, cur.cursor_key, cur.head from a2_cursors cur
+     where cur.session_id = ${SESSION} and cur.head is not null
+       and cur.failed_at = ${param.bigint("now")} and cur.claim_holder is null
+  ), unpinned as (
+    delete from a2_snapshot_pins pin using dead
+     where pin.session_id = ${SESSION} and pin.event_index = dead.head
+       and pin.consumer = dead.consumer and pin.cursor_key = dead.cursor_key
+    returning 1
+  ), unkept as (
+    delete from a2_snapshot_history history
+     where history.session_id = ${SESSION}
+       and exists (select 1 from dead)
+       and not exists (
+         select 1 from a2_snapshot_pins pin
+          where pin.session_id = history.session_id
+            and pin.reducer_name = history.reducer_name
+            and pin.up_to_index = history.up_to_index
+            and not exists (
+              select 1 from dead
+               where pin.event_index = dead.head
+                 and pin.consumer = dead.consumer
+                 and pin.cursor_key = dead.cursor_key)
+       )
+    returning 1
+  )
+  select jsonb_build_object('released', (select count(*) from unpinned))`;
+/** When nothing was claimed: the earliest live claim or retry hold that blocks a head. */
+const RETRY_AT = `
+  select jsonb_build_object('retry_at', min(cur.claim_expires_at))
+  ${ELIGIBLE}
+     and cur.claim_expires_at > ${param.bigint("now")}`;
+/** The cursor row `alias` whose head this attempt holds. */
+const heldBy = (alias) => `
+  ${alias}.session_id = ${SESSION}
+  and ${alias}.cursor_key = ${param.text("cursorKey")}
+  and ${alias}.consumer = ${CONSUMER} and ${alias}.head = ${INDEX}
+  and ${alias}.attempt_count = ${param.int("attempt")}
+  and ${alias}.failed_at is null and ${alias}.claim_holder is not null`;
+/**
+* Locks the cursor while this attempt holds its head, and stops unless it
+* does: a completion locks its cursor first. A cleared head is never locked.
+*/
+const HOLD = `
+  with boundary as materialized (
+    select ${clearIndexOf(SESSION)} as clear_index
+  ), held as materialized (
+    select cur.kind from a2_cursors cur, boundary
+     where ${heldBy("cur")} and ${INDEX} > boundary.clear_index
+     for update of cur
+  )
+  select case
+    when ${INDEX} <= boundary.clear_index then
+      jsonb_build_object('stop', 'superseded')
+    when not exists (select 1 from held) then
+      jsonb_build_object('stop', 'unheld')
+    else jsonb_build_object('held', (select kind from held limit 1))
+  end
+  from boundary`;
+/** A log cursor's types once it moves: the served consumer's (`types`, when `retype`), else its own. */
+const logTypesOf = (cur) => `(case when ${param.boolean("retype")} then ${param.jsonb("types")}
+         else ${cur}.types end)`;
+/**
+* The head cursor `cur` moves to from its head: its lane's next unfinished
+* event, the next event of a log cursor's types, or none for a concurrent
+* cursor. The lane's lookup is ordered by its whole key, so the lane's
+* primary key serves it.
+*/
+const nextHeadOf = (cur) => `
+  case ${cur}.kind
+    when 'lane' then (
+      select lane.idx from a2_lane_events lane
+       where lane.session_id = ${SESSION} and lane.consumer = ${cur}.consumer
+         and lane.lane = ${cur}.lane and not lane.done
+         and lane.idx > ${cur}.head
+       order by lane.consumer, lane.lane, lane.idx limit 1)
+    when 'log' then (${nextLogHead({
+	types: logTypesOf(cur),
+	after: `${cur}.head`
+})})
+  end`;
+/**
+* Takes the session lock when the held cursor would go idle: a lane or log
+* cursor with no next head. See `completeAttempt` for why a completion that
+* moves to a next head needs no lock.
+*/
+const LOCK_IF_IDLE = `
+  select jsonb_build_object('locked',
+           pg_advisory_xact_lock(hashtext(${SESSION}))::text is not null)
+    from a2_cursors cur
+   where ${heldBy("cur")} and cur.kind <> 'event'
+     and (${nextHeadOf("cur")}) is null`;
+/**
+* Moves the cursor `target` selects past its head `index`, if its head lies
+* above the clear marker: marks the lane's event done (with this attempt's
+* receipt, `receipt`), releases the head's snapshot pins with the history no
+* other pin keeps, and gives the cursor its next head with fresh dispatch
+* columns (a log or concurrent cursor keeps the receipt on the run). The
+* marker and the next head are read in one snapshot, after the cursor's lock.
+* Without a row it writes nothing, and stops if `stop`.
+*/
+const advance = ({ target, receipt, missing }) => `
+  with target as materialized (
+    select cur.* from a2_cursors cur
+     where ${target} and ${INDEX} > ${clearIndexOf(SESSION)}
+     order by cur.cursor_key limit 1
+     for update of cur
+  ), done as (
+    update a2_lane_events lane set done = true${receipt ? `, completed_attempt = ${param.int("attempt")},
+          returned_event_ids = ${param.jsonb("ids")}` : ""}
+      from target
+     where target.kind = 'lane' and lane.session_id = ${SESSION}
+       and lane.consumer = target.consumer and lane.lane = target.lane
+       and lane.idx = target.head
+    returning 1
+  ), unpinned as (
+    delete from a2_snapshot_pins pin using target
+     where pin.session_id = ${SESSION} and pin.event_index = target.head
+       and pin.consumer = target.consumer and pin.cursor_key = target.cursor_key
+    returning 1
+  ), unkept as (
+    delete from a2_snapshot_history history using target
+     where history.session_id = ${SESSION}
+       and not exists (
+         select 1 from a2_snapshot_pins pin
+          where pin.session_id = history.session_id
+            and pin.reducer_name = history.reducer_name
+            and pin.up_to_index = history.up_to_index
+            and not (pin.event_index = target.head
+                     and pin.consumer = target.consumer
+                     and pin.cursor_key = target.cursor_key)
+       )
+    returning 1
+  ), moved as (
+    update a2_cursors cur
+       set position = target.head, head = ${nextHeadOf("target")},
+           ${FRESH_DISPATCH},
+           types = case when target.kind = 'log'
+                        then ${logTypesOf("target")} else cur.types end${receipt ? `,
+           completed_idx = case when target.kind = 'lane'
+                                then cur.completed_idx else target.head end,
+           completed_attempt = case when target.kind = 'lane'
+                                    then cur.completed_attempt
+                                    else ${param.int("attempt")} end,
+           returned_event_ids = case when target.kind = 'lane'
+                                     then cur.returned_event_ids
+                                     else ${param.jsonb("ids")} end` : ""}
+      from target
+     where cur.session_id = ${SESSION} and cur.cursor_key = target.cursor_key
+       and cur.consumer = target.consumer and cur.epoch = target.epoch
+    returning cur.head
+  )
+  select case when exists (select 1 from moved)
+              then jsonb_build_object('advanced', true)
+              else jsonb_build_object(${missing === "continue" ? `'advanced', false` : `'${missing}', 'superseded'`}) end`;
+/** Completing a held head, once the cursor's lock is taken. */
+const COMPLETE = advance({
+	target: heldBy("cur"),
+	receipt: true,
+	missing: "stop"
+});
+/**
+* Completing a held head after appending its events, under the session lock:
+* the head can't have moved, but if it had, the events must not stand.
+*/
+const COMPLETE_APPENDED = advance({
+	target: heldBy("cur"),
+	receipt: true,
+	missing: "abort"
+});
+/**
+* A completion's checks before it appends, under the session lock, which the
+* cursor's lock preceded: a head the clear marker passed meanwhile stops, and
+* a returned id a live row owns aborts.
+*/
+const RETURN_CHECKS = `
+  select case
+    when ${INDEX} <= ${clearIndexOf(SESSION)} then
+      jsonb_build_object('stop', 'superseded')
+    when exists (
+      select 1 from a2_events event
+       where event.session_id = ${SESSION}
+         and event.event_id = any(${param.texts("ids")})
+         and event.idx >= ${clearIndexOf(SESSION)}
+    ) then jsonb_build_object('abort', 'owned')
+    else jsonb_build_object('base', (
+      select coalesce(max(idx), 0) from a2_events
+       where session_id = ${SESSION}))
+  end`;
+/** The consumer's dead-lettered head at `index`, locked. */
+const deadAt = (alias) => `
+  ${alias}.session_id = ${SESSION} and ${alias}.consumer = ${CONSUMER}
+  and ${alias}.head = ${INDEX} and ${alias}.failed_at is not null`;
+/**
+* Locks the dead letter, or stops: the statements after it act only on the
+* row this one locked.
+*/
+const LOCK_DEAD = `
+  with dead as materialized (
+    select cur.cursor_key from a2_cursors cur
+     where ${deadAt("cur")} and ${INDEX} > ${clearIndexOf(SESSION)}
+     order by cur.cursor_key limit 1
+     for update
+  )
+  select case when exists (select 1 from dead)
+              then jsonb_build_object('redriven', true)
+              else jsonb_build_object('stop', 'alive', 'redriven', false,
+                     'has_pending',
+                     ${pendingIn(SESSION, param.texts("served"))}) end`;
+/** Clears a dead letter, keeping its claim history and last failure. */
+const RETRY_DEAD = `
+  with target as materialized (
+    select cur.cursor_key, cur.epoch from a2_cursors cur
+     where ${deadAt("cur")} and ${INDEX} > ${clearIndexOf(SESSION)}
+     order by cur.cursor_key limit 1
+     for update of cur
+  ), retried as (
+    update a2_cursors cur set failed_at = null, failure_count = 0
+      from target
+     where cur.session_id = ${SESSION} and cur.cursor_key = target.cursor_key
+       and cur.consumer = ${CONSUMER} and cur.epoch = target.epoch
+    returning 1
+  )
+  select jsonb_build_object('retried', count(*)) from retried`;
+const SKIP_DEAD = advance({
+	target: deadAt("cur"),
+	receipt: false,
+	missing: "continue"
+});
+const PENDING = `
+  select jsonb_build_object('has_pending',
+           ${pendingIn(SESSION, param.texts("served"))})`;
+/**
+* One log cursor as `wakeLog` finds it: the session's head and clear marker,
+* the cursor's latest run, where a run would start (`start`), and the next
+* event it takes from there unless the run has a head. `retyped` says whether
+* the run's types are stale. CTEs, for a `with`.
+*/
+const LOG_CURSOR = `
+  boundary as materialized (
+    select coalesce(max(idx), 0) as session_head,
+           ${clearIndexOf(SESSION)} as clear_index
+      from a2_events where session_id = ${SESSION}
+  ), latest as materialized (
+    select boundary.*, cur.*,
+           case when cur.epoch is not null
+                  then greatest(cur.position, boundary.clear_index)
+                when ${param.boolean("backfill")} then boundary.clear_index
+                else boundary.session_head end as start
+      from boundary
+      left join lateral (
+        select * from a2_cursors cur
+         where cur.session_id = ${SESSION}
+           and cur.cursor_key = ${param.text("cursorKey")}
+           and cur.consumer = ${CONSUMER}
+         order by cur.epoch desc limit 1
+      ) cur on true
+  ), found as materialized (
+    select latest.*,
+           latest.types is distinct from ${param.jsonb("types")} as retyped,
+           case when latest.head > latest.clear_index then null
+                else ${nextLogHead({
+	types: param.jsonb("types"),
+	after: "latest.start"
+})} end as next_head
+      from latest
+  )`;
+/**
+* A run with a head gets no next one: it is left as it is, claim and all,
+* and so is an idle run with nothing new to take. Only their types change.
+*/
+const KEEPS_RUN = "found.epoch is not null and found.next_head is null";
+/** No run yet, and nothing after the latest clear: none is started. */
+const NO_RUN_NEEDED = "found.epoch is null and found.session_head = found.clear_index";
+/** `wakeLog` without the lock: stops when there is nothing to write. */
+const READ_LOG = `
+  with ${LOG_CURSOR}
+  select case when ${KEEPS_RUN} and not found.retyped
+              then jsonb_build_object('stop', 'unchanged',
+                     'cursor', to_jsonb(found))
+              when ${NO_RUN_NEEDED}
+              then jsonb_build_object('stop', 'empty', 'empty', true,
+                     'head', found.session_head)
+              else jsonb_build_object('stale', true) end
+    from found`;
+/**
+* `wakeLog` under the session lock. A kept run takes the consumer's types,
+* unless another operation holds its row: the session lock is held, so this
+* waits for none. Otherwise a run starts at `start`, retiring the runs it
+* replaces. One with a head is keyed by it; one with nothing to run is idle
+* at its position, as a run that finished its last head is, keyed by that
+* position so the next run, which starts after it, sorts later.
+*/
+const WAKE_LOG = `
+  with ${LOG_CURSOR}, held as materialized (
+    select cur.ctid from a2_cursors cur, found
+     where ${KEEPS_RUN} and found.retyped
+       and cur.session_id = ${SESSION}
+       and cur.cursor_key = ${param.text("cursorKey")}
+       and cur.consumer = ${CONSUMER} and cur.epoch = found.epoch
+       and cur.types is distinct from ${param.jsonb("types")}
+     for update of cur skip locked
+  ), retype as (
+    update a2_cursors cur set types = ${param.jsonb("types")} from held
+     where cur.ctid = held.ctid
+  ), target as (
+    select ${param.text("cursorKey")} as cursor_key, ${CONSUMER} as consumer
+      from found where not (${KEEPS_RUN}) and not (${NO_RUN_NEEDED})
+  ), ${RETIRE_RUNS("target", "(select clear_index from found)")}, started as (
+    insert into a2_cursors
+      (session_id, consumer, cursor_key, epoch, lane, kind, position, head,
+       types)
+    select ${SESSION}, target.consumer, target.cursor_key,
+           coalesce(found.next_head, found.start), ${param.text("lane")}, 'log',
+           found.start, found.next_head, ${param.jsonb("types")}
+      from found, target
+    returning *
+  )
+  select jsonb_build_object(
+           'cursor', coalesce((select to_jsonb(started) from started),
+                              to_jsonb(found)),
+           'head', found.session_head, 'clear_index', found.clear_index,
+           'empty', ${NO_RUN_NEEDED})
+    from found`;
+/**
+* The statements that start the cursor work a batch of `events` carries,
+* with their parameters: each event by its position in the batch, from 1,
+* since its index is assigned under the lock. `started` says whether it
+* starts work for a served consumer.
+*/
+const enqueue = (events, consumers) => {
+	const served = consumers && new Set(consumers.map(({ name }) => name));
+	let started = false;
+	const singles = [];
+	const queued = [];
+	const lanes = /* @__PURE__ */ new Map();
+	events.forEach((event, offset) => {
+		const ord = offset + 1;
+		for (const target of event.targets ?? []) {
+			if (!served || served.has(target.consumer)) started = true;
+			if (target.lane === null) {
+				singles.push({
+					consumer: target.consumer,
+					ord
+				});
+				continue;
+			}
+			queued.push({
+				consumer: target.consumer,
+				lane: target.lane,
+				ord
+			});
+			const key = cursorKeyOf(target.lane, ord);
+			const first = `${target.consumer}\u0000${key}`;
+			if (!lanes.has(first)) lanes.set(first, {
+				consumer: target.consumer,
+				cursor_key: key,
+				lane: target.lane,
+				ord
+			});
+		}
+	});
+	const logs = [];
+	for (const consumer of consumers ?? []) {
+		const log = consumer.log;
+		if (!log) continue;
+		const offset = events.findIndex((event) => event.type !== "a2.cleared" && (log.types === null || log.types.includes(event.type)));
+		if (offset === -1) continue;
+		logs.push({
+			consumer: consumer.name,
+			cursor_key: cursorKeyOf(log.lane, 0),
+			lane: log.lane,
+			ord: offset + 1,
+			types: log.types,
+			backfill: log.backfill
+		});
+	}
+	if (logs.length > 0) started = true;
+	return {
+		statements: [
+			singles.length > 0 && START_EVENTS,
+			queued.length > 0 && QUEUE_LANES,
+			queued.length > 0 && START_LANES,
+			logs.length > 0 && WAKE_LOGS
+		],
+		params: {
+			singles,
+			queued,
+			lanes: [...lanes.values()],
+			logs,
+			clearType: CLEAR_EVENT_TYPE
+		},
+		started
+	};
+};
+/**
+* The rows a batch inserted at `base + 1`, as the store returns them.
+* `events` are what the batch sent.
+*/
+const insertedRows = ({ sessionId, events, base, now }) => events.map((event, offset) => ({
+	id: event.id,
+	type: event.type,
+	payload: structuredClone(event.payload),
+	index: base + 1 + offset,
+	sessionId,
+	createdAt: new Date(now),
+	cause: event.cause ? { ...event.cause } : null
+}));
+/** A served log consumer's types, for a cursor that moves past its head. */
+const retypeOf = (consumer, consumers) => {
+	const log = consumers?.find(({ name }) => name === consumer)?.log;
+	return log ? {
+		retype: true,
+		types: log.types
+	} : {
+		retype: false,
+		types: null
+	};
+};
+function postgres$1(options = {}) {
+	const clock = options.clock ?? SYSTEM_CLOCK;
+	const generateId = options.ids ?? RANDOM_IDS;
+	const instanceId = crypto.randomUUID();
+	let closed = false;
+	if (options.listenConnectionString === "") throw new TypeError("listenConnectionString must be a direct Postgres connection string");
+	if (!options.client && !options.connectionString) throw new TypeError("postgres() needs a connectionString or an injected client");
+	const injected = options.client ? sharePostgresClient(options.client) : void 0;
+	const connection = retryableLazy(async () => {
+		let lease = injected;
+		if (!lease) {
+			const pg = await loadPg();
+			const connectionString = options.connectionString;
+			const key = postgresConnectionKey({
+				connectionString,
+				defaults: pg.default.defaults
+			});
+			lease = sharePostgresPool({
+				key,
+				create: () => {
+					const pool = new pg.default.Pool({ connectionString });
+					pool.on("error", () => {});
+					return postgresPoolClient(pool);
+				}
+			});
+		}
+		return {
+			lease,
+			client: explainingPostgresClient(lease.value.client)
+		};
+	});
+	const client = async () => {
+		if (closed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+		const { client: explaining } = await connection.get();
+		if (closed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+		return explaining;
+	};
+	const notifications = options.listenConnectionString ? postgresNotificationScope(async () => {
+		const c = await client();
+		await (await connection.get()).lease.value.initialize({
+			key: "triggers",
+			run: () => checkPostgresTriggers(c)
+		});
+		const pg = await loadPg();
+		const connectionString = options.listenConnectionString;
+		const key = postgresConnectionKey({
+			connectionString,
+			defaults: pg.default.defaults
+		});
+		return sharePostgresListener({
+			key,
+			create: () => createListener({
+				pg,
+				connectionString
+			})
+		});
+	}) : void 0;
+	const presenceSubscriptions = /* @__PURE__ */ new Map();
+	const readStateBatch = async (requests, reducerName) => {
+		if (requests.length === 0) return [];
+		const c = await client();
+		const input = requests.map((request, position) => ({
+			position,
+			sessionId: request.sessionId,
+			throughIndex: request.throughIndex ?? null,
+			snapshotThroughIndex: request.snapshotThroughIndex ?? request.throughIndex ?? null
+		}));
+		const { rows } = await c.query(`with request as materialized (
+         select * from jsonb_to_recordset($1::jsonb) as value(
+           position integer,
+           "sessionId" text,
+           "throughIndex" bigint,
+           "snapshotThroughIndex" bigint
+         )
+       ), bounded as materialized (
+         select request.*, coalesce(clears.clear_index, 0) as clear_index
+           from request
+           left join a2_clears clears on clears.session_id = request."sessionId"
+       ), selected as materialized (
+         select request.position,
+                request."sessionId" as session_id,
+                request."throughIndex" as through_index,
+                request.clear_index,
+                head.up_to_index as head_index,
+                candidate.up_to_index as snapshot_index,
+                candidate.state as snapshot_state
+           from bounded request
+           left join a2_snapshots head
+             on head.session_id = request."sessionId"
+            and head.reducer_name = $2
+            and head.up_to_index >= request.clear_index
+           left join lateral (
+             select up_to_index, state from (
+               select head.up_to_index, head.state
+                where request."snapshotThroughIndex" is null
+                   or head.up_to_index <= request."snapshotThroughIndex"
+               union all
+               select history.up_to_index, history.state
+                 from a2_snapshot_history history
+                where history.session_id = request."sessionId"
+                  and history.reducer_name = $2
+                  and history.up_to_index >= request.clear_index
+                  and (
+                    request."snapshotThroughIndex" is null
+                    or history.up_to_index <= request."snapshotThroughIndex"
+                  )
+             ) candidates
+             order by up_to_index desc
+             limit 1
+           ) candidate on true
+       )
+       select selected.position, 0 as row_order, selected.session_id,
+              selected.head_index, selected.snapshot_index,
+              selected.snapshot_state, selected.clear_index,
+              null::bigint as idx, null::text as event_type,
+              null::jsonb as payload, null::text as event_id,
+              null::bigint as created_at
+         from selected
+       union all
+       select selected.position, 1 as row_order, event.session_id,
+              selected.head_index, null::bigint as snapshot_index,
+              null::jsonb as snapshot_state, selected.clear_index,
+              event.idx, event.event_type, event.payload,
+              event.event_id, event.created_at
+         from selected
+         join a2_events event on event.session_id = selected.session_id
+        where event.idx > greatest(
+                coalesce(selected.snapshot_index, 0),
+                selected.clear_index - 1
+              )
+          and (
+            selected.through_index is null
+            or event.idx <= selected.through_index
+          )
+       order by position, row_order, idx`, [jsonb(input), reducerName]);
+		const reads = requests.map(() => ({
+			headIndex: null,
+			snapshot: null,
+			events: []
+		}));
+		for (const row of rows) {
+			const read = reads[asNumber(row["position"])];
+			if (row["row_order"] === 0 || row["row_order"] === "0") {
+				const clearIndex = asNumber(row["clear_index"]);
+				if (clearIndex > 0) read.clearIndex = clearIndex;
+				read.headIndex = row["head_index"] === null ? null : asNumber(row["head_index"]);
+				if (row["snapshot_index"] !== null) read.snapshot = {
+					index: asNumber(row["snapshot_index"]),
+					state: row["snapshot_state"]
+				};
+			} else read.events.push(toEvent(row));
+		}
+		return reads;
+	};
+	const begin = notifications ? `begin; set local a2.presence_source = '${instanceId}'` : "begin";
+	const withTx = async (fn) => {
+		const c = await client();
+		if (c.connect) {
+			const conn = await c.connect();
+			try {
+				await conn.query(begin);
+				const result = await fn((text, values) => conn.query(text, values));
+				await conn.query("commit");
+				return result;
+			} catch (err) {
+				await conn.query("rollback").catch(() => {});
+				throw err;
+			} finally {
+				conn.release();
+			}
+		}
+		const resource = (await connection.get()).lease.value;
+		return resource.exclusive(async () => {
+			const raw = resource.raw;
+			await raw.query(begin);
+			try {
+				const result = await fn((text, values) => raw.query(text, values).catch((error) => {
+					throw explainPostgresError(error);
+				}));
+				await raw.query("commit");
+				return result;
+			} catch (err) {
+				await raw.query("rollback").catch(() => {});
+				throw err;
+			}
+		});
+	};
+	/**
+	* Runs `statements` (the falsy ones dropped) as one `a2_batch` call with
+	* `params`, and the session's id as `session`. Its rows come back in order;
+	* an aborted call throws what `abort` makes of the aborting row.
+	*/
+	const run = async ({ sessionId, statements, params, abort = () => new A2Error("STORE_UNAVAILABLE", "postgres store operation failed") }) => {
+		const c = await client();
+		try {
+			const { rows } = await c.query(BATCH, [statements.flatMap((statement) => statement === false ? [] : [compact(statement)]), jsonb({
+				...params,
+				session: sessionId
+			})]);
+			return rows.map((row) => row["r"]);
+		} catch (error) {
+			const reason = abortedBatch(error);
+			if (reason) throw abort(reason);
+			throw error;
+		}
+	};
+	/** Whether `index` is at or below the boundary, read in a fresh statement. */
+	const clearedAt = async ({ query, sessionId, index }) => {
+		const { rows } = await query(`select ${clearIndexOf("$1")} as clear_index`, [sessionId]);
+		return index <= asNumber(rows[0]?.["clear_index"]);
+	};
+	/**
+	* A completion that does not hold its head: a stale attempt, or a retry
+	* after an unknown acknowledgement, which replays the committed children.
+	* Takes no lock.
+	*/
+	const settleUnheld = async ({ query, sessionId, consumer, lane, index, attempt, events }) => {
+		const superseded = { outcome: "superseded" };
+		const { rows: cursorRows } = await query(`select latest.kind, latest.head, covering.completed_idx,
+              covering.completed_attempt, covering.returned_event_ids
+         from (
+           select kind, head from a2_cursors
+            where session_id = $1 and cursor_key = $2 and consumer = $3
+            order by epoch desc limit 1
+         ) latest
+         left join lateral (
+           select completed_idx, completed_attempt, returned_event_ids
+             from a2_cursors
+            where session_id = $1 and cursor_key = $2 and consumer = $3
+              and epoch <= $4
+            order by epoch desc limit 1
+         ) covering on true`, [
+			sessionId,
+			cursorKeyOf(lane, index),
+			consumer,
+			index
+		]);
+		const cursor = cursorRows[0];
+		if (!cursor) {
+			if (await hasEvent(query, sessionId, index)) return superseded;
+			if (await clearedAt({
+				query,
+				sessionId,
+				index
+			})) return superseded;
+			throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+		}
+		const ids = events.map((event) => event.id);
+		if (new Set(ids).size !== ids.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains the same event id more than once");
+		if (asNullableNumber(cursor["head"]) === index) return superseded;
+		let completion;
+		if (cursor["kind"] === "lane") {
+			const { rows } = await query(`select completed_attempt, returned_event_ids from a2_lane_events
+          where session_id = $1 and consumer = $2 and lane = $3 and idx = $4`, [
+				sessionId,
+				consumer,
+				lane,
+				index
+			]);
+			completion = rows[0] && {
+				attempt: asNullableNumber(rows[0]["completed_attempt"]),
+				ids: rows[0]["returned_event_ids"]
+			};
+		} else if (asNullableNumber(cursor["completed_idx"]) === index) completion = {
+			attempt: asNullableNumber(cursor["completed_attempt"]),
+			ids: cursor["returned_event_ids"]
+		};
+		if (!completion || completion.attempt !== attempt) return superseded;
+		const returnedIds = completion.ids === null || completion.ids === void 0 ? null : decodeReturnedEventIds(completion.ids);
+		if (returnedIds === null || returnedIds.length !== ids.length || returnedIds.some((id, offset) => id !== ids[offset])) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "completed attempt does not match the returned event batch");
+		if (events.length === 0) return {
+			outcome: "completed",
+			events: []
+		};
+		const { rows: existing } = await query(`select session_id, idx, event_type, payload, event_id, created_at, cause
+         from a2_events where session_id = $1 and event_id = any($2::text[])`, [sessionId, ids]);
+		const byId = new Map(existing.map((row) => [row["event_id"], row]));
+		const ordered = ids.map((id) => byId.get(id));
+		if (ordered.some((row) => !row) && await clearedAt({
+			query,
+			sessionId,
+			index
+		})) return superseded;
+		if (ordered.some((row) => {
+			const cause = row ? decodeCause(row["cause"]) : null;
+			return !row || cause?.consumer !== consumer || cause.lane !== lane || cause.index !== index || cause.attempt !== attempt;
+		})) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event retry does not match the committed batch");
+		return {
+			outcome: "completed",
+			events: idempotentReplay(events, ordered.map(toStored))
+		};
+	};
+	const store = {
+		async append(sessionId, events, appendOptions) {
+			const consumers = appendOptions?.consumers;
+			const served = servedNames(consumers);
+			if (events.length === 0) return wrap(async () => {
+				const { rows } = await (await client()).query(`select ${pendingIn("$1", "$2")} as has_pending`, [sessionId, served]);
+				return {
+					events: [],
+					hasPending: rows[0]?.["has_pending"] === true
+				};
+			});
+			return wrap(async () => {
+				const suppliedIds = events.filter((e) => e.id !== void 0).map((e) => e.id);
+				if (new Set(suppliedIds).size !== suppliedIds.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "batch contains the same event id more than once");
+				const now = clock.now().getTime();
+				const rows = events.map((event, offset) => ({
+					ord: offset + 1,
+					id: event.id ?? generateId(),
+					type: event.type,
+					payload: event.payload,
+					cause: event.cause ?? null
+				}));
+				const causes = [...new Map(events.flatMap((event) => event.cause ? [[jsonb(event.cause), event.cause]] : [])).values()];
+				const work = enqueue(events, consumers);
+				const originIndex = appendOptions?.originIndex;
+				const checked = (await run({
+					sessionId,
+					statements: [
+						LOCK_SESSION,
+						APPEND_CHECKS,
+						causes.length > 0 && FENCE,
+						suppliedIds.length > 0 && REUSE_IDS,
+						INSERT_EVENTS,
+						...work.statements
+					],
+					params: {
+						...work.params,
+						served,
+						ids: suppliedIds,
+						count: events.length,
+						origin: originIndex ?? null,
+						causes: causes.map((cause, offset) => ({
+							ord: offset + 1,
+							consumer: cause.consumer,
+							cursor_key: cursorKeyOf(cause.lane, cause.index),
+							idx: cause.index,
+							attempt: cause.attempt
+						})),
+						events: rows,
+						now
+					},
+					abort: (reason) => {
+						switch (reason["abort"]) {
+							case "mixed": {
+								const owned = asNumber(reason["owned"]);
+								return new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${owned} already-appended and ${events.length - owned} fresh events`);
+							}
+							case "cleared": return sessionClearedError(`scheduled work from event ${originIndex} was cleared in session '${sessionId}'`);
+							case "superseded": return supersededAttemptError(sessionId, causes[asNumber(reason["ord"]) - 1]);
+							case "held": return new A2Error("STORE_UNAVAILABLE", `an event id being reused is still held by cleared work in session '${sessionId}'`);
+							default: return new A2Error("STORE_UNAVAILABLE", "postgres store operation failed");
+						}
+					}
+				})).find((row) => row["stop"] === "replay" || "base" in row);
+				if (checked["stop"] === "replay") return {
+					events: idempotentReplay(events, checked["events"].map(toStored)),
+					hasPending: checked["has_pending"] === true
+				};
+				return {
+					events: insertedRows({
+						sessionId,
+						events: rows,
+						base: asNumber(checked["base"]),
+						now
+					}),
+					hasPending: checked["has_pending"] === true || work.started
+				};
+			});
+		},
+		async wakeLog({ sessionId, consumer }) {
+			const { log } = consumer;
+			return wrap(async () => {
+				const found = (await run({
+					sessionId,
+					statements: [
+						READ_LOG,
+						LOCK_SESSION,
+						WAKE_LOG
+					],
+					params: {
+						cursorKey: cursorKeyOf(log.lane, 0),
+						consumer: consumer.name,
+						lane: log.lane,
+						types: log.types,
+						backfill: log.backfill,
+						clearType: CLEAR_EVENT_TYPE
+					}
+				})).at(-1);
+				if (found["empty"] === true) {
+					const head = asNumber(found["head"]);
+					return {
+						cursor: idleLogCursor(consumer.name, log.lane, head),
+						head
+					};
+				}
+				const cursor = found["cursor"];
+				const clearIndex = asNumber(found["stop"] === "unchanged" ? cursor["clear_index"] : found["clear_index"]);
+				return {
+					cursor: toCursor(cursor, clearIndex),
+					head: asNumber(found["stop"] === "unchanged" ? cursor["session_head"] : found["head"])
+				};
+			});
+		},
+		async cursors(sessionId) {
+			return wrap(async () => {
+				const { rows } = await (await client()).query(`with boundary as materialized (
+             select ${clearIndexOf("$1")} as clear_index
+           )
+           select cur.*, boundary.clear_index
+             from a2_cursors cur, boundary
+            where cur.session_id = $1
+              and (
+                cur.head > boundary.clear_index
+                or (cur.kind <> 'event' and not exists (
+                  select 1 from a2_cursors later
+                   where later.session_id = cur.session_id
+                     and later.cursor_key = cur.cursor_key
+                     and later.consumer = cur.consumer
+                     and later.epoch > cur.epoch
+                ) and (
+                  cur.kind = 'log'
+                  or (cur.head is null and cur.position > boundary.clear_index)
+                ))
+              )`, [sessionId]);
+				return rows.map((row) => toCursor(row, asNumber(row["clear_index"]))).toSorted(byCursor);
+			});
+		},
+		async read(sessionId, opts) {
+			return wrap(async () => {
+				const c = await client();
+				const conditions = ["session_id = $1"];
+				const params = [sessionId];
+				if (opts?.afterIndex !== void 0) {
+					params.push(opts.afterIndex);
+					conditions.push(`idx > $${params.length}`);
+				}
+				if (opts?.throughIndex !== void 0) {
+					params.push(opts.throughIndex);
+					conditions.push(`idx <= $${params.length}`);
+				}
+				conditions.push(`idx >= ${clearIndexOf("$1")}`);
+				const { rows } = await c.query(`select session_id, idx, event_type, payload, event_id, created_at, cause
+             from a2_events where ${conditions.join(" and ")} order by idx`, params);
+				return rows.map(toStored);
+			});
+		},
+		async readHistory(sessionId, opts) {
+			return wrap(async () => {
+				if (opts?.throughIndex !== void 0 && opts.throughIndex <= (opts.afterIndex ?? 0)) return [];
+				const c = await client();
+				const conditions = ["session_id = $1"];
+				const params = [sessionId];
+				if (opts?.afterIndex !== void 0) {
+					params.push(opts.afterIndex);
+					conditions.push(`idx > $${params.length}`);
+				}
+				if (opts?.throughIndex !== void 0) {
+					params.push(opts.throughIndex);
+					conditions.push(`idx <= $${params.length}`);
+				}
+				conditions.push(`idx >= ${clearIndexOf("$1")}`);
+				const { rows } = await c.query(`select session_id, idx, event_id, event_type, payload, created_at
+             from a2_events where ${conditions.join(" and ")} order by idx`, params);
+				return rows.map(toEvent);
+			});
+		},
+		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, exclude = [], consumers, maxFailures, through }) {
+			return wrap(async () => {
+				const now = clock.now().getTime();
+				const results = await run({
+					sessionId,
+					statements: [
+						CLAIM,
+						RELEASE_DEAD,
+						RETRY_AT
+					],
+					params: {
+						now,
+						served: servedNames(consumers),
+						excluded: exclude.map((ref) => ({
+							consumer: ref.consumer,
+							cursor_key: cursorKeyOf(ref.lane, ref.index)
+						})),
+						holder,
+						expiresAt: expiresAtMs ?? now + ttlMs,
+						maxFailures: maxFailures ?? null,
+						through: through ?? null
+					}
+				});
+				const rows = results.filter((row) => "e_idx" in row);
+				const unseen = rows.filter((row) => row["e_idx"] === null);
+				if (unseen.length > 0) {
+					const { rows: events } = await (await client()).query(`select ${HEAD_COLUMNS} from a2_events event
+              where event.session_id = $1 and event.idx = any($2::bigint[])`, [sessionId, unseen.map((row) => row["head"])]);
+					const byIndex = new Map(events.map((event) => [asNumber(event["e_idx"]), event]));
+					for (const row of unseen) Object.assign(row, byIndex.get(asNumber(row["head"])));
+				}
+				const heads = rows.filter((row) => row["e_idx"] !== null);
+				if (heads.length > 0) {
+					const events = heads.map((row) => {
+						const head = toHead(row);
+						const clearIndex = asNumber(row["clear_index"]);
+						if (clearIndex > 0) head.clearIndex = clearIndex;
+						return head;
+					}).toSorted(byHead);
+					return {
+						outcome: "claimed",
+						events,
+						head: Math.max(...heads.map((row) => asNumber(row["session_head"])), ...events.map((event) => event.index))
+					};
+				}
+				const retryAt = results.at(-1)["retry_at"];
+				return retryAt === null || retryAt === void 0 ? { outcome: "settled" } : {
+					outcome: "busy",
+					retryAt: new Date(asNumber(retryAt))
+				};
+			});
+		},
+		async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {
+			if (claims.length === 0) return {
+				renewed: [],
+				superseded: []
+			};
+			return wrap(async () => {
+				const c = await client();
+				const now = clock.now().getTime();
+				const expiresAt = expiresAtMs ?? now + ttlMs;
+				const ordered = claims.toSorted((a, b) => a.index - b.index || compareText(a.consumer, b.consumer));
+				const { rows } = await c.query(`with listed as (
+             select * from unnest($3::text[], $4::text[], $5::bigint[], $6::int[])
+               with ordinality as listed(consumer, cursor_key, idx, attempt, ord)
+           ), renewed as (
+             update a2_cursors cur set claim_expires_at = $7
+               from listed
+              where cur.session_id = $1
+                and cur.cursor_key = listed.cursor_key
+                and cur.consumer = listed.consumer
+                and cur.head = listed.idx
+                and listed.idx > ${clearIndexOf("$1")}
+                and cur.attempt_count = listed.attempt
+                and cur.failed_at is null
+                and cur.claim_holder = $2
+                and cur.claim_expires_at > $8
+              returning cur.cursor_key, cur.consumer, cur.head
+           )
+           select listed.ord, latest.head, latest.position, latest.attempt_count,
+                  latest.epoch is not null as found,
+                  exists(
+                    select 1 from renewed
+                     where renewed.cursor_key = listed.cursor_key
+                       and renewed.consumer = listed.consumer
+                       and renewed.head = listed.idx
+                  ) as renewed,
+                  listed.idx <= ${clearIndexOf("$1")} as cleared
+             from listed
+             left join lateral (
+               select cur.epoch, cur.head, cur.position, cur.attempt_count
+                 from a2_cursors cur
+                where cur.session_id = $1
+                  and cur.cursor_key = listed.cursor_key
+                  and cur.consumer = listed.consumer
+                order by cur.epoch desc limit 1
+             ) latest on true
+            order by listed.ord`, [
+					sessionId,
+					holder,
+					ordered.map((claim) => claim.consumer),
+					ordered.map((claim) => cursorKeyOf(claim.lane, claim.index)),
+					ordered.map((claim) => claim.index),
+					ordered.map((claim) => claim.attempt),
+					expiresAt,
+					now
+				]);
+				const renewed = [];
+				const superseded = [];
+				for (const row of rows) {
+					const { attempt, ...ref } = ordered[asNumber(row["ord"]) - 1];
+					if (row["renewed"] === true) {
+						renewed.push(ref);
+						continue;
+					}
+					if (row["cleared"] === true) {
+						superseded.push(ref);
+						continue;
+					}
+					if (row["found"] !== true) continue;
+					const head = asNullableNumber(row["head"]);
+					if (head !== ref.index && asNumber(row["position"]) < ref.index) continue;
+					if (head !== ref.index || asNumber(row["attempt_count"]) > attempt) superseded.push(ref);
+				}
+				return {
+					renewed,
+					superseded
+				};
+			});
+		},
+		async completeAttempt({ sessionId, consumer, lane, index, attempt, events, consumers }) {
+			return wrap(async () => {
+				const ids = events.map((event) => event.id);
+				const duplicated = new Set(ids).size !== ids.length;
+				const cause = {
+					consumer,
+					lane,
+					index,
+					attempt
+				};
+				const now = clock.now().getTime();
+				const rows = events.map((event, offset) => ({
+					ord: offset + 1,
+					id: event.id,
+					type: event.type,
+					payload: event.payload,
+					cause
+				}));
+				const work = events.length > 0 && !duplicated ? enqueue(events, consumers) : void 0;
+				const results = await run({
+					sessionId,
+					statements: duplicated ? [HOLD] : work ? [
+						HOLD,
+						LOCK_SESSION,
+						RETURN_CHECKS,
+						REUSE_IDS,
+						INSERT_EVENTS,
+						...work.statements,
+						COMPLETE_APPENDED
+					] : [
+						HOLD,
+						LOCK_IF_IDLE,
+						COMPLETE
+					],
+					params: {
+						...work?.params,
+						...retypeOf(consumer, consumers),
+						cursorKey: cursorKeyOf(lane, index),
+						consumer,
+						index,
+						attempt,
+						ids,
+						count: events.length,
+						events: rows,
+						now,
+						clearType: CLEAR_EVENT_TYPE
+					},
+					abort: (reason) => reason["abort"] === "owned" ? new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains an already-appended event id") : new A2Error("STORE_UNAVAILABLE", reason["abort"] === "held" ? `an event id being reused is still held by cleared work in session '${sessionId}'` : "postgres store operation failed")
+				});
+				const held = results[0];
+				if (held["stop"] === "superseded") return { outcome: "superseded" };
+				if (held["stop"] === "unheld") {
+					const c = await client();
+					return settleUnheld({
+						query: (text, values) => c.query(text, values),
+						sessionId,
+						consumer,
+						lane,
+						index,
+						attempt,
+						events
+					});
+				}
+				if (duplicated) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains the same event id more than once");
+				if (results.at(-1)["stop"] === "superseded") return { outcome: "superseded" };
+				const checked = results.find((row) => "base" in row);
+				return {
+					outcome: "completed",
+					events: checked ? insertedRows({
+						sessionId,
+						events: rows,
+						base: asNumber(checked["base"]),
+						now
+					}) : []
+				};
+			});
+		},
+		async failAttempt({ sessionId, consumer, lane, index, attempt, error, maxFailures, retryAfterMs }) {
+			return wrap(() => withTx(async (query) => {
+				const now = clock.now().getTime();
+				const cursorKey = cursorKeyOf(lane, index);
+				const { rows } = await query(`with current as materialized (
+             select cur.* from a2_cursors cur
+              where cur.session_id = $1 and cur.cursor_key = $2
+                and cur.consumer = $3 and cur.head = $4
+                and cur.head > ${clearIndexOf("$1")}
+              for update of cur
+           ), updated as (
+             update a2_cursors cur set
+               failure_count = cur.failure_count + 1,
+               last_error = $6,
+               last_failed_at = $8,
+               last_failed_attempt = $5,
+               failed_at = case
+                 when cur.failure_count + 1 >= $7 then $8
+                 else cur.failed_at
+               end,
+               claim_holder = null,
+               claim_expires_at = case
+                 when cur.failure_count + 1 >= $7 then null
+                 else $9::bigint
+               end
+             from current
+             where cur.session_id = $1 and cur.cursor_key = $2
+               and cur.consumer = $3 and cur.epoch = current.epoch
+               and current.attempt_count = $5
+               and current.failed_at is null
+               and current.claim_holder is not null
+             returning cur.failure_count, cur.failed_at
+           )
+           select case
+             when $4 <= ${clearIndexOf("$1")} then 'cleared'
+             when not exists (select 1 from current) then 'missing'
+             when exists (
+               select 1 from updated where failed_at is not null
+             ) then 'dead_lettered'
+             when exists (select 1 from updated) then 'failed'
+             when exists (
+               select 1 from current where attempt_count <> $5
+             ) then 'superseded'
+             when exists (
+               select 1 from current
+                where claim_holder is null and last_failed_attempt = $5
+                  and failed_at is null
+             ) then 'failed'
+             when exists (
+               select 1 from current where failed_at is not null
+             ) then 'dead_lettered'
+             else 'superseded'
+           end as outcome,
+           coalesce(
+             (select failure_count from updated),
+             (select failure_count from current)
+           ) as failure_count`, [
+					sessionId,
+					cursorKey,
+					consumer,
+					index,
+					attempt,
+					error,
+					maxFailures,
+					now,
+					retryAfterMs === void 0 ? null : now + retryAfterMs
+				]);
+				const row = rows[0];
+				if (row?.["outcome"] === "cleared") return {
+					outcome: "superseded",
+					failureCount: 0
+				};
+				if (!row || row["outcome"] === "missing") {
+					const { rows: cursorRows } = await query(`select 1 from a2_cursors
+                where session_id = $1 and cursor_key = $2 and consumer = $3`, [
+						sessionId,
+						cursorKey,
+						consumer
+					]);
+					if (cursorRows.length > 0 || await hasEvent(query, sessionId, index) || await clearedAt({
+						query,
+						sessionId,
+						index
+					})) return {
+						outcome: "superseded",
+						failureCount: 0
+					};
+					throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+				}
+				if (row["outcome"] === "dead_lettered") await releasePins({
+					query,
+					sessionId,
+					consumer,
+					cursorKey,
+					index
+				});
+				return {
+					outcome: row["outcome"],
+					failureCount: asNumber(row["failure_count"])
+				};
+			}));
+		},
+		async deadLetters(sessionId) {
+			return wrap(async () => {
+				const { rows } = await (await client()).query(`select cur.*, ${HEAD_COLUMNS}
+             from a2_cursors cur
+             join a2_events event
+               on event.session_id = cur.session_id and event.idx = cur.head
+            where cur.session_id = $1
+              and cur.failed_at is not null
+              and cur.head > ${clearIndexOf("$1")}`, [sessionId]);
+				return rows.map(toHead).toSorted(byHead);
+			});
+		},
+		async redrive({ sessionId, consumer, index, action, consumers }) {
+			return wrap(async () => {
+				const results = await run({
+					sessionId,
+					statements: [
+						action === "skip" && LOCK_SESSION,
+						LOCK_DEAD,
+						action === "skip" ? SKIP_DEAD : RETRY_DEAD,
+						PENDING
+					],
+					params: {
+						...retypeOf(consumer, consumers),
+						consumer,
+						index,
+						served: servedNames(consumers),
+						clearType: CLEAR_EVENT_TYPE
+					}
+				});
+				return {
+					redriven: results.find((row) => "redriven" in row)?.["redriven"] === true,
+					hasPending: results.at(-1)["has_pending"] === true
+				};
+			});
+		},
+		async readState(sessionId, reducerName, stateOptions) {
+			return wrap(async () => (await readStateBatch([{
+				sessionId,
+				...stateOptions?.throughIndex === void 0 ? {} : { throughIndex: stateOptions.throughIndex },
+				...stateOptions?.snapshotThroughIndex === void 0 ? {} : { snapshotThroughIndex: stateOptions.snapshotThroughIndex }
+			}], reducerName))[0]);
+		},
+		async readStates(requests, reducerName) {
+			return wrap(() => readStateBatch(requests, reducerName));
+		},
+		async putSnapshots(sessionId, reducerName, writes) {
+			await wrap(() => withTx(async (query) => {
+				const requested = [...new Map(writes.map((write) => [write.index, write])).values()].toSorted((a, b) => a.index - b.index);
+				if (requested.length === 0) return;
+				await query("select pg_advisory_xact_lock(hashtext($1), hashtext($2))", [sessionId, reducerName]);
+				const { rows: headRows } = await query(`select boundary.clear_index, head.up_to_index, head.state, head.updated_at
+               from (select ${clearIndexOf("$1")} as clear_index) boundary
+               left join lateral (
+                 select up_to_index, state, updated_at from a2_snapshots
+                  where session_id = $1 and reducer_name = $2
+                  for update
+               ) head on true`, [sessionId, reducerName]);
+				const clearIndex = asNumber(headRows[0]?.["clear_index"]);
+				const normalized = requested.filter((write) => write.index >= clearIndex);
+				if (normalized.length === 0) return;
+				const currentHead = headRows[0]?.["up_to_index"] == null ? void 0 : headRows[0];
+				const requestedPins = normalized.flatMap((write) => (write.pins ?? []).map((pin) => ({
+					eventIndex: pin.index,
+					consumer: pin.consumer,
+					cursorKey: cursorKeyOf(pin.lane, pin.index),
+					snapshotIndex: write.index
+				})));
+				if (requestedPins.length > 0) {
+					const heads = [...new Map(requestedPins.map((pin) => [`${pin.consumer}\u0000${pin.cursorKey}\u0000${pin.eventIndex}`, pin])).values()];
+					const { rows: live } = await query(`select cur.consumer, cur.cursor_key, cur.head
+                 from a2_cursors cur
+                 join unnest($2::text[], $3::text[], $4::bigint[])
+                   as pin(consumer, cursor_key, idx)
+                   on cur.consumer = pin.consumer
+                  and cur.cursor_key = pin.cursor_key
+                  and cur.head = pin.idx
+                where cur.session_id = $1 and cur.head > $5
+                  and cur.failed_at is null
+                order by cur.cursor_key, cur.consumer
+                for share of cur`, [
+						sessionId,
+						heads.map((pin) => pin.consumer),
+						heads.map((pin) => pin.cursorKey),
+						heads.map((pin) => pin.eventIndex),
+						clearIndex
+					]);
+					const unfinished = new Set(live.map((row) => `${String(row["consumer"])}\u0000${String(row["cursor_key"])}\u0000${asNumber(row["head"])}`));
+					const accepted = requestedPins.filter((pin) => unfinished.has(`${pin.consumer}\u0000${pin.cursorKey}\u0000${pin.eventIndex}`));
+					if (accepted.length > 0) await query(`insert into a2_snapshot_pins
+                   (session_id, event_index, consumer, cursor_key, reducer_name, up_to_index)
+                 select $1, pin."eventIndex", pin.consumer, pin."cursorKey",
+                        $2, pin."snapshotIndex"
+                   from jsonb_to_recordset($3::jsonb) as pin(
+                     "eventIndex" bigint,
+                     consumer text,
+                     "cursorKey" text,
+                     "snapshotIndex" bigint
+                   )
+                 on conflict do nothing`, [
+						sessionId,
+						reducerName,
+						jsonb(accepted)
+					]);
+				}
+				const latestWrite = normalized.at(-1);
+				const writesHead = !currentHead || latestWrite.index >= asNumber(currentHead["up_to_index"]);
+				const advancesHead = !currentHead || latestWrite.index > asNumber(currentHead["up_to_index"]);
+				const finalHeadIndex = advancesHead ? latestWrite.index : asNumber(currentHead["up_to_index"]);
+				const { rows: pinRows } = await query(`select distinct up_to_index from a2_snapshot_pins
+              where session_id = $1 and reducer_name = $2
+                and up_to_index = any($3::bigint[])`, [
+					sessionId,
+					reducerName,
+					[.../* @__PURE__ */ new Set([...normalized.map((write) => write.index), ...currentHead ? [asNumber(currentHead["up_to_index"])] : []])]
+				]);
+				const pinned = new Set(pinRows.map((row) => asNumber(row["up_to_index"])));
+				const historical = /* @__PURE__ */ new Map();
+				if (advancesHead && currentHead && asNumber(currentHead["up_to_index"]) >= clearIndex && pinned.has(asNumber(currentHead["up_to_index"]))) {
+					const index = asNumber(currentHead["up_to_index"]);
+					historical.set(index, {
+						index,
+						state: currentHead["state"],
+						updatedAt: asNumber(currentHead["updated_at"])
+					});
+				}
+				const updatedAt = clock.now().getTime();
+				for (const write of normalized) if (write.index < finalHeadIndex && pinned.has(write.index)) historical.set(write.index, {
+					index: write.index,
+					state: write.state,
+					updatedAt
+				});
+				if (historical.size > 0) await query(`insert into a2_snapshot_history
+                 (session_id, reducer_name, up_to_index, state, updated_at)
+               select $1, $2, snapshot.index, snapshot.state, snapshot."updatedAt"
+                 from jsonb_to_recordset($3::jsonb) as snapshot(
+                   index bigint,
+                   state jsonb,
+                   "updatedAt" bigint
+                 )
+               on conflict (session_id, reducer_name, up_to_index) do update set
+                 state = excluded.state,
+                 updated_at = excluded.updated_at`, [
+					sessionId,
+					reducerName,
+					jsonb([...historical.values()])
+				]);
+				if (writesHead) {
+					await query(`insert into a2_snapshots
+                 (session_id, reducer_name, up_to_index, state, updated_at)
+               values ($1, $2, $3, $4::jsonb, $5)
+               on conflict (session_id, reducer_name) do update set
+                 up_to_index = excluded.up_to_index,
+                 state = excluded.state,
+                 updated_at = excluded.updated_at
+               where excluded.up_to_index >= a2_snapshots.up_to_index`, [
+						sessionId,
+						reducerName,
+						latestWrite.index,
+						jsonb(latestWrite.state),
+						clock.now().getTime()
+					]);
+					await query(`delete from a2_snapshot_history
+                where session_id = $1 and reducer_name = $2 and up_to_index = $3`, [
+						sessionId,
+						reducerName,
+						latestWrite.index
+					]);
+				}
+			}));
+		},
+		presence: {
+			async set(ns, participant, values, meta) {
+				const entries = Object.entries(values);
+				if (entries.length === 0) return;
+				await wrap(async () => {
+					const atMs = meta.at.getTime();
+					const nowMs = clock.now().getTime();
+					const expiresAtMs = nowMs + meta.ttlMs;
+					const applied = nullProtoRecord();
+					const write = async (query) => {
+						for (const [field, value] of entries) if ((await query(`insert into a2_presence
+                   (ns, participant, field, value, seen, at, expires_at)
+                 values ($1, $2, $3, $4::jsonb, $5, $6, $7)
+                 on conflict (ns, participant, field) do update set
+                   value = excluded.value,
+                   seen = excluded.seen,
+                   at = excluded.at,
+                   expires_at = excluded.expires_at
+                 where a2_presence.at <= excluded.at
+                    or a2_presence.expires_at <= $8${notifications ? " returning field" : ""}`, [
+							ns,
+							participant,
+							field,
+							jsonb(value),
+							meta.seen,
+							atMs,
+							expiresAtMs,
+							nowMs
+						])).rows.length) applied[field] = structuredClone(value);
+					};
+					if (notifications) await withTx(write);
+					else {
+						const c = await client();
+						await write((text, parameters) => c.query(text, parameters));
+					}
+					if (Object.keys(applied).length) {
+						const patch = {
+							participant,
+							values: applied,
+							seen: meta.seen,
+							at: new Date(atMs)
+						};
+						const subscription = presenceSubscriptions.get(ns);
+						subscription?.poll.update(patch);
+						for (const listener of subscription?.listeners ?? []) listener(patch);
+					}
+				});
+			},
+			async read(ns) {
+				return wrap(async () => {
+					const c = await client();
+					const now = clock.now().getTime();
+					const { rows } = await c.query(`with swept as (
+               delete from a2_presence
+                where ns = $1 and expires_at <= $2
+             )
+             select participant, field, value, seen, at, expires_at
+               from a2_presence
+              where ns = $1 and expires_at > $2 and value <> 'null'::jsonb
+              order by participant, field`, [ns, now]);
+					return rows.map((row) => ({
+						participant: row["participant"],
+						field: row["field"],
+						value: row["value"],
+						seen: asNumber(row["seen"]),
+						at: new Date(asNumber(row["at"])),
+						expiresAt: new Date(asNumber(row["expires_at"]))
+					}));
+				});
+			}
+		},
+		stream(sessionId, opts) {
+			const readAfter = (afterIndex) => wrap(async () => {
+				const { rows } = await (await client()).query(`select session_id, idx, event_type, payload, event_id, created_at
+               from a2_events
+              where session_id = $1 and idx > $2
+                and idx >= ${clearIndexOf("$1")}
+              order by idx`, [sessionId, afterIndex]);
+				return rows.map(toEvent);
+			});
+			if (notifications) return notifications.stream({
+				channel: postgresNotificationChannel({
+					kind: "events",
+					sessionId
+				}),
+				read: readAfter,
+				startAfter: opts?.startAfter ?? 0
+			});
+			return pollingStream(readAfter, opts?.startAfter !== void 0 ? { startAfter: opts.startAfter } : {});
+		},
+		async clear({ sessionId, ifLastIndex, cause }) {
+			return wrap(() => withTx(async (query) => {
+				await lockSession(query, sessionId);
+				const { rows: headRows } = await query(`select coalesce(max(idx), 0) as head,
+                    ${clearIndexOf("$1")} as clear_index
+               from a2_events where session_id = $1`, [sessionId]);
+				const head = asNumber(headRows[0]?.["head"]);
+				const clearIndex = asNumber(headRows[0]?.["clear_index"]);
+				if (cause) await assertCurrentCause({
+					query,
+					sessionId,
+					cause,
+					clearIndex,
+					lock: "update"
+				});
+				if (ifLastIndex !== void 0 && clearIndex === ifLastIndex + 1) return {
+					cleared: true,
+					index: head,
+					clearIndex
+				};
+				if (ifLastIndex !== void 0 && ifLastIndex !== head) return {
+					cleared: false,
+					index: head,
+					clearIndex
+				};
+				if (head === 0 || clearIndex === head) return {
+					cleared: true,
+					index: head,
+					clearIndex
+				};
+				const marker = head + 1;
+				await query(`insert into a2_events
+               (session_id, idx, event_type, payload, event_id, created_at, cause)
+             values ($1, $2, $3, 'null'::jsonb, $4, $5, null)`, [
+					sessionId,
+					marker,
+					CLEAR_EVENT_TYPE,
+					generateId(),
+					clock.now().getTime()
+				]);
+				await query(`with released as (
+               update a2_cursors
+                  set head = null, ${FRESH_DISPATCH}
+                where session_id = $1 and cursor_key = $3 and consumer = $4
+                  and head = $5
+             )
+             insert into a2_clears (session_id, clear_index) values ($1, $2)
+             on conflict (session_id) do update set clear_index = excluded.clear_index`, [
+					sessionId,
+					marker,
+					cause ? cursorKeyOf(cause.lane, cause.index) : null,
+					cause?.consumer ?? null,
+					cause?.index ?? null
+				]);
+				return {
+					cleared: true,
+					index: marker,
+					clearIndex: marker
+				};
+			}));
+		},
+		async reclaim(sessionId) {
+			return wrap(() => withTx(async (query) => {
+				const { rows } = await query(`with boundary as materialized (
+               select ${clearIndexOf("$1")} as clear_index
+             ), batch as materialized (
+               select idx from a2_events
+                where session_id = $1
+                  and idx < (select clear_index from boundary)
+                order by idx
+                limit $2
+                for update skip locked
+             ), deleted as (
+               delete from a2_events event using batch
+                where event.session_id = $1 and event.idx = batch.idx
+                returning event.idx
+             ), pins as (
+               delete from a2_snapshot_pins pin using deleted
+                where pin.session_id = $1 and pin.event_index = deleted.idx
+             ), lanes as materialized (
+               -- Each lane's queue through the batch, by the lane's own key.
+               select lane.ctid from a2_cursors cur
+                 join a2_lane_events lane
+                   on lane.session_id = cur.session_id
+                  and lane.consumer = cur.consumer and lane.lane = cur.lane
+                where cur.session_id = $1 and cur.kind = 'lane'
+                  and lane.idx <= (select max(idx) from batch)
+                for update of lane skip locked
+             ), gone_lanes as (
+               delete from a2_lane_events target using lanes
+                where target.ctid = lanes.ctid
+             ), singles as materialized (
+               select cur.ctid from a2_cursors cur
+                 join batch on cur.cursor_key = '#' || batch.idx
+                where cur.session_id = $1 and cur.kind = 'event'
+                for update of cur skip locked
+             ), gone_singles as (
+               delete from a2_cursors target using singles
+                where target.ctid = singles.ctid
+             )
+             select (select count(*) from deleted) as deleted,
+                    (select clear_index from boundary) as clear_index`, [sessionId, RECLAIM_BATCH]);
+				const deleted = asNumber(rows[0]?.["deleted"]);
+				const clearIndex = asNumber(rows[0]?.["clear_index"]);
+				if (clearIndex === 0) return {
+					deleted: 0,
+					done: true
+				};
+				const { rows: remaining } = await query("select 1 from a2_events where session_id = $1 and idx < $2 limit 1", [sessionId, clearIndex]);
+				if (remaining.length > 0) return {
+					deleted,
+					done: false
+				};
+				const { rows: swept } = await query(`with lanes as materialized (
+               select ctid from a2_lane_events
+                where session_id = $1 and idx < $2
+                for update skip locked
+             ), cursors as materialized (
+               select cur.ctid from a2_cursors cur
+                where ${SUPERSEDED_CURSOR}
+                for update skip locked
+             ), pins as materialized (
+               select ctid from a2_snapshot_pins
+                where session_id = $1 and up_to_index < $2
+                for update skip locked
+             ), history as materialized (
+               select ctid from a2_snapshot_history
+                where session_id = $1 and up_to_index < $2
+                for update skip locked
+             ), heads as materialized (
+               select ctid from a2_snapshots
+                where session_id = $1 and up_to_index < $2
+                for update skip locked
+             ), gone_lanes as (
+               delete from a2_lane_events target using lanes
+                where target.ctid = lanes.ctid
+             ), gone_cursors as (
+               delete from a2_cursors target using cursors
+                where target.ctid = cursors.ctid
+             ), gone_pins as (
+               delete from a2_snapshot_pins target using pins where target.ctid = pins.ctid
+             ), gone_history as (
+               delete from a2_snapshot_history target using history
+                where target.ctid = history.ctid
+             ), gone_heads as (
+               delete from a2_snapshots target using heads where target.ctid = heads.ctid
+             )
+             select (select count(*) from a2_lane_events
+                      where session_id = $1 and idx < $2)
+                  + (select count(*) from a2_cursors cur
+                      where ${SUPERSEDED_CURSOR})
+                  + (select count(*) from a2_snapshot_pins
+                      where session_id = $1 and up_to_index < $2)
+                  + (select count(*) from a2_snapshot_history
+                      where session_id = $1 and up_to_index < $2)
+                  + (select count(*) from a2_snapshots
+                      where session_id = $1 and up_to_index < $2)
+                  - (select count(*) from lanes)
+                  - (select count(*) from cursors)
+                  - (select count(*) from pins)
+                  - (select count(*) from history)
+                  - (select count(*) from heads) as skipped`, [sessionId, clearIndex]);
+				return {
+					deleted,
+					done: asNumber(swept[0]?.["skipped"]) === 0
+				};
+			}));
+		},
+		async close() {
+			if (closed) return;
+			closed = true;
+			for (const subscription of presenceSubscriptions.values()) subscription.stop();
+			presenceSubscriptions.clear();
+			await notifications?.close();
+			const opened = await connection.peek()?.catch(() => void 0);
+			await (injected ?? opened?.lease)?.release();
+		}
+	};
+	if (notifications) {
+		const presence = store.presence;
+		const read = presence.read;
+		presence.read = async (ns) => {
+			const subscription = presenceSubscriptions.get(ns);
+			await subscription?.ready;
+			await subscription?.poll.ready;
+			return subscription ? subscription.poll.snapshot(() => read(ns)) : read(ns);
+		};
+		presence.subscribe = (ns, onPatch) => {
+			if (closed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
+			let subscription = presenceSubscriptions.get(ns);
+			if (!subscription) {
+				const listeners = /* @__PURE__ */ new Set();
+				let dirty = false;
+				let ended = false;
+				let waiting;
+				const lease = notifications.watch({
+					channel: postgresNotificationChannel({
+						kind: "presence",
+						sessionId: ns
+					}),
+					notify: (source) => {
+						if (source === instanceId) return;
+						dirty = true;
+						waiting?.cancel();
+					}
+				});
+				const poll = pollPresence({
+					read: async () => {
+						await lease.ready;
+						if (ended || closed) return [];
+						dirty = false;
+						return read(ns);
+					},
+					deliver: (patch) => {
+						for (const listener of listeners) listener(patch);
+					},
+					sleep: () => {
+						waiting = defaultSleep(dirty ? 0 : NOTIFY_TIMINGS.safetyReadMs);
+						return waiting;
+					}
+				});
+				lease.ready.catch(() => poll.stop());
+				subscription = {
+					listeners,
+					ready: lease.ready,
+					poll,
+					stop() {
+						ended = true;
+						poll.stop();
+						lease.stop();
+						waiting?.cancel();
+					}
+				};
+				presenceSubscriptions.set(ns, subscription);
+			}
+			subscription.listeners.add(onPatch);
+			let stopped = false;
+			return () => {
+				if (stopped) return;
+				stopped = true;
+				subscription.listeners.delete(onPatch);
+				if (subscription.listeners.size === 0) {
+					presenceSubscriptions.delete(ns);
+					subscription.stop();
+				}
+			};
+		};
+	}
+	return store;
+}
+//#endregion
 //#region src/store/postgres-db.ts
 const SCHEMA_FILE = "node_modules/@vercel/board/sql/postgres/schema.sql";
 /** The board's own error for tables that aren't there: the fix is a file to apply. */