experimental-a2 0.20.0 → 0.21.1

package/dist/store-postgres.js

@@ -1,12 +1,11 @@
-import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-DGI4jTQ5.js";
-import { _ as nullProtoRecord, r as NOTIFY_TIMINGS } from "./internal-CscSY7K_.js";
-import { n as pollingStream, t as defaultSleep } from "./store-polling-7WJV0YWP.js";
+import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-wHd5GCpZ.js";
+import { _ as nullProtoRecord, r as NOTIFY_TIMINGS } from "./internal-Bc4PvfHk.js";
+import { n as pollingStream, t as defaultSleep } from "./store-polling-DYNyxCev.js";
 import { r as platformWaitUntil } from "./platform-B4TnJtWu.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
-import { t as idempotentReplay } from "./idempotent-replay-JdgMQRRm.js";
+import { a as idempotentReplay, i as idleLogCursor, n as decodeCause, r as decodeReturnedEventIds, t as cursorKeyOf } from "./store-codec-DwrWlgQx.js";
 import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS.js";
-import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
-import { t as pollPresence } from "./store-presence-polling-B1ixeqIS.js";
+import { t as pollPresence } from "./store-presence-polling-CzQ0wdtM.js";
 import { createHash } from "node:crypto";
 //#region src/postgres-notifications.ts
 const postgresNotificationChannel = ({ kind, sessionId }) => `a2_${kind}_${createHash("md5").update(sessionId).digest("hex")}`;
@@ -171,35 +170,72 @@ function postgresNotifications(createConnection) {
 		}
 	};
 }
+//#endregion
+//#region src/postgres-schema.ts
+/**
+* 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 apply = (file) => `apply ${PACKAGE}/sql/postgres/${file} to this database`;
 const SEE_DOCS = `See ${PACKAGE}/docs/stores/04-postgres.mdx.`;
-const VERSION = "select version from a2_schema";
-const VERSION_AND_TRIGGERS = `select version, (select count(*) 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')))
-  as notify_triggers from a2_schema`;
-/** Explains a failed version read, or returns undefined when the schema is not the cause. */
-const diagnose = async (client) => {
-	const [found] = (await client.query(`select
-      to_regclass('a2_schema') is not null as marked,
-      to_regclass('a2_events') is not null as installed,
-      has_table_privilege(to_regclass('a2_schema'), 'select') as readable`)).rows;
-	if (!found) return void 0;
-	if (!found["marked"]) return new A2Error("STORE_NOT_CONFIGURED", found["installed"] ? `This Postgres database has A2's tables but no a2_schema version. That is expected once after upgrading from a release that created its tables at runtime, and your events are untouched. A2 doesn't create or change tables at runtime: ${apply("schema.sql")}. ${SEE_DOCS}` : `A2's tables aren't in this Postgres database, and A2 doesn't create tables at runtime: ${apply("schema.sql")}. ${SEE_DOCS}`);
-	if (found["readable"] === false) return new A2Error("STORE_NOT_CONFIGURED", `The role this store connects as can't read a2_schema. Apply schema.sql as that role, or grant it select on a2_schema and select, insert, update, and delete on A2's other tables. ${SEE_DOCS}`);
-};
-/** Reads the schema version (and, with a listener, the triggers) in one query that takes no lock a writer holds. */
-const checkPostgresSchema = async ({ client, listen }) => {
-	let row;
-	try {
-		row = (await client.query(listen ? VERSION_AND_TRIGGERS : VERSION)).rows[0];
-	} catch (err) {
-		throw await diagnose(client).catch(() => void 0) ?? err;
+/** 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;
 	}
-	const version = Number(row?.["version"] ?? 0);
-	if (version < 1) throw new A2Error("STORE_NOT_CONFIGURED", `This Postgres database has A2 schema version ${version}, and this release of experimental-a2 needs version 1: ${apply("schema.sql")}. ${SEE_DOCS}`);
-	if (listen && Number(row?.["notify_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("notifications.sql")}. ${SEE_DOCS}`);
+};
+/** 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}`);
 };
 //#endregion
 //#region src/postgres-notification-scope.ts
@@ -510,12 +546,26 @@ const sharePostgresListener = ({ key, create }) => acquire({
 *
 * Semantics mirror the sqlite backend: `index` is stored as `idx`,
 * timestamps are epoch milliseconds written from the injected clock —
-* never SQL `now()`. Streams poll by default; an optional direct
-* connection enables LISTEN/NOTIFY for events and presence. Appends serialize per session via
+* 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.
+* 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
@@ -523,50 +573,178 @@ const asNumber = (value) => Number(value);
 * 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;
-const toDate = (ms) => ms === null || ms === void 0 ? null : new Date(asNumber(ms));
-const toCause = (raw) => {
-	if (raw === null || raw === void 0) return null;
-	const value = typeof raw === "string" ? JSON.parse(raw) : raw;
-	if (!Number.isInteger(value.index) || Number(value.index) < 1 || !Number.isInteger(value.attempt) || Number(value.attempt) < 1) throw new TypeError("stored event has an invalid cause");
-	if (value.batchSize !== void 0 && (!Number.isInteger(value.batchSize) || Number(value.batchSize) < 1)) throw new TypeError("stored event has an invalid cause");
-	return {
-		index: Number(value.index),
-		attempt: Number(value.attempt),
-		...value.batchSize === void 0 ? {} : { batchSize: Number(value.batchSize) }
-	};
+/**
+* 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)`
 };
-const toStored = (row) => ({
+/** 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"])),
-	cause: toCause(row["cause"]),
+	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,
-	processedAt: toDate(row["processed_at"]),
-	processedByAttempt: row["processed_by_attempt"] === null || row["processed_by_attempt"] === void 0 ? null : asNumber(row["processed_by_attempt"]),
-	returnedEventIds: row["returned_event_ids"] === null || row["returned_event_ids"] === void 0 ? null : decodeReturnedEventIds(row["returned_event_ids"]),
 	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: row["last_failed_attempt"] === null || row["last_failed_attempt"] === void 0 ? null : asNumber(row["last_failed_attempt"]),
+	lastFailedAttempt: asNullableNumber(row["last_failed_attempt"]),
 	lastError: row["last_error"] ?? null,
-	failedAt: toDate(row["failed_at"]),
-	claimHolder: row["claim_holder"] ?? null,
-	claimExpiresAt: toDate(row["claim_expires_at"])
+	failedAt: toDate(row["failed_at"])
 });
-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 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();
@@ -600,10 +778,16 @@ const createListener = ({ pg, connectionString }) => postgresNotifications(async
 		}
 	};
 });
-/** A dead-lettered event's snapshot pins, and history no pin keeps. */
-const releasePins = async ({ query, sessionId, index }) => {
+/** 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`, [sessionId, index]);
+      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 (
@@ -613,6 +797,781 @@ const releasePins = async ({ query, sessionId, index }) => {
              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. When every event's id belongs to
+* this session already, the batch is a retry: it stops with the committed
+* rows. Some owned, or one in another session, 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.event_id = any(${param.texts("ids")})
+       and not (event.session_id = ${SESSION}
+                and event.idx < boundary.clear_index)
+  )
+  select case
+    when exists (select 1 from owned where session_id <> ${SESSION}) then
+      jsonb_build_object('abort', 'foreign', 'event_id', (
+        select event_id from owned where session_id <> ${SESSION}
+         order by idx limit 1))
+    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.event_id = any(${param.texts("ids")})
+         and not (event.session_id = ${SESSION}
+                  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(options = {}) {
 	const clock = options.clock ?? SYSTEM_CLOCK;
 	const generateId = options.ids ?? RANDOM_IDS;
@@ -639,30 +1598,23 @@ function postgres(options = {}) {
 				}
 			});
 		}
-		try {
-			const listen = Boolean(options.listenConnectionString);
-			const resource = lease.value;
-			await resource.initialize({
-				key: listen ? "schema+triggers" : "schema",
-				run: () => checkPostgresSchema({
-					client: resource.client,
-					listen
-				})
-			});
-			return lease;
-		} catch (error) {
-			if (!injected) await lease.release().catch(() => {});
-			throw error;
-		}
+		return {
+			lease,
+			client: explainingPostgresClient(lease.value.client)
+		};
 	});
 	const client = async () => {
 		if (closed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
-		const lease = await connection.get();
+		const { client: explaining } = await connection.get();
 		if (closed) throw new A2Error("STORE_UNAVAILABLE", "the store was closed");
-		return lease.value.client;
+		return explaining;
 	};
 	const notifications = options.listenConnectionString ? postgresNotificationScope(async () => {
-		await client();
+		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({
@@ -791,12 +1743,14 @@ function postgres(options = {}) {
 				conn.release();
 			}
 		}
-		const resource = (await connection.get()).value;
+		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));
+				const result = await fn((text, values) => raw.query(text, values).catch((error) => {
+					throw explainPostgresError(error);
+				}));
 				await raw.query("commit");
 				return result;
 			} catch (err) {
@@ -806,171 +1760,247 @@ function postgres(options = {}) {
 		});
 	};
 	/**
-	* The rows owning `ids`. This session's rows below its clear marker do
-	* not own their ids: they are deleted here so the ids can be reused.
+	* 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 liveOwnersOf = async ({ query, sessionId, clearIndex, ids }) => {
-		if (ids.length === 0) return [];
-		const { rows } = await query("select * from a2_events where event_id = any($1::text[]) order by idx", [ids]);
-		const stale = rows.filter((row) => row["session_id"] === sessionId && asNumber(row["idx"]) < clearIndex);
-		if (stale.length === 0) return rows;
-		const { rows: deleted } = await query(`with stale as materialized (
-         select idx from a2_events
-          where session_id = $1 and event_id = any($2::text[])
-          order by idx
-          for update skip locked
-       )
-       delete from a2_events event using stale
-        where event.session_id = $1 and event.idx = stale.idx
-        returning event.idx`, [sessionId, stale.map((row) => row["event_id"])]);
-		if (deleted.length < stale.length) throw new A2Error("STORE_UNAVAILABLE", `an event id being reused is still held by cleared work in session '${sessionId}'`);
-		return rows.filter((row) => !stale.includes(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"]);
 	};
-	/** Insert one event; its lane is ready unless an unfinished lane event of this lifetime precedes it. */
-	const insertEvent = async ({ query, row, clearIndex, returning = false }) => {
-		const { rows } = await query(`insert into a2_events
-         (session_id, idx, event_type, payload, event_id, created_at,
-          cause, lane, lane_ready, processed_at)
-       values (
-         $1, $2, $3, $4::jsonb, $5, $6, $7::jsonb, $8,
-         $8::text is null or not exists (
-           select 1 from a2_events
-            where session_id = $1 and lane = $8 and processed_at is null
-              and idx > $10
-         ),
-         $9
-       )${returning ? " returning *" : ""}`, [
-			row.sessionId,
-			row.index,
-			row.type,
-			jsonb(row.payload),
-			row.id,
-			row.createdAt,
-			row.cause ? jsonb(row.cause) : null,
-			row.lane,
-			row.processedAt,
-			clearIndex
+	/**
+	* 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
 		]);
-		return rows[0];
+		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 event_id = any($1::text[])`, [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 || row["session_id"] !== sessionId || 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 exists(
-               select 1 from a2_events
-               where session_id = $1 and processed_at is null
-                 and idx > ${clearIndexOf("$1")}
-             ) as has_pending`, [sessionId]);
+				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(() => withTx(async (query) => {
-				await query("select pg_advisory_xact_lock(hashtext($1))", [sessionId]);
-				const { rows: statusRows } = await query(`select coalesce(max(idx), 0) as max,
-                    ${clearIndexOf("$1")} as clear_index,
-                    exists(
-                      select 1 from a2_events pending
-                      where pending.session_id = $1
-                        and pending.processed_at is null
-                        and pending.idx > ${clearIndexOf("$1")}
-                    ) as session_has_pending
-               from a2_events
-              where session_id = $1`, [sessionId]);
-				const base = asNumber(statusRows[0]?.["max"]);
-				const clearIndex = asNumber(statusRows[0]?.["clear_index"]);
-				const sessionHasPending = statusRows[0]?.["session_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");
-				if (suppliedIds.length > 0) {
-					const existing = await liveOwnersOf({
-						query,
-						sessionId,
-						clearIndex,
-						ids: suppliedIds
-					});
-					if (existing.length > 0) {
-						const foreign = existing.find((row) => row["session_id"] !== sessionId);
-						if (foreign) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${String(foreign["event_id"])}' already exists in another session`);
-						if (existing.length === events.length) return {
-							events: idempotentReplay(events, existing.map(toStored)),
-							hasPending: sessionHasPending
-						};
-						throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`);
-					}
-				}
+				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;
-				if (originIndex !== void 0 && originIndex <= clearIndex) throw sessionClearedError(`scheduled work from event ${originIndex} was cleared in session '${sessionId}'`);
-				for (const e of events) if (e.cause && e.cause.index <= clearIndex) throw supersededAttemptError(sessionId, e.cause);
-				const causeIndexes = [...new Set(events.filter((e) => e.cause !== void 0).map((e) => e.cause.index))];
-				if (causeIndexes.length > 0) {
-					const { rows: parents } = await query(`select idx, attempt_count, failed_at from a2_events
-                where session_id = $1 and idx = any($2::bigint[])
-                for update`, [sessionId, causeIndexes]);
-					const byIndex = new Map(parents.map((row) => [asNumber(row["idx"]), row]));
-					for (const e of events) {
-						if (!e.cause) continue;
-						const parent = byIndex.get(e.cause.index);
-						if (!parent) throw new TypeError(`no event at index ${e.cause.index} in session '${sessionId}'`);
-						if (asNumber(parent["attempt_count"]) !== e.cause.attempt || parent["failed_at"] !== null) throw supersededAttemptError(sessionId, e.cause);
+				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 "foreign": return new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${String(reason["event_id"])}' already exists in another session`);
+							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");
+						}
 					}
-				}
-				const now = clock.now().getTime();
-				const inserted = [];
-				for (let i = 0; i < events.length; i += 1) {
-					const e = events[i];
-					const id = e.id ?? generateId();
-					const index = base + 1 + i;
-					await insertEvent({
-						query,
-						row: {
-							sessionId,
-							index,
-							type: e.type,
-							payload: e.payload,
-							id,
-							createdAt: now,
-							cause: e.cause ?? null,
-							lane: e.lane ?? null,
-							processedAt: e.settled ? now : null
-						},
-						clearIndex
-					});
-					inserted.push({
-						id,
-						type: e.type,
-						payload: structuredClone(e.payload),
-						index,
+				})).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,
-						createdAt: new Date(now),
-						cause: e.cause ? { ...e.cause } : null,
-						lane: e.lane ?? null,
-						processedAt: e.settled ? new Date(now) : null,
-						processedByAttempt: null,
-						returnedEventIds: null,
-						firstClaimedAt: null,
-						lastClaimedAt: null,
-						attemptCount: 0,
-						failureCount: 0,
-						lastFailedAt: null,
-						lastFailedAttempt: null,
-						lastError: null,
-						failedAt: null,
-						claimHolder: null,
-						claimExpiresAt: null
-					});
+						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 {
-					events: inserted,
-					hasPending: sessionHasPending || events.some((event) => event.settled !== true)
+					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 () => {
@@ -986,7 +2016,8 @@ function postgres(options = {}) {
 					conditions.push(`idx <= $${params.length}`);
 				}
 				conditions.push(`idx >= ${clearIndexOf("$1")}`);
-				const { rows } = await c.query(`select * from a2_events where ${conditions.join(" and ")} order by idx`, params);
+				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);
 			});
 		},
@@ -1010,79 +2041,57 @@ function postgres(options = {}) {
 				return rows.map(toEvent);
 			});
 		},
-		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes = [], maxFailures }) {
-			return wrap(() => withTx(async (query) => {
+		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, exclude = [], consumers, maxFailures, through }) {
+			return wrap(async () => {
 				const now = clock.now().getTime();
-				const expiresAt = expiresAtMs ?? now + ttlMs;
-				const exhausted = `(claimed.claim_holder is not null
-               and claimed.failure_count + 1 >= $6::int)`;
-				const { rows } = await query(`with eligible as materialized (
-               select event.idx
-                 from a2_events event
-                where event.session_id = $1
-                  and event.processed_at is null
-                  and event.failed_at is null
-                  and event.lane_ready
-                  and event.idx > ${clearIndexOf("$1")}
-                  and (event.claim_expires_at is null or event.claim_expires_at <= $2)
-                  and not (event.idx = any($5::bigint[]))
-                for update of event
-             )
-             update a2_events claimed set
-               attempt_count = claimed.attempt_count + 1,
-               failure_count = claimed.failure_count
-                 + case when claimed.claim_holder is null then 0 else 1 end,
-               failed_at = case when ${exhausted} then $2::bigint else claimed.failed_at end,
-               first_claimed_at = case when ${exhausted}
-                 then claimed.first_claimed_at
-                 else coalesce(claimed.first_claimed_at, $2::bigint) end,
-               last_claimed_at = case when ${exhausted}
-                 then claimed.last_claimed_at else $2::bigint end,
-               claim_holder = case when ${exhausted} then null else $3::text end,
-               claim_expires_at = case when ${exhausted} then null else $4::bigint end
-             from eligible
-             where claimed.session_id = $1 and claimed.idx = eligible.idx
-             returning claimed.*, ${clearIndexOf("$1")} as clear_index`, [
+				const results = await run({
 					sessionId,
-					now,
-					holder,
-					expiresAt,
-					[...excludeIndexes],
-					maxFailures ?? null
-				]);
-				for (const row of rows) if (row["failed_at"] !== null) await releasePins({
-					query,
-					sessionId,
-					index: asNumber(row["idx"])
+					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
+					}
 				});
-				if (rows.length > 0) return {
-					outcome: "claimed",
-					events: rows.map((row) => {
-						const stored = toStored(row);
+				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) stored.clearIndex = clearIndex;
-						return stored;
-					}).toSorted((a, b) => a.index - b.index)
-				};
-				const { rows: activeRows } = await query(`select min(claim_expires_at) as retry_at
-               from a2_events
-              where session_id = $1
-                and processed_at is null
-                and failed_at is null
-                and lane_ready
-                and idx > ${clearIndexOf("$1")}
-                and claim_expires_at > $2
-                and not (idx = any($3::bigint[]))`, [
-					sessionId,
-					now,
-					[...excludeIndexes]
-				]);
-				const retryAt = activeRows[0]?.["retry_at"];
+						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 {
@@ -1093,233 +2102,203 @@ function postgres(options = {}) {
 				const c = await client();
 				const now = clock.now().getTime();
 				const expiresAt = expiresAtMs ?? now + ttlMs;
-				const indexes = claims.map((claim) => claim.index);
-				const attempts = new Map(claims.map((claim) => [claim.index, claim.attempt]));
+				const ordered = claims.toSorted((a, b) => a.index - b.index || compareText(a.consumer, b.consumer));
 				const { rows } = await c.query(`with listed as (
-             select idx, attempt
-               from unnest($3::bigint[], $6::int[]) as listed(idx, attempt)
-           ),
-           renewed as (
-             update a2_events event set claim_expires_at = $1
+             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 event.session_id = $2
-                and event.idx = listed.idx
-                and event.idx > ${clearIndexOf("$2")}
-                and event.attempt_count = listed.attempt
-                and event.processed_at is null
-                and event.failed_at is null
-                and event.claim_holder = $4
-                and event.claim_expires_at > $5
-              returning event.idx
+              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.idx, event.attempt_count,
-                  exists(select 1 from renewed where renewed.idx = listed.idx)
-                    as renewed,
-                  listed.idx <= ${clearIndexOf("$2")} as cleared
+           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 a2_events event
-               on event.session_id = $2 and event.idx = listed.idx`, [
-					expiresAt,
+             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,
-					indexes,
 					holder,
-					now,
-					claims.map((claim) => claim.attempt)
+					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 index = asNumber(row["idx"]);
-					if (row["renewed"] === true) renewed.push(index);
-					else if (row["cleared"] === true || row["attempt_count"] !== null && asNumber(row["attempt_count"]) > (attempts.get(index) ?? 0)) superseded.push(index);
+					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: renewed.toSorted((a, b) => a - b),
-					superseded: superseded.toSorted((a, b) => a - b)
+					renewed,
+					superseded
 				};
 			});
 		},
-		async completeAttempt({ sessionId, index, attempt, events }) {
-			return wrap(() => withTx(async (query) => {
-				const { rows: parentRows } = await query(`select boundary.clear_index, parent.*
-               from (select ${clearIndexOf("$1")} as clear_index) boundary
-               left join lateral (
-                 select * from a2_events
-                  where session_id = $1 and idx = $2 and idx > boundary.clear_index
-                  for update
-               ) parent on true`, [sessionId, index]);
-				if (index <= asNumber(parentRows[0]?.["clear_index"])) return { outcome: "superseded" };
-				const parent = parentRows[0]?.["idx"] == null ? void 0 : parentRows[0];
-				if (!parent) {
-					if (await clearedAt({
-						query,
-						sessionId,
-						index
-					})) return { outcome: "superseded" };
-					throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
-				}
+		async completeAttempt({ sessionId, consumer, lane, index, attempt, events, consumers }) {
+			return wrap(async () => {
 				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 (parent["processed_at"] !== null) {
-					if (asNumber(parent["processed_by_attempt"]) !== attempt) return { outcome: "superseded" };
-					const returnedIds = parent["returned_event_ids"] === null || parent["returned_event_ids"] === void 0 ? null : decodeReturnedEventIds(parent["returned_event_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 * from a2_events
-                where event_id = any($1::text[])`, [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 { outcome: "superseded" };
-					if (ordered.some((row) => {
-						const cause = row ? toCause(row["cause"]) : null;
-						return !row || row["session_id"] !== sessionId || 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))
-					};
-				}
-				if (asNumber(parent["attempt_count"]) !== attempt || parent["claim_holder"] === null || parent["claim_holder"] === void 0 || parent["failed_at"] !== null) return { outcome: "superseded" };
-				await query("select pg_advisory_xact_lock(hashtext($1))", [sessionId]);
-				const { rows: maxRows } = await query(`select coalesce(max(idx), 0) as max, ${clearIndexOf("$1")} as clear_index
-               from a2_events where session_id = $1`, [sessionId]);
-				const clearIndex = asNumber(maxRows[0]?.["clear_index"]);
-				if (index <= clearIndex) return { outcome: "superseded" };
-				if (ids.length > 0) {
-					if ((await liveOwnersOf({
-						query,
-						sessionId,
-						clearIndex,
-						ids
-					})).length > 0) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains an already-appended event id");
-				}
-				const base = asNumber(maxRows[0]?.["max"]);
+				const duplicated = new Set(ids).size !== ids.length;
+				const cause = {
+					consumer,
+					lane,
+					index,
+					attempt
+				};
 				const now = clock.now().getTime();
-				const inserted = [];
-				for (let offset = 0; offset < events.length; offset += 1) {
-					const event = events[offset];
-					const childIndex = base + offset + 1;
-					const row = await insertEvent({
-						query,
-						row: {
-							sessionId,
-							index: childIndex,
-							type: event.type,
-							payload: event.payload,
-							id: event.id,
-							createdAt: now,
-							cause: {
-								index,
-								attempt
-							},
-							lane: event.lane ?? null,
-							processedAt: event.settled ? now : null
-						},
-						clearIndex,
-						returning: true
+				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
 					});
-					inserted.push(toStored(row));
 				}
-				await query(`update a2_events set
-               processed_at = $1,
-               processed_by_attempt = $2,
-               returned_event_ids = $5::jsonb,
-               lane_ready = false,
-               claim_holder = null,
-               claim_expires_at = null
-             where session_id = $3 and idx = $4`, [
-					now,
-					attempt,
-					sessionId,
-					index,
-					jsonb(ids)
-				]);
-				await query(`delete from a2_snapshot_pins
-              where session_id = $1 and event_index = $2`, [sessionId, index]);
-				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 parentLane = parent["lane"] ?? null;
-				if (parentLane !== null) await query(`update a2_events set lane_ready = true
-                where session_id = $1
-                  and idx = (
-                    select idx from a2_events
-                     where session_id = $1 and lane = $2 and processed_at is null
-                       and idx > $3
-                     order by idx limit 1
-                  )`, [
-					sessionId,
-					parentLane,
-					clearIndex
-				]);
+				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: inserted
+					events: checked ? insertedRows({
+						sessionId,
+						events: rows,
+						base: asNumber(checked["base"]),
+						now
+					}) : []
 				};
-			}));
+			});
 		},
-		async failAttempt({ sessionId, index, attempt, error, maxFailures, retryAfterMs }) {
-			const now = clock.now().getTime();
+		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 e.* from a2_events e
-             where e.session_id = $1 and e.idx = $2
-               and e.idx > ${clearIndexOf("$1")}
-             for update of e
+             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_events e set
-               failure_count = e.failure_count + 1,
-               last_error = $4,
-               last_failed_at = $6,
-               last_failed_attempt = $3,
+             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 e.failure_count + 1 >= $5 then $6
-                 else e.failed_at
+                 when cur.failure_count + 1 >= $7 then $8
+                 else cur.failed_at
                end,
                claim_holder = null,
                claim_expires_at = case
-                 when e.failure_count + 1 >= $5 then null
-                 else $7::bigint
+                 when cur.failure_count + 1 >= $7 then null
+                 else $9::bigint
                end
              from current
-             where e.session_id = $1
-               and e.idx = $2
-               and current.processed_at is null
+             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.attempt_count = $3
                and current.claim_holder is not null
-             returning e.failure_count, e.failed_at
+             returning cur.failure_count, cur.failed_at
            )
            select case
-             when $2 <= ${clearIndexOf("$1")} then 'cleared'
+             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 processed_at is not null or attempt_count <> $3
+               select 1 from current where attempt_count <> $5
              ) then 'superseded'
-             when exists (
-               select 1 from current where failed_at is not null
-             ) then 'dead_lettered'
              when exists (
                select 1 from current
-                where claim_holder is null and last_failed_attempt = $3
+                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(
@@ -1327,6 +2306,8 @@ function postgres(options = {}) {
              (select failure_count from current)
            ) as failure_count`, [
 					sessionId,
+					cursorKey,
+					consumer,
 					index,
 					attempt,
 					error,
@@ -1340,7 +2321,13 @@ function postgres(options = {}) {
 					failureCount: 0
 				};
 				if (!row || row["outcome"] === "missing") {
-					if (await clearedAt({
+					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
@@ -1353,6 +2340,8 @@ function postgres(options = {}) {
 				if (row["outcome"] === "dead_lettered") await releasePins({
 					query,
 					sessionId,
+					consumer,
+					cursorKey,
 					index
 				});
 				return {
@@ -1363,54 +2352,39 @@ function postgres(options = {}) {
 		},
 		async deadLetters(sessionId) {
 			return wrap(async () => {
-				const { rows } = await (await client()).query(`select * from a2_events
-            where session_id = $1
-              and processed_at is null
-              and failed_at is not null
-              and idx > ${clearIndexOf("$1")}
-            order by idx`, [sessionId]);
-				return rows.map(toStored);
+				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, index, action }) {
-			return wrap(() => withTx(async (query) => {
-				if (action === "skip") await query("select pg_advisory_xact_lock(hashtext($1))", [sessionId]);
-				const { rows } = await query(`select lane from a2_events
-              where session_id = $1 and idx = $2
-                and idx > ${clearIndexOf("$1")}
-                and processed_at is null
-                and failed_at is not null
-              for update`, [sessionId, index]);
-				const row = rows[0];
-				if (row && action === "retry") await query(`update a2_events set failed_at = null, failure_count = 0
-                where session_id = $1 and idx = $2`, [sessionId, index]);
-				else if (row) {
-					await query(`update a2_events set processed_at = $3, lane_ready = false
-                where session_id = $1 and idx = $2`, [
-						sessionId,
+		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,
-						clock.now().getTime()
-					]);
-					const lane = row["lane"] ?? null;
-					if (lane !== null) await query(`update a2_events set lane_ready = true
-                  where session_id = $1
-                    and idx = (
-                      select idx from a2_events
-                       where session_id = $1 and lane = $2 and processed_at is null
-                         and idx > ${clearIndexOf("$1")}
-                       order by idx limit 1
-                    )`, [sessionId, lane]);
-				}
-				const { rows: status } = await query(`select exists(
-               select 1 from a2_events
-               where session_id = $1 and processed_at is null
-                 and idx > ${clearIndexOf("$1")}
-             ) as has_pending`, [sessionId]);
+						served: servedNames(consumers),
+						clearType: CLEAR_EVENT_TYPE
+					}
+				});
 				return {
-					redriven: row !== void 0,
-					hasPending: status[0]?.["has_pending"] === true
+					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([{
@@ -1438,25 +2412,41 @@ function postgres(options = {}) {
 				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.pinEventIndexes ?? []).map((eventIndex) => ({
-					eventIndex,
+				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 { rows: events } = await query(`select idx, processed_at, failed_at from a2_events
-                where session_id = $1 and idx = any($2::bigint[]) and idx > $3
-                for update`, [
+					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,
-						[...new Set(requestedPins.map((pin) => pin.eventIndex))],
+						heads.map((pin) => pin.consumer),
+						heads.map((pin) => pin.cursorKey),
+						heads.map((pin) => pin.eventIndex),
 						clearIndex
 					]);
-					const unfinished = new Set(events.filter((row) => row["processed_at"] === null && row["failed_at"] === null).map((row) => asNumber(row["idx"])));
-					const accepted = requestedPins.filter((pin) => unfinished.has(pin.eventIndex));
+					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, reducer_name, up_to_index)
-                 select $1, pin."eventIndex", $2, pin."snapshotIndex"
+                   (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`, [
@@ -1627,21 +2617,19 @@ function postgres(options = {}) {
 		},
 		async clear({ sessionId, ifLastIndex, cause }) {
 			return wrap(() => withTx(async (query) => {
-				await query("select pg_advisory_xact_lock(hashtext($1))", [sessionId]);
+				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) {
-					if (cause.index <= clearIndex) throw supersededAttemptError(sessionId, cause);
-					const { rows: parents } = await query(`select attempt_count, failed_at from a2_events
-                where session_id = $1 and idx = $2
-                for update`, [sessionId, cause.index]);
-					const parent = parents[0];
-					if (!parent) throw new TypeError(`no event at index ${cause.index} in session '${sessionId}'`);
-					if (asNumber(parent["attempt_count"]) !== cause.attempt || parent["failed_at"] !== null) throw supersededAttemptError(sessionId, cause);
-				}
+				if (cause) await assertCurrentCause({
+					query,
+					sessionId,
+					cause,
+					clearIndex,
+					lock: "update"
+				});
 				if (ifLastIndex !== void 0 && clearIndex === ifLastIndex + 1) return {
 					cleared: true,
 					index: head,
@@ -1658,31 +2646,27 @@ function postgres(options = {}) {
 					clearIndex
 				};
 				const marker = head + 1;
-				const now = clock.now().getTime();
-				await insertEvent({
-					query,
-					row: {
-						sessionId,
-						index: marker,
-						type: CLEAR_EVENT_TYPE,
-						payload: null,
-						id: generateId(),
-						createdAt: now,
-						cause: null,
-						lane: null,
-						processedAt: now
-					},
-					clearIndex
-				});
+				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_events
-                  set lane_ready = false, claim_holder = null, claim_expires_at = null
-                where session_id = $1 and idx = $3
+               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 {
@@ -1710,6 +2694,26 @@ function postgres(options = {}) {
              ), 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]);
@@ -1719,16 +2723,20 @@ function postgres(options = {}) {
 					deleted: 0,
 					done: true
 				};
-				if (deleted > 0) return {
-					deleted,
-					done: false
-				};
 				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: 0,
+					deleted,
 					done: false
 				};
-				const { rows: swept } = await query(`with pins as materialized (
+				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
@@ -1740,6 +2748,12 @@ function postgres(options = {}) {
                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 (
@@ -1748,17 +2762,23 @@ function postgres(options = {}) {
              ), gone_heads as (
                delete from a2_snapshots target using heads where target.ctid = heads.ctid
              )
-             select (select count(*) from a2_snapshot_pins
+             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: 0,
+					deleted,
 					done: asNumber(swept[0]?.["skipped"]) === 0
 				};
 			}));
@@ -1769,8 +2789,8 @@ function postgres(options = {}) {
 			for (const subscription of presenceSubscriptions.values()) subscription.stop();
 			presenceSubscriptions.clear();
 			await notifications?.close();
-			const lease = await connection.peek()?.catch(() => void 0);
-			await (injected ?? lease)?.release();
+			const opened = await connection.peek()?.catch(() => void 0);
+			await (injected ?? opened?.lease)?.release();
 		}
 	};
 	if (notifications) {