@vercel/board 0.16.0 → 0.18.0

package/dist/server-DtFrWxi3-Boa6gdWO.mjs

@@ -0,0 +1,3602 @@
+import { a as isSessionCleared, i as asStoreUnavailable, o as sessionClearedError, r as NonRetriableError, t as A2Error } from "./session-clear-wHd5GCpZ-BnKSxReK.mjs";
+import { n as cloneInitial, o as validateSync, r as foldEvent } from "./reducer-CjmvZSAb-D_OSISmj.mjs";
+import { _ as serverInternals, a as RESERVED_PARTICIPANT_IDS, c as STREAM_TIMINGS, d as drainSettledHooks, f as failedPreviousAttempt, g as runtimeConsumers, h as runtimeConsumerFactory, m as nullProtoRecord, o as SOCKET_TIMINGS, p as markSchedulerSendFailure, r as POLL_TIMINGS, s as STATE_CACHE, t as DRAIN_TIMINGS, v as stateTailReaders } from "./internal-CvsrprnU-CRY89I-b.mjs";
+import { a as takeBuffered, i as presenceTombstones, n as isSerializedEvent, r as parseSerializedEvent, t as bufferedEvents } from "./stream-buffer-DrTyiIuo-BKy-vI14.mjs";
+import { i as streamActivities, n as defaultSleep, t as createStreamActivity } from "./store-polling-BZt2Rf3D-BiEM6_HB.mjs";
+import { r as platformWaitUntil, t as invocationDeadlineMs } from "./platform-B4TnJtWu-CwcTyKg2.mjs";
+import { t as retryableLazy } from "./retryable-lazy-DZWmHpii-Bye-W8q7.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/reducer-runtime-DQwz_J59.js
+const runtimeKey = Symbol("a2.reducerRuntime");
+function encodeState(options) {
+	const storage = options.reducer[runtimeKey]?.storage;
+	return storage ? storage.encode(options.state) : options.state;
+}
+function decodeState(options) {
+	const storage = options.reducer[runtimeKey]?.storage;
+	return storage ? storage.decode(options.state) : options.state;
+}
+//#endregion
+//#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/bounded-cache-CPHWF-8h.js
+function boundedCache({ maxEntries, maxBytes }) {
+	const entries = /* @__PURE__ */ new Map();
+	let total = 0;
+	const remove = (key) => {
+		const entry = entries.get(key);
+		if (!entry) return;
+		entries.delete(key);
+		total -= entry.bytes;
+	};
+	return {
+		get(key) {
+			const entry = entries.get(key);
+			if (!entry) return void 0;
+			entries.delete(key);
+			entries.set(key, entry);
+			return entry.value;
+		},
+		set(key, value, bytes) {
+			remove(key);
+			if (bytes > maxBytes / 4) return;
+			entries.set(key, {
+				value,
+				bytes
+			});
+			total += bytes;
+			for (const oldest of entries.keys()) {
+				if (entries.size <= maxEntries && total <= maxBytes) break;
+				remove(oldest);
+			}
+		},
+		delete: remove,
+		deleteWhere(match) {
+			for (const key of entries.keys()) if (match(key)) remove(key);
+		}
+	};
+}
+//#endregion
+//#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/wire-CV-Z7wz-.js
+/**
+* The wire format shared by server.fetch and experimental-a2/client
+* (browser side): events as JSON with ISO timestamps, and the A2Error
+* envelope. Internal module — both entry points re-export what's
+* public.
+*/
+function eventToWire(event) {
+	return {
+		id: event.id,
+		type: event.type,
+		payload: event.payload,
+		index: event.index,
+		sessionId: event.sessionId,
+		createdAt: event.createdAt.toISOString()
+	};
+}
+const lastEncoding = (encode) => {
+	let last;
+	let text = "";
+	return (value) => {
+		if (value !== last) {
+			text = encode(value);
+			last = value;
+		}
+		return text;
+	};
+};
+const isoJson = lastEncoding((ms) => JSON.stringify(new Date(ms).toISOString()));
+const sessionJson = lastEncoding((id) => JSON.stringify(id));
+const typeJson = lastEncoding((type) => JSON.stringify(type));
+/**
+* `JSON.stringify(eventToWire(event))` for the parsed event, built around the
+* stored payload text instead of parsing and re-serializing it.
+*/
+function serializedEventToWireJson(event) {
+	return `{"id":${JSON.stringify(event.id)},"type":${typeJson(event.type)},"payload":${event.payloadJson},"index":${event.index},"sessionId":${sessionJson(event.sessionId)},"createdAt":${isoJson(event.createdAtMs)}}`;
+}
+function wireVersion(value) {
+	return value === "2" ? 2 : 1;
+}
+/**
+* Events already held by a stream join one write while it is shorter than
+* this many characters, so a write can exceed it by the event that crosses it.
+*/
+const EVENT_WRITE_CHARS = 65536;
+/** Stream items that are events, as opposed to snapshot or presence frames. */
+function isStreamEvent(item) {
+	return !("kind" in item) && !("snapshot" in item) && !("participant" in item);
+}
+/**
+* `first` and the events `iterator` already holds, encoded, until the batch
+* reaches `EVENT_WRITE_CHARS`; `last` is the batch's final event.
+*/
+function heldEventBatch(options) {
+	const { iterator, encode } = options;
+	let last = options.first;
+	const events = [encode(last)];
+	let chars = events[0].length;
+	while (chars < EVENT_WRITE_CHARS) {
+		const held = takeBuffered(iterator);
+		if (!held) break;
+		const json = encode(held);
+		events.push(json);
+		chars += json.length + 1;
+		last = held;
+	}
+	return {
+		events,
+		last
+	};
+}
+/** One version 2 event as JSON, splicing a held row's stored payload. */
+function compactEventJson(event) {
+	if (!isSerializedEvent(event)) return JSON.stringify({
+		id: event.id,
+		type: event.type,
+		payload: event.payload,
+		index: event.index,
+		createdAt: event.createdAt.getTime()
+	});
+	return `{"id":${JSON.stringify(event.id)},"type":${typeJson(event.type)},"payload":${event.payloadJson},"index":${event.index},"createdAt":${event.createdAtMs}}`;
+}
+function presencePatchToWire(patch) {
+	return {
+		participant: patch.participant,
+		values: patch.values,
+		seen: patch.seen,
+		at: patch.at.toISOString()
+	};
+}
+function presenceSnapshotToWire(snapshot) {
+	const wire = nullProtoRecord();
+	for (const [participant, fields] of Object.entries(snapshot.snapshot)) {
+		const wireFields = nullProtoRecord();
+		for (const [field, entry] of Object.entries(fields)) {
+			if (entry === void 0) continue;
+			wireFields[field] = {
+				value: entry.value,
+				seen: entry.seen,
+				at: entry.at.toISOString()
+			};
+		}
+		wire[participant] = wireFields;
+	}
+	return { snapshot: wire };
+}
+const ERROR_STATUS = {
+	INVALID_PAYLOAD: 400,
+	FORBIDDEN: 403,
+	UNKNOWN_EVENT_TYPE: 400,
+	PARTIAL_DUPLICATE_BATCH: 400,
+	SUPERSEDED_ATTEMPT: 409,
+	SESSION_CLEARED: 409,
+	CLAIM_EXPIRED: 409,
+	STORE_UNAVAILABLE: 503,
+	STORE_NOT_CONFIGURED: 500,
+	UNKNOWN_PRESENCE_FIELD: 400,
+	PRESENCE_NOT_SUPPORTED: 500,
+	CONSUMER_DEAD_LETTERED: 500
+};
+function errorStatus(code) {
+	return ERROR_STATUS[isServerErrorCode(code) ? code : "STORE_UNAVAILABLE"];
+}
+function errorToWire(error) {
+	const failure = asA2Error(error);
+	const body = { error: {
+		code: failure.code,
+		message: failure.message
+	} };
+	if (failure.details !== void 0) body.error.details = failure.details;
+	return body;
+}
+/** Wrap an arbitrary thrown value for the wire: known server codes pass through,
+* anything else becomes STORE_UNAVAILABLE — from the client's
+* perspective an unknown server failure is retryable-once, not a
+* protocol contract. */
+function asA2Error(error) {
+	return error instanceof A2Error && isServerErrorCode(error.code) ? error : new A2Error("STORE_UNAVAILABLE", "internal error", { cause: error });
+}
+const isServerErrorCode = (code) => Object.hasOwn(ERROR_STATUS, code);
+function stateSnapshotToWire(frame) {
+	return frame.state === void 0 ? {
+		...frame,
+		state: null,
+		stateUndefined: true
+	} : frame;
+}
+const SOCKET_PING_FRAME = JSON.stringify({ kind: "ping" });
+/** One stream item as a socket frame — `sseResponse`'s framing over
+* the same codecs, with `kind` instead of an SSE event name. On a
+* multiplexed socket presence frames carry the `sessionId` tag; events
+* already carry theirs in the wire event. */
+function socketFrameFor(item, sessionId) {
+	const tag = sessionId === void 0 ? {} : { sessionId };
+	if ("kind" in item) return JSON.stringify(stateSnapshotToWire(item));
+	if ("snapshot" in item) return JSON.stringify({
+		kind: "presence-snapshot",
+		...presenceSnapshotToWire(item),
+		...tag
+	});
+	if ("participant" in item) return JSON.stringify({
+		kind: "presence",
+		...presencePatchToWire(item),
+		...tag
+	});
+	return JSON.stringify({
+		kind: "event",
+		...eventToWire(item)
+	});
+}
+/** A version 2 batch frame from compact event JSON; a multiplexed
+* socket names the batch's session once. */
+function socketEventsFor(events, sessionId) {
+	return `{"kind":"events",${sessionId === void 0 ? "" : `"sessionId":${JSON.stringify(sessionId)},`}"events":[${events.join(",")}]}`;
+}
+function socketAckFor(req, events, sessionId) {
+	return JSON.stringify({
+		kind: "ack",
+		req,
+		events: events.map(eventToWire),
+		...sessionId === void 0 ? {} : { sessionId }
+	});
+}
+function socketErrorAckFor(req, error, sessionId) {
+	return JSON.stringify({
+		kind: "ack",
+		req,
+		...errorToWire(error),
+		...sessionId === void 0 ? {} : { sessionId }
+	});
+}
+function socketSubscribedFor(options) {
+	const { sessionId, attempt } = options;
+	return JSON.stringify({
+		kind: "subscribed",
+		sessionId,
+		...attempt === void 0 ? {} : { attempt }
+	});
+}
+/** The subscription-over notice: with a `reason` the server rejected
+* or lost the session's stream, without one it ended cleanly. */
+function socketUnsubscribedFor(options) {
+	const { sessionId, attempt, reason, error } = options;
+	return JSON.stringify({
+		kind: "unsubscribed",
+		sessionId,
+		...attempt === void 0 ? {} : { attempt },
+		...reason === void 0 ? {} : { reason },
+		...error === void 0 ? {} : errorToWire(error)
+	});
+}
+//#endregion
+//#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/server-DtFrWxi3.js
+/**
+* The push envelope's trust boundary for `{ sessionId, events, presence? }`,
+* shared verbatim by the HTTP
+* POST lane and the socket's push/presence frames so INVALID_PAYLOAD
+* shapes are one implementation. Internal module, not public API.
+*/
+const invalidPushBody = (message) => new A2Error("INVALID_PAYLOAD", `malformed push body: ${message}`);
+const invalid = invalidPushBody;
+function parsePresenceSibling(value) {
+	if (value === void 0) return void 0;
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw invalid("presence must be an object when present");
+	const { participant, values, seen, at } = value;
+	if (typeof participant !== "string" || participant.length === 0) throw invalid("presence.participant must be a non-empty string");
+	if (RESERVED_PARTICIPANT_IDS.has(participant)) throw invalid(`presence.participant must not be '${participant}'`);
+	if (values === null || typeof values !== "object" || Array.isArray(values)) throw invalid("presence.values must be an object");
+	if (seen !== void 0 && (typeof seen !== "number" || !Number.isFinite(seen) || seen < 0)) throw invalid("presence.seen must be a non-negative number when present");
+	if (at !== void 0 && (typeof at !== "number" || !Number.isFinite(at) || at < 0 || at > 864e13)) throw invalid("presence.at must be a non-negative epoch-milliseconds timestamp within the Date range when present");
+	const out = {
+		participant,
+		values
+	};
+	if (seen !== void 0) out.seen = seen;
+	if (at !== void 0) out.at = at;
+	return out;
+}
+/** The longest event id a push may carry: ids are indexed, and Postgres's index rows have a limit. */
+const MAX_PUSHED_ID = 256;
+/** A UUIDv5, the shape of the ids A2 derives (deterministic-id.ts). */
+const DERIVED_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/** The events half of the envelope, shared by the POST body and socket
+* `push` frames so INVALID_PAYLOAD shapes have one implementation. */
+function parsePushEvents(events) {
+	if (!Array.isArray(events) || events.length === 0) throw invalid("events must be a non-empty array");
+	return events.map((event, i) => {
+		if (event === null || typeof event !== "object") throw invalid(`events[${i}] must be an object`);
+		const { type, payload, id } = event;
+		if (typeof type !== "string" || type.length === 0) throw invalid(`events[${i}].type must be a non-empty string`);
+		if (id !== void 0 && typeof id !== "string") throw invalid(`events[${i}].id must be a string when present`);
+		if (id !== void 0 && (id.length === 0 || id.length > MAX_PUSHED_ID)) throw invalid(`events[${i}].id must be 1-${MAX_PUSHED_ID} characters when present`);
+		if (id !== void 0 && DERIVED_ID.test(id)) throw invalid(`events[${i}].id is shaped like the ids A2 derives for consumers (a UUIDv5); use crypto.randomUUID() or idempotentId()`);
+		const out = {
+			type,
+			payload
+		};
+		if (id !== void 0) out.id = id;
+		return out;
+	});
+}
+/**
+* Validate the push envelope — `{ sessionId, events, presence? }` —
+* throwing `INVALID_PAYLOAD` on a malformed body. Payload validation
+* against the machine's schemas happens in `append` and `setPresence`,
+* not here. Either plane may appear alone: a presence-only push has no
+* (or empty) `events`.
+*/
+async function parsePushBody(req) {
+	let body;
+	try {
+		body = await req.json();
+	} catch (cause) {
+		throw new A2Error("INVALID_PAYLOAD", "push body is not valid JSON", { cause });
+	}
+	if (body === null || typeof body !== "object") throw invalid("expected an object");
+	const { sessionId, events, presence } = body;
+	if (typeof sessionId !== "string" || sessionId.length === 0) throw invalid("sessionId must be a non-empty string");
+	const parsedPresence = parsePresenceSibling(presence);
+	if (parsedPresence !== void 0 && (events === void 0 || Array.isArray(events) && events.length === 0)) return {
+		sessionId,
+		events: [],
+		presence: parsedPresence
+	};
+	const parsed = parsePushEvents(events);
+	return parsedPresence !== void 0 ? {
+		sessionId,
+		events: parsed,
+		presence: parsedPresence
+	} : {
+		sessionId,
+		events: parsed
+	};
+}
+/**
+* The A2 socket protocol's server half (specs/a2-api.md §13): the
+* per-socket shell — teardown, backpressure, heartbeat, the malformed
+* budget, and the in-flight bound. `sessionSocket` binds one session to
+* one socket; `sessionsSocket` is the opt-in multiplexed handler. Only
+* `A2Socket`, the structural socket the platform hands over, is public.
+*/
+const messageText = (data) => {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+	if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data);
+	if (Array.isArray(data) && data.every(ArrayBuffer.isView)) {
+		const decoder = new TextDecoder();
+		let text = "";
+		for (const part of data) text += decoder.decode(part, { stream: true });
+		return text + decoder.decode();
+	}
+	return null;
+};
+/**
+* How many unparseable or invalid frames a socket may send before it
+* is closed (1008): the budget absorbs isolated client bugs without
+* letting a broken peer spin the validation path forever. Push frames
+* with a usable `req` never count — their failures are answered with
+* error acks, exactly like the POST path's 4xx bodies.
+*/
+const MAX_MALFORMED_FRAMES = 5;
+function socketShell(socket, release, onFrame, deadlineAt) {
+	let torn = false;
+	let malformed = 0;
+	let heartbeat;
+	let deadline;
+	const teardown = () => {
+		if (torn) return;
+		torn = true;
+		if (heartbeat !== void 0) clearInterval(heartbeat);
+		if (deadline !== void 0) clearTimeout(deadline);
+		release();
+	};
+	const shutdown = (code, reason) => {
+		if (torn) return;
+		teardown();
+		try {
+			socket.close(code, reason);
+		} catch {}
+	};
+	const send = (data) => {
+		if (torn) return;
+		if (typeof socket.bufferedAmount === "number" && socket.bufferedAmount > SOCKET_TIMINGS.disconnectWaterMarkBytes) {
+			shutdown(1008, "backpressure: peer not reading");
+			return;
+		}
+		try {
+			socket.send(data);
+		} catch {
+			teardown();
+		}
+	};
+	const malformedFrame = (reason) => {
+		malformed += 1;
+		if (malformed >= MAX_MALFORMED_FRAMES) shutdown(1008, `too many malformed frames (last: ${reason})`);
+	};
+	let inFlight = 0;
+	const track = (work) => {
+		inFlight += 1;
+		work.finally(() => {
+			inFlight -= 1;
+		});
+	};
+	const handleMessage = (data) => {
+		if (torn) return;
+		const text = messageText(data);
+		if (text === null) {
+			malformedFrame("non-text frame");
+			return;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(text);
+		} catch {
+			malformedFrame("frame is not valid JSON");
+			return;
+		}
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+			malformedFrame("frame is not an object");
+			return;
+		}
+		onFrame(parsed);
+	};
+	socket.on("message", handleMessage);
+	socket.on("close", teardown);
+	socket.on("error", teardown);
+	heartbeat = setInterval(() => send(SOCKET_PING_FRAME), STREAM_TIMINGS.sseHeartbeatMs);
+	heartbeat.unref?.();
+	if (deadlineAt !== void 0) {
+		deadline = setTimeout(() => shutdown(1e3, "deadline"), Math.max(0, deadlineAt - Date.now()));
+		deadline.unref?.();
+	}
+	return {
+		torn: () => torn,
+		send,
+		shutdown,
+		malformedFrame,
+		buffered: () => typeof socket.bufferedAmount === "number" ? socket.bufferedAmount : 0,
+		overCap: () => inFlight >= SOCKET_TIMINGS.maxInFlightMessages,
+		track
+	};
+}
+const socketSubscription = (options) => {
+	const { target, startAfter, presence, attempt } = options;
+	return {
+		target,
+		iterator: (presence ? target.stream({
+			startAfter,
+			presence: true
+		}) : target.stream({ startAfter }))[Symbol.asyncIterator](),
+		stopped: false,
+		...attempt === void 0 ? {} : { attempt }
+	};
+};
+const stopSubscription = (subscription) => {
+	subscription.stopped = true;
+	subscription.iterator.return?.()?.catch(() => {});
+};
+/**
+* Sends a subscription's items until it ends. With `batch`, an event and
+* the events its iterator already holds go out as one frame.
+*/
+const pumpSubscription = async (options) => {
+	const { shell, subscription, frameFor, batch } = options;
+	for (;;) {
+		while (!shell.torn() && !subscription.stopped && shell.buffered() > SOCKET_TIMINGS.highWaterMarkBytes) await new Promise((wake) => setTimeout(wake, SOCKET_TIMINGS.resumePollMs));
+		if (shell.torn() || subscription.stopped) return;
+		const { value, done } = await subscription.iterator.next();
+		if (shell.torn() || subscription.stopped || done) return;
+		if (!batch || !isStreamEvent(value)) {
+			shell.send(frameFor(value));
+			continue;
+		}
+		const { events } = heldEventBatch({
+			first: value,
+			iterator: subscription.iterator,
+			encode: compactEventJson
+		});
+		shell.send(batch(events));
+	}
+};
+const handleSocketPush = async (shell, target, sessionId, frame, req, ackSessionId, gatePush, activate) => {
+	try {
+		const events = parsePushEvents(frame["events"]);
+		const denial = await gatePush?.(sessionId, events, void 0) ?? null;
+		if (denial !== null) {
+			shell.send(socketErrorAckFor(req, denial, ackSessionId));
+			return;
+		}
+		activate();
+		const appended = await target.append(...events);
+		activate();
+		shell.send(socketAckFor(req, appended, ackSessionId));
+	} catch (error) {
+		shell.send(socketErrorAckFor(req, asA2Error(error), ackSessionId));
+	}
+};
+const applySocketPresence = async (shell, target, sessionId, frame, gatePush) => {
+	if (typeof target.setPresence !== "function") {
+		shell.malformedFrame("presence frame on a presence-less session");
+		return;
+	}
+	let patch;
+	try {
+		patch = parsePresenceSibling(frame);
+	} catch {
+		shell.malformedFrame("invalid presence frame");
+		return;
+	}
+	if (!patch) return;
+	try {
+		if ((await gatePush?.(sessionId, [], patch) ?? null) !== null) return;
+		await target.setPresence(patch);
+	} catch (error) {
+		const failure = asA2Error(error);
+		if (failure.code === "INVALID_PAYLOAD" || failure.code === "UNKNOWN_PRESENCE_FIELD") {
+			shell.malformedFrame("invalid presence frame");
+			return;
+		}
+		shell.shutdown(1011, "internal error");
+	}
+};
+function sessionSocket(sessionId, session, socket, options) {
+	const target = session;
+	const subscription = socketSubscription({
+		target,
+		startAfter: options?.startAfter ?? 0,
+		presence: options?.presence === true
+	});
+	const handleFrame = (frame) => {
+		switch (frame["kind"]) {
+			case "push": {
+				const req = frame["req"];
+				if (typeof req !== "number") {
+					shell.malformedFrame("push frame without a numeric req");
+					return;
+				}
+				if (frame["sessionId"] !== void 0) {
+					shell.send(socketErrorAckFor(req, new A2Error("INVALID_PAYLOAD", "sessionId is not allowed on a single-session socket")));
+					return;
+				}
+				if (shell.overCap()) {
+					shell.send(socketErrorAckFor(req, new A2Error("STORE_UNAVAILABLE", "push shed: too many in flight on this socket")));
+					return;
+				}
+				shell.track(handleSocketPush(shell, target, sessionId, frame, req, void 0, options?.gatePush, () => streamActivities.get(subscription.iterator)?.activate()));
+				return;
+			}
+			case "presence":
+				if (frame["sessionId"] !== void 0) {
+					shell.malformedFrame("sessionId is not allowed on a single-session socket");
+					return;
+				}
+				if (!shell.overCap()) shell.track(applySocketPresence(shell, target, sessionId, frame, options?.gatePush));
+				return;
+			default: return;
+		}
+	};
+	const shell = socketShell(socket, () => stopSubscription(subscription), handleFrame, options?.deadline);
+	pumpSubscription({
+		shell,
+		subscription,
+		frameFor: socketFrameFor,
+		...options?.wire === 2 ? { batch: (events) => socketEventsFor(events) } : {}
+	}).then(() => shell.shutdown(1e3), () => shell.shutdown(1011, "stream failed"));
+}
+const parseSubscribeEntries = (value) => {
+	if (!Array.isArray(value) || value.length === 0) return null;
+	const entries = [];
+	for (const entry of value) {
+		if (entry === null || typeof entry !== "object") return null;
+		const { id, attempt, index, bootstrap, reducer } = entry;
+		if (typeof id !== "string" || id.length === 0) return null;
+		if (attempt !== void 0 && (typeof attempt !== "number" || !Number.isSafeInteger(attempt) || attempt < 0)) return null;
+		if (reducer !== void 0 && (typeof reducer !== "string" || reducer.length === 0)) return null;
+		const lane = {
+			id,
+			...attempt === void 0 ? {} : { attempt }
+		};
+		if (bootstrap === true) {
+			if (index !== void 0 || typeof reducer !== "string") return null;
+			entries.push({
+				...lane,
+				bootstrap: true,
+				reducer
+			});
+		} else {
+			if (bootstrap !== void 0 || typeof index !== "number" || !Number.isSafeInteger(index) || index < 0) return null;
+			entries.push({
+				...lane,
+				index,
+				...reducer === void 0 ? {} : { reducer }
+			});
+		}
+	}
+	return entries;
+};
+/**
+* Speak the multiplexed A2 socket protocol (specs/a2-api.md §13)
+* against many sessions on one socket. `subscribe` frames open a
+* per-session pump at that session's own resume frontier; push and
+* presence frames route by `sessionId` through the same validation
+* seams as the POST lane; every down frame carries the `sessionId` it
+* belongs to. One heartbeat, one
+* malformed budget, one in-flight bound, one backpressure gauge — per
+* socket, shared by all sessions. A session's stream ending or failing
+* answers `unsubscribed` for that session; only the peer, the
+* deadline, the malformed budget, or backpressure closes the socket.
+*/
+function sessionsSocket(resolve, socket, options) {
+	const presence = options?.presence === true;
+	const subscriptions = /* @__PURE__ */ new Map();
+	const retire = (id, subscription) => {
+		if (subscriptions.get(id) === subscription) subscriptions.delete(id);
+	};
+	const runSubscription = async (id, subscription) => {
+		const { attempt } = subscription;
+		try {
+			await pumpSubscription({
+				shell,
+				subscription,
+				frameFor: (item) => socketFrameFor(item, id),
+				...options?.wire === 2 ? { batch: (events) => socketEventsFor(events, id) } : {}
+			});
+			if (shell.torn() || subscription.stopped) return;
+			retire(id, subscription);
+			shell.send(socketUnsubscribedFor({
+				sessionId: id,
+				attempt
+			}));
+		} catch (error) {
+			if (shell.torn() || subscription.stopped) return;
+			retire(id, subscription);
+			shell.send(socketUnsubscribedFor({
+				sessionId: id,
+				attempt,
+				reason: "stream failed",
+				error: asA2Error(error)
+			}));
+		}
+	};
+	const startSubscription = async (entry) => {
+		const { id, attempt } = entry;
+		const index = entry.index ?? 0;
+		const existing = subscriptions.get(id);
+		if (existing) {
+			stopSubscription(existing);
+			subscriptions.delete(id);
+		}
+		let session;
+		try {
+			session = await resolve(id, index, entry);
+		} catch (error) {
+			if (!shell.torn()) shell.send(socketUnsubscribedFor({
+				sessionId: id,
+				attempt,
+				reason: "stream failed",
+				error: asA2Error(error)
+			}));
+			return;
+		}
+		if (shell.torn()) return;
+		if (session === null) {
+			shell.send(socketUnsubscribedFor({
+				sessionId: id,
+				attempt,
+				reason: "subscribe rejected",
+				error: new A2Error("FORBIDDEN", "the subscription is not authorized")
+			}));
+			return;
+		}
+		const subscription = socketSubscription({
+			target: session,
+			startAfter: index,
+			presence,
+			attempt
+		});
+		subscriptions.set(id, subscription);
+		shell.send(socketSubscribedFor({
+			sessionId: id,
+			attempt
+		}));
+		runSubscription(id, subscription);
+	};
+	let controlTail = Promise.resolve();
+	const control = (work) => {
+		controlTail = controlTail.then(work).catch(() => {});
+	};
+	const handlePush = async (frame, req, sessionId) => {
+		const subscription = subscriptions.get(sessionId);
+		if (subscription === void 0) {
+			shell.send(socketErrorAckFor(req, new A2Error("STORE_UNAVAILABLE", "session is not subscribed on this socket"), sessionId));
+			return;
+		}
+		await handleSocketPush(shell, subscription.target, sessionId, frame, req, sessionId, options?.gatePush, () => {
+			const current = subscriptions.get(sessionId);
+			if (current) streamActivities.get(current.iterator)?.activate();
+		});
+	};
+	const handlePresence = async (frame, sessionId) => {
+		const subscription = subscriptions.get(sessionId);
+		if (subscription === void 0) return;
+		await applySocketPresence(shell, subscription.target, sessionId, frame, options?.gatePush);
+	};
+	const handleFrame = (frame) => {
+		switch (frame["kind"]) {
+			case "subscribe": {
+				const entries = parseSubscribeEntries(frame["sessions"]);
+				if (entries === null) {
+					shell.malformedFrame("malformed subscribe frame");
+					return;
+				}
+				for (const entry of entries) control(() => startSubscription(entry));
+				return;
+			}
+			case "unsubscribe": {
+				const ids = frame["sessions"];
+				if (!Array.isArray(ids) || ids.length === 0 || !ids.every((id) => typeof id === "string")) {
+					shell.malformedFrame("malformed unsubscribe frame");
+					return;
+				}
+				for (const id of ids) control(() => {
+					const subscription = subscriptions.get(id);
+					if (subscription === void 0) return;
+					stopSubscription(subscription);
+					subscriptions.delete(id);
+				});
+				return;
+			}
+			case "push": {
+				const req = frame["req"];
+				const sessionId = frame["sessionId"];
+				if (shell.overCap()) {
+					if (typeof req === "number") shell.send(socketErrorAckFor(req, new A2Error("STORE_UNAVAILABLE", "push shed: too many in flight on this socket"), typeof sessionId === "string" ? sessionId : void 0));
+					else shell.malformedFrame("push frame without a numeric req");
+					return;
+				}
+				if (typeof req !== "number") {
+					shell.malformedFrame("push frame without a numeric req");
+					return;
+				}
+				if (typeof sessionId !== "string" || sessionId.length === 0) {
+					shell.send(socketErrorAckFor(req, new A2Error("INVALID_PAYLOAD", "push frame without a sessionId")));
+					return;
+				}
+				shell.track(handlePush(frame, req, sessionId));
+				return;
+			}
+			case "presence": {
+				if (shell.overCap()) return;
+				const sessionId = frame["sessionId"];
+				if (typeof sessionId !== "string" || sessionId.length === 0) {
+					shell.malformedFrame("presence frame without a sessionId");
+					return;
+				}
+				shell.track(handlePresence(frame, sessionId));
+				return;
+			}
+			default: return;
+		}
+	};
+	const shell = socketShell(socket, () => {
+		for (const subscription of subscriptions.values()) stopSubscription(subscription);
+		subscriptions.clear();
+	}, (frame) => handleFrame(frame), options?.deadline);
+}
+/**
+* The SSE response protocol — framing, heartbeat, deadline, and
+* teardown for the live stream lane. Internal module: `server.fetch` is
+* the sanctioned caller; the framing rules stay
+* documented on `sseResponse` because the client's parser (and the
+* stall watchdog) depend on them.
+*/
+/**
+* Pipe a live event iterable into an SSE `Response`. Each event is one
+* frame — `id:` carries the event-log index, `data:` the JSON event.
+* Frames for events the iterable already holds are written together. With
+* `wire: 2` those events share one frame instead: `data:` is a JSON array of
+* `CompactWireEvent`s and `id:` the last one's index. A
+* `stream({ presence: true })` iterable also yields presence items,
+* which ride as named frames old clients skip: `event:
+* presence-snapshot` first (the map, ISO dates), then `event: presence`
+* per patch — no `id:`, presence never advances the resume frontier. A
+* disconnecting client cancels the stream, which closes the underlying
+* subscription. Two kinds of comment frames ride along: a `: connected`
+* prelude that flushes headers immediately, and a `: ping` heartbeat
+* every 15 seconds so clients (and proxies) can tell a quiet stream
+* from a dead connection — the session client's stall watchdog counts
+* on it. When the platform exposes an invocation deadline, the response
+* closes cleanly one second before it so the client reconnects without
+* a platform-timeout failure.
+*/
+function sseResponse(iterable, options = {}) {
+	const write = options.wire === 2 ? batchedFrames : eventFrames;
+	const iterator = iterable[Symbol.asyncIterator]();
+	const encoder = new TextEncoder();
+	let heartbeat;
+	let deadlineTimer;
+	let closed = false;
+	let iteratorReturned = false;
+	let stopActivity;
+	const stopTimers = () => {
+		stopActivity?.();
+		stopActivity = void 0;
+		if (heartbeat !== void 0) clearInterval(heartbeat);
+		if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
+		heartbeat = void 0;
+		deadlineTimer = void 0;
+	};
+	const returnIterator = async () => {
+		if (iteratorReturned) return;
+		iteratorReturned = true;
+		await iterator.return?.();
+	};
+	const stream = new ReadableStream({
+		start(controller) {
+			controller.enqueue(encoder.encode(": connected\n\n"));
+			const activity = streamActivities.get(iterator);
+			if (activity) {
+				const announce = (idle) => {
+					if (closed) return;
+					controller.enqueue(encoder.encode(`event: a2-activity\ndata: ${idle ? "idle" : "active"}\n\n`));
+				};
+				stopActivity = activity.subscribe(announce);
+				if (activity.idle) announce(true);
+			}
+			heartbeat = setInterval(() => {
+				try {
+					controller.enqueue(encoder.encode(": ping\n\n"));
+				} catch {
+					stopTimers();
+				}
+			}, STREAM_TIMINGS.sseHeartbeatMs);
+			heartbeat.unref?.();
+			const invocationDeadline = invocationDeadlineMs();
+			if (invocationDeadline !== null) {
+				const delay = Math.max(0, invocationDeadline - Date.now() - STREAM_TIMINGS.sseDeadlineGraceMs);
+				deadlineTimer = setTimeout(() => {
+					if (closed) return;
+					closed = true;
+					stopTimers();
+					returnIterator().catch(() => {});
+					try {
+						controller.close();
+					} catch {}
+				}, delay);
+				deadlineTimer.unref?.();
+			}
+		},
+		async pull(controller) {
+			try {
+				const { value, done } = await iterator.next();
+				if (closed) return;
+				if (done) {
+					closed = true;
+					stopTimers();
+					controller.close();
+					return;
+				}
+				controller.enqueue(encoder.encode(write(value, iterator)));
+			} catch (error) {
+				if (closed) return;
+				closed = true;
+				stopTimers();
+				returnIterator().catch(() => {});
+				throw error;
+			}
+		},
+		async cancel() {
+			if (closed) return;
+			closed = true;
+			stopTimers();
+			await returnIterator();
+		}
+	});
+	return new Response(stream, {
+		status: 200,
+		headers: {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache, no-transform",
+			connection: "keep-alive"
+		}
+	});
+}
+/** Version 1: one frame per event, then each event the iterator holds. */
+function eventFrames(first, iterator) {
+	let frames = frameFor(first);
+	while (frames.length < EVENT_WRITE_CHARS) {
+		const event = takeBuffered(iterator);
+		if (!event) break;
+		frames += frameFor(event);
+	}
+	return frames;
+}
+/**
+* Version 2: events this write carries share one frame, a JSON array whose
+* `id:` is its last index. Held events are always events, so only `first`
+* can be a snapshot or presence frame.
+*/
+function batchedFrames(first, iterator) {
+	const lead = isStreamEvent(first) ? "" : frameFor(first);
+	const head = isStreamEvent(first) ? first : takeBuffered(iterator);
+	if (!head) return lead;
+	const { events, last } = heldEventBatch({
+		first: head,
+		iterator,
+		encode: compactJsonLine
+	});
+	return `${lead}id: ${last.index}\ndata: [${events.join(",")}]\n\n`;
+}
+const compactJsonLine = (event) => isSerializedEvent(event) && /[\r\n]/.test(event.payloadJson) ? compactEventJson(parseSerializedEvent(event)) : compactEventJson(event);
+function frameFor(item) {
+	if ("kind" in item) return `event: a2-snapshot\ndata: ${JSON.stringify(stateSnapshotToWire(item))}\n\n`;
+	if ("snapshot" in item) return `event: presence-snapshot\ndata: ${JSON.stringify(presenceSnapshotToWire(item))}\n\n`;
+	if ("participant" in item) return `event: presence\ndata: ${JSON.stringify(presencePatchToWire(item))}\n\n`;
+	if (isSerializedEvent(item)) return /[\r\n]/.test(item.payloadJson) ? `id: ${item.index}\ndata: ${JSON.stringify(eventToWire(parseSerializedEvent(item)))}\n\n` : `id: ${item.index}\ndata: ${serializedEventToWireJson(item)}\n\n`;
+	return `id: ${item.index}\ndata: ${JSON.stringify(eventToWire(item))}\n\n`;
+}
+function bootstrapStream(options) {
+	return { [Symbol.asyncIterator]() {
+		let closed = false;
+		let index;
+		let source;
+		let stopActivity;
+		const abort = new AbortController();
+		const activity = createStreamActivity(() => {
+			if (source) streamActivities.get(source)?.activate();
+		});
+		const iterator = {
+			async next() {
+				if (closed) return {
+					done: true,
+					value: void 0
+				};
+				if (index === void 0) {
+					let cancel;
+					const cancelled = new Promise((resolve) => {
+						cancel = () => resolve(void 0);
+						abort.signal.addEventListener("abort", cancel, { once: true });
+					});
+					try {
+						const snapshot = await Promise.race([options.snapshot(), cancelled]);
+						if (closed || snapshot === void 0) return {
+							done: true,
+							value: void 0
+						};
+						index = snapshot.index;
+						return {
+							done: false,
+							value: snapshot
+						};
+					} finally {
+						if (cancel) abort.signal.removeEventListener("abort", cancel);
+					}
+				}
+				if (!source) {
+					source = options.stream(index)[Symbol.asyncIterator]();
+					const sourceActivity = streamActivities.get(source);
+					if (sourceActivity) {
+						activity.setIdle(sourceActivity.idle);
+						stopActivity = sourceActivity.subscribe(activity.setIdle);
+					}
+				}
+				const result = await source.next();
+				return closed ? {
+					done: true,
+					value: void 0
+				} : result;
+			},
+			async return() {
+				if (closed) return {
+					done: true,
+					value: void 0
+				};
+				closed = true;
+				abort.abort();
+				stopActivity?.();
+				await source?.return?.();
+				return {
+					done: true,
+					value: void 0
+				};
+			}
+		};
+		streamActivities.set(iterator, activity);
+		bufferedEvents.set(iterator, () => closed || !source ? void 0 : takeBuffered(source));
+		return iterator;
+	} };
+}
+const serverFetchHooks = /* @__PURE__ */ new WeakMap();
+const parseHistoryBounds = (gte, lte) => {
+	if (gte === null || lte === null) throw new A2Error("INVALID_PAYLOAD", "a history read takes both gte and lte");
+	const bounds = {
+		gte: Number(gte),
+		lte: Number(lte)
+	};
+	for (const [name, value] of Object.entries(bounds)) if (!Number.isSafeInteger(value) || value < 0) throw new A2Error("INVALID_PAYLOAD", `history ${name} must be a non-negative safe integer`);
+	if (bounds.gte > bounds.lte) throw new A2Error("INVALID_PAYLOAD", "history gte must be less than or equal to lte");
+	return bounds;
+};
+const parseResumeIndex = (raw) => {
+	if (raw === null) return 0;
+	const index = Number(raw);
+	if (!Number.isSafeInteger(index) || index < 0) throw new A2Error("INVALID_PAYLOAD", "stream index must be a non-negative safe integer");
+	return index;
+};
+const parseSubscription = (params) => {
+	const reducer = params.get("reducer");
+	const bootstrap = params.get("bootstrap");
+	const index = params.get("index");
+	if (reducer === "") throw new A2Error("INVALID_PAYLOAD", "empty reducer name");
+	if (bootstrap !== null) {
+		if (bootstrap !== "1" || index !== null || reducer === null) throw new A2Error("INVALID_PAYLOAD", "bootstrap requires a reducer and no index");
+		return {
+			bootstrap: true,
+			reducer
+		};
+	}
+	return {
+		index: parseResumeIndex(index),
+		...reducer === null ? {} : { reducer }
+	};
+};
+const errorResponse = (error) => {
+	const a2error = asA2Error(error);
+	return Response.json(errorToWire(a2error), { status: errorStatus(a2error.code) });
+};
+const forbidden = () => new A2Error("FORBIDDEN", "the operation is not authorized");
+const freezePush = (sessionId, events, presence, transport) => {
+	for (const event of events) Object.freeze(event);
+	Object.freeze(events);
+	if (presence !== void 0) {
+		Object.freeze(presence.values);
+		Object.freeze(presence);
+	}
+	return {
+		type: "push",
+		sessionId,
+		events,
+		...presence === void 0 ? {} : { presence },
+		transport
+	};
+};
+function createServerFetch(server) {
+	const presence = Object.keys(server.contract.presence).length > 0;
+	const fetch = async (request, options) => {
+		const authorized = async (operation) => {
+			try {
+				return await options?.authorize?.(Object.freeze(operation)) !== false;
+			} catch (cause) {
+				throw new A2Error("STORE_UNAVAILABLE", "authorization failed", { cause });
+			}
+		};
+		const authorize = async (operation) => {
+			if (!await authorized(operation)) throw forbidden();
+		};
+		const validateIngress = async (context) => {
+			await serverFetchHooks.get(fetch)?.validateIngress?.(context);
+		};
+		const gateSocketPush = async (sessionId, events, pushedPresence) => {
+			try {
+				await authorize(freezePush(sessionId, events, pushedPresence, "websocket"));
+				await validateIngress({
+					sessionId,
+					events,
+					...pushedPresence === void 0 ? {} : { presence: pushedPresence }
+				});
+				return null;
+			} catch (error) {
+				return asA2Error(error);
+			}
+		};
+		const selectedSession = (sessionId, selection) => {
+			const reducer = server.contract.reducer;
+			if (selection.reducer !== void 0 && reducer !== void 0 && reducer.name !== selection.reducer) throw new A2Error("INVALID_PAYLOAD", "client reducer does not match the public contract reducer");
+			const target = server.session(sessionId);
+			const streamTarget = target;
+			if (!selection.bootstrap) return streamTarget;
+			if (!reducer) throw new A2Error("INVALID_PAYLOAD", "contract has no public reducer");
+			return {
+				...streamTarget,
+				stream: (streamOptions) => bootstrapStream({
+					snapshot: async () => {
+						const initial = await target.state(reducer);
+						return {
+							kind: "snapshot",
+							sessionId,
+							name: reducer.name,
+							index: initial.index,
+							state: encodeState({
+								reducer,
+								state: initial.state
+							}),
+							...initial.clearIndex === void 0 ? {} : { clearIndex: initial.clearIndex }
+						};
+					},
+					stream: (index) => {
+						const bounds = {
+							startAfter: index,
+							presence: streamOptions.presence === true
+						};
+						return target.stream(bounds);
+					}
+				})
+			};
+		};
+		const attachMultiplexed = (wire) => (socket) => {
+			const deadline = invocationDeadlineMs();
+			sessionsSocket(async (sessionId, startAfter, selection = { index: startAfter }) => {
+				const operation = {
+					type: "stream",
+					sessionId,
+					startAfter,
+					...selection.bootstrap ? { bootstrap: true } : {},
+					transport: "websocket"
+				};
+				return await authorized(operation) ? selectedSession(sessionId, selection) : null;
+			}, socket, {
+				presence,
+				wire,
+				...deadline === null ? {} : { deadline },
+				gatePush: gateSocketPush
+			});
+		};
+		try {
+			if (request.method === "GET") {
+				if (request.headers.get("upgrade")?.toLowerCase() === "websocket") {
+					if (options?.upgradeWebSocket === void 0) return new Response("WebSocket upgrade requested, but server.fetch() has no upgrade implementation", { status: 426 });
+					const { searchParams } = new URL(request.url);
+					const wire = wireVersion(searchParams.get("wire"));
+					if (options.multiplexWebSocket === true) return await options.upgradeWebSocket(attachMultiplexed(wire));
+					const sessionId = searchParams.get("sessionId");
+					if (sessionId === null || sessionId.length === 0) throw new A2Error("INVALID_PAYLOAD", "missing sessionId");
+					const selection = parseSubscription(searchParams);
+					const startAfter = selection.index ?? 0;
+					await authorize({
+						type: "stream",
+						sessionId,
+						startAfter,
+						...selection.bootstrap ? { bootstrap: true } : {},
+						transport: "websocket"
+					});
+					const target = selectedSession(sessionId, selection);
+					const attach = (socket) => {
+						const deadline = invocationDeadlineMs();
+						sessionSocket(sessionId, target, socket, {
+							startAfter,
+							presence,
+							wire,
+							...deadline === null ? {} : { deadline },
+							gatePush: gateSocketPush
+						});
+					};
+					return await options.upgradeWebSocket(attach);
+				}
+				const { searchParams } = new URL(request.url);
+				const sessionId = searchParams.get("sessionId");
+				if (sessionId === null || sessionId.length === 0) throw new A2Error("INVALID_PAYLOAD", "missing sessionId");
+				const gteRaw = searchParams.get("gte");
+				const lteRaw = searchParams.get("lte");
+				if (gteRaw !== null || lteRaw !== null) {
+					const bounds = parseHistoryBounds(gteRaw, lteRaw);
+					await authorize({
+						type: "history",
+						sessionId,
+						...bounds,
+						transport: "http"
+					});
+					const { events, clearIndex } = await server.historyPage(sessionId, bounds);
+					const first = Math.max(bounds.gte, (clearIndex ?? 0) + 1);
+					const covered = events.length === Math.max(0, bounds.lte - first + 1);
+					return Response.json(events.map(eventToWire), { headers: {
+						"a2-history-covered": String(covered),
+						...clearIndex === void 0 ? {} : { "a2-clear-index": String(clearIndex) }
+					} });
+				}
+				const selection = parseSubscription(searchParams);
+				const startAfter = selection.index ?? 0;
+				await authorize({
+					type: "stream",
+					sessionId,
+					startAfter,
+					...selection.bootstrap ? { bootstrap: true } : {},
+					transport: "http"
+				});
+				const target = selectedSession(sessionId, selection);
+				return sseResponse(presence ? target.stream({
+					startAfter,
+					presence: true
+				}) : target.stream({ startAfter }), { wire: wireVersion(searchParams.get("wire")) });
+			}
+			if (request.method === "POST") {
+				const body = await parsePushBody(request);
+				await authorize(freezePush(body.sessionId, body.events, body.presence, "http"));
+				await validateIngress({
+					sessionId: body.sessionId,
+					events: body.events,
+					...body.presence === void 0 ? {} : { presence: body.presence }
+				});
+				const session = server.session(body.sessionId);
+				if (body.presence !== void 0) {
+					const target = session;
+					if (typeof target.setPresence !== "function") throw invalidPushBody("presence is not declared by this contract");
+					await target.setPresence(body.presence);
+				}
+				const appended = body.events.length === 0 ? [] : await session.append(...body.events);
+				return Response.json(appended.map(eventToWire));
+			}
+			return new Response("Method Not Allowed", {
+				status: 405,
+				headers: { allow: "GET, POST" }
+			});
+		} catch (error) {
+			return errorResponse(error);
+		}
+	};
+	return fetch;
+}
+/**
+* Deterministic default ids for consumer `session.append` calls. A consumer
+* re-run after a crash calls `session.append` again; giving
+* each call a deterministic id — derived from the triggering event's id
+* and the caller's stable name — makes the re-run a no-op via the store's
+* per-session unique index on event ids.
+*
+* The id is a UUIDv5-shaped SHA-1 over
+* `(namespace, triggerEventId, name, itemOrdinal)`, computed with
+* WebCrypto so it runs on any platform a2 core targets.
+*/
+const APPEND_NAMESPACE = "a2:handler-append:v2";
+const RETURN_NAMESPACE = "a2:handler-return:v1";
+const SCHEDULE_NAMESPACE = "a2:schedule:v1";
+const SCHEDULED_EVENT_NAMESPACE = "a2:scheduled-event:v1";
+const SCHEDULE_CLEAR_NAMESPACE = "a2:schedule-clear:v1";
+async function deterministicIdFromInput(input) {
+	const digest = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(input));
+	const bytes = new Uint8Array(digest).slice(0, 16);
+	bytes[6] = (bytes[6] ?? 0) & 15 | 80;
+	bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+async function deterministicId(parts) {
+	return deterministicIdFromInput(parts.join("\0"));
+}
+/**
+* `consumer` keys the id on the consumer that appends, so two consumers of
+* one event never collide. A2's own consumers pass none: their types are
+* disjoint, so the event alone keys them.
+*/
+async function deterministicEventId(triggerEventId, name, itemOrdinal, consumer) {
+	if (name.length === 0) throw new TypeError("append name must not be empty");
+	return deterministicId([
+		APPEND_NAMESPACE,
+		triggerEventId,
+		name,
+		itemOrdinal,
+		...consumer === void 0 ? [] : [consumer]
+	]);
+}
+async function deterministicReturnedEventId(triggerEventId, itemOrdinal, consumer) {
+	return deterministicId([
+		RETURN_NAMESPACE,
+		triggerEventId,
+		itemOrdinal,
+		...consumer === void 0 ? [] : [consumer]
+	]);
+}
+/**
+* The id of a scheduled append. `clearIndex` is the lifetime the trigger was
+* claimed in; it joins the input only when positive, so a trigger id reused
+* after a clear schedules a distinct task while sessions never cleared keep
+* the ids they always had.
+*/
+async function deterministicScheduleId(contract, sessionId, triggerEventId, name, clearIndex = 0, consumer) {
+	return deterministicIdFromInput(JSON.stringify([
+		SCHEDULE_NAMESPACE,
+		contract,
+		sessionId,
+		triggerEventId,
+		name,
+		...clearIndex > 0 ? [clearIndex] : [],
+		...consumer === void 0 ? [] : [{ consumer }]
+	]));
+}
+async function deterministicScheduleClearId({ contract, sessionId, triggerEventId, clearIndex, name, ifLastIndex, consumer }) {
+	return deterministicIdFromInput(JSON.stringify([
+		SCHEDULE_CLEAR_NAMESPACE,
+		contract,
+		sessionId,
+		triggerEventId,
+		clearIndex,
+		name,
+		ifLastIndex,
+		...consumer === void 0 ? [] : [{ consumer }]
+	]));
+}
+async function deterministicScheduledEventId(scheduleId, itemOrdinal) {
+	return deterministicId([
+		SCHEDULED_EVENT_NAMESPACE,
+		scheduleId,
+		itemOrdinal
+	]);
+}
+/**
+* The default when no telemetry is configured. Spans cost nothing, but
+* `recordError` prints: it only ever receives errors a2 swallows by
+* design, so without a configured sink the console is the one place
+* they can surface. Passing `telemetry` replaces this sink wholesale.
+*/
+const CONSOLE_TELEMETRY = { span: (name, attributes, fn) => fn({
+	setAttribute: () => {},
+	recordError: (error) => {
+		console.error(`[a2] error in ${name}`, attributes, error);
+	}
+}) };
+/**
+* Deliver one authenticated scheduler append through an A2 server's ordinary
+* top-level append path. Custom scheduler adapters call this after validating
+* their transport envelope; application code normally uses `session.schedule`.
+*/
+async function deliverSchedulerAppend(server, task) {
+	if (server.contract.name !== task.contract) throw new TypeError(`a2 scheduler: append task for contract '${task.contract}' cannot be delivered to '${server.contract.name}'`);
+	const { originIndex } = task;
+	if (originIndex !== void 0 && (!Number.isSafeInteger(originIndex) || originIndex < 1)) throw new TypeError("a2 scheduler: append task originIndex must be a positive safe integer");
+	const internals = serverInternals.get(server);
+	if (!internals) throw new TypeError(`a2 scheduler: server for contract '${task.contract}' cannot receive scheduled appends`);
+	await internals.schedulerAppend(task.sessionId, task.events, originIndex);
+}
+/**
+* Deliver one authenticated scheduler clear: a conditional
+* `clear({ ifLastIndex })` that resolves after its deletion finishes, so a
+* provider retry resumes an interrupted deletion. Custom scheduler adapters
+* call this after validating their transport envelope; application code uses
+* `session.schedule.clear`.
+*/
+async function deliverSchedulerClear(server, task) {
+	if (server.contract.name !== task.contract) throw new TypeError(`a2 scheduler: clear task for contract '${task.contract}' cannot be delivered to '${server.contract.name}'`);
+	if (task.kind !== "clear" || !Number.isSafeInteger(task.ifLastIndex) || task.ifLastIndex < 0) throw new TypeError("a2 scheduler: a clear task needs kind \"clear\" and a non-negative safe integer ifLastIndex");
+	const internals = serverInternals.get(server);
+	if (!internals) throw new TypeError(`a2 scheduler: server for contract '${task.contract}' cannot receive scheduled clears`);
+	await internals.schedulerClear(task.sessionId, task.ifLastIndex);
+}
+const CONSUMER_NAME = /^[a-z0-9][a-z0-9._:-]{0,127}$/i;
+/** Define a consumer: a named reader of each session's log. */
+function consumer(options) {
+	return defineConsumer(options, false);
+}
+/**
+* `consumer()`, and for A2's own runtimes (`runtime`) a name under `a2.` and
+* child ids without the name: their types are disjoint, so the event alone
+* keys them, and regrouping A2's consumers never changes an id.
+*/
+function defineConsumer(options, runtime) {
+	const contract = options?.contract;
+	if (!contract || typeof contract.name !== "string") throw new TypeError("consumer expects options with a contract");
+	const consumerName = options.name;
+	if (typeof consumerName !== "string" || !CONSUMER_NAME.test(consumerName)) throw new TypeError("consumer name must be 1-128 letters, digits, and . _ : - characters");
+	if (consumerName.startsWith("a2.") !== runtime) throw new TypeError(runtime ? `A2's own consumers are named under 'a2.'` : `consumer names starting with 'a2.' are reserved`);
+	const types = options.types === void 0 ? null : [...options.types];
+	if (types?.length === 0) throw new TypeError(`consumer '${consumerName}' lists no types; leave types out to take every type`);
+	for (const type of types ?? []) if (!Object.hasOwn(contract.events, type)) throw new TypeError(`contract '${contract.name}' has no event type '${String(type)}'`);
+	const lane = options.lane ?? null;
+	if (lane !== null && typeof lane !== "function" && (typeof lane !== "string" || lane.length === 0)) throw new TypeError(`lane for consumer '${consumerName}' must be a non-empty string or a function`);
+	const backfill = options.backfill ?? false;
+	if (backfill && typeof lane !== "string") throw new TypeError(`consumer '${consumerName}' backfills, so its lane must be a string`);
+	if (backfill && options.abortOn !== void 0) throw new TypeError(`consumer '${consumerName}' backfills, so it can't use abortOn`);
+	return { run(fn) {
+		if (typeof fn !== "function") throw new TypeError(`consumer '${consumerName}' needs a run function`);
+		const defined = {
+			name: consumerName,
+			contract: { name: contract.name },
+			spec: {
+				types,
+				lane,
+				backfill,
+				abortOn: options.abortOn ?? null,
+				run: fn
+			}
+		};
+		if (runtime) runtimeConsumers.add(defined);
+		return defined;
+	} };
+}
+runtimeConsumerFactory.define = (options) => defineConsumer(options, true);
+/** A registered consumer as the store needs to know it. */
+const storeConsumerOf = (registered) => registered.log ? {
+	name: registered.name,
+	log: registered.log
+} : { name: registered.name };
+const MAX_FAILURES = 10;
+/** How long `consume` waits before looking again at a head it can't run. */
+const CONSUME_WAIT_MIN_MS = 25;
+const CONSUME_WAIT_MAX_MS = 1e3;
+/**
+* `task`, or a rejection with `signal`'s reason once it aborts. The task runs
+* on either way, and its own failure is caught, so nothing goes unhandled.
+*/
+const untilAborted = (task, signal) => {
+	if (!signal) return task;
+	task.catch(() => {});
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(signal.reason);
+		signal.addEventListener("abort", abort, { once: true });
+		task.then(resolve, reject).finally(() => {
+			signal.removeEventListener("abort", abort);
+		});
+	});
+};
+/** How long an event waits after its `failureCount`th failed attempt. */
+const failureRetryDelayMs = (failureCount) => Math.min(DRAIN_TIMINGS.failureRetryBaseMs * 2 ** Math.max(failureCount - 1, 0), DRAIN_TIMINGS.failureRetryMaxMs);
+/** Abort a lost attempt's consumer and release its drain slot. */
+function endSuperseded(entry, message) {
+	entry.supersede.abort(new A2Error("SUPERSEDED_ATTEMPT", message));
+	entry.fence({
+		status: "superseded",
+		opensLane: false,
+		appendsEvents: false
+	});
+}
+/** Pause between clear-deletion batches that found only locked rows. */
+const RECLAIM_STALL_MS = 20;
+const RECLAIM_STALL_LIMIT = 50;
+/** Default: how long a presence value survives without a refreshing set. */
+const PRESENCE_TTL_MS = 6e4;
+function createDrainSignal() {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		version: 0,
+		closed: false,
+		notify() {
+			this.version += 1;
+			for (const listener of listeners) listener();
+			listeners.clear();
+		},
+		wait(version) {
+			if (this.version !== version) return {
+				promise: Promise.resolve(),
+				cancel: () => {}
+			};
+			let resolve;
+			const promise = new Promise((done) => {
+				resolve = done;
+			});
+			listeners.add(resolve);
+			return {
+				promise,
+				cancel: () => listeners.delete(resolve)
+			};
+		}
+	};
+}
+function dispatchAbortEvent(hub, event) {
+	let relevant = false;
+	for (const subscription of hub.subscriptions) {
+		if (!subscription.types.has(event.type)) continue;
+		relevant = true;
+		if (subscription.matches(event)) subscription.controller.abort();
+	}
+	if (relevant) hub.seen.set(event.index, event);
+}
+function pruneAbortHub(hub) {
+	let minimum = Infinity;
+	const types = /* @__PURE__ */ new Set();
+	for (const subscription of hub.subscriptions) {
+		minimum = Math.min(minimum, subscription.triggerIndex);
+		for (const type of subscription.types) types.add(type);
+	}
+	for (const [index, event] of hub.seen) if (index <= minimum || !types.has(event.type)) hub.seen.delete(index);
+}
+/**
+* Deadlines tighten the claim/watchdog window, and a passed deadline ends
+* claiming: a claim then could not run, only lapse and be claimed again until
+* the platform ends the process. A platform timeout otherwise follows the
+* same path as any other process death: the in-flight event remains pending
+* and a fresh invocation retries it.
+*/
+function nextClaimWindow() {
+	const nowMs = Date.now();
+	const deadlineMs = invocationDeadlineMs();
+	const deadlineTtlMs = deadlineMs === null ? DRAIN_TIMINGS.claimTtlMs : deadlineMs - nowMs;
+	const deadlineCapped = deadlineMs !== null && deadlineTtlMs <= DRAIN_TIMINGS.claimTtlMs;
+	const ttlMs = Math.max(1, Math.min(DRAIN_TIMINGS.claimTtlMs, deadlineTtlMs));
+	const expiresAtMs = nowMs + ttlMs;
+	return {
+		ttlMs,
+		expiresAtMs,
+		watchdogAtMs: expiresAtMs + DRAIN_TIMINGS.watchdogGraceMs,
+		deadlineCapped,
+		pastDeadline: deadlineMs !== null && deadlineTtlMs <= 0
+	};
+}
+function schedulerSlot(dueAt) {
+	return Math.ceil(dueAt / 1e3) * 1e3;
+}
+function currentSchedulerSlot(now) {
+	return Math.floor(now / 1e3) * 1e3;
+}
+/**
+* The namespace separator between machine name and session id in
+* storage. Machines sharing one store backend (the dev-default sqlite
+* file, a shared Postgres) must not collide on session ids; the machine
+* name is what makes multi-machine apps unambiguous (a2-api.md §1), so
+* it prefixes every storage key.
+*/
+const NS = "";
+const devDefaultStore = retryableLazy(() => import("./store-sqlite-BmwL3pUR.mjs").then((m) => m.sqlite()));
+/** Waits for a scheduler arm for at most `schedulerArmTimeoutMs`. */
+async function joinSchedulerArm(arm) {
+	let timeout = null;
+	try {
+		await Promise.race([arm, new Promise((_, reject) => {
+			timeout = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`a2 scheduler arm timed out after ${DRAIN_TIMINGS.schedulerArmTimeoutMs}ms`));
+			}, DRAIN_TIMINGS.schedulerArmTimeoutMs);
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+function environment() {
+	const env = typeof process === "undefined" ? void 0 : process.env?.["NODE_ENV"];
+	if (env === "test") return "test";
+	if (env === "production") return "production";
+	return "development";
+}
+function describeError(err) {
+	if (err instanceof Error) return err.stack ?? `${err.name}: ${err.message}`;
+	return String(err);
+}
+/**
+* Comparison key for a presence value in the degraded-tier diff — an
+* LWW tie can replace a value without moving its `seen`/`at` stamp.
+*/
+function fingerprint(value) {
+	return JSON.stringify(value) ?? "";
+}
+function foldPresenceRows(rows) {
+	const map = nullProtoRecord();
+	for (const row of rows) (map[row.participant] ??= nullProtoRecord())[row.field] = {
+		value: row.value,
+		seen: row.seen,
+		at: row.at
+	};
+	return map;
+}
+/** One cursor head, as a map key. */
+const headKey = (ref) => JSON.stringify([
+	ref.consumer,
+	ref.lane,
+	ref.index
+]);
+const headRefOf = (head) => ({
+	consumer: head.consumer,
+	lane: head.lane,
+	index: head.index
+});
+const addSnapshotWrite = (writes, index, state, pin) => {
+	let write = writes.get(index);
+	if (!write) {
+		write = {
+			state: cloneInitial(state),
+			pins: /* @__PURE__ */ new Map()
+		};
+		writes.set(index, write);
+	}
+	if (pin !== void 0) write.pins.set(headKey(pin), pin);
+};
+/** Whether a registered consumer runs events of this type. */
+const takes = (registered, type) => registered.types === null || registered.types.has(type);
+/** Implement a contract: bind its vocabulary to storage and reactions. */
+function createServer(options) {
+	const serverContract = options?.contract;
+	if (serverContract === null || typeof serverContract !== "object" || typeof serverContract.name !== "string" || serverContract.events === null) throw new TypeError("createServer expects options with a contract (see a2.contract)");
+	if (Object.hasOwn(options, "handlers")) throw new TypeError("createServer no longer takes handlers: write each as a consumer in `consumers` (see https://www.a2.dev/upgrades/0-21)");
+	const name = serverContract.name;
+	const defs = serverContract.events;
+	const presenceDefs = serverContract.presence;
+	const declaresPresence = Object.keys(presenceDefs).length > 0;
+	const presenceNotSupported = () => new A2Error("PRESENCE_NOT_SUPPORTED", `the contract '${name}' declares presence but the store backend for its server has no presence capability (A2Store.presence)`);
+	if (options.presence !== void 0) {
+		if (!declaresPresence) throw new TypeError(`the presence option requires a contract that declares presence fields — '${name}' has none`);
+		const { ttlMs } = options.presence;
+		if (ttlMs !== void 0 && (!Number.isInteger(ttlMs) || ttlMs <= 0)) throw new TypeError("presence.ttlMs must be a positive integer of milliseconds");
+	}
+	const presenceTtlMs = options.presence?.ttlMs ?? PRESENCE_TTL_MS;
+	let makeStore;
+	if (options.store) {
+		const explicit = options.store;
+		if (declaresPresence && !explicit.presence) throw presenceNotSupported();
+		makeStore = () => Promise.resolve(explicit);
+	} else {
+		const env = environment();
+		if (env === "production") {
+			const error = () => new A2Error("STORE_NOT_CONFIGURED", `the server for '${name}' has no store configured and NODE_ENV is 'production' — pass an explicit store backend (e.g. postgres from 'experimental-a2/store-postgres')`);
+			if (process.env["NEXT_PHASE"] !== "phase-production-build") throw error();
+			makeStore = () => Promise.reject(error());
+		} else makeStore = env === "test" ? () => import("./store-memory-ZLiZbH3R.mjs").then((m) => m.memory()) : devDefaultStore.get;
+	}
+	if (declaresPresence && !options.store) {
+		const inner = makeStore;
+		makeStore = async () => {
+			const store = await inner();
+			if (!store.presence) throw presenceNotSupported();
+			return store;
+		};
+	}
+	const resolveStore = retryableLazy(makeStore).get;
+	const telemetry = options.telemetry ?? CONSOLE_TELEMETRY;
+	const scheduler = options.scheduler;
+	const abortMatcherOf = (spec) => {
+		let abortOn = null;
+		if (spec !== void 0 && spec !== null) {
+			abortOn = /* @__PURE__ */ new Map();
+			const pairs = Array.isArray(spec) ? spec.map((abortType) => [abortType, true]) : Object.entries(spec);
+			for (const [abortType, matcher] of pairs) {
+				if (matcher === void 0) continue;
+				if (!Object.hasOwn(defs, abortType)) throw new TypeError(`contract '${name}' has no event type '${String(abortType)}' — cannot abort on it`);
+				abortOn.set(String(abortType), matcher);
+			}
+			if (abortOn.size === 0) abortOn = null;
+		}
+		return abortOn;
+	};
+	const laneContext = (sessionId, event) => ({
+		sessionId,
+		event: {
+			type: event.type,
+			payload: structuredClone(event.payload),
+			...event.id === void 0 ? {} : { id: event.id }
+		}
+	});
+	const registeredConsumers = /* @__PURE__ */ new Map();
+	/** A consumer definition as the server runs it. */
+	const registrationOf = (defined) => {
+		const { types, lane, backfill, abortOn, run } = defined.spec;
+		const matcher = abortMatcherOf(abortOn);
+		return {
+			name: defined.name,
+			types: types === null ? null : new Set(types),
+			laneOf: typeof lane === "string" ? null : lane === null ? () => null : (sessionId, event) => {
+				const resolved = lane(laneContext(sessionId, event));
+				if (resolved !== null && (typeof resolved !== "string" || resolved.length === 0)) throw new TypeError(`lane for consumer '${defined.name}' must resolve to a non-empty string or null`);
+				return resolved;
+			},
+			log: typeof lane === "string" ? {
+				lane,
+				types: types === null ? null : [...types],
+				backfill
+			} : void 0,
+			abortOn: () => matcher,
+			run,
+			anonymousIds: runtimeConsumers.has(defined)
+		};
+	};
+	/** The definitions the server runs, so `consume` can tell its own from another. */
+	const definitions = /* @__PURE__ */ new Map();
+	/** A consumer written inline is `consumer()`'s options and `run`, on this contract. */
+	const definitionOf = (entry) => {
+		if (entry === null || typeof entry !== "object" || "spec" in entry || !("run" in entry)) return entry;
+		const { run, ...rest } = entry;
+		return consumer({
+			...rest,
+			contract: serverContract
+		}).run(run);
+	};
+	for (const entry of options.consumers ?? []) {
+		const defined = definitionOf(entry);
+		if (defined?.contract?.name !== name || !defined.spec) throw new TypeError(`createServer for '${name}' got a consumer of another contract`);
+		if (registeredConsumers.has(defined.name)) throw new TypeError(`two consumers are named '${defined.name}'`);
+		registeredConsumers.set(defined.name, registrationOf(defined));
+		definitions.set(defined.name, defined);
+	}
+	const anonymousTypes = /* @__PURE__ */ new Map();
+	for (const registered of registeredConsumers.values()) {
+		if (!registered.anonymousIds) continue;
+		for (const type of registered.types ?? Object.keys(defs)) {
+			const other = anonymousTypes.get(type);
+			if (other !== void 0) throw new TypeError(`A2's consumers '${other}' and '${registered.name}' both take '${type}'`);
+			anonymousTypes.set(type, registered.name);
+		}
+	}
+	/** The consumers this server serves, as the store needs to know them. */
+	const storeConsumers = [...registeredConsumers.values()].map(storeConsumerOf);
+	/** Whether an event starts cursor work for any consumer. */
+	const startsWork = (event) => (event.targets?.length ?? 0) > 0 || [...registeredConsumers.values()].some((registered) => registered.log && takes(registered, event.type));
+	const prefix = `${name}${NS}`;
+	const nsId = (sessionId) => `${prefix}${sessionId}`;
+	const stripNs = (stored) => stored.slice(prefix.length);
+	const toPublic = (row) => ({
+		id: row.id,
+		type: row.type,
+		payload: row.payload,
+		index: row.index,
+		sessionId: stripNs(row.sessionId),
+		createdAt: row.createdAt
+	});
+	const inFlight = /* @__PURE__ */ new Set();
+	const track = (p) => {
+		inFlight.add(p);
+		const drop = () => {
+			inFlight.delete(p);
+		};
+		p.then(drop, drop);
+	};
+	const schedulerArmSlots = /* @__PURE__ */ new Map();
+	/**
+	* Start an optional scheduler arm without putting it on the execution path.
+	* The returned raw promise lets the initial append report failure; the
+	* tracked copy is always rejection-safe for heartbeat callers.
+	*/
+	const startSchedulerArm = (sessionId, dueAt) => {
+		if (!scheduler) return null;
+		const slottedDueAt = schedulerSlot(dueAt);
+		const slotKey = JSON.stringify([sessionId, slottedDueAt]);
+		const existing = schedulerArmSlots.get(slotKey);
+		if (existing) return existing.promise;
+		const raw = Promise.resolve().then(() => scheduler.schedule({
+			version: 1,
+			kind: "drain",
+			contract: name,
+			sessionId,
+			dueAt: slottedDueAt
+		}));
+		const forget = setTimeout(() => {
+			if (schedulerArmSlots.get(slotKey)?.promise === raw) schedulerArmSlots.delete(slotKey);
+		}, Math.max(0, slottedDueAt - Date.now()) + 1e3);
+		forget.unref?.();
+		schedulerArmSlots.set(slotKey, {
+			promise: raw,
+			forget
+		});
+		raw.then(void 0, () => {
+			const current = schedulerArmSlots.get(slotKey);
+			if (current?.promise !== raw) return;
+			clearTimeout(current.forget);
+			schedulerArmSlots.delete(slotKey);
+		});
+		const safe = raw.catch(() => {});
+		track(safe);
+		platformWaitUntil(safe);
+		return raw;
+	};
+	const scheduledDrains = /* @__PURE__ */ new Map();
+	const scheduleDrain = (sessionId, watchdogDueAt) => {
+		const existing = scheduledDrains.get(sessionId);
+		if (existing && !existing.signal.closed) {
+			existing.signal.notify();
+			return;
+		}
+		if (existing) scheduledDrains.delete(sessionId);
+		const signal = createDrainSignal();
+		const p = new Promise((resolve) => {
+			queueMicrotask(() => {
+				drainSession(sessionId, {
+					watchdogDueAt,
+					signal
+				}).then(() => resolve()).catch(() => resolve());
+			});
+		}).finally(() => {
+			if (scheduledDrains.get(sessionId)?.promise === p) scheduledDrains.delete(sessionId);
+		});
+		scheduledDrains.set(sessionId, {
+			signal,
+			promise: p
+		});
+		track(p);
+		platformWaitUntil(p);
+	};
+	const validateEvents = (sessionId, events, resolveDispatchMetadata = true) => {
+		if (events.length === 0) throw new TypeError("append requires at least one event");
+		return events.map((e) => {
+			const schema = Object.hasOwn(defs, e.type) ? defs[e.type] : void 0;
+			if (!schema) throw new A2Error("UNKNOWN_EVENT_TYPE", `contract '${name}' has no event type '${String(e.type)}'`);
+			const result = validateSync(schema, e.payload, `event '${e.type}'`);
+			if (result.issues) throw new A2Error("INVALID_PAYLOAD", `invalid payload for event '${e.type}' on machine '${name}'`, { details: result.issues });
+			const validated = {
+				type: e.type,
+				payload: result.value
+			};
+			if (e.id !== void 0) validated.id = e.id;
+			if (!resolveDispatchMetadata) return validated;
+			const targets = [];
+			for (const registered of registeredConsumers.values()) {
+				if (!registered.laneOf || !takes(registered, e.type)) continue;
+				targets.push({
+					consumer: registered.name,
+					lane: registered.laneOf(sessionId, validated)
+				});
+			}
+			if (targets.length > 0) validated.targets = targets;
+			return validated;
+		});
+	};
+	/**
+	* Validate + write. `onAppended` runs inside the telemetry span, so
+	* the drain it schedules is created in the append's active context —
+	* with a real tracer, causal work remains connected.
+	*/
+	const appendCore = (sessionId, events, source, mode, onAppended, cause, generatedIds, requireDurableInitialArm = false, originIndex) => telemetry.span("a2.append", {
+		"a2.contract": name,
+		"a2.session_id": sessionId,
+		"a2.append.source": source,
+		"a2.append.mode": mode,
+		"a2.append.types": events.map((e) => String(e.type)).join(","),
+		"a2.append.count": events.length
+	}, async (span) => {
+		if (mode === "dispatch" && !scheduler) throw new TypeError("append.dispatch requires a configured scheduler adapter");
+		assertSessionId(sessionId);
+		const validated = validateEvents(sessionId, events);
+		if (cause) for (const [index, event] of validated.entries()) event.cause = generatedIds?.[index] ? {
+			...cause,
+			batchSize: events.length
+		} : cause;
+		const store = await resolveStore();
+		let rows;
+		let shouldHealSession;
+		try {
+			const result = await store.append(nsId(sessionId), validated, {
+				consumers: storeConsumers,
+				...originIndex === void 0 ? {} : { originIndex }
+			});
+			rows = result.events;
+			shouldHealSession = result.hasPending && !(source === "consumer" && !validated.some(startsWork));
+		} catch (err) {
+			throw asStoreUnavailable(err);
+		}
+		const appended = rows.map(toPublic);
+		const initialWatchdogAt = shouldHealSession && scheduler && source === "external" && mode === "inline" ? schedulerSlot(nextClaimWindow().watchdogAtMs) : void 0;
+		const initialArm = initialWatchdogAt !== void 0 ? startSchedulerArm(sessionId, initialWatchdogAt) : null;
+		const dispatchArm = shouldHealSession && mode === "dispatch" ? startSchedulerArm(sessionId, currentSchedulerSlot(Date.now())) : null;
+		if (shouldHealSession && mode === "inline") onAppended(appended, initialWatchdogAt);
+		if (dispatchArm) await dispatchArm;
+		if (initialArm) try {
+			await joinSchedulerArm(initialArm);
+		} catch (err) {
+			span.setAttribute("a2.append.armed", false);
+			span.recordError(err);
+			if (requireDurableInitialArm) throw err;
+		}
+		return appended;
+	});
+	const readHistory = async (sessionId, bounds) => {
+		const gte = bounds?.gte;
+		const lte = bounds?.lte;
+		assertHistoryIndex("gte", gte);
+		assertHistoryIndex("lte", lte);
+		if (gte !== void 0 && lte !== void 0 && gte > lte) throw new RangeError("history.gte must be less than or equal to history.lte");
+		if (lte === 0) return [];
+		const store = await resolveStore();
+		try {
+			const readOptions = gte === void 0 && lte === void 0 ? void 0 : {
+				...gte === void 0 ? {} : { afterIndex: Math.max(0, gte - 1) },
+				...lte === void 0 ? {} : { throughIndex: lte }
+			};
+			return (await (store.readHistory ? store.readHistory(nsId(sessionId), readOptions) : store.read(nsId(sessionId), readOptions))).filter((row) => (gte === void 0 || row.index >= gte) && (lte === void 0 || row.index <= lte));
+		} catch (err) {
+			throw asStoreUnavailable(err);
+		}
+	};
+	const readStoreState = async (store, sessionId, reducerName, throughIndex, snapshotThroughIndex) => {
+		try {
+			return await store.readState(nsId(sessionId), reducerName, throughIndex === void 0 && snapshotThroughIndex === void 0 ? void 0 : {
+				...throughIndex === void 0 ? {} : { throughIndex },
+				...snapshotThroughIndex === void 0 ? {} : { snapshotThroughIndex }
+			});
+		} catch (err) {
+			throw asStoreUnavailable(err);
+		}
+	};
+	const planStateReads = (batch) => {
+		const bySession = /* @__PURE__ */ new Map();
+		for (const entry of batch) {
+			const entries = bySession.get(entry.sessionId);
+			if (entries) entries.push(entry);
+			else bySession.set(entry.sessionId, [entry]);
+		}
+		const plans = [];
+		for (const [sessionId, entries] of bySession) {
+			const boundaries = entries.flatMap((entry) => entry.throughIndex === void 0 ? [] : [entry.throughIndex]);
+			const plan = {
+				sessionId,
+				entries
+			};
+			if (boundaries.length === entries.length) plan.throughIndex = Math.max(...boundaries);
+			if (boundaries.length > 0) plan.snapshotThroughIndex = Math.min(...boundaries);
+			plans.push(plan);
+		}
+		return plans;
+	};
+	const persistSnapshots = ({ store, reducer, sessionId, snapshots }) => {
+		const persistence = Promise.resolve().then(() => telemetry.span("a2.snapshot", {
+			"a2.contract": name,
+			"a2.session_id": sessionId,
+			"a2.snapshot.reducer": reducer.name,
+			"a2.snapshot.index": snapshots.at(-1).index,
+			"a2.snapshot.count": snapshots.length
+		}, async (span) => {
+			try {
+				await store.putSnapshots(nsId(sessionId), reducer.name, snapshots);
+			} catch (error) {
+				try {
+					span.recordError(error);
+				} catch (telemetryError) {
+					throw new AggregateError([error, telemetryError], "Snapshot write and error reporting failed", { cause: telemetryError });
+				}
+			}
+		})).catch((error) => {
+			console.error("[a2] error in a2.snapshot telemetry", {
+				sessionId,
+				reducer: reducer.name,
+				index: snapshots.at(-1).index
+			}, error);
+		});
+		track(persistence);
+		platformWaitUntil(persistence);
+	};
+	const stateCache = boundedCache(STATE_CACHE);
+	const cacheState = (key, next) => {
+		const current = stateCache.get(key);
+		if (current?.reducer === next.reducer && (current.index > next.index || current.index === next.index && current.persistedIndex >= next.persistedIndex)) return;
+		stateCache.set(key, next, next.bytes);
+	};
+	const writeSnapshots = ({ store, reducer, sessionId, writes }) => {
+		const snapshots = [...writes].toSorted(([a], [b]) => a - b).map(([index, write]) => {
+			const snapshot = {
+				index,
+				state: encodeState({
+					reducer,
+					state: write.state
+				})
+			};
+			if (write.pins.size > 0) snapshot.pins = [...write.pins.values()];
+			return snapshot;
+		});
+		if (snapshots.length > 0) persistSnapshots({
+			store,
+			reducer,
+			sessionId,
+			snapshots
+		});
+		return snapshots;
+	};
+	/**
+	* Folds `rows` from `position` in bound order, resolving each entry with a
+	* clone once the rows through its bound are folded. `visit` sees each
+	* entry's state before later rows are folded into it.
+	*/
+	const foldEntries = ({ reducer, entries, rows, position, state, index, clearIndex, snapshot, visit }) => {
+		const start = position;
+		const ordered = entries.toSorted((a, b) => (a.throughIndex ?? Number.POSITIVE_INFINITY) - (b.throughIndex ?? Number.POSITIVE_INFINITY));
+		for (const entry of ordered) {
+			const target = entry.throughIndex ?? Number.POSITIVE_INFINITY;
+			while (position < rows.length && rows[position].index <= target) {
+				const row = rows[position];
+				state = foldEvent(reducer, state, toPublic(row));
+				index = row.index;
+				position += 1;
+			}
+			if (entry.triggerIndex !== void 0 && entry.triggerIndex <= clearIndex || entry.throughIndex !== void 0 && entry.throughIndex > 0 && entry.throughIndex < clearIndex) {
+				entry.reject(sessionClearedError(`session '${entry.sessionId}' was cleared at index ${clearIndex}`));
+				continue;
+			}
+			entry.span.setAttribute("a2.state.snapshot", snapshot);
+			entry.span.setAttribute("a2.state.folded", position - start);
+			entry.span.setAttribute("a2.state.index", index);
+			visit(entry, state, index, position - start);
+			entry.resolve({
+				state: cloneInitial(state),
+				index,
+				...clearIndex > 0 && index >= clearIndex ? { clearIndex } : {}
+			});
+		}
+		return {
+			state,
+			index,
+			position
+		};
+	};
+	/**
+	* Events from `fromIndex` (inclusive) through `throughIndex` or the newest
+	* event, or null when the tail is too long to be worth folding in memory.
+	*/
+	const readCachedTail = async (store, sessionId, fromIndex, throughIndex) => {
+		const readTail = stateTailReaders.get(store);
+		if (readTail) try {
+			return await readTail(nsId(sessionId), fromIndex, throughIndex);
+		} catch (err) {
+			throw asStoreUnavailable(err);
+		}
+		const limit = fromIndex + STATE_CACHE.maxTail;
+		const capped = throughIndex === void 0 || throughIndex > limit;
+		const rows = await readHistory(sessionId, {
+			gte: fromIndex,
+			lte: capped ? limit : throughIndex
+		});
+		return capped && rows.at(-1)?.index === limit ? null : rows;
+	};
+	/**
+	* Serves a plan from the cached state when every read is at or past the
+	* cached index. A read bounded at the cached index by an event whose id
+	* matches the cached one (a consumer's own trigger) needs no store request;
+	* any other read fetches the tail from the cached event onward and checks
+	* that event's id. Returns false when the store must answer instead.
+	*/
+	const foldCachedPlan = async (store, reducer, plan) => {
+		const key = stateCacheKey(plan.sessionId, reducer.name);
+		const cached = stateCache.get(key);
+		if (cached?.reducer !== reducer) return false;
+		if (plan.entries.some((entry) => entry.throughIndex !== void 0 && entry.throughIndex < cached.index)) return false;
+		let rows = [];
+		if (plan.entries.some((entry) => entry.throughIndex !== cached.index || entry.throughEventId !== cached.lastId)) {
+			const tail = await readCachedTail(store, plan.sessionId, cached.index, plan.throughIndex);
+			if (!tail) return false;
+			if (tail[0]?.index !== cached.index || tail[0].id !== cached.lastId || tail.some((row, position) => position > 0 && isSessionCleared(row))) {
+				stateCache.delete(key);
+				return false;
+			}
+			rows = tail;
+		}
+		const writes = /* @__PURE__ */ new Map();
+		const folded = foldEntries({
+			reducer,
+			entries: plan.entries,
+			rows,
+			position: 1,
+			state: rows.length > 1 ? cloneInitial(cached.state) : cached.state,
+			index: cached.index,
+			clearIndex: cached.clearIndex,
+			snapshot: "memory",
+			visit: (entry, state, index) => {
+				if (entry.pin !== void 0) addSnapshotWrite(writes, index, state, entry.pin);
+			}
+		});
+		const added = Math.max(0, folded.position - 1);
+		const rewritesHead = folded.index - cached.persistedIndex >= STATE_CACHE.snapshotEvery;
+		if (rewritesHead && !writes.has(folded.index)) writes.set(folded.index, {
+			state: folded.state,
+			pins: /* @__PURE__ */ new Map()
+		});
+		const snapshots = writeSnapshots({
+			store,
+			reducer,
+			sessionId: plan.sessionId,
+			writes
+		});
+		const measure = rewritesHead || cached.unmeasured + added >= STATE_CACHE.measureEvery;
+		let grown = 0;
+		if (!measure) for (let position = 1; position < folded.position; position += 1) grown += JSON.stringify(rows[position].payload)?.length ?? 0;
+		cacheState(key, {
+			reducer,
+			index: folded.index,
+			lastId: added > 0 ? rows[folded.position - 1].id : cached.lastId,
+			state: folded.state,
+			bytes: measure ? measuredBytes(reducer, folded.state, folded.index, snapshots) : cached.bytes + grown,
+			unmeasured: measure ? 0 : cached.unmeasured + added,
+			persistedIndex: Math.max(cached.persistedIndex, snapshots.at(-1)?.index ?? 0),
+			clearIndex: cached.clearIndex
+		});
+		return true;
+	};
+	const foldStatePlan = async (store, reducer, plan, stateRead) => {
+		let state = cloneInitial(reducer.initialState);
+		let index = 0;
+		let snapshotOutcome = "miss";
+		const snap = stateRead.snapshot;
+		let rows = stateRead.events;
+		let clearIndex = stateRead.clearIndex ?? 0;
+		if (snap) {
+			let decoded;
+			try {
+				decoded = decodeState({
+					reducer,
+					state: snap.state
+				});
+			} catch {
+				snapshotOutcome = "rejected";
+			}
+			if (snapshotOutcome !== "rejected" && reducer.stateSchema) {
+				const result = validateSync(reducer.stateSchema, decoded, "the stateSchema");
+				if (result.issues) snapshotOutcome = "rejected";
+				else {
+					state = result.value;
+					index = snap.index;
+					snapshotOutcome = "hit";
+				}
+			} else if (snapshotOutcome !== "rejected") {
+				state = decoded;
+				index = snap.index;
+				snapshotOutcome = "hit";
+			}
+		}
+		if (snapshotOutcome === "rejected") {
+			try {
+				rows = await store.read(nsId(plan.sessionId), plan.throughIndex === void 0 ? void 0 : { throughIndex: plan.throughIndex });
+			} catch (err) {
+				throw asStoreUnavailable(err);
+			}
+			if (rows[0] && isSessionCleared(rows[0])) clearIndex = Math.max(clearIndex, rows[0].index);
+		}
+		const writes = /* @__PURE__ */ new Map();
+		const folded = foldEntries({
+			reducer,
+			entries: plan.entries,
+			rows,
+			position: 0,
+			state,
+			index,
+			clearIndex,
+			snapshot: snapshotOutcome,
+			visit: (entry, entryState, entryIndex, count) => {
+				if (entryIndex === 0) return;
+				if (count === 0 && entry.pin === void 0) return;
+				const advancesHead = stateRead.headIndex === null || entryIndex > stateRead.headIndex;
+				const repairsHead = snapshotOutcome === "rejected" && entryIndex === stateRead.headIndex;
+				if (!advancesHead && !repairsHead && entry.pin === void 0) return;
+				addSnapshotWrite(writes, entryIndex, entryState, entry.pin);
+			}
+		});
+		const snapshots = writeSnapshots({
+			store,
+			reducer,
+			sessionId: plan.sessionId,
+			writes
+		});
+		if (folded.position > 0 && STATE_CACHE.maxEntries > 0) cacheState(stateCacheKey(plan.sessionId, reducer.name), {
+			reducer,
+			index: folded.index,
+			lastId: rows[folded.position - 1].id,
+			state: folded.state,
+			bytes: measuredBytes(reducer, folded.state, folded.index, snapshots),
+			unmeasured: 0,
+			persistedIndex: Math.min(Math.max(stateRead.headIndex ?? 0, ...writes.keys()), folded.index),
+			clearIndex
+		});
+	};
+	const pendingStateReads = /* @__PURE__ */ new Map();
+	const flushStateReads = async (store, reducer, batch) => {
+		const plans = [];
+		await Promise.all(planStateReads(batch).map(async (plan) => {
+			try {
+				if (!await foldCachedPlan(store, reducer, plan)) plans.push(plan);
+			} catch (error) {
+				for (const entry of plan.entries) entry.reject(error);
+			}
+		}));
+		if (plans.length === 0) return;
+		let reads;
+		try {
+			reads = store.readStates ? await store.readStates(plans.map((plan) => ({
+				sessionId: nsId(plan.sessionId),
+				...plan.throughIndex === void 0 ? {} : { throughIndex: plan.throughIndex },
+				...plan.snapshotThroughIndex === void 0 ? {} : { snapshotThroughIndex: plan.snapshotThroughIndex }
+			})), reducer.name) : plans.map((plan) => readStoreState(store, plan.sessionId, reducer.name, plan.throughIndex, plan.snapshotThroughIndex));
+			if (reads.length !== plans.length) throw new TypeError("store.readStates must return one result per request");
+		} catch (error) {
+			const failure = asStoreUnavailable(error);
+			for (const plan of plans) for (const entry of plan.entries) entry.reject(failure);
+			return;
+		}
+		await Promise.all(plans.map(async (plan, position) => {
+			try {
+				await foldStatePlan(store, reducer, plan, await reads[position]);
+			} catch (error) {
+				for (const entry of plan.entries) entry.reject(error);
+			}
+		}));
+	};
+	const enqueueStateRead = (store, sessionId, reducer, bounds, span) => new Promise((resolve, reject) => {
+		const reducerName = reducer.name;
+		let batch = pendingStateReads.get(reducerName);
+		if (!batch) {
+			const opened = [];
+			pendingStateReads.set(reducerName, opened);
+			queueMicrotask(() => {
+				pendingStateReads.delete(reducerName);
+				flushStateReads(store, reducer, opened);
+			});
+			batch = opened;
+		}
+		batch.push({
+			sessionId,
+			...bounds,
+			span,
+			resolve,
+			reject
+		});
+	});
+	const readState = async (sessionId, reducer, bounds) => {
+		const store = await resolveStore();
+		return telemetry.span("a2.state", {
+			"a2.contract": name,
+			"a2.session_id": sessionId,
+			"a2.state.reducer": reducer.name
+		}, (span) => enqueueStateRead(store, sessionId, reducer, bounds, span));
+	};
+	const makeSchedule = (sessionId, trigger) => {
+		const triggerEventId = trigger?.id ?? null;
+		/** Timers a consumer sets key on its name, except A2's own. */
+		const triggerConsumer = trigger && !registeredConsumers.get(trigger.consumer)?.anonymousIds ? trigger.consumer : void 0;
+		const triggerCreatedAt = trigger?.createdAt.getTime();
+		const clearIndex = trigger?.clearIndex ?? 0;
+		const schedule = async (scheduleName, timing, ...events) => {
+			if (!scheduler) throw new TypeError("session.schedule requires a configured scheduler adapter");
+			assertScheduleName(scheduleName);
+			if (events.length === 0) throw new TypeError("schedule requires at least one event");
+			const dueAt = scheduleDueAt(timing, triggerCreatedAt ?? Date.now());
+			const payloads = events.map((event) => cloneScheduledPayload(event.payload));
+			const snapshottedEvents = events.map((event, index) => event.id === void 0 ? {
+				type: event.type,
+				payload: payloads[index]
+			} : {
+				type: event.type,
+				payload: payloads[index],
+				id: event.id
+			});
+			const validated = validateEvents(sessionId, structuredClone(snapshottedEvents), false);
+			const scheduleId = await deterministicScheduleId(name, sessionId, triggerEventId, scheduleName, clearIndex, triggerConsumer);
+			const scheduledEvents = await Promise.all(validated.map(async (event, item) => ({
+				id: event.id ?? await deterministicScheduledEventId(scheduleId, item),
+				type: event.type,
+				payload: payloads[item]
+			})));
+			if (new Set(scheduledEvents.map((event) => event.id)).size !== scheduledEvents.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "scheduled batch contains the same event id more than once");
+			try {
+				await scheduler.schedule({
+					version: 1,
+					kind: "append",
+					id: scheduleId,
+					contract: name,
+					sessionId,
+					dueAt,
+					events: scheduledEvents,
+					...trigger ? { originIndex: trigger.index } : {}
+				});
+			} catch (error) {
+				throw markSchedulerSendFailure(error);
+			}
+		};
+		const clear = async (scheduleName, clearOptions) => {
+			if (!scheduler) throw new TypeError("session.schedule.clear requires a configured scheduler adapter");
+			assertScheduleName(scheduleName);
+			if (clearOptions === null || typeof clearOptions !== "object") throw new TypeError("schedule.clear requires an ifLastIndex");
+			const { ifLastIndex, ...timing } = clearOptions;
+			assertClearIndex(ifLastIndex);
+			const dueAt = scheduleDueAt(timing, triggerCreatedAt ?? Date.now());
+			const store = await resolveStore();
+			if (!store.clear || !store.reclaim) throw new TypeError("session.schedule.clear requires a store that supports clearing");
+			const id = await deterministicScheduleClearId({
+				contract: name,
+				sessionId,
+				triggerEventId,
+				clearIndex,
+				name: scheduleName,
+				ifLastIndex,
+				...triggerConsumer === void 0 ? {} : { consumer: triggerConsumer }
+			});
+			try {
+				await scheduler.schedule({
+					version: 1,
+					kind: "clear",
+					id,
+					contract: name,
+					sessionId,
+					dueAt,
+					ifLastIndex
+				});
+			} catch (error) {
+				throw markSchedulerSendFailure(error);
+			}
+		};
+		return Object.assign(schedule, { clear });
+	};
+	const toSessionEvent = (id, event) => ({
+		id: event.id,
+		type: event.type,
+		payload: event.payload,
+		index: event.index,
+		sessionId: id,
+		createdAt: event.createdAt
+	});
+	const streamEvents = (id, startAfter) => {
+		let closed = false;
+		let inner;
+		let stopActivity;
+		const activity = createStreamActivity(() => {
+			if (inner && !closed) streamActivities.get(inner)?.activate();
+		});
+		let closing;
+		const close = () => {
+			closed = true;
+			closing ??= (async () => {
+				stopActivity?.();
+				await inner?.return?.();
+			})();
+			return closing;
+		};
+		const outer = async function* () {
+			const store = await resolveStore();
+			if (closed) return;
+			inner = store.stream(nsId(id), { startAfter })[Symbol.asyncIterator]();
+			const sourceActivity = streamActivities.get(inner);
+			if (sourceActivity) {
+				stopActivity = sourceActivity.subscribe(activity.setIdle);
+				activity.setIdle(sourceActivity.idle);
+			}
+			try {
+				for (;;) {
+					if (closed) return;
+					const result = await inner.next();
+					if (closed || result.done) return;
+					yield toSessionEvent(id, result.value);
+				}
+			} finally {
+				await close();
+			}
+		};
+		const iterator = outer();
+		return { [Symbol.asyncIterator]() {
+			const stream = {
+				next: () => iterator.next(),
+				async return() {
+					await close();
+					return iterator.return(void 0);
+				},
+				async throw(error) {
+					await close();
+					return iterator.throw(error);
+				}
+			};
+			streamActivities.set(stream, activity);
+			bufferedEvents.set(stream, () => {
+				const event = closed || !inner ? void 0 : takeBuffered(inner);
+				if (!event) return void 0;
+				if (!isSerializedEvent(event)) return toSessionEvent(id, event);
+				event.sessionId = id;
+				return event;
+			});
+			return stream;
+		} };
+	};
+	const requirePresence = (store) => {
+		if (!store.presence) throw presenceNotSupported();
+		return store.presence;
+	};
+	const setPresence = async (sessionId, patch, fallbackSeen) => {
+		if (typeof patch.participant !== "string" || patch.participant.length === 0) throw new TypeError("presence participant must be a non-empty string");
+		if (RESERVED_PARTICIPANT_IDS.has(patch.participant)) throw new TypeError(`presence participant must not be '${patch.participant}'`);
+		if (patch.at !== void 0 && (typeof patch.at !== "number" || !Number.isFinite(patch.at) || patch.at < 0 || patch.at > 864e13)) throw new TypeError("presence at must be non-negative epoch milliseconds within the Date range");
+		const validated = nullProtoRecord();
+		for (const [field, value] of Object.entries(patch.values)) {
+			if (value === void 0) continue;
+			const schema = Object.hasOwn(presenceDefs, field) ? presenceDefs[field] : RESERVED_PARTICIPANT_IDS.has(field) ? void 0 : presenceDefs["*"];
+			if (!schema) throw new A2Error("UNKNOWN_PRESENCE_FIELD", `contract '${name}' has no presence field '${field}'`);
+			if (value === null) {
+				validated[field] = null;
+				continue;
+			}
+			const result = validateSync(schema, value, `presence field '${field}'`);
+			if (result.issues) throw new A2Error("INVALID_PAYLOAD", `invalid value for presence field '${field}' on machine '${name}'`, { details: result.issues });
+			validated[field] = result.value;
+		}
+		const store = await resolveStore();
+		try {
+			await requirePresence(store).set(nsId(sessionId), patch.participant, validated, {
+				seen: patch.seen ?? fallbackSeen,
+				at: new Date(patch.at ?? Date.now()),
+				ttlMs: presenceTtlMs
+			});
+		} catch (err) {
+			throw asStoreUnavailable(err);
+		}
+	};
+	const readPresenceMap = async (sessionId) => {
+		const store = await resolveStore();
+		let rows;
+		try {
+			rows = await requirePresence(store).read(nsId(sessionId));
+		} catch (err) {
+			throw asStoreUnavailable(err);
+		}
+		return foldPresenceRows(rows);
+	};
+	/**
+	* The two-plane feed. Patches ride `subscribe` when the adapter has
+	* the push tier; without it the map is re-read and diffed whenever
+	* the event feed wakes, and at the poll idle ceiling while it is
+	* silent — degraded means later, not lost while watched.
+	*/
+	const streamWithPresence = (id, startAfter) => {
+		const ns = nsId(id);
+		let closed = false;
+		let events;
+		let pendingEvent = null;
+		let unsubscribe;
+		let sleeper = null;
+		let wakeQueue = null;
+		let presenceInterval = Math.min(POLL_TIMINGS.activeFloorMs, POLL_TIMINGS.idleCeilingMs);
+		let presenceActivityVersion = 0;
+		let stopActivity;
+		const activity = createStreamActivity(() => {
+			if (closed) return;
+			presenceActivityVersion += 1;
+			presenceInterval = Math.min(POLL_TIMINGS.activeFloorMs, POLL_TIMINGS.idleCeilingMs);
+			sleeper?.cancel();
+			if (events) streamActivities.get(events)?.activate();
+		});
+		let closing;
+		const close = () => {
+			closed = true;
+			sleeper?.cancel();
+			wakeQueue?.();
+			closing ??= (async () => {
+				try {
+					stopActivity?.();
+					unsubscribe?.();
+				} finally {
+					await events?.return?.();
+				}
+			})();
+			return closing;
+		};
+		const outer = async function* () {
+			const store = await resolveStore();
+			if (closed) return;
+			const api = requirePresence(store);
+			const readRows = async () => {
+				try {
+					return await api.read(ns);
+				} catch (err) {
+					throw asStoreUnavailable(err);
+				}
+			};
+			const painted = /* @__PURE__ */ new Map();
+			const paintedDeletes = presenceTombstones();
+			const diffRows = (rows) => {
+				const patches = [];
+				const live = /* @__PURE__ */ new Map();
+				for (const row of rows) {
+					let liveFields = live.get(row.participant);
+					if (!liveFields) {
+						liveFields = /* @__PURE__ */ new Set();
+						live.set(row.participant, liveFields);
+					}
+					liveFields.add(row.field);
+					const stamp = {
+						seen: row.seen,
+						atMs: row.at.getTime(),
+						value: fingerprint(row.value)
+					};
+					const prior = painted.get(row.participant)?.get(row.field);
+					if (prior && prior.seen === stamp.seen && prior.atMs === stamp.atMs && prior.value === stamp.value) continue;
+					let paintedFields = painted.get(row.participant);
+					if (!paintedFields) {
+						paintedFields = /* @__PURE__ */ new Map();
+						painted.set(row.participant, paintedFields);
+					}
+					paintedFields.set(row.field, stamp);
+					patches.push({
+						participant: row.participant,
+						values: { [row.field]: row.value },
+						seen: row.seen,
+						at: row.at
+					});
+				}
+				for (const [participant, fields] of painted) {
+					for (const [field, prior] of fields) {
+						if (live.get(participant)?.has(field)) continue;
+						fields.delete(field);
+						patches.push({
+							participant,
+							values: { [field]: null },
+							seen: prior.seen,
+							at: new Date(prior.atMs)
+						});
+					}
+					if (fields.size === 0) painted.delete(participant);
+				}
+				return patches;
+			};
+			const paint = (patch) => {
+				let fields = painted.get(patch.participant);
+				for (const [field, value] of Object.entries(patch.values)) {
+					const write = {
+						participant: patch.participant,
+						field,
+						at: patch.at
+					};
+					if (value === null || value === void 0) {
+						fields?.delete(field);
+						if (value === null) paintedDeletes.keep(write);
+						continue;
+					}
+					paintedDeletes.drop(write);
+					if (!fields) {
+						fields = /* @__PURE__ */ new Map();
+						painted.set(patch.participant, fields);
+					}
+					fields.set(field, {
+						seen: patch.seen,
+						atMs: patch.at.getTime(),
+						value: fingerprint(value)
+					});
+				}
+				if (fields?.size === 0) painted.delete(patch.participant);
+			};
+			const queue = /* @__PURE__ */ new Map();
+			const enqueue = (patch) => {
+				if (closed) return;
+				activity.activate();
+				for (const [field, value] of Object.entries(patch.values)) {
+					if (value === void 0) continue;
+					let fields = queue.get(patch.participant);
+					if (!fields) {
+						fields = /* @__PURE__ */ new Map();
+						queue.set(patch.participant, fields);
+					}
+					const queued = fields.get(field);
+					if (queued && queued.at.getTime() > patch.at.getTime()) continue;
+					fields.set(field, {
+						value,
+						seen: patch.seen,
+						at: patch.at
+					});
+				}
+				wakeQueue?.();
+			};
+			const outdated = (write) => {
+				const prior = painted.get(write.participant)?.get(write.field);
+				return prior !== void 0 && prior.atMs > write.at.getTime() || paintedDeletes.outranks(write);
+			};
+			const dequeue = () => {
+				for (const [participant, fields] of queue) {
+					for (const [field, stamp] of fields) {
+						fields.delete(field);
+						if (fields.size === 0) queue.delete(participant);
+						if (outdated({
+							participant,
+							field,
+							at: stamp.at
+						})) continue;
+						return {
+							participant,
+							values: { [field]: stamp.value },
+							seen: stamp.seen,
+							at: stamp.at
+						};
+					}
+					queue.delete(participant);
+				}
+				return null;
+			};
+			try {
+				unsubscribe = api.subscribe?.(ns, enqueue);
+				events = store.stream(ns, { startAfter })[Symbol.asyncIterator]();
+				const sourceActivity = streamActivities.get(events);
+				if (sourceActivity) {
+					stopActivity = sourceActivity.subscribe(activity.setIdle);
+					activity.setIdle(sourceActivity.idle);
+				}
+				const snapshotRows = await readRows();
+				if (closed) return;
+				for (const row of snapshotRows) {
+					let fields = painted.get(row.participant);
+					if (!fields) {
+						fields = /* @__PURE__ */ new Map();
+						painted.set(row.participant, fields);
+					}
+					fields.set(row.field, {
+						seen: row.seen,
+						atMs: row.at.getTime(),
+						value: fingerprint(row.value)
+					});
+				}
+				yield { snapshot: foldPresenceRows(snapshotRows) };
+				for (;;) {
+					if (closed) return;
+					for (;;) {
+						const patch = dequeue();
+						if (!patch) break;
+						if (closed) return;
+						paint(patch);
+						yield patch;
+					}
+					pendingEvent ??= events.next();
+					let woke;
+					if (unsubscribe) {
+						const arrival = new Promise((resolve) => {
+							wakeQueue = resolve;
+						});
+						woke = await Promise.race([pendingEvent.then(() => "event"), arrival.then(() => "patch")]);
+						wakeQueue = null;
+						if (closed) return;
+						if (woke === "patch") continue;
+					} else {
+						sleeper = defaultSleep(presenceInterval);
+						woke = await Promise.race([pendingEvent.then(() => "event"), sleeper.promise.then(() => "tick")]);
+						sleeper.cancel();
+						sleeper = null;
+					}
+					if (closed) return;
+					if (woke === "event") {
+						const result = await pendingEvent;
+						pendingEvent = null;
+						if (closed || result.done) return;
+						activity.activate();
+						yield toSessionEvent(id, result.value);
+					}
+					if (!closed && !unsubscribe) {
+						const version = presenceActivityVersion;
+						const rows = await readRows();
+						if (closed) return;
+						const patches = diffRows(rows);
+						if (patches.length > 0) activity.activate();
+						else if (version === presenceActivityVersion) presenceInterval = Math.min(presenceInterval * 2, POLL_TIMINGS.idleCeilingMs);
+						for (const patch of patches) {
+							if (closed) return;
+							yield patch;
+						}
+					}
+				}
+			} finally {
+				pendingEvent?.catch(() => {});
+				await close();
+				wakeQueue = null;
+			}
+		};
+		const iterator = outer();
+		return { [Symbol.asyncIterator]() {
+			const stream = {
+				next: () => iterator.next(),
+				async return() {
+					await close();
+					return iterator.return(void 0);
+				},
+				async throw(error) {
+					await close();
+					return iterator.throw(error);
+				}
+			};
+			streamActivities.set(stream, activity);
+			bufferedEvents.set(stream, () => {
+				if (closed || !events || pendingEvent) return void 0;
+				const event = takeBuffered(events);
+				if (!event) return void 0;
+				if (!isSerializedEvent(event)) return toSessionEvent(id, event);
+				event.sessionId = id;
+				return event;
+			});
+			return stream;
+		} };
+	};
+	const reclaimAll = async (store, ns) => {
+		for (let stalls = 0;;) {
+			let batch;
+			try {
+				batch = await store.reclaim(ns);
+			} catch (err) {
+				throw asStoreUnavailable(err);
+			}
+			if (batch.done) return;
+			if (batch.deleted > 0) {
+				stalls = 0;
+				continue;
+			}
+			stalls += 1;
+			if (stalls === RECLAIM_STALL_LIMIT) throw new A2Error("STORE_UNAVAILABLE", `deleting the cleared history of session '${stripNs(ns)}' made no progress`);
+			await defaultSleep(RECLAIM_STALL_MS).promise;
+		}
+	};
+	const clearSession = async (sessionId, clearOptions, attempt) => {
+		const ifLastIndex = clearOptions?.ifLastIndex;
+		if (ifLastIndex !== void 0) assertClearIndex(ifLastIndex);
+		const store = await resolveStore();
+		if (!store.clear || !store.reclaim) throw new TypeError("session.clear requires a store that supports clearing");
+		const ns = nsId(sessionId);
+		let result;
+		try {
+			result = await store.clear({
+				sessionId: ns,
+				...ifLastIndex === void 0 ? {} : { ifLastIndex },
+				...attempt ? { cause: attempt.cause } : {}
+			});
+		} catch (err) {
+			throw asStoreUnavailable(err);
+		}
+		if (result.cleared) {
+			const cachePrefix = stateCacheKey(sessionId, "");
+			stateCache.deleteWhere((key) => key.startsWith(cachePrefix));
+		}
+		const deletion = reclaimAll(store, ns);
+		if (attempt) {
+			if (attempt.cause.index <= result.clearIndex) attempt.end();
+			const kept = deletion.catch(() => void 0);
+			track(kept);
+			platformWaitUntil(kept);
+		}
+		await deletion;
+		return {
+			cleared: result.cleared,
+			index: result.index
+		};
+	};
+	const redrivingStore = async (method) => {
+		const store = await resolveStore();
+		if (!store.deadLetters || !store.redrive) throw new TypeError(`session.${method} requires a store that supports redriving dead letters`);
+		return store;
+	};
+	const listDeadLetters = async (sessionId) => {
+		const store = await redrivingStore("deadLetters");
+		let rows;
+		try {
+			rows = await store.deadLetters(nsId(sessionId));
+		} catch (err) {
+			throw asStoreUnavailable(err);
+		}
+		return rows.flatMap((row) => row.failedAt === null ? [] : [{
+			...toPublic(row),
+			consumer: row.consumer,
+			lane: row.lane,
+			attemptCount: row.attemptCount,
+			failureCount: row.failureCount,
+			lastError: row.lastError,
+			failedAt: row.failedAt
+		}]);
+	};
+	const redriveEvent = async (sessionId, target, redriveOptions) => {
+		const index = target?.index;
+		const redriven = target?.consumer;
+		assertRedriveIndex(index);
+		if (typeof redriven !== "string" || redriven.length === 0) throw new TypeError("redrive requires a consumer name");
+		const action = redriveOptions?.action;
+		if (action !== "retry" && action !== "skip") throw new TypeError("redrive requires action 'retry' or 'skip'");
+		return telemetry.span("a2.redrive", {
+			"a2.contract": name,
+			"a2.session_id": sessionId,
+			"a2.redrive.index": index,
+			"a2.redrive.consumer": redriven,
+			"a2.redrive.action": action
+		}, async (span) => {
+			const store = await redrivingStore("redrive");
+			let result;
+			try {
+				result = await store.redrive({
+					sessionId: nsId(sessionId),
+					consumer: redriven,
+					index,
+					action,
+					consumers: storeConsumers
+				});
+			} catch (err) {
+				throw asStoreUnavailable(err);
+			}
+			span.setAttribute("a2.redrive.redriven", result.redriven);
+			if (result.hasPending) {
+				const watchdogAt = scheduler ? schedulerSlot(nextClaimWindow().watchdogAtMs) : void 0;
+				const arm = watchdogAt === void 0 ? null : startSchedulerArm(sessionId, watchdogAt);
+				scheduleDrain(sessionId, watchdogAt);
+				if (arm) try {
+					await joinSchedulerArm(arm);
+				} catch (err) {
+					span.setAttribute("a2.redrive.armed", false);
+					span.recordError(err);
+				}
+			}
+			return { redriven: result.redriven };
+		});
+	};
+	/**
+	* `session.consume`: wakes the consumer's cursor, then drains only that
+	* consumer until its head lies past `through`. A head another invocation
+	* holds, or one waiting out a failure, is waited for; a dead-lettered head
+	* throws.
+	*/
+	/** Per session, which consumer's running head is waiting in `consume` on which: a cycle never ends. */
+	const consumeWaits = /* @__PURE__ */ new Map();
+	const consumeSession = (sessionId, defined, consumeOptions = {}, trigger = null) => {
+		assertSessionId(sessionId);
+		if (defined?.contract?.name !== name || !defined.spec) throw new TypeError(`session.consume for '${name}' got a consumer of another contract`);
+		const own = definitions.get(defined.name);
+		if (own !== void 0 && own !== defined) throw new TypeError(`this server runs a different consumer named '${defined.name}'`);
+		if (defined.name === trigger?.consumer) throw new TypeError(`consumer '${defined.name}' can't consume itself: its own head is running`);
+		const registered = own ? registeredConsumers.get(defined.name) : registrationOf(defined);
+		const log = registered.log;
+		if (!log) throw new TypeError(`consumer '${defined.name}' needs a string lane to be consumed: only then does it have one position`);
+		const { through: requested, signal } = consumeOptions;
+		if (requested !== void 0) assertConsumeIndex(requested);
+		const waiter = trigger?.consumer;
+		const waits = waiter === void 0 ? void 0 : consumeWaits.get(sessionId) ?? consumeWaits.set(sessionId, /* @__PURE__ */ new Map()).get(sessionId);
+		let cycle = false;
+		if (waiter !== void 0 && waits) {
+			for (let next = defined.name; next !== void 0 && !cycle; next = waits.get(next)) cycle = next === waiter;
+			if (!cycle) waits.set(waiter, defined.name);
+		}
+		const storeConsumer = {
+			name: registered.name,
+			log
+		};
+		const consumed = telemetry.span("a2.consume", {
+			"a2.contract": name,
+			"a2.session_id": sessionId,
+			"a2.consume.consumer": registered.name
+		}, async (span) => {
+			const store = await resolveStore();
+			const ns = nsId(sessionId);
+			let woken = await store.wakeLog({
+				sessionId: ns,
+				consumer: storeConsumer
+			});
+			const through = Math.min(requested ?? woken.head, woken.head);
+			span.setAttribute("a2.consume.through", through);
+			const done = () => woken.cursor.head === null || woken.cursor.head > through;
+			if (cycle && !done()) throw new TypeError(`consumer '${waiter}' can't consume '${defined.name}' through ${through}: '${defined.name}' is waiting on it in session '${sessionId}'`);
+			let drains = 0;
+			let wait = CONSUME_WAIT_MIN_MS;
+			while (!done()) {
+				signal?.throwIfAborted();
+				const { cursor } = woken;
+				if (cursor.failedAt !== null) throw new A2Error("CONSUMER_DEAD_LETTERED", `consumer '${registered.name}' is dead-lettered at event ${cursor.head} in session '${sessionId}': ${cursor.lastError ?? "every attempt ended before it finished"}`);
+				drains += 1;
+				const drained = drainSession(sessionId, {
+					only: registered,
+					through
+				});
+				try {
+					await untilAborted(drained, signal);
+				} catch (error) {
+					if (signal?.aborted) drained.then(() => scheduleDrain(sessionId), () => {});
+					throw error;
+				}
+				const before = cursor;
+				woken = await store.wakeLog({
+					sessionId: ns,
+					consumer: storeConsumer
+				});
+				const moved = woken.cursor.head !== before.head || woken.cursor.attemptCount !== before.attemptCount;
+				if (done() || moved) {
+					wait = CONSUME_WAIT_MIN_MS;
+					continue;
+				}
+				const sleep = defaultSleep(wait);
+				const abort = () => sleep.cancel();
+				signal?.addEventListener("abort", abort, { once: true });
+				await sleep.promise;
+				signal?.removeEventListener("abort", abort);
+				wait = Math.min(wait * 2, CONSUME_WAIT_MAX_MS);
+			}
+			if (drains > 0 || own && woken.cursor.head !== null) scheduleDrain(sessionId);
+			const index = woken.cursor.head === null ? woken.head : woken.cursor.head - 1;
+			span.setAttribute("a2.consume.index", index);
+			span.setAttribute("a2.consume.drains", drains);
+			return { index };
+		});
+		return waiter === void 0 || cycle ? consumed : consumed.finally(() => {
+			waits?.delete(waiter);
+			if (waits?.size === 0) consumeWaits.delete(sessionId);
+		});
+	};
+	const makeSession = (id, append, trigger, attempt) => ({
+		id,
+		append,
+		consume: (defined, consumeOptions) => consumeSession(id, defined, consumeOptions, trigger),
+		schedule: makeSchedule(id, trigger),
+		clear: (clearOptions) => clearSession(id, clearOptions, attempt),
+		history: async (bounds) => (await readHistory(id, bounds)).filter((row) => !isSessionCleared(row)).map(toPublic),
+		state: (reducer = serverContract.reducer, stateOptions) => {
+			if (!reducer) throw new A2Error("INVALID_PAYLOAD", "contract has no public reducer");
+			const through = stateOptions?.through ?? trigger?.index;
+			if (through !== void 0 && through !== "latest") assertStateIndex(through);
+			const bounds = {};
+			if (through !== void 0 && through !== "latest") {
+				bounds.throughIndex = through;
+				if (trigger) bounds.pin = headRefOf(trigger);
+				if (through === trigger?.index && !attempt?.signal.aborted) bounds.throughEventId = trigger.id;
+			}
+			if (trigger) bounds.triggerIndex = trigger.index;
+			return readState(id, reducer, bounds);
+		},
+		stream: (opts) => {
+			const startAfter = opts?.startAfter ?? 0;
+			assertStreamIndex(startAfter);
+			return opts?.presence === true ? streamWithPresence(id, startAfter) : streamEvents(id, startAfter);
+		},
+		...declaresPresence ? {
+			setPresence: (patch) => setPresence(id, patch, trigger?.index ?? 0),
+			presence: () => readPresenceMap(id)
+		} : {}
+	});
+	/** The consumer name a trigger's child ids key on, if any. */
+	const idConsumerOf = (trigger) => registeredConsumers.get(trigger.consumer)?.anonymousIds ? void 0 : trigger.consumer;
+	const makeCtx = (trigger, attempt, signal, endAttempt) => {
+		const publicSessionId = stripNs(trigger.sessionId);
+		const idConsumer = idConsumerOf(trigger);
+		const cause = {
+			consumer: trigger.consumer,
+			lane: trigger.lane,
+			index: trigger.index,
+			attempt
+		};
+		const append = async (appendName, ...events) => {
+			assertAppendName(appendName);
+			const generatedIds = events.map((event) => event.id === void 0);
+			const withIds = await Promise.all(events.map(async (event, item) => {
+				if (event.id !== void 0) return event;
+				const id = await deterministicEventId(trigger.id, appendName, item, idConsumer);
+				return {
+					...event,
+					id
+				};
+			}));
+			return appendCore(publicSessionId, withIds, "consumer", "inline", (_rows, watchdogDueAt) => scheduleDrain(publicSessionId, watchdogDueAt), cause, generatedIds);
+		};
+		const ctx = {
+			event: toPublic(trigger),
+			attempt,
+			session: makeSession(publicSessionId, append, trigger, {
+				cause,
+				end: endAttempt,
+				signal
+			}),
+			signal
+		};
+		if (attempt > 1 && trigger.lastFailedAttempt === attempt - 1) failedPreviousAttempt.add(ctx);
+		return ctx;
+	};
+	const abortHubs = /* @__PURE__ */ new Map();
+	const createAbortHub = (store, ns, startAfter) => {
+		const hub = {
+			subscriptions: /* @__PURE__ */ new Set(),
+			seen: /* @__PURE__ */ new Map(),
+			startAfter,
+			ready: Promise.resolve(),
+			watch: null,
+			error: null,
+			iterator: null,
+			stopped: false
+		};
+		hub.ready = (async () => {
+			const existing = await store.read(ns, { afterIndex: startAfter });
+			for (const event of existing) dispatchAbortEvent(hub, event);
+			const tail = existing.at(-1)?.index ?? startAfter;
+			const iterator = store.stream(ns, { startAfter: tail })[Symbol.asyncIterator]();
+			hub.iterator = iterator;
+			hub.watch = (async () => {
+				for (;;) {
+					const { value, done } = await iterator.next();
+					if (done || value === void 0 || hub.stopped) return;
+					dispatchAbortEvent(hub, value);
+				}
+			})().catch((error) => {
+				hub.error = error;
+			});
+		})().catch((error) => {
+			hub.error = error;
+			if (abortHubs.get(ns) === hub) abortHubs.delete(ns);
+			throw error;
+		});
+		abortHubs.set(ns, hub);
+		return hub;
+	};
+	const subscribeAbort = async (store, ns, trigger, abortOn, attempt) => {
+		let hub = abortHubs.get(ns);
+		const created = hub === void 0;
+		if (!hub) hub = createAbortHub(store, ns, trigger.index);
+		const activeTypes = /* @__PURE__ */ new Set();
+		for (const active of hub.subscriptions) for (const type of active.types) activeTypes.add(type);
+		const publicTrigger = toPublic(trigger);
+		const subscription = {
+			controller: new AbortController(),
+			triggerIndex: trigger.index,
+			types: new Set(abortOn.keys()),
+			matches: (event) => {
+				if (event.index <= trigger.index) return false;
+				const matcher = abortOn.get(event.type);
+				if (matcher === void 0) return false;
+				return matcher === true ? true : matcher(toPublic(event), publicTrigger, { attempt });
+			}
+		};
+		hub.subscriptions.add(subscription);
+		if (!created && (trigger.index < hub.startAfter || [...subscription.types].some((type) => !activeTypes.has(type)))) {
+			const earlier = await store.read(ns, { afterIndex: trigger.index });
+			hub.startAfter = Math.min(hub.startAfter, trigger.index);
+			for (const event of earlier) dispatchAbortEvent(hub, event);
+		}
+		for (const event of hub.seen.values()) if (subscription.matches(event)) subscription.controller.abort();
+		await hub.ready;
+		if (hub.error !== null) throw hub.error;
+		return {
+			signal: subscription.controller.signal,
+			monitor: async (operation) => {
+				const outcome = await Promise.race([operation.then((value) => ({
+					type: "completed",
+					value
+				}), (error) => ({
+					type: "run-failed",
+					error
+				})), hub.watch.then(() => hub.error === null ? { type: "monitor-closed" } : {
+					type: "monitor-failed",
+					error: hub.error
+				})]);
+				if (outcome.type === "completed") return outcome.value;
+				if (outcome.type === "run-failed") throw outcome.error;
+				if (outcome.type === "monitor-failed") {
+					for (const active of hub.subscriptions) active.controller.abort(outcome.error);
+					await operation.catch(() => {});
+					throw outcome.error;
+				}
+				await operation.catch(() => {});
+				throw new Error("abort monitor closed while consumers were active");
+			},
+			close: async () => {
+				hub.subscriptions.delete(subscription);
+				if (hub.subscriptions.size > 0) {
+					pruneAbortHub(hub);
+					return;
+				}
+				hub.stopped = true;
+				abortHubs.delete(ns);
+				await hub.ready;
+				await hub.iterator?.return?.();
+				await hub.watch;
+			}
+		};
+	};
+	const returnedEvents = async (sessionId, trigger, result) => {
+		if (result === void 0) return [];
+		const events = Array.isArray(result) ? [...result] : [result];
+		if (events.length === 0) return [];
+		const idConsumer = idConsumerOf(trigger);
+		const withIds = await Promise.all(events.map(async (event, item) => {
+			const withId = { ...event };
+			withId.id = event.id ?? await deterministicReturnedEventId(trigger.id, item, idConsumer);
+			return withId;
+		}));
+		return validateEvents(sessionId, withIds).map((event) => Object.assign(event, {
+			id: event.id,
+			cause: {
+				consumer: trigger.consumer,
+				lane: trigger.lane,
+				index: trigger.index,
+				attempt: trigger.attemptCount
+			}
+		}));
+	};
+	const drainSession = async (sessionId, drainOptions = {}) => {
+		const result = await runDrain(sessionId, drainOptions);
+		if (result.settled && drainOptions.only === void 0) drainSettledHooks.get(self)?.(sessionId);
+		return result;
+	};
+	const runDrain = (sessionId, { watchdogDueAt, signal, handOffFailure = false, only, through } = {}) => telemetry.span("a2.drain", {
+		"a2.contract": name,
+		"a2.session_id": sessionId
+	}, async (span) => {
+		const store = await resolveStore();
+		const ns = nsId(sessionId);
+		const holder = crypto.randomUUID();
+		/** Running heads, keyed by `headKey`: one event can run for several consumers. */
+		const active = /* @__PURE__ */ new Map();
+		const excluded = /* @__PURE__ */ new Map();
+		let processed = 0;
+		let sawFailure = false;
+		let schedulerArm;
+		let heartbeat = null;
+		let lapseTimer = null;
+		let retryTimer = null;
+		let renewal = null;
+		let stopRenewing = false;
+		const lapseDue = () => {
+			lapseTimer = null;
+			const nowMs = Date.now();
+			for (const entry of active.values()) {
+				if (entry.lapsed || entry.expiresAtMs > nowMs) continue;
+				entry.lapsed = true;
+				entry.supersede.abort(new A2Error("CLAIM_EXPIRED", `the claim on event ${entry.ref.index} for consumer '${entry.ref.consumer}' in session '${sessionId}' lapsed without renewal`));
+			}
+			scheduleLapse();
+		};
+		const scheduleLapse = () => {
+			if (lapseTimer) {
+				clearTimeout(lapseTimer);
+				lapseTimer = null;
+			}
+			let next = Number.POSITIVE_INFINITY;
+			for (const entry of active.values()) if (!entry.lapsed) next = Math.min(next, entry.expiresAtMs);
+			if (next === Number.POSITIVE_INFINITY) return;
+			lapseTimer = setTimeout(lapseDue, Math.max(0, next - Date.now()));
+			lapseTimer.unref?.();
+		};
+		const scheduleRenewRetry = () => {
+			if (stopRenewing || retryTimer) return;
+			const nowMs = Date.now();
+			if (![...active.values()].some((entry) => !entry.lapsed && entry.expiresAtMs > nowMs)) return;
+			const delay = DRAIN_TIMINGS.renewRetryMs * (.5 + Math.random() * .5);
+			retryTimer = setTimeout(() => {
+				retryTimer = null;
+				renew();
+			}, delay);
+			retryTimer.unref?.();
+		};
+		const alignWatchdogAt = (minimumDueAt) => {
+			if (watchdogDueAt === void 0) return minimumDueAt;
+			return watchdogDueAt + Math.max(0, Math.ceil((minimumDueAt - watchdogDueAt) / DRAIN_TIMINGS.claimHeartbeatMs)) * DRAIN_TIMINGS.claimHeartbeatMs;
+		};
+		const requestWatchdog = (dueAt) => {
+			const arm = startSchedulerArm(sessionId, alignWatchdogAt(dueAt));
+			if (arm) schedulerArm = arm;
+		};
+		const renew = () => {
+			if (stopRenewing || renewal || active.size === 0) return renewal ?? Promise.resolve();
+			const window = nextClaimWindow();
+			requestWatchdog(window.watchdogAtMs);
+			const claims = [...active.values()].map((entry) => ({
+				...entry.ref,
+				attempt: entry.attempt
+			}));
+			const operation = store.renewClaims({
+				sessionId: ns,
+				holder,
+				claims,
+				ttlMs: window.ttlMs,
+				...window.deadlineCapped ? { expiresAtMs: window.expiresAtMs } : {}
+			}).then((result) => {
+				for (const ref of result.renewed) {
+					const entry = active.get(headKey(ref));
+					if (entry && !entry.lapsed) entry.expiresAtMs = window.expiresAtMs;
+				}
+				for (const ref of result.superseded) {
+					const entry = active.get(headKey(ref));
+					if (!entry || entry.completing) continue;
+					endSuperseded(entry, `a newer attempt owns event ${ref.index} for consumer '${ref.consumer}' in session '${sessionId}'`);
+				}
+				if (window.deadlineCapped) stopRenewing = true;
+				scheduleLapse();
+			}, () => {
+				scheduleRenewRetry();
+			});
+			let tracked;
+			tracked = operation.finally(() => {
+				if (renewal === tracked) renewal = null;
+			});
+			renewal = tracked;
+			return tracked;
+		};
+		/** Records a head the store dead-lettered on takeover; it never runs. */
+		const reportExhausted = (event) => telemetry.span("a2.event", {
+			"a2.contract": name,
+			"a2.session_id": sessionId,
+			"a2.event.type": event.type,
+			"a2.event.index": event.index,
+			"a2.event.id": event.id,
+			"a2.event.consumer": event.consumer,
+			"a2.event.attempt": event.attemptCount,
+			"a2.event.handled": registeredConsumers.has(event.consumer),
+			...event.lane === null ? {} : { "a2.event.lane": event.lane }
+		}, async (eventSpan) => {
+			eventSpan.setAttribute("a2.event.outcome", "dead_lettered");
+		});
+		const runEvent = async (event, supersedeSignal, endAttempt, beginCompleting, sessionHead) => {
+			const registration = only?.name === event.consumer ? only : registeredConsumers.get(event.consumer);
+			const abortOn = registration?.abortOn(event.type) ?? null;
+			return telemetry.span("a2.event", {
+				"a2.contract": name,
+				"a2.session_id": sessionId,
+				"a2.event.type": event.type,
+				"a2.event.index": event.index,
+				"a2.event.id": event.id,
+				"a2.event.consumer": event.consumer,
+				"a2.event.attempt": event.attemptCount,
+				"a2.event.handled": registration !== void 0,
+				"a2.event.age_ms": Math.max(0, Date.now() - event.createdAt.getTime()),
+				...sessionHead === void 0 ? {} : { "a2.event.lag": Math.max(0, sessionHead - event.index) },
+				...event.lane === null ? {} : { "a2.event.lane": event.lane }
+			}, async (eventSpan) => {
+				let subscription;
+				let runSignal = supersedeSignal;
+				let completion;
+				let completing = false;
+				try {
+					if (abortOn) {
+						subscription = await subscribeAbort(store, ns, event, abortOn, event.attemptCount);
+						runSignal = AbortSignal.any([supersedeSignal, subscription.signal]);
+					}
+					const operation = registration?.run(makeCtx(event, event.attemptCount, runSignal, endAttempt));
+					const result = operation ? await (subscription ? subscription.monitor(operation) : operation) : void 0;
+					if (subscription) {
+						await subscription.close();
+						subscription = void 0;
+					}
+					const returned = await returnedEvents(sessionId, event, result);
+					await renewal;
+					completing = true;
+					beginCompleting();
+					completion = await telemetry.span("a2.commit", {
+						"a2.contract": name,
+						"a2.session_id": sessionId,
+						"a2.commit.operation": "complete",
+						"a2.commit.index": event.index,
+						"a2.commit.attempt": event.attemptCount
+					}, async (commitSpan) => {
+						const committed = await store.completeAttempt({
+							sessionId: ns,
+							consumer: event.consumer,
+							lane: event.lane,
+							index: event.index,
+							attempt: event.attemptCount,
+							events: returned,
+							consumers: storeConsumers
+						});
+						commitSpan.setAttribute("a2.commit.outcome", committed.outcome);
+						return committed;
+					});
+				} catch (err) {
+					if (supersedeSignal.aborted && err === supersedeSignal.reason) {
+						eventSpan.setAttribute("a2.event.outcome", "surrendered");
+						return {
+							status: "surrendered",
+							opensLane: false,
+							appendsEvents: false
+						};
+					}
+					const refused = completing && err instanceof A2Error && err.code === "PARTIAL_DUPLICATE_BATCH";
+					if (completing && !refused) throw err;
+					eventSpan.recordError(err);
+					const failure = await telemetry.span("a2.commit", {
+						"a2.contract": name,
+						"a2.session_id": sessionId,
+						"a2.commit.operation": "fail",
+						"a2.commit.index": event.index,
+						"a2.commit.attempt": event.attemptCount
+					}, async (commitSpan) => {
+						const result = await store.failAttempt({
+							sessionId: ns,
+							consumer: event.consumer,
+							lane: event.lane,
+							index: event.index,
+							attempt: event.attemptCount,
+							error: describeError(err),
+							maxFailures: err instanceof NonRetriableError || refused ? 1 : MAX_FAILURES,
+							retryAfterMs: failureRetryDelayMs(event.failureCount + 1)
+						});
+						commitSpan.setAttribute("a2.commit.outcome", result.outcome);
+						return result;
+					});
+					eventSpan.setAttribute("a2.event.outcome", failure.outcome);
+					return {
+						status: failure.outcome,
+						opensLane: false,
+						appendsEvents: false
+					};
+				} finally {
+					await subscription?.close();
+				}
+				eventSpan.setAttribute("a2.event.outcome", completion.outcome === "completed" ? "processed" : completion.outcome);
+				if (completion.outcome === "superseded") return {
+					status: "superseded",
+					opensLane: false,
+					appendsEvents: false
+				};
+				if (runSignal.aborted) eventSpan.setAttribute("a2.event.aborted", true);
+				return {
+					status: "processed",
+					opensLane: event.lane !== null,
+					appendsEvents: completion.events.length > 0
+				};
+			});
+		};
+		let claimAgain = false;
+		const start = (event, expiresAtMs, sessionHead) => {
+			const ref = headRefOf(event);
+			const key = headKey(ref);
+			const previous = active.get(key);
+			if (previous) endSuperseded(previous, `a newer attempt owns event ${event.index} for consumer '${event.consumer}' in session '${sessionId}'`);
+			const supersede = new AbortController();
+			let fence;
+			const fenced = new Promise((resolve) => {
+				fence = resolve;
+			});
+			const endAttempt = () => endSuperseded({
+				supersede,
+				fence
+			}, `event ${event.index} for consumer '${event.consumer}' in session '${sessionId}' was cleared`);
+			let entry;
+			const execution = Promise.race([runEvent(event, supersede.signal, endAttempt, () => {
+				entry.completing = true;
+			}, sessionHead), fenced]).then((eventOutcome) => {
+				if (active.get(key) === entry) active.delete(key);
+				if (eventOutcome.status === "processed") processed += 1;
+				if (eventOutcome.status === "failed") {
+					excluded.set(key, ref);
+					sawFailure = true;
+				}
+				claimAgain ||= eventOutcome.opensLane || eventOutcome.appendsEvents;
+				return eventOutcome;
+			});
+			entry = {
+				ref,
+				attempt: event.attemptCount,
+				execution,
+				supersede,
+				fence,
+				expiresAtMs,
+				lapsed: false,
+				completing: false
+			};
+			active.set(key, entry);
+			scheduleLapse();
+			if (!heartbeat && !stopRenewing) {
+				heartbeat = setInterval(() => void renew(), DRAIN_TIMINGS.claimHeartbeatMs);
+				heartbeat.unref?.();
+			}
+		};
+		let outcome = "settled";
+		let shouldClaim = true;
+		try {
+			for (;;) {
+				const signalVersion = signal?.version ?? 0;
+				let claim;
+				if (shouldClaim) {
+					const window = nextClaimWindow();
+					if (window.pastDeadline) {
+						outcome = "busy";
+						break;
+					}
+					claim = await telemetry.span("a2.claim", {
+						"a2.contract": name,
+						"a2.session_id": sessionId
+					}, async (claimSpan) => {
+						const result = await store.claimAvailable({
+							sessionId: ns,
+							holder,
+							ttlMs: window.ttlMs,
+							maxFailures: MAX_FAILURES,
+							...window.deadlineCapped ? { expiresAtMs: window.expiresAtMs } : {},
+							consumers: only ? [storeConsumerOf(only)] : storeConsumers,
+							...through === void 0 ? {} : { through },
+							...excluded.size === 0 ? {} : { exclude: [...excluded.values()] }
+						});
+						claimSpan.setAttribute("a2.claim.outcome", result.outcome);
+						claimSpan.setAttribute("a2.claim.count", result.outcome === "claimed" ? result.events.length : 0);
+						return result;
+					});
+					if (claim.outcome === "claimed") {
+						const runnable = claim.events.filter((event) => event.failedAt === null);
+						for (const event of claim.events) if (event.failedAt !== null) await reportExhausted(event);
+						if (runnable.length > 0) requestWatchdog(window.watchdogAtMs);
+						if (window.deadlineCapped) stopRenewing = true;
+						for (const event of runnable) start(event, window.expiresAtMs, claim.head);
+						shouldClaim = false;
+					}
+				}
+				if (claim?.outcome === "claimed" && [...active.values()].some((entry) => entry.lapsed)) {
+					shouldClaim = true;
+					continue;
+				}
+				if (active.size > 0) {
+					const wake = signal?.wait(signalVersion);
+					const hasLapsed = [...active.values()].some((entry) => entry.lapsed);
+					const retry = claim?.outcome === "busy" && hasLapsed ? defaultSleep(Math.max(0, claim.retryAt.getTime() - Date.now())) : void 0;
+					const retryDue = await Promise.race([
+						...[...active.values()].map((entry) => entry.execution.then(() => false)),
+						...wake ? [wake.promise.then(() => false)] : [],
+						...retry ? [retry.promise.then(() => true)] : []
+					]);
+					wake?.cancel();
+					retry?.cancel();
+					shouldClaim = retryDue || claimAgain || active.size === 0 || hasLapsed || signal !== void 0 && signal.version !== signalVersion;
+					claimAgain = false;
+					continue;
+				}
+				if (!shouldClaim) {
+					shouldClaim = true;
+					continue;
+				}
+				if (claim === void 0) continue;
+				if (signal && signal.version !== signalVersion) continue;
+				if (claimAgain) {
+					claimAgain = false;
+					continue;
+				}
+				if (claim.outcome === "busy") {
+					requestWatchdog(claim.retryAt.getTime() + DRAIN_TIMINGS.watchdogGraceMs);
+					outcome = "busy";
+				} else if (sawFailure) outcome = "stalled";
+				if (signal) signal.closed = true;
+				break;
+			}
+		} catch (error) {
+			if (!handOffFailure || schedulerArm === void 0) throw error;
+			span.recordError(error);
+			outcome = "failed";
+		} finally {
+			if (signal) signal.closed = true;
+			stopRenewing = true;
+			if (heartbeat) clearInterval(heartbeat);
+			if (retryTimer) clearTimeout(retryTimer);
+			await renewal;
+			await Promise.allSettled([...active.values()].map((entry) => entry.execution));
+			if (lapseTimer) clearTimeout(lapseTimer);
+		}
+		span.setAttribute("a2.drain.processed", processed);
+		span.setAttribute("a2.drain.outcome", outcome);
+		return {
+			settled: outcome === "settled",
+			outcome,
+			processed,
+			...schedulerArm ? { schedulerArm } : {}
+		};
+	});
+	const appendExternal = async (sessionId, mode, events, requireDurableInitialArm = false, originIndex) => {
+		return appendCore(sessionId, events, "external", mode, (_rows, watchdogDueAt) => scheduleDrain(sessionId, watchdogDueAt), void 0, void 0, requireDurableInitialArm, originIndex);
+	};
+	const session = (id) => {
+		assertSessionId(id);
+		const appendInline = async (...events) => appendExternal(id, "inline", events);
+		const appendDispatch = async (...events) => appendExternal(id, "dispatch", events);
+		const append = Object.assign(appendInline, { dispatch: appendDispatch });
+		return Object.assign(makeSession(id, append, null), {
+			deadLetters: () => listDeadLetters(id),
+			redrive: (target, redriveOptions) => redriveEvent(id, target, redriveOptions)
+		});
+	};
+	const historyPage = async (sessionId, bounds) => {
+		assertSessionId(sessionId);
+		const rows = await readHistory(sessionId, bounds);
+		const marker = rows[0] && isSessionCleared(rows[0]) ? rows[0] : void 0;
+		return {
+			events: (marker ? rows.slice(1) : rows).map(toPublic),
+			...marker ? { clearIndex: marker.index } : {}
+		};
+	};
+	const self = {
+		contract: serverContract,
+		fetch: createServerFetch({
+			contract: serverContract,
+			session,
+			historyPage
+		}),
+		session,
+		async drain(sessionId) {
+			assertSessionId(sessionId);
+			const { settled } = await drainSession(sessionId);
+			return { settled };
+		}
+	};
+	serverInternals.set(self, {
+		settle: async () => {
+			while (inFlight.size > 0) await Promise.allSettled(inFlight);
+		},
+		schedulerDrain: (sessionId, opts) => {
+			assertSessionId(sessionId);
+			return drainSession(sessionId, {
+				watchdogDueAt: opts?.watchdogDueAt,
+				handOffFailure: true
+			});
+		},
+		schedulerAppend: async (sessionId, events, originIndex) => {
+			if (!scheduler) throw new TypeError("scheduled append delivery requires a configured scheduler adapter");
+			assertSessionId(sessionId);
+			try {
+				await appendExternal(sessionId, "inline", [...events], true, originIndex);
+			} catch (error) {
+				if (originIndex !== void 0 && error instanceof A2Error && error.code === "SESSION_CLEARED") return;
+				throw error;
+			}
+		},
+		historyWithMarkers: async (sessionId, gte) => (await readHistory(sessionId, { gte })).map(toPublic),
+		schedulerClear: async (sessionId, ifLastIndex) => {
+			assertSessionId(sessionId);
+			assertClearIndex(ifLastIndex);
+			await clearSession(sessionId, { ifLastIndex }, void 0);
+		}
+	});
+	return self;
+}
+function assertSessionId(id) {
+	if (typeof id !== "string" || id.length === 0) throw new TypeError("session id must be a non-empty string");
+	if (id.includes(NS)) throw new TypeError("session id contains a reserved control character");
+}
+function assertHistoryIndex(name, value) {
+	if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) throw new TypeError(`history.${name} must be a non-negative safe integer`);
+}
+function assertStreamIndex(value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("stream.startAfter must be a non-negative safe integer");
+}
+function assertStateIndex(value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("state.through must be a non-negative safe integer");
+}
+function assertConsumeIndex(value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("consume through must be a non-negative safe integer");
+}
+function assertRedriveIndex(value) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new TypeError("redrive requires a positive safe-integer index");
+}
+function assertClearIndex(value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("ifLastIndex must be a non-negative safe integer");
+}
+function assertAppendName(name) {
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("consumer append name must be a non-empty string");
+}
+function assertScheduleName(name) {
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("schedule name must be a non-empty string");
+}
+const SCHEDULE_DELAY = /^(?:0|[1-9]\d*)(?:\.\d+)?(ms|s|m|h|d)$/;
+const SCHEDULE_DELAY_MULTIPLIER = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5
+};
+function scheduleDueAt(timing, baseTime) {
+	if (timing === null || typeof timing !== "object" || Array.isArray(timing)) throw new TypeError("schedule timing must contain exactly one of 'delay' or 'at'");
+	const record = timing;
+	const hasDelay = Object.hasOwn(record, "delay");
+	const hasAt = Object.hasOwn(record, "at");
+	if (hasDelay === hasAt) throw new TypeError("schedule timing must contain exactly one of 'delay' or 'at'");
+	let dueAt;
+	if (hasAt) {
+		const at = record["at"];
+		if (!(at instanceof Date) || !Number.isFinite(at.getTime())) throw new TypeError("schedule at must be a valid Date");
+		dueAt = at.getTime();
+	} else {
+		const delay = record["delay"];
+		if (typeof delay !== "string") throw new TypeError("schedule delay must use ms, s, m, h, or d (for example '30s')");
+		const match = SCHEDULE_DELAY.exec(delay);
+		const amount = match ? Number(delay.slice(0, -match[1].length)) : NaN;
+		if (!match || !Number.isFinite(amount) || amount <= 0) throw new TypeError("schedule delay must be positive and use ms, s, m, h, or d (for example '30s')");
+		dueAt = baseTime + amount * SCHEDULE_DELAY_MULTIPLIER[match[1]];
+	}
+	if (!Number.isFinite(dueAt)) throw new TypeError("schedule due time must be a finite epoch time");
+	return dueAt;
+}
+function assertScheduledPayload(payload) {
+	try {
+		if (isJsonValue(payload, /* @__PURE__ */ new WeakSet())) return;
+	} catch {}
+	throw new TypeError("session.schedule event payload must be JSON-serializable");
+}
+function cloneScheduledPayload(payload) {
+	assertScheduledPayload(payload);
+	try {
+		const cloned = structuredClone(payload);
+		const encoded = JSON.stringify(cloned);
+		if (encoded === void 0) throw new TypeError();
+		return JSON.parse(encoded);
+	} catch {
+		throw new TypeError("session.schedule event payload must be JSON-serializable");
+	}
+}
+function isJsonValue(value, ancestors) {
+	if (value === null) return true;
+	if (typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value) && !Object.is(value, -0);
+	if (typeof value !== "object") return false;
+	if (ancestors.has(value)) return false;
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			const keys = Reflect.ownKeys(value);
+			if (keys.length !== value.length + 1 || !keys.includes("length")) return false;
+			for (let index = 0; index < value.length; index += 1) {
+				const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+				if (!descriptor || !descriptor.enumerable || !("value" in descriptor) || !isJsonValue(descriptor.value, ancestors)) return false;
+			}
+			return true;
+		}
+		if (Object.getPrototypeOf(value) !== Object.prototype) return false;
+		for (const key of Reflect.ownKeys(value)) {
+			if (typeof key !== "string") return false;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (!descriptor || !descriptor.enumerable || !("value" in descriptor) || !isJsonValue(descriptor.value, ancestors)) return false;
+		}
+		return true;
+	} finally {
+		ancestors.delete(value);
+	}
+}
+const measuredBytes = (reducer, state, index, snapshots) => JSON.stringify(snapshots.find((snapshot) => snapshot.index === index)?.state ?? encodeState({
+	reducer,
+	state
+}))?.length ?? 0;
+const stateCacheKey = (sessionId, reducerName) => `${sessionId}\u0000${reducerName}`;
+//#endregion
+export { deliverSchedulerClear as i, createServer as n, deliverSchedulerAppend as r, consumer as t };