@vercel/board 0.16.0 → 0.18.0

package/dist/store-memory-Bas9Uq5C.mjs

@@ -0,0 +1,872 @@
+import { n as CLEAR_EVENT_TYPE, o as sessionClearedError, s as supersededAttemptError, t as A2Error } from "./session-clear-wHd5GCpZ-BnKSxReK.mjs";
+import { m as nullProtoRecord } from "./internal-CvsrprnU-CRY89I-b.mjs";
+import { a as idleLogCursor, i as idempotentReplay } from "./store-codec-DwrWlgQx-CYxGW0aD.mjs";
+import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS-BWBgzBHp.mjs";
+//#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-memory.js
+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,
+	payload: structuredClone(row.payload),
+	index: row.index,
+	sessionId: row.sessionId,
+	createdAt: new Date(row.createdAt),
+	cause: row.cause ? { ...row.cause } : null
+});
+const toEvent = (row) => ({
+	id: row.id,
+	type: row.type,
+	payload: structuredClone(row.payload),
+	index: row.index,
+	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 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();
+	/** 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();
+	const snapshotPins = /* @__PURE__ */ new Map();
+	const snapshotPinCounts = /* @__PURE__ */ new Map();
+	const streamSubscribers = /* @__PURE__ */ new Map();
+	/** ns → participant → field → latest surviving write. */
+	const presenceRows = /* @__PURE__ */ new Map();
+	const presenceSubscribers = /* @__PURE__ */ new Map();
+	const notifyStreams = (sessionId, rows) => {
+		const subs = streamSubscribers.get(sessionId);
+		if (!subs) return;
+		for (const listener of subs) for (const row of rows) listener(row);
+	};
+	const logOf = (sessionId) => {
+		let log = sessions.get(sessionId);
+		if (!log) {
+			log = {
+				rows: [],
+				offset: 0,
+				clearIndex: 0,
+				byEventId: /* @__PURE__ */ new Map()
+			};
+			sessions.set(sessionId, log);
+		}
+		return log;
+	};
+	const rowAt = (sessionId, index) => {
+		const log = sessions.get(sessionId);
+		return log && index > log.offset ? log.rows[index - log.offset - 1] : void 0;
+	};
+	const clearIndexOf = (sessionId) => sessions.get(sessionId)?.clearIndex ?? 0;
+	/** The session's row owning `id`, ignoring rows below its clear. */
+	const ownerOf = (sessionId, id) => {
+		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, ref) => {
+		const pinKey = headPinKey(sessionId, ref);
+		const checkpoints = snapshotPins.get(pinKey);
+		if (!checkpoints) return;
+		for (const key of checkpoints) {
+			const next = (snapshotPinCounts.get(key) ?? 1) - 1;
+			if (next === 0) {
+				snapshotPinCounts.delete(key);
+				historicalSnapshots.delete(key);
+			} else snapshotPinCounts.set(key, next);
+		}
+		snapshotPins.delete(pinKey);
+	};
+	/** 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;
+		}
+		return null;
+	};
+	/** 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, 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;
+	};
+	/** The attempt-currency fence shared by consumer appends and clears. */
+	const assertCurrentCause = (sessionId, cause) => {
+		if (cause.index <= clearIndexOf(sessionId)) 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, 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);
+			}
+		}
+		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");
+		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, consumers, cause) => {
+		const log = logOf(sessionId);
+		const base = headOf(log);
+		const inserted = events.map((candidate, offset) => ({
+			id: candidate.id ?? generateId(),
+			type: candidate.type,
+			payload: structuredClone(candidate.payload),
+			index: base + 1 + offset,
+			sessionId,
+			createdAt: new Date(now),
+			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);
+			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. */
+	const dropCheckpointsBelow = (sessionId, clearIndex) => {
+		const prefix = `${sessionId}\u0000`;
+		for (const [key, snapshot] of snapshots) {
+			if (!key.startsWith(prefix) || snapshot.index >= clearIndex) continue;
+			snapshots.delete(key);
+			snapshotPinCounts.delete(`${key}\u0000${snapshot.index}`);
+		}
+		for (const [key, snapshot] of historicalSnapshots) {
+			if (!key.startsWith(prefix) || snapshot.index >= clearIndex) continue;
+			historicalSnapshots.delete(key);
+			snapshotPinCounts.delete(key);
+		}
+	};
+	const readStateOf = (sessionId, reducerName, throughIndex, snapshotThroughIndex) => {
+		const key = snapshotKey(sessionId, reducerName);
+		const clearIndex = clearIndexOf(sessionId);
+		const snapshotFrontier = snapshotThroughIndex ?? throughIndex;
+		const stored = snapshots.get(key);
+		const head = stored && stored.index >= clearIndex ? stored : void 0;
+		let candidate = head && (snapshotFrontier === void 0 || head.index <= snapshotFrontier) ? head : null;
+		if (snapshotFrontier !== void 0) {
+			const prefix = `${key}\u0000`;
+			for (const [historicalKey, snapshot] of historicalSnapshots) if (historicalKey.startsWith(prefix) && snapshot.index >= clearIndex && snapshot.index <= snapshotFrontier && (!candidate || snapshot.index > candidate.index)) candidate = snapshot;
+		}
+		const snapshot = candidate ? {
+			index: candidate.index,
+			state: structuredClone(candidate.state)
+		} : null;
+		const afterIndex = Math.max(snapshot?.index ?? 0, clearIndex - 1);
+		return {
+			headIndex: head?.index ?? null,
+			snapshot,
+			events: (sessions.get(sessionId)?.rows ?? []).filter((row) => row.index > afterIndex && (throughIndex === void 0 || row.index <= throughIndex)).map(toEvent),
+			...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) {
+			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 {
+					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 inserted = insert(sessionId, events, clock.now(), consumers);
+			notifyStreams(sessionId, inserted);
+			return {
+				events: inserted.map(toStored),
+				hasPending: hasPending(sessionId, consumers)
+			};
+		},
+		async clear({ sessionId, ifLastIndex, cause }) {
+			if (cause) assertCurrentCause(sessionId, cause);
+			const log = sessions.get(sessionId);
+			const head = headOf(log);
+			const clearIndex = log?.clearIndex ?? 0;
+			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] = insert(sessionId, [{
+				type: CLEAR_EVENT_TYPE,
+				payload: null
+			}], clock.now(), void 0);
+			logOf(sessionId).clearIndex = marker.index;
+			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,
+				index: marker.index,
+				clearIndex: marker.index
+			};
+		},
+		async reclaim(sessionId) {
+			const log = sessions.get(sessionId);
+			if (!log || log.offset >= log.clearIndex - 1) return {
+				deleted: 0,
+				done: true
+			};
+			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 (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 {
+				deleted: removed.length,
+				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 [];
+			const head = headOf(log);
+			const after = Math.max(opts?.afterIndex ?? 0, log.clearIndex - 1, log.offset);
+			const through = Math.min(opts?.throughIndex ?? head, head);
+			if (through <= after) return [];
+			return log.rows.slice(after - log.offset, through - log.offset).map(toStored);
+		},
+		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((exclude ?? []).map((ref) => cursorKey(ref.consumer, ref.lane, ref.index)));
+			const served = servedBy(consumers);
+			const eligible = [];
+			let retryAt = null;
+			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(cursor);
+			}
+			if (eligible.length === 0) return retryAt ? {
+				outcome: "busy",
+				retryAt
+			} : { outcome: "settled" };
+			const clearIndex = clearIndexOf(sessionId);
+			return {
+				outcome: "claimed",
+				events: eligible.map((cursor) => {
+					const head = claim({
+						sessionId,
+						cursor,
+						holder,
+						now: claimedAt,
+						expiresAt,
+						maxFailures
+					});
+					if (clearIndex > 0) head.clearIndex = clearIndex;
+					return head;
+				}).toSorted(byHead),
+				head: headOf(sessions.get(sessionId))
+			};
+		},
+		async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {
+			const now = clock.now();
+			const expiresAt = new Date(expiresAtMs ?? now.getTime() + ttlMs);
+			const clearIndex = clearIndexOf(sessionId);
+			const renewed = [];
+			const superseded = [];
+			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 = 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 (dispatch.failedAt === null && dispatch.claimHolder === holder && dispatch.claimExpiresAt !== null && dispatch.claimExpiresAt > now) {
+					dispatch.claimExpiresAt = new Date(expiresAt);
+					renewed.push(ref);
+				}
+			}
+			return {
+				renewed,
+				superseded
+			};
+		},
+		async completeAttempt({ sessionId, consumer, lane, index, attempt, events, consumers }) {
+			if (index <= clearIndexOf(sessionId)) 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 (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?.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: events.length === 0 ? [] : idempotentReplay(events, existing.map(toStored))
+				};
+			}
+			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 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, consumer, lane, index, attempt, error, maxFailures, retryAfterMs }) {
+			if (index <= clearIndexOf(sessionId)) return {
+				outcome: "superseded",
+				failureCount: 0
+			};
+			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: cursor.head === index ? dispatch.failureCount : 0
+			};
+			if (dispatch.lastFailedAttempt === attempt && dispatch.claimHolder === null) return {
+				outcome: dispatch.failedAt ? "dead_lettered" : "failed",
+				failureCount: dispatch.failureCount
+			};
+			if (dispatch.failedAt) return {
+				outcome: "dead_lettered",
+				failureCount: dispatch.failureCount
+			};
+			dispatch.failureCount += 1;
+			dispatch.lastError = error;
+			const failedAt = clock.now();
+			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: dispatch.failureCount
+				};
+			}
+			return {
+				outcome: "failed",
+				failureCount: dispatch.failureCount
+			};
+		},
+		async deadLetters(sessionId) {
+			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, consumer, index, action, consumers }) {
+			const cursor = deadHeadOf(sessionId, consumer, index);
+			if (!cursor) return {
+				redriven: false,
+				hasPending: hasPending(sessionId, consumers)
+			};
+			refreshLogTypes(sessionId, consumers);
+			if (action === "skip") advance(sessionId, cursor);
+			else {
+				cursor.dispatch.failedAt = null;
+				cursor.dispatch.failureCount = 0;
+			}
+			return {
+				redriven: true,
+				hasPending: hasPending(sessionId, consumers)
+			};
+		},
+		async readState(sessionId, reducerName, stateOptions) {
+			return readStateOf(sessionId, reducerName, stateOptions?.throughIndex, stateOptions?.snapshotThroughIndex);
+		},
+		async readStates(requests, reducerName) {
+			return requests.map((request) => readStateOf(request.sessionId, reducerName, request.throughIndex, request.snapshotThroughIndex));
+		},
+		async putSnapshots(sessionId, reducerName, writes) {
+			const key = snapshotKey(sessionId, reducerName);
+			const clearIndex = clearIndexOf(sessionId);
+			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 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();
+						snapshotPins.set(pinKey, pinned);
+					}
+					if (!pinned.has(checkpoint)) {
+						pinned.add(checkpoint);
+						snapshotPinCounts.set(checkpoint, (snapshotPinCounts.get(checkpoint) ?? 0) + 1);
+					}
+				}
+				const current = snapshots.get(key);
+				if (!current || write.index >= current.index) {
+					if (current && write.index > current.index && current.index >= clearIndex) {
+						const currentCheckpoint = checkpointKey(sessionId, reducerName, current.index);
+						if ((snapshotPinCounts.get(currentCheckpoint) ?? 0) > 0) historicalSnapshots.set(currentCheckpoint, {
+							index: current.index,
+							state: structuredClone(current.state),
+							updatedAt: new Date(current.updatedAt)
+						});
+					}
+					snapshots.set(key, {
+						index: write.index,
+						state: structuredClone(write.state),
+						updatedAt: clock.now()
+					});
+					historicalSnapshots.delete(checkpoint);
+				} else if (write.index < current.index && (snapshotPinCounts.get(checkpoint) ?? 0) > 0) historicalSnapshots.set(checkpoint, {
+					index: write.index,
+					state: structuredClone(write.state),
+					updatedAt: clock.now()
+				});
+			}
+		},
+		presence: {
+			async set(ns, participant, values, meta) {
+				let participants = presenceRows.get(ns);
+				if (!participants) {
+					participants = /* @__PURE__ */ new Map();
+					presenceRows.set(ns, participants);
+				}
+				let fields = participants.get(participant);
+				if (!fields) {
+					fields = /* @__PURE__ */ new Map();
+					participants.set(participant, fields);
+				}
+				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.expiresAt > now && existing.at > meta.at) continue;
+					fields.set(field, {
+						value: structuredClone(value),
+						seen: meta.seen,
+						at: new Date(meta.at),
+						expiresAt: new Date(expiresAtMs)
+					});
+					applied[field] = structuredClone(value);
+					appliedCount += 1;
+				}
+				if (fields.size === 0) participants.delete(participant);
+				if (participants.size === 0) presenceRows.delete(ns);
+				if (appliedCount === 0) return;
+				const subs = presenceSubscribers.get(ns);
+				if (!subs) return;
+				const patch = {
+					participant,
+					values: applied,
+					seen: meta.seen,
+					at: new Date(meta.at)
+				};
+				for (const listener of subs) listener(patch);
+			},
+			async read(ns) {
+				const participants = presenceRows.get(ns);
+				if (!participants) return [];
+				const now = clock.now();
+				const rows = [];
+				for (const [participant, fields] of participants) {
+					for (const [field, entry] of fields) {
+						if (entry.expiresAt <= now) {
+							fields.delete(field);
+							continue;
+						}
+						if (entry.value === null) continue;
+						rows.push({
+							participant,
+							field,
+							value: structuredClone(entry.value),
+							seen: entry.seen,
+							at: new Date(entry.at),
+							expiresAt: new Date(entry.expiresAt)
+						});
+					}
+					if (fields.size === 0) participants.delete(participant);
+				}
+				if (participants.size === 0) presenceRows.delete(ns);
+				return rows;
+			},
+			subscribe(ns, onPatch) {
+				let subs = presenceSubscribers.get(ns);
+				if (!subs) {
+					subs = /* @__PURE__ */ new Set();
+					presenceSubscribers.set(ns, subs);
+				}
+				subs.add(onPatch);
+				return () => {
+					subs.delete(onPatch);
+					if (subs.size === 0) presenceSubscribers.delete(ns);
+				};
+			}
+		},
+		stream(sessionId, opts) {
+			const startAfter = opts?.startAfter ?? 0;
+			return { [Symbol.asyncIterator]() {
+				let last = Math.max(startAfter, clearIndexOf(sessionId) - 1);
+				let wake = null;
+				let closed = false;
+				const onRow = () => {
+					wake?.();
+				};
+				let subs = streamSubscribers.get(sessionId);
+				if (!subs) {
+					subs = /* @__PURE__ */ new Set();
+					streamSubscribers.set(sessionId, subs);
+				}
+				subs.add(onRow);
+				const stop = () => {
+					if (closed) return;
+					closed = true;
+					subs.delete(onRow);
+					if (subs.size === 0) streamSubscribers.delete(sessionId);
+					wake?.();
+				};
+				return {
+					async next() {
+						try {
+							for (;;) {
+								if (closed) return {
+									value: void 0,
+									done: true
+								};
+								const log = sessions.get(sessionId);
+								const row = log?.rows[Math.max(0, last - log.offset)];
+								if (row) {
+									const value = toStored(row);
+									last = row.index;
+									return {
+										value,
+										done: false
+									};
+								}
+								await new Promise((resolve) => {
+									wake = resolve;
+								});
+								wake = null;
+							}
+						} catch (error) {
+							stop();
+							throw error;
+						}
+					},
+					async return() {
+						stop();
+						return {
+							value: void 0,
+							done: true
+						};
+					}
+				};
+			} };
+		}
+	};
+}
+//#endregion
+export { memory as t };