@vercel/board 0.16.0 → 0.17.0

package/dist/store-sqlite-CxxPCcCT.mjs

@@ -0,0 +1,1053 @@
+import { n as CLEAR_EVENT_TYPE, o as sessionClearedError, s as supersededAttemptError, t as A2Error } from "./session-clear-wHd5GCpZ-BnKSxReK.mjs";
+import { r as pollingStream } from "./store-polling-BZt2Rf3D-BiEM6_HB.mjs";
+import { a as idleLogCursor, i as idempotentReplay, n as decodeCause, r as decodeReturnedEventIds, t as cursorKeyOf } from "./store-codec-DwrWlgQx-CYxGW0aD.mjs";
+import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS-BWBgzBHp.mjs";
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/store-sqlite.js
+/**
+* experimental-a2/store-sqlite — sqlite store backend (the dev default, `.a2/dev.db`).
+*
+* Built on `node:sqlite` (Node ≥ 22.13) so it ships with zero
+* dependencies. Implements the A2Store interface; the conformance suite
+* in test/conformance is the executable contract.
+*
+* The spec's `index` column is stored as `idx` (a2-implementation.md
+* §11 — `index` collides with a reserved word) and mapped back at the
+* API boundary. Timestamps are epoch milliseconds written from the
+* injected clock — never SQL `now()` — so tests can time-travel against
+* real storage.
+*/
+/** The cursor layout; databases from before it are rejected, not migrated. */
+const LAYOUT = "cursors-1";
+const SCHEMA = `
+create table if not exists a2_meta (
+  key   text not null primary key,
+  value text not null
+) strict;
+
+create table if not exists a2_events (
+  session_id   text    not null,
+  idx          integer not null,
+  event_type   text    not null,
+  payload      text    not null,
+  event_id     text    not null,
+  created_at   integer not null,
+  cause        text,
+  primary key (session_id, idx)
+) strict;
+
+create unique index if not exists a2_events_session_event_id
+  on a2_events (session_id, event_id);
+drop index if exists a2_events_event_id;
+create index if not exists a2_events_types on a2_events (session_id, event_type, idx);
+
+create table if not exists a2_cursors (
+  session_id   text    not null,
+  consumer     text    not null,
+  cursor_key   text    not null,
+  lane         text,
+  kind         text    not null,
+  position     integer not null,
+  head         integer,
+  types        text,
+  attempt_count integer not null default 0,
+  first_claimed_at integer,
+  last_claimed_at integer,
+  claim_holder text,
+  claim_expires_at integer,
+  failure_count integer not null default 0,
+  last_failed_at integer,
+  last_failed_attempt integer,
+  last_error   text,
+  failed_at    integer,
+  completed_idx integer,
+  completed_attempt integer,
+  returned_event_ids text,
+  primary key (session_id, consumer, cursor_key)
+) strict;
+
+create index if not exists a2_cursors_heads
+  on a2_cursors (session_id, head) where head is not null;
+
+create table if not exists a2_lane_events (
+  session_id   text    not null,
+  consumer     text    not null,
+  lane         text    not null,
+  idx          integer not null,
+  done         integer not null default 0,
+  completed_attempt integer,
+  returned_event_ids text,
+  primary key (session_id, consumer, lane, idx)
+) strict;
+
+create table if not exists a2_snapshots (
+  session_id   text    not null,
+  reducer_name text    not null,
+  up_to_index  integer not null,
+  state        text    not null,
+  updated_at   integer not null,
+  primary key (session_id, reducer_name)
+) strict;
+
+create table if not exists a2_snapshot_history (
+  session_id   text    not null,
+  reducer_name text    not null,
+  up_to_index  integer not null,
+  state        text    not null,
+  updated_at   integer not null,
+  primary key (session_id, reducer_name, up_to_index)
+) strict;
+
+create table if not exists a2_snapshot_pins (
+  session_id   text    not null,
+  consumer     text    not null,
+  cursor_key   text    not null,
+  event_index  integer not null,
+  reducer_name text    not null,
+  up_to_index  integer not null,
+  primary key (session_id, consumer, cursor_key, event_index, reducer_name, up_to_index)
+) strict;
+
+create index if not exists a2_snapshot_pins_checkpoint
+  on a2_snapshot_pins (session_id, reducer_name, up_to_index);
+
+create table if not exists a2_clears (
+  session_id  text    not null primary key,
+  clear_index integer not null
+) strict;
+
+create table if not exists a2_presence (
+  ns          text    not null,
+  participant text    not null,
+  field       text    not null,
+  value       text    not null,
+  seen        integer not null,
+  at          integer not null,
+  expires_at  integer not null,
+  primary key (ns, participant, field)
+) strict;
+`;
+/**
+* Switching journal modes takes an exclusive lock, and — unlike normal
+* statements — the switch can return SQLITE_BUSY without consulting the
+* busy handler while several connections race it (instances cold-booting
+* against one file). Bounded synchronous retry; the window is boot-only
+* and tiny. Found by the multi-process torture test.
+*/
+const setWalJournalMode = (db) => {
+	for (let attempt = 0;; attempt += 1) try {
+		db.exec("pragma journal_mode = wal");
+		return;
+	} catch (err) {
+		if (!(err.errcode === 5) || attempt >= 100) throw err;
+		Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+	}
+};
+const wrap = (fn) => {
+	try {
+		return fn();
+	} catch (err) {
+		if (err instanceof A2Error || err instanceof TypeError) throw err;
+		throw new A2Error("STORE_UNAVAILABLE", "sqlite store operation failed", { cause: err });
+	}
+};
+const toDate = (ms) => ms === null ? null : new Date(Number(ms));
+const toNumber = (value) => value === null ? null : Number(value);
+const toStored = (row) => ({
+	id: row.event_id,
+	type: row.event_type,
+	payload: JSON.parse(row.payload),
+	index: Number(row.idx),
+	sessionId: row.session_id,
+	createdAt: new Date(Number(row.created_at)),
+	cause: decodeCause(row.cause)
+});
+const toEvent = (row) => ({
+	id: row.event_id,
+	type: row.event_type,
+	payload: JSON.parse(row.payload),
+	index: Number(row.idx),
+	sessionId: row.session_id,
+	createdAt: new Date(Number(row.created_at))
+});
+const toCursor = (row) => ({
+	consumer: row.consumer,
+	lane: row.lane,
+	position: Number(row.position),
+	head: toNumber(row.head),
+	firstClaimedAt: toDate(row.first_claimed_at),
+	lastClaimedAt: toDate(row.last_claimed_at),
+	attemptCount: Number(row.attempt_count),
+	claimHolder: row.claim_holder,
+	claimExpiresAt: toDate(row.claim_expires_at),
+	failureCount: Number(row.failure_count),
+	lastFailedAt: toDate(row.last_failed_at),
+	lastFailedAttempt: toNumber(row.last_failed_attempt),
+	lastError: row.last_error,
+	failedAt: toDate(row.failed_at)
+});
+const toHead = (row) => {
+	const { position: _position, head: _head, ...dispatch } = toCursor(row);
+	return {
+		...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
+		}),
+		...dispatch
+	};
+};
+const RECLAIM_BATCH = 256;
+/** The head columns every claim, dead letter, and listing joins in. */
+const HEAD_SELECT = `
+  select cursor.*,
+         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
+    from a2_cursors cursor
+    join a2_events event
+      on event.session_id = cursor.session_id and event.idx = cursor.head`;
+/** 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`;
+const placeholders = (count) => Array.from({ length: count }, () => "?").join(", ");
+const compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function sqlite(options = {}) {
+	const path = options.path ?? ".a2/dev.db";
+	const clock = options.clock ?? SYSTEM_CLOCK;
+	const generateId = options.ids ?? RANDOM_IDS;
+	if (path !== ":memory:") mkdirSync(dirname(resolve(
+		/* turbopackIgnore: true */
+		path
+	)), { recursive: true });
+	const db = new DatabaseSync(path);
+	db.exec("pragma busy_timeout = 5000");
+	setWalJournalMode(db);
+	db.exec("pragma synchronous = normal");
+	if (db.prepare("select 1 from pragma_table_info('a2_events') where name = ?").get("processed_at")) {
+		db.close();
+		throw new A2Error("STORE_NOT_CONFIGURED", `the sqlite database at '${path}' has the A2 layout from before consumers; delete it, or point the store at a fresh database file`);
+	}
+	db.exec(SCHEMA);
+	db.prepare("insert into a2_meta (key, value) values ('layout', ?) on conflict (key) do nothing").run(LAYOUT);
+	const insertEvent = db.prepare(`insert into a2_events
+       (session_id, idx, event_type, payload, event_id, created_at, cause)
+     values (?, ?, ?, ?, ?, ?, ?)`);
+	const selectHead = db.prepare("select coalesce(max(idx), 0) as max from a2_events where session_id = ?");
+	const headOf = (sessionId) => Number(selectHead.get(sessionId).max);
+	const selectEvent = db.prepare("select 1 from a2_events where session_id = ? and idx = ?");
+	const selectCursor = db.prepare("select * from a2_cursors where session_id = ? and consumer = ? and cursor_key = ?");
+	const cursorOf = (sessionId, ref) => selectCursor.get(sessionId, ref.consumer, cursorKeyOf(ref.lane, ref.index));
+	const insertEventCursor = db.prepare(`insert into a2_cursors
+       (session_id, consumer, cursor_key, lane, kind, position, head)
+     values (?, ?, ?, null, 'event', ?, ?)`);
+	const insertLaneEvent = db.prepare(`insert into a2_lane_events (session_id, consumer, lane, idx)
+     values (?, ?, ?, ?)`);
+	const queueLaneHead = db.prepare(`insert into a2_cursors
+       (session_id, consumer, cursor_key, lane, kind, position, head)
+     values (?, ?, ?, ?, 'lane', ?, ?)
+     on conflict (session_id, consumer, cursor_key) do update set
+       head = excluded.head,
+       position = max(a2_cursors.position, excluded.position),
+       ${FRESH_DISPATCH}
+     where a2_cursors.head is null or a2_cursors.head <= excluded.position`);
+	const openLogCursor = db.prepare(`insert into a2_cursors
+       (session_id, consumer, cursor_key, lane, kind, position, head, types)
+     values (?, ?, ?, ?, 'log', ?, ?, ?)`);
+	const wakeLogCursor = db.prepare(`update a2_cursors set types = ?, head = ?
+      where session_id = ? and consumer = ? and cursor_key = ?`);
+	const refreshTypes = db.prepare(`update a2_cursors set types = ?
+      where session_id = ? and consumer = ? and kind = 'log'
+        and types is not ?`);
+	const nextLogHeadAll = db.prepare(`select min(idx) as next from a2_events
+      where session_id = ? and idx > ? and event_type != ?`);
+	const nextLogHeadOf = db.prepare(`select min(idx) as next from a2_events
+      where session_id = ? and idx > ? and event_type != ?
+        and event_type in (select value from json_each(?))`);
+	const nextLogHead = (sessionId, after, types) => toNumber((types === null ? nextLogHeadAll.get(sessionId, after, CLEAR_EVENT_TYPE) : nextLogHeadOf.get(sessionId, after, CLEAR_EVENT_TYPE, types)).next);
+	const nextLaneHead = db.prepare(`select min(idx) as next from a2_lane_events
+      where session_id = ? and consumer = ? and lane = ? and done = 0
+        and idx > ?`);
+	const selectLaneEvent = db.prepare(`select completed_attempt, returned_event_ids from a2_lane_events
+      where session_id = ? and consumer = ? and lane = ? and idx = ?`);
+	const finishLaneEvent = db.prepare(`update a2_lane_events
+        set done = 1, completed_attempt = ?, returned_event_ids = ?
+      where session_id = ? and consumer = ? and lane = ? and idx = ?`);
+	const moveCursor = db.prepare(`update a2_cursors set position = ?, head = ?, ${FRESH_DISPATCH}
+      where session_id = ? and consumer = ? and cursor_key = ?`);
+	const recordCompletion = db.prepare(`update a2_cursors
+        set completed_idx = ?, completed_attempt = ?, returned_event_ids = ?
+      where session_id = ? and consumer = ? and cursor_key = ?`);
+	const upsertPresence = db.prepare(`insert into a2_presence (ns, participant, field, value, seen, at, expires_at)
+     values (?, ?, ?, ?, ?, ?, ?)
+     on conflict (ns, participant, field) do update set
+       value = excluded.value,
+       seen = excluded.seen,
+       at = excluded.at,
+       expires_at = excluded.expires_at
+     where a2_presence.at <= excluded.at or a2_presence.expires_at <= ?`);
+	const sweepPresence = db.prepare("delete from a2_presence where ns = ? and expires_at <= ?");
+	const selectPresence = db.prepare(`select participant, field, value, seen, at, expires_at
+       from a2_presence
+      where ns = ? and expires_at > ? and value != 'null'
+      order by participant, field`);
+	const selectByIds = (count) => db.prepare(`select * from a2_events
+        where session_id = ? and event_id in (${placeholders(count)})
+        order by idx`);
+	const selectClearIndex = db.prepare("select clear_index from a2_clears where session_id = ?");
+	const clearIndexOf = (sessionId) => Number(selectClearIndex.get(sessionId)?.clear_index ?? 0);
+	const deleteEventById = db.prepare("delete from a2_events where session_id = ? and event_id = ?");
+	/** Served consumers as a SQL condition on `cursor.consumer`. */
+	const servedClause = (consumers) => consumers === void 0 ? {
+		sql: "",
+		params: []
+	} : consumers.length === 0 ? {
+		sql: "and 0",
+		params: []
+	} : {
+		sql: `and cursor.consumer in (${placeholders(consumers.length)})`,
+		params: consumers.map((consumer) => consumer.name)
+	};
+	const hasPending = (sessionId, clearIndex, consumers) => {
+		const served = servedClause(consumers);
+		return db.prepare(`select 1 from a2_cursors cursor
+            where cursor.session_id = ? and cursor.head > ?
+              and cursor.failed_at is null ${served.sql}
+            limit 1`).get(sessionId, clearIndex, ...served.params) !== void 0;
+	};
+	/**
+	* The session's rows owning `ids`. Rows below its clear marker do not
+	* own their ids: they are deleted here so the ids can be reused.
+	*/
+	const liveOwnersOf = (sessionId, clearIndex, ids) => {
+		if (ids.length === 0) return [];
+		return selectByIds(ids.length).all(sessionId, ...ids).filter((row) => {
+			if (Number(row.idx) >= clearIndex) return true;
+			deleteEventById.run(sessionId, row.event_id);
+			return false;
+		});
+	};
+	/** The attempt-currency fence shared by consumer appends and clears. */
+	const assertCurrentCause = ({ sessionId, cause, clearIndex }) => {
+		if (cause.index <= clearIndex) throw supersededAttemptError(sessionId, cause);
+		const cursor = cursorOf(sessionId, cause);
+		if (!cursor || toNumber(cursor.head) !== cause.index || Number(cursor.attempt_count) !== cause.attempt || cursor.failed_at !== null) throw supersededAttemptError(sessionId, cause);
+	};
+	const tx = (fn) => {
+		db.exec("begin immediate");
+		try {
+			const result = fn();
+			db.exec("commit");
+			return result;
+		} catch (err) {
+			try {
+				db.exec("rollback");
+			} catch {}
+			throw err;
+		}
+	};
+	/** A finished or dead head's snapshot pins, and history no pin keeps. */
+	const releasePins = (sessionId, consumer, cursorKey, index) => {
+		db.prepare(`delete from a2_snapshot_pins
+        where session_id = ? and consumer = ? and cursor_key = ? and event_index = ?`).run(sessionId, consumer, cursorKey, index);
+		db.prepare(`delete from a2_snapshot_history
+        where session_id = ?
+          and not exists (
+            select 1 from a2_snapshot_pins pin
+             where pin.session_id = a2_snapshot_history.session_id
+               and pin.reducer_name = a2_snapshot_history.reducer_name
+               and pin.up_to_index = a2_snapshot_history.up_to_index
+          )`).run(sessionId);
+	};
+	/** Moves a cursor past its head; the next head starts fresh. */
+	const advance = (sessionId, cursor) => {
+		const done = Number(cursor.head);
+		releasePins(sessionId, cursor.consumer, cursor.cursor_key, done);
+		let next;
+		if (cursor.kind === "event") next = null;
+		else if (cursor.kind === "lane") next = toNumber(nextLaneHead.get(sessionId, cursor.consumer, cursor.lane, Math.max(done, clearIndexOf(sessionId))).next);
+		else {
+			const { types } = selectCursor.get(sessionId, cursor.consumer, cursor.cursor_key);
+			next = nextLogHead(sessionId, done, types);
+		}
+		moveCursor.run(done, next, sessionId, cursor.consumer, cursor.cursor_key);
+	};
+	/**
+	* Brings a log consumer's cursor up to date and records its types. A
+	* missing cursor opens at the clear marker with `backfill`, otherwise at
+	* `base`; an idle one takes the next event of its types after its
+	* position; one with a head keeps it, claim and all. Returns its key.
+	*/
+	const wakeLogAt = ({ sessionId, consumer, log, base, clearIndex }) => {
+		const types = log.types === null ? null : JSON.stringify(log.types);
+		const key = cursorKeyOf(log.lane, 0);
+		const existing = selectCursor.get(sessionId, consumer, key);
+		if (existing) {
+			wakeLogCursor.run(types, existing.head === null ? nextLogHead(sessionId, Number(existing.position), types) : Number(existing.head), sessionId, consumer, key);
+			return key;
+		}
+		const position = log.backfill ? clearIndex : base;
+		openLogCursor.run(sessionId, consumer, key, log.lane, position, nextLogHead(sessionId, position, types), types);
+		return key;
+	};
+	/** Starts the cursor work an inserted batch carries. */
+	const enqueue = ({ sessionId, events, base, clearIndex, consumers }) => {
+		events.forEach((event, offset) => {
+			const index = base + 1 + offset;
+			for (const target of event.targets ?? []) {
+				if (target.lane === null) {
+					insertEventCursor.run(sessionId, target.consumer, cursorKeyOf(null, index), index - 1, index);
+					continue;
+				}
+				insertLaneEvent.run(sessionId, target.consumer, target.lane, index);
+				queueLaneHead.run(sessionId, target.consumer, cursorKeyOf(target.lane, index), target.lane, clearIndex, index);
+			}
+		});
+		for (const consumer of consumers ?? []) {
+			const log = consumer.log;
+			if (!log) continue;
+			if (!events.some((event) => event.type !== "a2.cleared" && (log.types === null || log.types.includes(event.type)))) continue;
+			wakeLogAt({
+				sessionId,
+				consumer: consumer.name,
+				log,
+				base,
+				clearIndex
+			});
+		}
+	};
+	const refreshLogTypes = (sessionId, consumers) => {
+		for (const consumer of consumers ?? []) {
+			if (!consumer.log) continue;
+			const types = consumer.log.types === null ? null : JSON.stringify(consumer.log.types);
+			refreshTypes.run(types, sessionId, consumer.name, types);
+		}
+	};
+	const insertBatch = ({ sessionId, events, clearIndex, consumers, cause }) => {
+		const base = headOf(sessionId);
+		const now = clock.now().getTime();
+		const inserted = events.map((event, offset) => {
+			const id = event.id ?? generateId();
+			const index = base + 1 + offset;
+			const eventCause = cause ?? event.cause ?? null;
+			insertEvent.run(sessionId, index, event.type, JSON.stringify(event.payload) ?? "null", id, now, eventCause ? JSON.stringify(eventCause) : null);
+			return {
+				id,
+				type: event.type,
+				payload: structuredClone(event.payload),
+				index,
+				sessionId,
+				createdAt: new Date(now),
+				cause: eventCause ? { ...eventCause } : null
+			};
+		});
+		enqueue({
+			sessionId,
+			events,
+			base,
+			clearIndex,
+			consumers
+		});
+		return inserted;
+	};
+	return {
+		async append(sessionId, events, appendOptions) {
+			const consumers = appendOptions?.consumers;
+			if (events.length === 0) return wrap(() => ({
+				events: [],
+				hasPending: hasPending(sessionId, clearIndexOf(sessionId), consumers)
+			}));
+			return wrap(() => tx(() => {
+				const clearIndex = clearIndexOf(sessionId);
+				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 = liveOwnersOf(sessionId, clearIndex, suppliedIds);
+					if (existing.length > 0) {
+						if (existing.length === events.length) return {
+							events: idempotentReplay(events, existing.map(toStored)),
+							hasPending: hasPending(sessionId, clearIndex, consumers)
+						};
+						throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`);
+					}
+				}
+				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) assertCurrentCause({
+					sessionId,
+					cause: e.cause,
+					clearIndex
+				});
+				return {
+					events: insertBatch({
+						sessionId,
+						events,
+						clearIndex,
+						consumers
+					}),
+					hasPending: hasPending(sessionId, clearIndex, consumers)
+				};
+			}));
+		},
+		async wakeLog({ sessionId, consumer }) {
+			return wrap(() => {
+				const { lane } = consumer.log;
+				const marker = clearIndexOf(sessionId);
+				if (headOf(sessionId) === marker && !selectCursor.get(sessionId, consumer.name, cursorKeyOf(lane, 0))) return {
+					cursor: idleLogCursor(consumer.name, lane, marker),
+					head: marker
+				};
+				return tx(() => {
+					const head = headOf(sessionId);
+					const key = wakeLogAt({
+						sessionId,
+						consumer: consumer.name,
+						log: consumer.log,
+						base: head,
+						clearIndex: clearIndexOf(sessionId)
+					});
+					const cursor = selectCursor.get(sessionId, consumer.name, key);
+					return {
+						cursor: toCursor(cursor),
+						head
+					};
+				});
+			});
+		},
+		async cursors(sessionId) {
+			return wrap(() => {
+				const clearIndex = clearIndexOf(sessionId);
+				return db.prepare(`select * from a2_cursors
+              where session_id = ?
+                and (
+                  kind = 'log'
+                  or head > ?
+                  or (kind = 'lane' and head is null and position > ?)
+                )
+              order by consumer, lane is null, lane, head`).all(sessionId, clearIndex, clearIndex).map(toCursor);
+			});
+		},
+		async read(sessionId, opts) {
+			return wrap(() => {
+				const conditions = ["session_id = ?", "idx >= coalesce((select clear_index from a2_clears where session_id = ?), 0)"];
+				const params = [sessionId, sessionId];
+				if (opts?.afterIndex !== void 0) {
+					conditions.push("idx > ?");
+					params.push(opts.afterIndex);
+				}
+				if (opts?.throughIndex !== void 0) {
+					conditions.push("idx <= ?");
+					params.push(opts.throughIndex);
+				}
+				return db.prepare(`select * from a2_events where ${conditions.join(" and ")} order by idx`).all(...params).map(toStored);
+			});
+		},
+		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, exclude = [], consumers, maxFailures, through }) {
+			return wrap(() => tx(() => {
+				refreshLogTypes(sessionId, consumers);
+				const now = clock.now().getTime();
+				const expiresAt = expiresAtMs ?? now + ttlMs;
+				const clearIndex = clearIndexOf(sessionId);
+				const served = servedClause(consumers);
+				const excludedKeys = exclude.map((ref) => `${ref.consumer}\u0000${cursorKeyOf(ref.lane, ref.index)}`);
+				const exclusion = excludedKeys.length === 0 ? "" : `and cursor.consumer || char(0) || cursor.cursor_key
+                     not in (${placeholders(excludedKeys.length)})`;
+				const filter = `
+            where cursor.session_id = ?
+              and cursor.head > ?
+              and cursor.failed_at is null
+              ${through === void 0 ? "" : "and cursor.head <= ?"}
+              ${served.sql}
+              ${exclusion}`;
+				const params = [
+					sessionId,
+					clearIndex,
+					...through === void 0 ? [] : [through],
+					...served.params,
+					...excludedKeys,
+					now
+				];
+				const eligible = db.prepare(`select cursor.consumer, cursor.cursor_key,
+                      cursor.claim_holder, cursor.failure_count
+                 from a2_cursors cursor
+                ${filter}
+                  and (cursor.claim_expires_at is null
+                       or cursor.claim_expires_at <= ?)
+                order by cursor.head, cursor.consumer`).all(...params);
+				if (eligible.length > 0) {
+					const claimHead = db.prepare(`update a2_cursors set
+                 attempt_count = attempt_count + 1,
+                 failure_count = failure_count
+                   + case when claim_holder is null then 0 else 1 end,
+                 first_claimed_at = coalesce(first_claimed_at, ?),
+                 last_claimed_at = ?,
+                 claim_holder = ?,
+                 claim_expires_at = ?
+               where session_id = ? and consumer = ? and cursor_key = ?`);
+					const deadLetterHead = db.prepare(`update a2_cursors set
+                 attempt_count = attempt_count + 1,
+                 failure_count = failure_count + 1,
+                 failed_at = ?,
+                 claim_holder = null,
+                 claim_expires_at = null
+               where session_id = ? and consumer = ? and cursor_key = ?`);
+					const selectHeadRow = db.prepare(`${HEAD_SELECT}
+                where cursor.session_id = ? and cursor.consumer = ?
+                  and cursor.cursor_key = ?`);
+					return {
+						outcome: "claimed",
+						events: eligible.map((row) => {
+							const exhausted = row.claim_holder !== null && maxFailures !== void 0 && Number(row.failure_count) + 1 >= maxFailures;
+							if (exhausted) deadLetterHead.run(now, sessionId, row.consumer, row.cursor_key);
+							else claimHead.run(now, now, holder, expiresAt, sessionId, row.consumer, row.cursor_key);
+							const claimed = toHead(selectHeadRow.get(sessionId, row.consumer, row.cursor_key));
+							if (exhausted) releasePins(sessionId, row.consumer, row.cursor_key, claimed.index);
+							if (clearIndex > 0) claimed.clearIndex = clearIndex;
+							return claimed;
+						}),
+						head: headOf(sessionId)
+					};
+				}
+				const active = db.prepare(`select min(cursor.claim_expires_at) as retry_at
+                 from a2_cursors cursor
+                ${filter}
+                  and cursor.claim_expires_at > ?`).get(...params);
+				return active.retry_at === null ? { outcome: "settled" } : {
+					outcome: "busy",
+					retryAt: new Date(Number(active.retry_at))
+				};
+			}));
+		},
+		async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {
+			if (claims.length === 0) return {
+				renewed: [],
+				superseded: []
+			};
+			return wrap(() => tx(() => {
+				const now = clock.now().getTime();
+				const expiresAt = expiresAtMs ?? now + ttlMs;
+				const renewed = [];
+				const superseded = [];
+				const extend = db.prepare(`update a2_cursors set claim_expires_at = ?
+              where session_id = ? and consumer = ? and cursor_key = ?
+                and head = ?
+                and attempt_count = ?
+                and failed_at is null
+                and claim_holder = ?
+                and claim_expires_at > ?`);
+				const clearIndex = clearIndexOf(sessionId);
+				const ordered = claims.toSorted((a, b) => a.index - b.index || compareText(a.consumer, b.consumer));
+				for (const { attempt, ...ref } of ordered) {
+					if (ref.index <= clearIndex) {
+						superseded.push(ref);
+						continue;
+					}
+					const cursor = cursorOf(sessionId, ref);
+					if (!cursor) continue;
+					const head = toNumber(cursor.head);
+					if (head !== ref.index && Number(cursor.position) < ref.index) continue;
+					if (head !== ref.index || Number(cursor.attempt_count) > attempt) {
+						superseded.push(ref);
+						continue;
+					}
+					const updated = extend.run(expiresAt, sessionId, ref.consumer, cursor.cursor_key, ref.index, attempt, holder, now);
+					if (Number(updated.changes) === 1) renewed.push(ref);
+				}
+				return {
+					renewed,
+					superseded
+				};
+			}));
+		},
+		async completeAttempt({ sessionId, consumer, lane, index, attempt, events, consumers }) {
+			return wrap(() => tx(() => {
+				const clearIndex = clearIndexOf(sessionId);
+				if (index <= clearIndex) return { outcome: "superseded" };
+				const cursor = cursorOf(sessionId, {
+					consumer,
+					lane,
+					index
+				});
+				if (!cursor) {
+					if (!selectEvent.get(sessionId, index)) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+					return { outcome: "superseded" };
+				}
+				refreshLogTypes(sessionId, consumers);
+				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 (toNumber(cursor.head) !== index) {
+					let completion;
+					if (cursor.kind === "lane") {
+						const row = selectLaneEvent.get(sessionId, consumer, lane, index);
+						completion = row && {
+							attempt: toNumber(row.completed_attempt),
+							ids: row.returned_event_ids
+						};
+					} else if (toNumber(cursor.completed_idx) === index) completion = {
+						attempt: toNumber(cursor.completed_attempt),
+						ids: cursor.returned_event_ids
+					};
+					if (!completion || completion.attempt !== attempt) return { outcome: "superseded" };
+					const returnedIds = completion.ids === null ? 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");
+					const existing = ids.length === 0 ? [] : selectByIds(ids.length).all(sessionId, ...ids);
+					const byId = new Map(existing.map((row) => [row.event_id, row]));
+					const ordered = ids.map((id) => byId.get(id));
+					if (ordered.some((row) => {
+						const cause = row ? decodeCause(row.cause) : null;
+						return !row || cause?.consumer !== consumer || cause.lane !== lane || cause.index !== index || cause.attempt !== attempt;
+					})) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event retry does not match the committed batch");
+					return {
+						outcome: "completed",
+						events: events.length === 0 ? [] : idempotentReplay(events, ordered.map(toStored))
+					};
+				}
+				if (Number(cursor.attempt_count) !== attempt || cursor.claim_holder === null || cursor.failed_at !== null) return { outcome: "superseded" };
+				if (liveOwnersOf(sessionId, clearIndex, ids).length > 0) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains an already-appended event id");
+				const inserted = insertBatch({
+					sessionId,
+					events,
+					clearIndex,
+					consumers,
+					cause: {
+						consumer,
+						lane,
+						index,
+						attempt
+					}
+				});
+				const returned = JSON.stringify(ids);
+				if (cursor.kind === "lane") finishLaneEvent.run(attempt, returned, sessionId, consumer, lane, index);
+				else recordCompletion.run(index, attempt, returned, sessionId, consumer, cursor.cursor_key);
+				advance(sessionId, cursor);
+				return {
+					outcome: "completed",
+					events: inserted
+				};
+			}));
+		},
+		async failAttempt({ sessionId, consumer, lane, index, attempt, error, maxFailures, retryAfterMs }) {
+			return wrap(() => tx(() => {
+				if (index <= clearIndexOf(sessionId)) return {
+					outcome: "superseded",
+					failureCount: 0
+				};
+				const current = cursorOf(sessionId, {
+					consumer,
+					lane,
+					index
+				});
+				if (!current) {
+					if (!selectEvent.get(sessionId, index)) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+					return {
+						outcome: "superseded",
+						failureCount: 0
+					};
+				}
+				if (toNumber(current.head) !== index) return {
+					outcome: "superseded",
+					failureCount: 0
+				};
+				const failureCount = Number(current.failure_count);
+				if (Number(current.attempt_count) !== attempt) return {
+					outcome: "superseded",
+					failureCount
+				};
+				if (current.claim_holder === null && current.last_failed_attempt !== null && Number(current.last_failed_attempt) === attempt) return {
+					outcome: current.failed_at === null ? "failed" : "dead_lettered",
+					failureCount
+				};
+				if (current.failed_at !== null) return {
+					outcome: "dead_lettered",
+					failureCount
+				};
+				if (current.claim_holder === null) return {
+					outcome: "superseded",
+					failureCount
+				};
+				const now = clock.now().getTime();
+				const nextFailureCount = failureCount + 1;
+				const deadLettered = nextFailureCount >= maxFailures;
+				db.prepare(`update a2_cursors set
+               failure_count = ?,
+               last_error = ?,
+               last_failed_at = ?,
+               last_failed_attempt = ?,
+               failed_at = ?,
+               claim_holder = null,
+               claim_expires_at = ?
+             where session_id = ? and consumer = ? and cursor_key = ?`).run(nextFailureCount, error, now, attempt, deadLettered ? now : null, deadLettered || retryAfterMs === void 0 ? null : now + retryAfterMs, sessionId, consumer, current.cursor_key);
+				if (deadLettered) releasePins(sessionId, consumer, current.cursor_key, index);
+				return {
+					outcome: deadLettered ? "dead_lettered" : "failed",
+					failureCount: nextFailureCount
+				};
+			}));
+		},
+		async deadLetters(sessionId) {
+			return wrap(() => {
+				return db.prepare(`${HEAD_SELECT}
+              where cursor.session_id = ?
+                and cursor.failed_at is not null
+                and cursor.head > coalesce(
+                  (select clear_index from a2_clears where session_id = ?), 0
+                )
+              order by cursor.head, cursor.consumer`).all(sessionId, sessionId).map(toHead);
+			});
+		},
+		async redrive({ sessionId, consumer, index, action, consumers }) {
+			return wrap(() => tx(() => {
+				const clearIndex = clearIndexOf(sessionId);
+				const cursor = index > clearIndex ? db.prepare(`select * from a2_cursors
+                      where session_id = ? and consumer = ? and head = ?
+                        and failed_at is not null`).get(sessionId, consumer, index) : void 0;
+				if (cursor) {
+					refreshLogTypes(sessionId, consumers);
+					if (action === "skip") {
+						if (cursor.kind === "lane") finishLaneEvent.run(null, null, sessionId, consumer, cursor.lane, index);
+						advance(sessionId, cursor);
+					} else db.prepare(`update a2_cursors set failed_at = null, failure_count = 0
+                  where session_id = ? and consumer = ? and cursor_key = ?`).run(sessionId, consumer, cursor.cursor_key);
+				}
+				return {
+					redriven: cursor !== void 0,
+					hasPending: hasPending(sessionId, clearIndex, consumers)
+				};
+			}));
+		},
+		async readState(sessionId, reducerName, stateOptions) {
+			return wrap(() => {
+				const throughIndex = stateOptions?.throughIndex ?? null;
+				const snapshotThroughIndex = stateOptions?.snapshotThroughIndex ?? throughIndex;
+				const rows = db.prepare(`with boundary as materialized (
+             select coalesce(
+               (select clear_index from a2_clears where session_id = ?), 0
+             ) as clear_index
+           ), head as materialized (
+             select up_to_index, state, updated_at
+               from a2_snapshots
+              where session_id = ? and reducer_name = ?
+                and up_to_index >= (select clear_index from boundary)
+           ), snapshot as materialized (
+             select up_to_index, state from (
+               select up_to_index, state from head
+                where (? is null or up_to_index <= ?)
+               union all
+               select up_to_index, state
+                 from a2_snapshot_history
+                where session_id = ? and reducer_name = ?
+                  and up_to_index >= (select clear_index from boundary)
+                  and (? is null or up_to_index <= ?)
+             ) order by up_to_index desc limit 1
+             )
+             select 0 as row_order, 'snapshot' as row_kind,
+                    (select clear_index from boundary) as clear_index,
+                    (select up_to_index from head) as head_index,
+                    (select up_to_index from snapshot) as snapshot_index,
+                    (select state from snapshot) as snapshot_state,
+                    null as session_id, null as idx, null as event_type,
+                    null as payload, null as event_id, null as created_at,
+                    null as cause
+             union all
+             select 1 as row_order, 'event' as row_kind,
+                    null as clear_index,
+                    (select up_to_index from head) as head_index,
+                    null as snapshot_index, null as snapshot_state,
+                    event.session_id, event.idx, event.event_type,
+                    event.payload, event.event_id, event.created_at,
+                    event.cause
+             from a2_events as event
+             where event.session_id = ?
+               and event.idx > max(
+                 coalesce((select up_to_index from snapshot), 0),
+                 (select clear_index from boundary) - 1
+               )
+               and (? is null or event.idx <= ?)
+             order by row_order, idx`).all(sessionId, sessionId, reducerName, snapshotThroughIndex, snapshotThroughIndex, sessionId, reducerName, snapshotThroughIndex, snapshotThroughIndex, sessionId, throughIndex, throughIndex);
+				const snapshot = rows.find((row) => row.row_kind === "snapshot");
+				const clearIndex = Number(snapshot?.clear_index ?? 0);
+				return {
+					...clearIndex > 0 ? { clearIndex } : {},
+					headIndex: snapshot?.head_index === null || snapshot?.head_index === void 0 ? null : Number(snapshot.head_index),
+					snapshot: snapshot?.snapshot_index !== null && snapshot?.snapshot_index !== void 0 ? {
+						index: Number(snapshot.snapshot_index),
+						state: JSON.parse(snapshot.snapshot_state)
+					} : null,
+					events: rows.filter((row) => row.row_kind === "event").map(toEvent)
+				};
+			});
+		},
+		async putSnapshots(sessionId, reducerName, writes) {
+			await wrap(() => tx(() => {
+				const selectSnapshotHead = db.prepare(`select up_to_index, state, updated_at from a2_snapshots
+              where session_id = ? and reducer_name = ?`);
+				const unfinished = db.prepare(`select 1 from a2_cursors
+              where session_id = ? and consumer = ? and cursor_key = ?
+                and head = ? and head > ? and failed_at is null`);
+				const insertPin = db.prepare(`insert or ignore into a2_snapshot_pins
+               (session_id, consumer, cursor_key, event_index, reducer_name, up_to_index)
+             values (?, ?, ?, ?, ?, ?)`);
+				const hasPin = db.prepare(`select 1 from a2_snapshot_pins
+              where session_id = ? and reducer_name = ? and up_to_index = ?
+              limit 1`);
+				const putHistory = db.prepare(`insert into a2_snapshot_history
+               (session_id, reducer_name, up_to_index, state, updated_at)
+             values (?, ?, ?, ?, ?)
+             on conflict (session_id, reducer_name, up_to_index) do update set
+               state = excluded.state, updated_at = excluded.updated_at`);
+				const putHead = db.prepare(`insert into a2_snapshots
+               (session_id, reducer_name, up_to_index, state, updated_at)
+             values (?, ?, ?, ?, ?)
+             on conflict (session_id, reducer_name) do update set
+               up_to_index = excluded.up_to_index,
+               state = excluded.state,
+               updated_at = excluded.updated_at
+             where excluded.up_to_index >= a2_snapshots.up_to_index`);
+				const deleteHistory = db.prepare(`delete from a2_snapshot_history
+              where session_id = ? and reducer_name = ? and up_to_index = ?`);
+				const clearIndex = clearIndexOf(sessionId);
+				for (const write of writes.toSorted((a, b) => a.index - b.index)) {
+					if (write.index < clearIndex) continue;
+					for (const pin of write.pins ?? []) {
+						const cursorKey = cursorKeyOf(pin.lane, pin.index);
+						if (unfinished.get(sessionId, pin.consumer, cursorKey, pin.index, clearIndex)) insertPin.run(sessionId, pin.consumer, cursorKey, pin.index, reducerName, write.index);
+					}
+					const head = selectSnapshotHead.get(sessionId, reducerName);
+					const now = clock.now().getTime();
+					if (!head || write.index >= Number(head.up_to_index)) {
+						if (head && write.index > Number(head.up_to_index) && Number(head.up_to_index) >= clearIndex && hasPin.get(sessionId, reducerName, Number(head.up_to_index))) putHistory.run(sessionId, reducerName, Number(head.up_to_index), head.state, Number(head.updated_at));
+						putHead.run(sessionId, reducerName, write.index, JSON.stringify(write.state) ?? "null", now);
+						deleteHistory.run(sessionId, reducerName, write.index);
+					} else if (write.index < Number(head.up_to_index) && hasPin.get(sessionId, reducerName, write.index)) putHistory.run(sessionId, reducerName, write.index, JSON.stringify(write.state) ?? "null", now);
+				}
+			}));
+		},
+		presence: {
+			async set(ns, participant, values, meta) {
+				const entries = Object.entries(values);
+				if (entries.length === 0) return;
+				wrap(() => tx(() => {
+					const atMs = meta.at.getTime();
+					const nowMs = clock.now().getTime();
+					const expiresAtMs = nowMs + meta.ttlMs;
+					for (const [field, value] of entries) upsertPresence.run(ns, participant, field, JSON.stringify(value) ?? "null", meta.seen, atMs, expiresAtMs, nowMs);
+				}));
+			},
+			async read(ns) {
+				return wrap(() => {
+					const now = clock.now().getTime();
+					sweepPresence.run(ns, now);
+					return selectPresence.all(ns, now).map((row) => ({
+						participant: row.participant,
+						field: row.field,
+						value: JSON.parse(row.value),
+						seen: Number(row.seen),
+						at: new Date(Number(row.at)),
+						expiresAt: new Date(Number(row.expires_at))
+					}));
+				});
+			}
+		},
+		stream(sessionId, opts) {
+			const readAfter = (afterIndex) => wrap(() => {
+				return db.prepare(`select * from a2_events
+                where session_id = ? and idx > ?
+                  and idx >= coalesce((select clear_index from a2_clears where session_id = ?), 0)
+                order by idx`).all(sessionId, afterIndex, sessionId).map(toStored);
+			});
+			return pollingStream(readAfter, opts?.startAfter !== void 0 ? { startAfter: opts.startAfter } : {});
+		},
+		async clear({ sessionId, ifLastIndex, cause }) {
+			return wrap(() => tx(() => {
+				const clearIndex = clearIndexOf(sessionId);
+				if (cause) assertCurrentCause({
+					sessionId,
+					cause,
+					clearIndex
+				});
+				const head = headOf(sessionId);
+				if (ifLastIndex !== void 0 && clearIndex === ifLastIndex + 1) return {
+					cleared: true,
+					index: head,
+					clearIndex
+				};
+				if (ifLastIndex !== void 0 && ifLastIndex !== head) return {
+					cleared: false,
+					index: head,
+					clearIndex
+				};
+				if (head === 0 || clearIndex === head) return {
+					cleared: true,
+					index: head,
+					clearIndex
+				};
+				const marker = head + 1;
+				insertEvent.run(sessionId, marker, CLEAR_EVENT_TYPE, "null", generateId(), clock.now().getTime(), null);
+				db.prepare(`insert into a2_clears (session_id, clear_index) values (?, ?)
+             on conflict (session_id) do update set clear_index = excluded.clear_index`).run(sessionId, marker);
+				db.prepare(`update a2_cursors
+                set position = ?, head = null, ${FRESH_DISPATCH},
+                    completed_idx = null, completed_attempt = null,
+                    returned_event_ids = null
+              where session_id = ? and kind = 'log'`).run(marker, sessionId);
+				db.prepare("delete from a2_snapshot_pins where session_id = ? and event_index < ?").run(sessionId, marker);
+				return {
+					cleared: true,
+					index: marker,
+					clearIndex: marker
+				};
+			}));
+		},
+		async reclaim(sessionId) {
+			return wrap(() => tx(() => {
+				const clearIndex = clearIndexOf(sessionId);
+				if (clearIndex === 0) return {
+					deleted: 0,
+					done: true
+				};
+				const last = db.prepare(`select max(idx) as last from (
+                 select idx from a2_events
+                  where session_id = ? and idx < ?
+                  order by idx limit ?
+               )`).get(sessionId, clearIndex, RECLAIM_BATCH);
+				let deleted = 0;
+				if (last.last !== null) {
+					const through = Number(last.last);
+					deleted = Number(db.prepare("delete from a2_events where session_id = ? and idx <= ?").run(sessionId, through).changes);
+					db.prepare("delete from a2_lane_events where session_id = ? and idx <= ?").run(sessionId, through);
+					db.prepare(`delete from a2_cursors
+                where session_id = ? and kind = 'event' and position < ?`).run(sessionId, through);
+				}
+				const done = db.prepare("select 1 from a2_events where session_id = ? and idx < ? limit 1").get(sessionId, clearIndex) === void 0;
+				if (done) {
+					db.prepare(`delete from a2_cursors
+                where session_id = ? and kind != 'log'
+                  and (head is null or head <= ?) and position <= ?`).run(sessionId, clearIndex, clearIndex);
+					for (const table of [
+						"a2_snapshot_pins",
+						"a2_snapshot_history",
+						"a2_snapshots"
+					]) db.prepare(`delete from ${table} where session_id = ? and up_to_index < ?`).run(sessionId, clearIndex);
+				}
+				return {
+					deleted,
+					done
+				};
+			}));
+		},
+		close() {
+			db.close();
+		}
+	};
+}
+//#endregion
+export { sqlite as t };