experimental-a2 0.20.0 → 0.22.0

package/dist/store-memory.js

@@ -1,10 +1,23 @@
-import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-DGI4jTQ5.js";
-import { _ as nullProtoRecord } from "./internal-CscSY7K_.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 { y as nullProtoRecord } from "./internal-CvsrprnU.js";
+import { a as idempotentReplay, i as idleLogCursor } from "./store-codec-DwrWlgQx.js";
 import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS.js";
 //#region src/store-memory.ts
 const RECLAIM_BATCH = 256;
 const headOf = (log) => log ? log.offset + log.rows.length : 0;
+const freshDispatch = () => ({
+	firstClaimedAt: null,
+	lastClaimedAt: null,
+	attemptCount: 0,
+	claimHolder: null,
+	claimExpiresAt: null,
+	failureCount: 0,
+	lastFailedAt: null,
+	lastFailedAttempt: null,
+	lastError: null,
+	failedAt: null
+});
+const date = (value) => value ? new Date(value) : null;
 const toStored = (row) => ({
 	id: row.id,
 	type: row.type,
@@ -12,21 +25,7 @@ const toStored = (row) => ({
 	index: row.index,
 	sessionId: row.sessionId,
 	createdAt: new Date(row.createdAt),
-	cause: row.cause ? { ...row.cause } : null,
-	lane: row.lane,
-	processedAt: row.processedAt ? new Date(row.processedAt) : null,
-	processedByAttempt: row.processedByAttempt,
-	returnedEventIds: row.returnedEventIds ? [...row.returnedEventIds] : null,
-	firstClaimedAt: row.firstClaimedAt ? new Date(row.firstClaimedAt) : null,
-	lastClaimedAt: row.lastClaimedAt ? new Date(row.lastClaimedAt) : null,
-	attemptCount: row.attemptCount,
-	claimHolder: row.claimHolder,
-	claimExpiresAt: row.claimExpiresAt ? new Date(row.claimExpiresAt) : null,
-	failureCount: row.failureCount,
-	lastFailedAt: row.lastFailedAt ? new Date(row.lastFailedAt) : null,
-	lastFailedAttempt: row.lastFailedAttempt,
-	lastError: row.lastError,
-	failedAt: row.failedAt ? new Date(row.failedAt) : null
+	cause: row.cause ? { ...row.cause } : null
 });
 const toEvent = (row) => ({
 	id: row.id,
@@ -36,15 +35,63 @@ const toEvent = (row) => ({
 	sessionId: row.sessionId,
 	createdAt: new Date(row.createdAt)
 });
+const toHead = (cursor, row) => ({
+	...toStored(row),
+	consumer: cursor.consumer,
+	lane: cursor.lane,
+	firstClaimedAt: date(cursor.dispatch.firstClaimedAt),
+	lastClaimedAt: date(cursor.dispatch.lastClaimedAt),
+	attemptCount: cursor.dispatch.attemptCount,
+	claimHolder: cursor.dispatch.claimHolder,
+	claimExpiresAt: date(cursor.dispatch.claimExpiresAt),
+	failureCount: cursor.dispatch.failureCount,
+	lastFailedAt: date(cursor.dispatch.lastFailedAt),
+	lastFailedAttempt: cursor.dispatch.lastFailedAttempt,
+	lastError: cursor.dispatch.lastError,
+	failedAt: date(cursor.dispatch.failedAt)
+});
+const toCursor = (cursor) => ({
+	consumer: cursor.consumer,
+	lane: cursor.lane,
+	position: cursor.position,
+	head: cursor.head,
+	firstClaimedAt: date(cursor.dispatch.firstClaimedAt),
+	lastClaimedAt: date(cursor.dispatch.lastClaimedAt),
+	attemptCount: cursor.dispatch.attemptCount,
+	claimHolder: cursor.dispatch.claimHolder,
+	claimExpiresAt: date(cursor.dispatch.claimExpiresAt),
+	failureCount: cursor.dispatch.failureCount,
+	lastFailedAt: date(cursor.dispatch.lastFailedAt),
+	lastFailedAttempt: cursor.dispatch.lastFailedAttempt,
+	lastError: cursor.dispatch.lastError,
+	failedAt: date(cursor.dispatch.failedAt)
+});
+const compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/** Consumer, then lane, with concurrent cursors last by head. */
+const byCursor = (a, b) => compareText(a.consumer, b.consumer) || (a.lane === null ? b.lane === null ? (a.head ?? 0) - (b.head ?? 0) : 1 : b.lane === null ? -1 : compareText(a.lane, b.lane));
+const cursorKey = (consumer, lane, index) => lane === null ? `${consumer}\u0000#${index}` : `${consumer}\u0000L${lane}`;
+const takes = (types, type) => type !== "a2.cleared" && (types === null || types.includes(type));
+const byHead = (a, b) => a.index - b.index || compareText(a.consumer, b.consumer);
 const snapshotKey = (sessionId, reducerName) => `${sessionId}\u0000${reducerName}`;
-const eventPinKey = (sessionId, index) => `${sessionId}\u0000${index}`;
+const headPinKey = (sessionId, ref) => `${sessionId}\u0000${cursorKey(ref.consumer, ref.lane, ref.index)}\u0000${ref.index}`;
+/** Whether a cursor belongs to a consumer the caller serves; omitted, every one. */
+const servedBy = (consumers) => {
+	if (!consumers) return () => true;
+	const names = new Set(consumers.map((consumer) => consumer.name));
+	return (cursor) => names.has(cursor.consumer);
+};
+/** A cursor's current head. */
+const refOf = (cursor) => ({
+	consumer: cursor.consumer,
+	lane: cursor.lane,
+	index: cursor.head
+});
 function memory(options = {}) {
 	const clock = options.clock ?? SYSTEM_CLOCK;
 	const generateId = options.ids ?? RANDOM_IDS;
 	const sessions = /* @__PURE__ */ new Map();
-	const dispatch = /* @__PURE__ */ new Map();
-	/** Global unique index on event ids, like the SQL schema's. */
-	const byEventId = /* @__PURE__ */ new Map();
+	/** Session id → cursor key → cursor. */
+	const cursors = /* @__PURE__ */ new Map();
 	/** Keyed by `${sessionId}\u0000${reducerName}` — a pure cache. */
 	const snapshots = /* @__PURE__ */ new Map();
 	const historicalSnapshots = /* @__PURE__ */ new Map();
@@ -65,7 +112,8 @@ function memory(options = {}) {
 			log = {
 				rows: [],
 				offset: 0,
-				clearIndex: 0
+				clearIndex: 0,
+				byEventId: /* @__PURE__ */ new Map()
 			};
 			sessions.set(sessionId, log);
 		}
@@ -76,14 +124,24 @@ function memory(options = {}) {
 		return log && index > log.offset ? log.rows[index - log.offset - 1] : void 0;
 	};
 	const clearIndexOf = (sessionId) => sessions.get(sessionId)?.clearIndex ?? 0;
-	/** The row owning `id`, ignoring this session's rows below its clear. */
+	/** The session's row owning `id`, ignoring rows below its clear. */
 	const ownerOf = (sessionId, id) => {
-		const row = byEventId.get(id);
-		return row?.sessionId === sessionId && row.index < clearIndexOf(sessionId) ? void 0 : row;
+		const log = sessions.get(sessionId);
+		const row = log?.byEventId.get(id);
+		return log && row && row.index >= log.clearIndex ? row : void 0;
+	};
+	const cursorsOf = (sessionId) => {
+		let map = cursors.get(sessionId);
+		if (!map) {
+			map = /* @__PURE__ */ new Map();
+			cursors.set(sessionId, map);
+		}
+		return map;
 	};
+	const cursorAt = (sessionId, ref) => cursors.get(sessionId)?.get(cursorKey(ref.consumer, ref.lane, ref.index));
 	const checkpointKey = (sessionId, reducerName, index) => `${snapshotKey(sessionId, reducerName)}\u0000${index}`;
-	const releaseSnapshotPins = (sessionId, eventIndex) => {
-		const pinKey = eventPinKey(sessionId, eventIndex);
+	const releaseSnapshotPins = (sessionId, ref) => {
+		const pinKey = headPinKey(sessionId, ref);
 		const checkpoints = snapshotPins.get(pinKey);
 		if (!checkpoints) return;
 		for (const key of checkpoints) {
@@ -95,97 +153,148 @@ function memory(options = {}) {
 		}
 		snapshotPins.delete(pinKey);
 	};
-	const dispatchOf = (sessionId) => {
-		let state = dispatch.get(sessionId);
-		if (!state) {
-			state = {
-				ready: /* @__PURE__ */ new Map(),
-				lanes: /* @__PURE__ */ new Map()
-			};
-			dispatch.set(sessionId, state);
-		}
-		return state;
-	};
-	const enqueue = (sessionId, row) => {
-		if (row.processedAt !== null) return;
-		const state = dispatchOf(sessionId);
-		if (row.lane === null) {
-			state.ready.set(row.index, row);
-			return;
-		}
-		let queue = state.lanes.get(row.lane);
-		if (!queue) {
-			queue = {
-				rows: [],
-				head: 0
-			};
-			state.lanes.set(row.lane, queue);
-		}
-		queue.rows.push(row);
-		if (queue.rows.length === 1) state.ready.set(row.index, row);
-	};
-	const settle = (sessionId, row) => {
-		const state = dispatchOf(sessionId);
-		state.ready.delete(row.index);
-		if (row.lane === null) return;
-		const queue = state.lanes.get(row.lane);
-		if (queue.rows[queue.head] !== row) return;
-		queue.head += 1;
-		if (queue.head === queue.rows.length) {
-			state.lanes.delete(row.lane);
-			return;
+	/** The next event after `after` that a log cursor takes, or null. */
+	const nextLogHead = (sessionId, after, types) => {
+		const log = sessions.get(sessionId);
+		if (!log) return null;
+		for (let offset = Math.max(0, after - log.offset); offset < log.rows.length; offset += 1) {
+			const row = log.rows[offset];
+			if (takes(types, row.type)) return row.index;
 		}
-		const next = queue.rows[queue.head];
-		if (next.failedAt === null) state.ready.set(next.index, next);
+		return null;
 	};
-	const find = (sessionId, index) => {
-		const row = rowAt(sessionId, index);
-		if (!row) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
-		return row;
+	/** Moves a cursor past its head: the next head starts with fresh bookkeeping. */
+	const advance = (sessionId, cursor) => {
+		const done = cursor.head;
+		releaseSnapshotPins(sessionId, refOf(cursor));
+		cursor.position = done;
+		cursor.dispatch = freshDispatch();
+		if (cursor.kind === "event") cursor.head = null;
+		else if (cursor.kind === "lane") {
+			cursor.queued += 1;
+			cursor.head = cursor.queue[cursor.queued] ?? null;
+		} else cursor.head = nextLogHead(sessionId, done, cursor.types);
 	};
-	const hasPending = (sessionId) => {
-		const log = sessions.get(sessionId);
-		return (log?.rows ?? []).some((row) => row.index > log.clearIndex && row.processedAt === null);
+	const hasPending = (sessionId, consumers) => {
+		const served = servedBy(consumers);
+		for (const cursor of cursors.get(sessionId)?.values() ?? []) if (cursor.head !== null && cursor.dispatch.failedAt === null && served(cursor)) return true;
+		return false;
 	};
-	const appendResult = (sessionId, events) => ({
-		events,
-		hasPending: hasPending(sessionId)
-	});
-	/** The attempt-currency fence shared by handler appends and clears. */
+	/** The attempt-currency fence shared by consumer appends and clears. */
 	const assertCurrentCause = (sessionId, cause) => {
 		if (cause.index <= clearIndexOf(sessionId)) throw supersededAttemptError(sessionId, cause);
-		const parent = find(sessionId, cause.index);
-		if (parent.attemptCount !== cause.attempt || parent.failedAt !== null) throw supersededAttemptError(sessionId, cause);
+		const cursor = cursorAt(sessionId, cause);
+		if (!cursor || cursor.head !== cause.index || cursor.dispatch.attemptCount !== cause.attempt || cursor.dispatch.failedAt !== null) throw supersededAttemptError(sessionId, cause);
+	};
+	const deadLetter = (sessionId, cursor, now) => {
+		cursor.dispatch.failedAt = new Date(now);
+		releaseSnapshotPins(sessionId, refOf(cursor));
 	};
-	const claim = ({ sessionId, row, holder, now, expiresAt, maxFailures }) => {
-		if (row.claimHolder !== null) {
-			row.failureCount += 1;
-			if (maxFailures !== void 0 && row.failureCount >= maxFailures) {
-				row.attemptCount += 1;
-				row.failedAt = new Date(now);
-				row.claimHolder = null;
-				row.claimExpiresAt = null;
-				dispatchOf(sessionId).ready.delete(row.index);
-				releaseSnapshotPins(sessionId, row.index);
-				return toStored(row);
+	const claim = ({ sessionId, cursor, holder, now, expiresAt, maxFailures }) => {
+		const dispatch = cursor.dispatch;
+		const row = rowAt(sessionId, cursor.head);
+		if (dispatch.claimHolder !== null) {
+			dispatch.failureCount += 1;
+			if (maxFailures !== void 0 && dispatch.failureCount >= maxFailures) {
+				dispatch.attemptCount += 1;
+				dispatch.claimHolder = null;
+				dispatch.claimExpiresAt = null;
+				deadLetter(sessionId, cursor, now);
+				return toHead(cursor, row);
 			}
 		}
-		row.attemptCount += 1;
-		row.firstClaimedAt ??= new Date(now);
-		row.lastClaimedAt = new Date(now);
-		row.claimHolder = holder;
-		row.claimExpiresAt = new Date(expiresAt);
-		return toStored(row);
+		dispatch.attemptCount += 1;
+		dispatch.firstClaimedAt ??= new Date(now);
+		dispatch.lastClaimedAt = new Date(now);
+		dispatch.claimHolder = holder;
+		dispatch.claimExpiresAt = new Date(expiresAt);
+		return toHead(cursor, row);
 	};
 	const checkBatchIds = (sessionId, events) => {
 		const supplied = events.filter((candidate) => candidate.id !== void 0);
 		if (new Set(supplied.map((candidate) => candidate.id)).size !== supplied.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "batch contains the same event id more than once");
-		const existing = supplied.map((candidate) => ownerOf(sessionId, candidate.id)).filter((row) => row !== void 0);
-		const foreign = existing.find((row) => row.sessionId !== sessionId);
-		if (foreign) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${foreign.id}' already exists in another session`);
-		return existing;
+		return supplied.map((candidate) => ownerOf(sessionId, candidate.id)).filter((row) => row !== void 0);
+	};
+	/** Records the types a declared log consumer takes on its cursor. */
+	const refreshLogTypes = (sessionId, consumers) => {
+		const map = cursors.get(sessionId);
+		if (!map) return;
+		for (const consumer of consumers ?? []) {
+			if (!consumer.log) continue;
+			const cursor = map.get(cursorKey(consumer.name, consumer.log.lane, 0));
+			if (cursor?.kind === "log") cursor.types = consumer.log.types;
+		}
+	};
+	/** Starts the cursor work an inserted batch carries. */
+	const enqueue = (sessionId, rows, events, base, consumers) => {
+		const map = cursorsOf(sessionId);
+		rows.forEach((row, offset) => {
+			for (const target of events[offset].targets ?? []) {
+				const key = cursorKey(target.consumer, target.lane, row.index);
+				if (target.lane === null) {
+					map.set(key, {
+						consumer: target.consumer,
+						lane: null,
+						kind: "event",
+						position: row.index - 1,
+						head: row.index,
+						dispatch: freshDispatch(),
+						queue: [],
+						queued: 0,
+						completions: /* @__PURE__ */ new Map(),
+						types: null
+					});
+					continue;
+				}
+				let cursor = map.get(key);
+				if (!cursor) {
+					cursor = {
+						consumer: target.consumer,
+						lane: target.lane,
+						kind: "lane",
+						position: clearIndexOf(sessionId),
+						head: null,
+						dispatch: freshDispatch(),
+						queue: [],
+						queued: 0,
+						completions: /* @__PURE__ */ new Map(),
+						types: null
+					};
+					map.set(key, cursor);
+				}
+				cursor.queue.push(row.index);
+				cursor.head ??= row.index;
+			}
+		});
+		const clearIndex = clearIndexOf(sessionId);
+		for (const consumer of consumers ?? []) {
+			const log = consumer.log;
+			if (!log) continue;
+			const first = rows.find((row) => takes(log.types, row.type));
+			if (!first) continue;
+			const key = cursorKey(consumer.name, log.lane, 0);
+			const cursor = map.get(key);
+			if (!cursor) {
+				const position = log.backfill ? clearIndex : base;
+				map.set(key, {
+					consumer: consumer.name,
+					lane: log.lane,
+					kind: "log",
+					position,
+					head: log.backfill ? nextLogHead(sessionId, position, log.types) : first.index,
+					dispatch: freshDispatch(),
+					queue: [],
+					queued: 0,
+					completions: /* @__PURE__ */ new Map(),
+					types: log.types
+				});
+			} else {
+				cursor.types = log.types;
+				cursor.head ??= nextLogHead(sessionId, cursor.position, log.types);
+			}
+		}
 	};
-	const insert = (sessionId, events, now, cause) => {
+	const insert = (sessionId, events, now, consumers, cause) => {
 		const log = logOf(sessionId);
 		const base = headOf(log);
 		const inserted = events.map((candidate, offset) => ({
@@ -195,28 +304,14 @@ function memory(options = {}) {
 			index: base + 1 + offset,
 			sessionId,
 			createdAt: new Date(now),
-			cause: cause ? { ...cause } : candidate.cause ? { ...candidate.cause } : null,
-			lane: candidate.lane ?? null,
-			processedAt: candidate.settled ? new Date(now) : null,
-			processedByAttempt: null,
-			returnedEventIds: null,
-			firstClaimedAt: null,
-			lastClaimedAt: null,
-			attemptCount: 0,
-			claimHolder: null,
-			claimExpiresAt: null,
-			failureCount: 0,
-			lastFailedAt: null,
-			lastFailedAttempt: null,
-			lastError: null,
-			failedAt: null
+			cause: cause ? { ...cause } : candidate.cause ? { ...candidate.cause } : null
 		}));
 		for (const row of inserted) if (ownerOf(sessionId, row.id)) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${row.id}' already exists`);
 		for (const row of inserted) {
 			log.rows.push(row);
-			byEventId.set(row.id, row);
-			enqueue(sessionId, row);
+			log.byEventId.set(row.id, row);
 		}
+		enqueue(sessionId, inserted, events, base, consumers);
 		return inserted;
 	};
 	/** Every cached fold of this session below its clear, head or historical. */
@@ -256,21 +351,35 @@ function memory(options = {}) {
 			...clearIndex > 0 ? { clearIndex } : {}
 		};
 	};
+	/** The dead-lettered head a redrive names, or undefined. */
+	const deadHeadOf = (sessionId, consumer, index) => {
+		if (index <= clearIndexOf(sessionId)) return void 0;
+		for (const cursor of cursors.get(sessionId)?.values() ?? []) if (cursor.consumer === consumer && cursor.head === index && cursor.dispatch.failedAt !== null) return cursor;
+	};
 	return {
 		async append(sessionId, events, appendOptions) {
-			if (events.length === 0) return appendResult(sessionId, []);
+			const consumers = appendOptions?.consumers;
+			if (events.length === 0) return {
+				events: [],
+				hasPending: hasPending(sessionId, consumers)
+			};
 			const existing = checkBatchIds(sessionId, events);
 			if (existing.length > 0) {
-				if (existing.length === events.length) return appendResult(sessionId, idempotentReplay(events, existing.map(toStored)));
+				if (existing.length === events.length) return {
+					events: idempotentReplay(events, existing.map(toStored)),
+					hasPending: hasPending(sessionId, 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 <= clearIndexOf(sessionId)) throw sessionClearedError(`scheduled work from event ${originIndex} was cleared in session '${sessionId}'`);
 			for (const event of events) if (event.cause) assertCurrentCause(sessionId, event.cause);
-			const now = clock.now();
-			const inserted = insert(sessionId, events, now);
+			const inserted = insert(sessionId, events, clock.now(), consumers);
 			notifyStreams(sessionId, inserted);
-			return appendResult(sessionId, inserted.map(toStored));
+			return {
+				events: inserted.map(toStored),
+				hasPending: hasPending(sessionId, consumers)
+			};
 		},
 		async clear({ sessionId, ifLastIndex, cause }) {
 			if (cause) assertCurrentCause(sessionId, cause);
@@ -294,11 +403,21 @@ function memory(options = {}) {
 			};
 			const [marker] = insert(sessionId, [{
 				type: CLEAR_EVENT_TYPE,
-				payload: null,
-				settled: true
-			}], clock.now());
+				payload: null
+			}], clock.now(), void 0);
 			logOf(sessionId).clearIndex = marker.index;
-			dispatch.delete(sessionId);
+			const map = cursors.get(sessionId);
+			for (const [key, cursor] of map ?? []) {
+				if (cursor.head !== null) releaseSnapshotPins(sessionId, refOf(cursor));
+				if (cursor.kind !== "log") {
+					map.delete(key);
+					continue;
+				}
+				cursor.position = marker.index;
+				cursor.head = null;
+				cursor.dispatch = freshDispatch();
+				cursor.completions.clear();
+			}
 			notifyStreams(sessionId, [marker]);
 			return {
 				cleared: true,
@@ -314,10 +433,7 @@ function memory(options = {}) {
 			};
 			const removed = log.rows.splice(0, Math.min(RECLAIM_BATCH, log.clearIndex - 1 - log.offset));
 			log.offset += removed.length;
-			for (const row of removed) {
-				if (byEventId.get(row.id) === row) byEventId.delete(row.id);
-				releaseSnapshotPins(sessionId, row.index);
-			}
+			for (const row of removed) if (log.byEventId.get(row.id) === row) log.byEventId.delete(row.id);
 			const done = log.offset === log.clearIndex - 1;
 			if (done) dropCheckpointsBelow(sessionId, log.clearIndex);
 			return {
@@ -325,6 +441,43 @@ function memory(options = {}) {
 				done
 			};
 		},
+		async wakeLog({ sessionId, consumer }) {
+			const { log } = consumer;
+			const key = cursorKey(consumer.name, log.lane, 0);
+			const head = headOf(sessions.get(sessionId));
+			let cursor = cursors.get(sessionId)?.get(key);
+			if (!cursor) {
+				const marker = clearIndexOf(sessionId);
+				if (head === marker) return {
+					cursor: idleLogCursor(consumer.name, log.lane, marker),
+					head
+				};
+				const position = log.backfill ? marker : head;
+				cursor = {
+					consumer: consumer.name,
+					lane: log.lane,
+					kind: "log",
+					position,
+					head: log.backfill ? nextLogHead(sessionId, position, log.types) : null,
+					dispatch: freshDispatch(),
+					queue: [],
+					queued: 0,
+					completions: /* @__PURE__ */ new Map(),
+					types: log.types
+				};
+				cursorsOf(sessionId).set(key, cursor);
+			} else {
+				cursor.types = log.types;
+				cursor.head ??= nextLogHead(sessionId, cursor.position, log.types);
+			}
+			return {
+				cursor: toCursor(cursor),
+				head
+			};
+		},
+		async cursors(sessionId) {
+			return [...cursors.get(sessionId)?.values() ?? []].filter((cursor) => cursor.kind !== "event" || cursor.head !== null).map(toCursor).toSorted(byCursor);
+		},
 		async read(sessionId, opts) {
 			const log = sessions.get(sessionId);
 			if (!log) return [];
@@ -334,41 +487,44 @@ function memory(options = {}) {
 			if (through <= after) return [];
 			return log.rows.slice(after - log.offset, through - log.offset).map(toStored);
 		},
-		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes, maxFailures }) {
+		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, exclude, consumers, maxFailures, through }) {
+			refreshLogTypes(sessionId, consumers);
 			const claimedAt = clock.now();
 			const now = claimedAt.getTime();
 			const expiresAt = new Date(expiresAtMs ?? now + ttlMs);
-			const excluded = new Set(excludeIndexes ?? []);
+			const excluded = new Set((exclude ?? []).map((ref) => cursorKey(ref.consumer, ref.lane, ref.index)));
+			const served = servedBy(consumers);
 			const eligible = [];
 			let retryAt = null;
-			for (const row of dispatchOf(sessionId).ready.values()) {
-				if (row.failedAt !== null || excluded.has(row.index)) continue;
-				if (row.claimExpiresAt && row.claimExpiresAt.getTime() > now) {
-					if (!retryAt || row.claimExpiresAt < retryAt) retryAt = new Date(row.claimExpiresAt);
+			for (const [key, cursor] of cursors.get(sessionId) ?? []) {
+				if (cursor.head === null || through !== void 0 && cursor.head > through || cursor.dispatch.failedAt !== null || !served(cursor) || excluded.has(key)) continue;
+				const expiry = cursor.dispatch.claimExpiresAt;
+				if (expiry && expiry.getTime() > now) {
+					if (!retryAt || expiry < retryAt) retryAt = new Date(expiry);
 					continue;
 				}
-				eligible.push(row);
+				eligible.push(cursor);
 			}
 			if (eligible.length === 0) return retryAt ? {
 				outcome: "busy",
 				retryAt
 			} : { outcome: "settled" };
-			eligible.sort((a, b) => a.index - b.index);
 			const clearIndex = clearIndexOf(sessionId);
 			return {
 				outcome: "claimed",
-				events: eligible.map((row) => {
-					const claimed = claim({
+				events: eligible.map((cursor) => {
+					const head = claim({
 						sessionId,
-						row,
+						cursor,
 						holder,
 						now: claimedAt,
 						expiresAt,
 						maxFailures
 					});
-					if (clearIndex > 0) claimed.clearIndex = clearIndex;
-					return claimed;
-				})
+					if (clearIndex > 0) head.clearIndex = clearIndex;
+					return head;
+				}).toSorted(byHead),
+				head: headOf(sessions.get(sessionId))
 			};
 		},
 		async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {
@@ -377,20 +533,23 @@ function memory(options = {}) {
 			const clearIndex = clearIndexOf(sessionId);
 			const renewed = [];
 			const superseded = [];
-			for (const { index, attempt } of claims.toSorted((a, b) => a.index - b.index)) {
-				if (index <= clearIndex) {
-					superseded.push(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 = rowAt(sessionId, index);
-				if (!row) continue;
-				if (row.attemptCount > attempt) {
-					superseded.push(row.index);
+				const cursor = cursorAt(sessionId, ref);
+				if (!cursor) continue;
+				const dispatch = cursor.dispatch;
+				if (cursor.head !== ref.index && cursor.position < ref.index) continue;
+				if (cursor.head !== ref.index || dispatch.attemptCount > attempt) {
+					superseded.push(ref);
 					continue;
 				}
-				if (row.processedAt === null && row.failedAt === null && row.claimHolder === holder && row.claimExpiresAt !== null && row.claimExpiresAt > now) {
-					row.claimExpiresAt = new Date(expiresAt);
-					renewed.push(row.index);
+				if (dispatch.failedAt === null && dispatch.claimHolder === holder && dispatch.claimExpiresAt !== null && dispatch.claimExpiresAt > now) {
+					dispatch.claimExpiresAt = new Date(expiresAt);
+					renewed.push(ref);
 				}
 			}
 			return {
@@ -398,103 +557,124 @@ function memory(options = {}) {
 				superseded
 			};
 		},
-		async completeAttempt({ sessionId, index, attempt, events }) {
+		async completeAttempt({ sessionId, consumer, lane, index, attempt, events, consumers }) {
 			if (index <= clearIndexOf(sessionId)) return { outcome: "superseded" };
-			const parent = find(sessionId, index);
-			const cause = {
-				index,
-				attempt
-			};
-			if (parent.processedAt !== null) {
-				if (parent.processedByAttempt !== attempt) return { outcome: "superseded" };
+			const cursor = cursorAt(sessionId, {
+				consumer,
+				lane,
+				index
+			});
+			if (!cursor) {
+				if (!rowAt(sessionId, index)) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+				return { outcome: "superseded" };
+			}
+			refreshLogTypes(sessionId, consumers);
+			if (cursor.head !== index) {
+				const completion = cursor.completions.get(index);
+				if (!completion || completion.attempt !== attempt) return { outcome: "superseded" };
 				const requestedIds = events.map((event) => event.id);
-				if (parent.returnedEventIds === null || parent.returnedEventIds.length !== requestedIds.length || parent.returnedEventIds.some((id, offset) => id !== requestedIds[offset])) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "completed attempt does not match the returned event batch");
+				if (completion.returnedEventIds.length !== requestedIds.length || completion.returnedEventIds.some((id, offset) => id !== requestedIds[offset])) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "completed attempt does not match the returned event batch");
 				const existing = checkBatchIds(sessionId, events);
-				if (existing.length !== events.length || existing.some((row) => row.cause?.index !== index || row.cause.attempt !== attempt)) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "completed attempt does not match the returned event batch");
+				if (existing.length !== events.length || existing.some((row) => row.cause?.consumer !== consumer || row.cause.lane !== lane || row.cause.index !== index || row.cause.attempt !== attempt)) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "completed attempt does not match the returned event batch");
 				return {
 					outcome: "completed",
-					events: idempotentReplay(events, existing.map(toStored))
+					events: events.length === 0 ? [] : idempotentReplay(events, existing.map(toStored))
 				};
 			}
-			if (parent.attemptCount !== attempt || parent.failedAt !== null || parent.claimHolder === null) return { outcome: "superseded" };
+			const dispatch = cursor.dispatch;
+			if (dispatch.attemptCount !== attempt || dispatch.failedAt !== null || dispatch.claimHolder === null) return { outcome: "superseded" };
 			if (checkBatchIds(sessionId, events).length > 0) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains already-appended ids");
-			const now = clock.now();
-			const inserted = insert(sessionId, events, now, cause);
-			parent.processedAt = new Date(now);
-			parent.processedByAttempt = attempt;
-			parent.returnedEventIds = events.map((event) => event.id);
-			parent.claimHolder = null;
-			parent.claimExpiresAt = null;
-			settle(sessionId, parent);
-			releaseSnapshotPins(sessionId, index);
+			const inserted = insert(sessionId, events, clock.now(), consumers, {
+				consumer,
+				lane,
+				index,
+				attempt
+			});
+			if (cursor.kind === "log") cursor.completions.clear();
+			cursor.completions.set(index, {
+				attempt,
+				returnedEventIds: events.map((event) => event.id)
+			});
+			advance(sessionId, cursor);
 			notifyStreams(sessionId, inserted);
 			return {
 				outcome: "completed",
 				events: inserted.map(toStored)
 			};
 		},
-		async failAttempt({ sessionId, index, attempt, error, maxFailures, retryAfterMs }) {
+		async failAttempt({ sessionId, consumer, lane, index, attempt, error, maxFailures, retryAfterMs }) {
 			if (index <= clearIndexOf(sessionId)) return {
 				outcome: "superseded",
 				failureCount: 0
 			};
-			const row = find(sessionId, index);
-			if (row.processedAt || row.attemptCount !== attempt || row.claimHolder === null && row.lastFailedAttempt !== attempt) return {
+			const cursor = cursorAt(sessionId, {
+				consumer,
+				lane,
+				index
+			});
+			if (!cursor) {
+				if (!rowAt(sessionId, index)) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
+				return {
+					outcome: "superseded",
+					failureCount: 0
+				};
+			}
+			const dispatch = cursor.dispatch;
+			if (cursor.head !== index || dispatch.attemptCount !== attempt || dispatch.claimHolder === null && dispatch.lastFailedAttempt !== attempt) return {
 				outcome: "superseded",
-				failureCount: row.failureCount
+				failureCount: cursor.head === index ? dispatch.failureCount : 0
 			};
-			if (row.lastFailedAttempt === attempt && row.claimHolder === null) return {
-				outcome: row.failedAt ? "dead_lettered" : "failed",
-				failureCount: row.failureCount
+			if (dispatch.lastFailedAttempt === attempt && dispatch.claimHolder === null) return {
+				outcome: dispatch.failedAt ? "dead_lettered" : "failed",
+				failureCount: dispatch.failureCount
 			};
-			if (row.failedAt) return {
+			if (dispatch.failedAt) return {
 				outcome: "dead_lettered",
-				failureCount: row.failureCount
+				failureCount: dispatch.failureCount
 			};
-			row.failureCount += 1;
-			row.lastError = error;
+			dispatch.failureCount += 1;
+			dispatch.lastError = error;
 			const failedAt = clock.now();
-			row.lastFailedAt = new Date(failedAt);
-			row.lastFailedAttempt = attempt;
-			row.claimHolder = null;
-			row.claimExpiresAt = retryAfterMs === void 0 || row.failureCount >= maxFailures ? null : new Date(failedAt.getTime() + retryAfterMs);
-			if (row.failureCount >= maxFailures) {
-				row.failedAt = new Date(failedAt);
-				dispatchOf(sessionId).ready.delete(row.index);
-				releaseSnapshotPins(sessionId, index);
+			dispatch.lastFailedAt = new Date(failedAt);
+			dispatch.lastFailedAttempt = attempt;
+			dispatch.claimHolder = null;
+			dispatch.claimExpiresAt = retryAfterMs === void 0 || dispatch.failureCount >= maxFailures ? null : new Date(failedAt.getTime() + retryAfterMs);
+			if (dispatch.failureCount >= maxFailures) {
+				deadLetter(sessionId, cursor, failedAt);
 				return {
 					outcome: "dead_lettered",
-					failureCount: row.failureCount
+					failureCount: dispatch.failureCount
 				};
 			}
 			return {
 				outcome: "failed",
-				failureCount: row.failureCount
+				failureCount: dispatch.failureCount
 			};
 		},
 		async deadLetters(sessionId) {
-			const log = sessions.get(sessionId);
-			return (log?.rows ?? []).filter((row) => row.index > log.clearIndex && row.processedAt === null && row.failedAt !== null).map(toStored);
+			const clearIndex = clearIndexOf(sessionId);
+			const dead = [];
+			for (const cursor of cursors.get(sessionId)?.values() ?? []) {
+				if (cursor.head === null || cursor.head <= clearIndex || cursor.dispatch.failedAt === null) continue;
+				dead.push(toHead(cursor, rowAt(sessionId, cursor.head)));
+			}
+			return dead.toSorted(byHead);
 		},
-		async redrive({ sessionId, index, action }) {
-			const row = index > clearIndexOf(sessionId) ? rowAt(sessionId, index) : void 0;
-			if (!row || row.processedAt !== null || row.failedAt === null) return {
+		async redrive({ sessionId, consumer, index, action, consumers }) {
+			const cursor = deadHeadOf(sessionId, consumer, index);
+			if (!cursor) return {
 				redriven: false,
-				hasPending: hasPending(sessionId)
+				hasPending: hasPending(sessionId, consumers)
 			};
-			if (action === "skip") {
-				row.processedAt = clock.now();
-				settle(sessionId, row);
-			} else {
-				row.failedAt = null;
-				row.failureCount = 0;
-				const state = dispatchOf(sessionId);
-				const queue = row.lane === null ? void 0 : state.lanes.get(row.lane);
-				if (row.lane === null || queue?.rows[queue.head] === row) state.ready.set(row.index, row);
+			refreshLogTypes(sessionId, consumers);
+			if (action === "skip") advance(sessionId, cursor);
+			else {
+				cursor.dispatch.failedAt = null;
+				cursor.dispatch.failureCount = 0;
 			}
 			return {
 				redriven: true,
-				hasPending: hasPending(sessionId)
+				hasPending: hasPending(sessionId, consumers)
 			};
 		},
 		async readState(sessionId, reducerName, stateOptions) {
@@ -509,10 +689,10 @@ function memory(options = {}) {
 			for (const write of writes.toSorted((a, b) => a.index - b.index)) {
 				if (write.index < clearIndex) continue;
 				const checkpoint = checkpointKey(sessionId, reducerName, write.index);
-				for (const eventIndex of write.pinEventIndexes ?? []) {
-					const event = rowAt(sessionId, eventIndex);
-					if (!event || event.index <= clearIndex || event.processedAt !== null || event.failedAt !== null) continue;
-					const pinKey = eventPinKey(sessionId, eventIndex);
+				for (const pin of write.pins ?? []) {
+					const cursor = cursorAt(sessionId, pin);
+					if (!cursor || pin.index <= clearIndex || cursor.head !== pin.index || cursor.dispatch.failedAt !== null) continue;
+					const pinKey = headPinKey(sessionId, pin);
 					let pinned = snapshotPins.get(pinKey);
 					if (!pinned) {
 						pinned = /* @__PURE__ */ new Set();
@@ -558,14 +738,14 @@ function memory(options = {}) {
 					fields = /* @__PURE__ */ new Map();
 					participants.set(participant, fields);
 				}
-				const expiresAtMs = clock.now().getTime() + meta.ttlMs;
+				const now = clock.now();
+				const expiresAtMs = now.getTime() + meta.ttlMs;
 				const applied = nullProtoRecord();
 				let appliedCount = 0;
 				for (const [field, value] of Object.entries(values)) {
 					const existing = fields.get(field);
-					if (existing && existing.at > meta.at) continue;
-					if (value === null) fields.delete(field);
-					else fields.set(field, {
+					if (existing && existing.expiresAt > now && existing.at > meta.at) continue;
+					fields.set(field, {
 						value: structuredClone(value),
 						seen: meta.seen,
 						at: new Date(meta.at),
@@ -598,6 +778,7 @@ function memory(options = {}) {
 							fields.delete(field);
 							continue;
 						}
+						if (entry.value === null) continue;
 						rows.push({
 							participant,
 							field,