experimental-a2 0.19.0 → 0.21.1

package/dist/store-sqlite.js

@@ -1,8 +1,7 @@
-import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-DGI4jTQ5.js";
-import { n as pollingStream } from "./store-polling-7WJV0YWP.js";
-import { t as idempotentReplay } from "./idempotent-replay-JdgMQRRm.js";
+import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-wHd5GCpZ.js";
+import { n as pollingStream } from "./store-polling-DYNyxCev.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 { dirname, resolve } from "node:path";
 import { mkdirSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
@@ -20,7 +19,14 @@ import { DatabaseSync } from "node:sqlite";
 * 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,
@@ -29,35 +35,50 @@ create table if not exists a2_events (
   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_event_id on 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,
-  lane_ready   integer not null default 0,
-  processed_at integer,
-  processed_by_attempt integer,
-  returned_event_ids 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,
-  attempt_count integer not null default 0,
+  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,
-  claim_holder text,
-  claim_expires_at integer,
-  primary key (session_id, idx)
+  completed_idx integer,
+  completed_attempt integer,
+  returned_event_ids text,
+  primary key (session_id, consumer, cursor_key)
 ) strict;
 
-create unique index if not exists a2_events_event_id on a2_events (event_id);
-create index if not exists a2_events_unprocessed
-  on a2_events (session_id, idx) where processed_at is null;
-create index if not exists a2_events_lane_pending
-  on a2_events (session_id, lane, idx) where processed_at is null;
-create index if not exists a2_events_dispatch_ready
-  on a2_events (session_id, idx)
-  where lane_ready = 1 and processed_at is null and failed_at is null;
-create index if not exists a2_events_claim_expiry
-  on a2_events (session_id, claim_expires_at)
-  where lane_ready = 1 and processed_at is null and failed_at is null;
+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,
@@ -79,10 +100,12 @@ create table if not exists a2_snapshot_history (
 
 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, event_index, reducer_name, up_to_index)
+  primary key (session_id, consumer, cursor_key, event_index, reducer_name, up_to_index)
 ) strict;
 
 create index if not exists a2_snapshot_pins_checkpoint
@@ -129,17 +152,7 @@ const wrap = (fn) => {
 	}
 };
 const toDate = (ms) => ms === null ? null : new Date(Number(ms));
-const toCause = (json) => {
-	if (json === null) return null;
-	const value = JSON.parse(json);
-	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) }
-	};
-};
+const toNumber = (value) => value === null ? null : Number(value);
 const toStored = (row) => ({
 	id: row.event_id,
 	type: row.event_type,
@@ -147,21 +160,7 @@ const toStored = (row) => ({
 	index: Number(row.idx),
 	sessionId: row.session_id,
 	createdAt: new Date(Number(row.created_at)),
-	cause: toCause(row.cause),
-	lane: row.lane,
-	processedAt: toDate(row.processed_at),
-	processedByAttempt: row.processed_by_attempt === null ? null : Number(row.processed_by_attempt),
-	returnedEventIds: row.returned_event_ids === null ? null : decodeReturnedEventIds(row.returned_event_ids),
-	firstClaimedAt: toDate(row.first_claimed_at),
-	lastClaimedAt: toDate(row.last_claimed_at),
-	attemptCount: Number(row.attempt_count),
-	failureCount: Number(row.failure_count),
-	lastFailedAt: toDate(row.last_failed_at),
-	lastFailedAttempt: row.last_failed_attempt === null ? null : Number(row.last_failed_attempt),
-	lastError: row.last_error,
-	failedAt: toDate(row.failed_at),
-	claimHolder: row.claim_holder,
-	claimExpiresAt: toDate(row.claim_expires_at)
+	cause: decodeCause(row.cause)
 });
 const toEvent = (row) => ({
 	id: row.event_id,
@@ -171,7 +170,55 @@ const toEvent = (row) => ({
 	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;
@@ -184,37 +231,60 @@ function sqlite(options = {}) {
 	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, lane, lane_ready, processed_at)
-     select ?, ?, ?, ?, ?, ?, ?, ?,
-            case
-              when ? is null then 1
-              when not exists (
-                select 1 from a2_events
-                 where session_id = ? and lane = ? and processed_at is null
-                   and idx > ?
-              ) then 1
-              else 0
-            end,
-            ?`);
-	const promoteLaneHead = db.prepare(`update a2_events set lane_ready = 1
-      where session_id = ?
-        and idx = (
-          select idx from a2_events
-           where session_id = ? and lane = ? and processed_at is null
-             and idx > ?
-           order by idx limit 1
-        )`);
-	const appendStatus = db.prepare(`select coalesce(
-              (select max(idx) from a2_events where session_id = ?),
-              0
-            ) as max,
-            exists(
-              select 1 from a2_events
-              where session_id = ? and processed_at is null and idx > ?
-            ) as has_pending`);
+       (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
@@ -230,38 +300,47 @@ function sqlite(options = {}) {
        from a2_presence
       where ns = ? and expires_at > ?
       order by participant, field`);
-	const selectByIds = (count) => db.prepare(`select stored.*,
-              exists(
-                select 1 from a2_events pending
-                where pending.session_id = ?
-                  and pending.processed_at is null
-                  and pending.idx > ?
-              ) as session_has_pending
-         from a2_events stored
-        where stored.event_id in (${Array.from({ length: count }, () => "?").join(", ")})
-        order by stored.idx`);
+	const selectByIds = (count) => db.prepare(`select * from a2_events
+        where 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 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.
 	*/
 	const liveOwnersOf = (sessionId, clearIndex, ids) => {
 		if (ids.length === 0) return [];
-		return selectByIds(ids.length).all(sessionId, clearIndex, ...ids).filter((row) => {
+		return selectByIds(ids.length).all(...ids).filter((row) => {
 			if (row.session_id !== sessionId || Number(row.idx) >= clearIndex) return true;
 			deleteEventById.run(sessionId, row.event_id);
 			return false;
 		});
 	};
-	const selectCauseParent = db.prepare("select attempt_count, failed_at from a2_events where session_id = ? and idx = ?");
-	/** The attempt-currency fence shared by handler appends and clears. */
+	/** The attempt-currency fence shared by consumer appends and clears. */
 	const assertCurrentCause = ({ sessionId, cause, clearIndex }) => {
 		if (cause.index <= clearIndex) throw supersededAttemptError(sessionId, cause);
-		const parent = selectCauseParent.get(sessionId, cause.index);
-		if (!parent) throw new TypeError(`no event at index ${cause.index} in session '${sessionId}'`);
-		if (Number(parent.attempt_count) !== cause.attempt || parent.failed_at !== null) 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");
@@ -276,9 +355,10 @@ function sqlite(options = {}) {
 			throw err;
 		}
 	};
-	/** A dead-lettered event's snapshot pins, and history no pin keeps. */
-	const releasePins = (sessionId, index) => {
-		db.prepare("delete from a2_snapshot_pins where session_id = ? and event_index = ?").run(sessionId, index);
+	/** 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 (
@@ -288,15 +368,104 @@ function sqlite(options = {}) {
                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) {
-			if (events.length === 0) return wrap(() => {
-				const status = appendStatus.get(sessionId, sessionId, clearIndexOf(sessionId));
-				return {
-					events: [],
-					hasPending: Number(status.has_pending) === 1
-				};
-			});
+			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);
@@ -308,7 +477,7 @@ function sqlite(options = {}) {
 						if (foreign) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${foreign.event_id}' already exists in another session`);
 						if (existing.length === events.length) return {
 							events: idempotentReplay(events, existing.map(toStored)),
-							hasPending: Number(existing[0].session_has_pending) === 1
+							hasPending: hasPending(sessionId, clearIndex, consumers)
 						};
 						throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`);
 					}
@@ -320,42 +489,55 @@ function sqlite(options = {}) {
 					cause: e.cause,
 					clearIndex
 				});
-				const status = appendStatus.get(sessionId, sessionId, clearIndex);
-				const base = Number(status.max);
-				const now = clock.now().getTime();
 				return {
-					events: events.map((e, i) => {
-						const id = e.id ?? generateId();
-						const index = base + 1 + i;
-						insertEvent.run(sessionId, index, e.type, JSON.stringify(e.payload) ?? "null", id, now, e.cause ? JSON.stringify(e.cause) : null, e.lane ?? null, e.lane ?? null, sessionId, e.lane ?? null, clearIndex, e.settled ? now : null);
-						return {
-							id,
-							type: e.type,
-							payload: structuredClone(e.payload),
-							index,
-							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: insertBatch({
+						sessionId,
+						events,
+						clearIndex,
+						consumers
 					}),
-					hasPending: Number(status.has_pending) === 1 || events.some((event) => event.settled !== true)
+					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)"];
@@ -371,24 +553,40 @@ function sqlite(options = {}) {
 				return db.prepare(`select * from a2_events where ${conditions.join(" and ")} order by idx`).all(...params).map(toStored);
 			});
 		},
-		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes = [], maxFailures }) {
+		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 exclusion = excludeIndexes.length === 0 ? "" : `and event.idx not in (${excludeIndexes.map(() => "?").join(", ")})`;
-				const eligible = db.prepare(`select event.idx, event.claim_holder, event.failure_count
-                 from a2_events event
-                where event.session_id = ?
-                  and event.processed_at is null
-                  and event.failed_at is null
-                  and event.lane_ready = 1
-                  and event.idx > ?
-                  and (event.claim_expires_at is null or event.claim_expires_at <= ?)
-                  ${exclusion}
-                order by event.idx`).all(sessionId, clearIndex, now, ...excludeIndexes);
+				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 update = db.prepare(`update a2_events set
+					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,
@@ -396,37 +594,35 @@ function sqlite(options = {}) {
                  last_claimed_at = ?,
                  claim_holder = ?,
                  claim_expires_at = ?
-               where session_id = ? and idx = ?
-               returning *`);
-					const deadLetter = () => db.prepare(`update a2_events set
-                   attempt_count = attempt_count + 1,
-                   failure_count = failure_count + 1,
-                   failed_at = ?,
-                   claim_holder = null,
-                   claim_expires_at = null
-                 where session_id = ? and idx = ?
-                 returning *`);
+               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;
-							const claimed = exhausted ? deadLetter().get(now, sessionId, row.idx) : update.get(now, now, holder, expiresAt, sessionId, row.idx);
-							if (exhausted) releasePins(sessionId, Number(row.idx));
-							const stored = toStored(claimed);
-							if (clearIndex > 0) stored.clearIndex = clearIndex;
-							return stored;
-						})
+							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(claim_expires_at) as retry_at
-                 from a2_events event
-                where session_id = ?
-                  and processed_at is null
-                  and failed_at is null
-                  and lane_ready = 1
-                  and idx > ?
-                  and claim_expires_at > ?
-                  ${exclusion}`).get(sessionId, clearIndex, now, ...excludeIndexes);
+				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))
@@ -443,113 +639,137 @@ function sqlite(options = {}) {
 				const expiresAt = expiresAtMs ?? now + ttlMs;
 				const renewed = [];
 				const superseded = [];
-				const currentAttempt = db.prepare("select attempt_count from a2_events where session_id = ? and idx = ?");
-				const extend = db.prepare(`update a2_events set claim_expires_at = ?
-              where session_id = ?
-                and idx = ?
+				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 processed_at is null
                 and failed_at is null
                 and claim_holder = ?
                 and claim_expires_at > ?`);
 				const clearIndex = clearIndexOf(sessionId);
-				for (const claim of claims) {
-					if (claim.index <= clearIndex) {
-						superseded.push(claim.index);
+				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 row = currentAttempt.get(sessionId, claim.index);
-					if (!row) continue;
-					if (Number(row.attempt_count) > claim.attempt) {
-						superseded.push(claim.index);
+					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, claim.index, claim.attempt, holder, now);
-					if (Number(updated.changes) === 1) renewed.push(claim.index);
+					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: renewed.toSorted((a, b) => a - b),
-					superseded: superseded.toSorted((a, b) => a - b)
+					renewed,
+					superseded
 				};
 			}));
 		},
-		async completeAttempt({ sessionId, index, attempt, events }) {
+		async completeAttempt({ sessionId, consumer, lane, index, attempt, events, consumers }) {
 			return wrap(() => tx(() => {
 				const clearIndex = clearIndexOf(sessionId);
 				if (index <= clearIndex) return { outcome: "superseded" };
-				const parent = db.prepare("select * from a2_events where session_id = ? and idx = ?").get(sessionId, index);
-				if (!parent) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+				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 (parent.processed_at !== null) {
-					if (Number(parent.processed_by_attempt) !== attempt) return { outcome: "superseded" };
-					const returnedIds = parent.returned_event_ids === null ? null : decodeReturnedEventIds(parent.returned_event_ids);
+				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, clearIndex, ...ids);
+					const existing = ids.length === 0 ? [] : selectByIds(ids.length).all(...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 || row.session_id !== sessionId || row.cause === null || toCause(row.cause)?.index !== index || toCause(row.cause)?.attempt !== attempt)) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event retry does not match the committed batch");
+					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))
+						events: events.length === 0 ? [] : idempotentReplay(events, ordered.map(toStored))
 					};
 				}
-				if (Number(parent.attempt_count) !== attempt || parent.claim_holder === null || parent.failed_at !== null) return { outcome: "superseded" };
+				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 status = appendStatus.get(sessionId, sessionId, clearIndex);
-				const now = clock.now().getTime();
-				db.prepare(`update a2_events set
-               processed_at = ?,
-               processed_by_attempt = ?,
-               returned_event_ids = ?,
-               lane_ready = 0,
-               claim_holder = null,
-               claim_expires_at = null
-             where session_id = ? and idx = ?`).run(now, attempt, JSON.stringify(ids), sessionId, index);
-				db.prepare("delete from a2_snapshot_pins where session_id = ? and event_index = ?").run(sessionId, 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);
-				if (parent.lane !== null) promoteLaneHead.run(sessionId, sessionId, parent.lane, clearIndex);
+				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: events.map((event, offset) => {
-						const id = event.id;
-						const childIndex = Number(status.max) + offset + 1;
-						const cause = {
-							index,
-							attempt
-						};
-						insertEvent.run(sessionId, childIndex, event.type, JSON.stringify(event.payload) ?? "null", id, now, JSON.stringify(cause), event.lane ?? null, event.lane ?? null, sessionId, event.lane ?? null, clearIndex, event.settled ? now : null);
-						return toStored(db.prepare("select * from a2_events where session_id = ? and idx = ?").get(sessionId, childIndex));
-					})
+					events: inserted
 				};
 			}));
 		},
-		async failAttempt({ sessionId, index, attempt, error, maxFailures, retryAfterMs }) {
+		async failAttempt({ sessionId, consumer, lane, index, attempt, error, maxFailures, retryAfterMs }) {
 			return wrap(() => tx(() => {
 				if (index <= clearIndexOf(sessionId)) return {
 					outcome: "superseded",
 					failureCount: 0
 				};
-				const current = db.prepare("select * from a2_events where session_id = ? and idx = ?").get(sessionId, index);
-				if (!current) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+				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 (current.processed_at !== null || Number(current.attempt_count) !== attempt) return {
+				if (Number(current.attempt_count) !== attempt) return {
 					outcome: "superseded",
 					failureCount
 				};
-				if (current.failed_at !== null) return {
-					outcome: "dead_lettered",
+				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.claim_holder === null && current.last_failed_attempt !== null && Number(current.last_failed_attempt) === attempt) return {
-					outcome: "failed",
+				if (current.failed_at !== null) return {
+					outcome: "dead_lettered",
 					failureCount
 				};
 				if (current.claim_holder === null) return {
@@ -559,7 +779,7 @@ function sqlite(options = {}) {
 				const now = clock.now().getTime();
 				const nextFailureCount = failureCount + 1;
 				const deadLettered = nextFailureCount >= maxFailures;
-				db.prepare(`update a2_events set
+				db.prepare(`update a2_cursors set
                failure_count = ?,
                last_error = ?,
                last_failed_at = ?,
@@ -567,8 +787,8 @@ function sqlite(options = {}) {
                failed_at = ?,
                claim_holder = null,
                claim_expires_at = ?
-             where session_id = ? and idx = ?`).run(nextFailureCount, error, now, attempt, deadLettered ? now : null, deadLettered || retryAfterMs === void 0 ? null : now + retryAfterMs, sessionId, index);
-				if (deadLettered) releasePins(sessionId, index);
+             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
@@ -577,31 +797,32 @@ function sqlite(options = {}) {
 		},
 		async deadLetters(sessionId) {
 			return wrap(() => {
-				return db.prepare(`select * from a2_events
-              where session_id = ?
-                and processed_at is null
-                and failed_at is not null
-                and idx > coalesce(
+				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 idx`).all(sessionId, sessionId).map(toStored);
+              order by cursor.head, cursor.consumer`).all(sessionId, sessionId).map(toHead);
 			});
 		},
-		async redrive({ sessionId, index, action }) {
+		async redrive({ sessionId, consumer, index, action, consumers }) {
 			return wrap(() => tx(() => {
 				const clearIndex = clearIndexOf(sessionId);
-				const row = index > clearIndex ? db.prepare("select lane, processed_at, failed_at from a2_events where session_id = ? and idx = ?").get(sessionId, index) : void 0;
-				const redriven = row !== void 0 && row.processed_at === null && row.failed_at !== null;
-				if (redriven && action === "skip") {
-					db.prepare(`update a2_events set processed_at = ?, lane_ready = 0
-                where session_id = ? and idx = ?`).run(clock.now().getTime(), sessionId, index);
-					if (row.lane !== null) promoteLaneHead.run(sessionId, sessionId, row.lane, clearIndex);
-				} else if (redriven) db.prepare(`update a2_events set failed_at = null, failure_count = 0
-                where session_id = ? and idx = ?`).run(sessionId, index);
-				const status = appendStatus.get(sessionId, sessionId, clearIndex);
+				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,
-					hasPending: Number(status.has_pending) === 1
+					redriven: cursor !== void 0,
+					hasPending: hasPending(sessionId, clearIndex, consumers)
 				};
 			}));
 		},
@@ -637,21 +858,15 @@ function sqlite(options = {}) {
                     (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, null as lane, null as lane_ready,
-                    null as processed_at,
-                    null as processed_by_attempt, null as returned_event_ids,
-                    null as first_claimed_at,
-                    null as last_claimed_at, null as attempt_count,
-                    null as failure_count, null as last_failed_at,
-                    null as last_failed_attempt, null as last_error,
-                    null as failed_at, null as claim_holder,
-                    null as claim_expires_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.*
+                    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(
@@ -675,14 +890,14 @@ function sqlite(options = {}) {
 		},
 		async putSnapshots(sessionId, reducerName, writes) {
 			await wrap(() => tx(() => {
-				const selectHead = db.prepare(`select up_to_index, state, updated_at from a2_snapshots
+				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_events
-              where session_id = ? and idx = ? and idx > ?
-                and processed_at is null and failed_at is null`);
+				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, event_index, reducer_name, up_to_index)
-             values (?, ?, ?, ?)`);
+               (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`);
@@ -704,8 +919,11 @@ function sqlite(options = {}) {
 				const clearIndex = clearIndexOf(sessionId);
 				for (const write of writes.toSorted((a, b) => a.index - b.index)) {
 					if (write.index < clearIndex) continue;
-					for (const eventIndex of write.pinEventIndexes ?? []) if (unfinished.get(sessionId, eventIndex, clearIndex)) insertPin.run(sessionId, eventIndex, reducerName, write.index);
-					const head = selectHead.get(sessionId, reducerName);
+					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));
@@ -758,7 +976,7 @@ function sqlite(options = {}) {
 					cause,
 					clearIndex
 				});
-				const head = Number(appendStatus.get(sessionId, sessionId, clearIndex).max);
+				const head = headOf(sessionId);
 				if (ifLastIndex !== void 0 && clearIndex === ifLastIndex + 1) return {
 					cleared: true,
 					index: head,
@@ -775,10 +993,15 @@ function sqlite(options = {}) {
 					clearIndex
 				};
 				const marker = head + 1;
-				const now = clock.now().getTime();
-				insertEvent.run(sessionId, marker, CLEAR_EVENT_TYPE, "null", generateId(), now, null, null, null, sessionId, null, clearIndex, now);
+				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,
@@ -802,14 +1025,21 @@ function sqlite(options = {}) {
 				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_snapshot_pins where session_id = ? and event_index <= ?").run(sessionId, through);
+					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) 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);
+				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