experimental-a2 0.9.0 → 0.11.0

package/dist/{server-CBET-jSz.js → server-Dkz2a84E.js}

@@ -1,40 +1,10 @@
 import { n as validateSync } from "./validate-XKT4FSNn.js";
 import { n as NonRetriableError, r as asStoreUnavailable, t as A2Error } from "./errors-DCk6ch5n.js";
-import { c as STREAM_TIMINGS, g as serverInternals, h as nullProtoRecord, i as POLL_TIMINGS, m as markSchedulerSendFailure, o as RESERVED_PARTICIPANT_IDS, s as SOCKET_TIMINGS, t as DRAIN_TIMINGS } from "./internal-DRXJ56EI.js";
-import { t as defaultSleep } from "./store-polling-6DW7F1DT.js";
-import { _ as socketErrorAckFor, a as errorToWire, b as socketUnsubscribedFor, g as socketAckFor, h as presenceSnapshotToWire, i as errorStatus, n as asA2Error, p as presencePatchToWire, s as eventToWire, t as SOCKET_PING_FRAME, v as socketFrameFor, y as socketSubscribedFor } from "./wire--yji6mO3.js";
+import { c as STREAM_TIMINGS, g as serverInternals, h as nullProtoRecord, i as POLL_TIMINGS, m as markSchedulerSendFailure, o as RESERVED_PARTICIPANT_IDS, s as SOCKET_TIMINGS, t as DRAIN_TIMINGS } from "./internal-Dq2qYxou.js";
+import { i as streamActivities, r as createStreamActivity, t as defaultSleep } from "./store-polling-CmxUbV93.js";
+import { r as platformWaitUntil, t as invocationDeadlineMs } from "./platform-B4TnJtWu.js";
+import { _ as socketErrorAckFor, a as errorToWire, b as socketUnsubscribedFor, g as socketAckFor, h as presenceSnapshotToWire, i as errorStatus, n as asA2Error, p as presencePatchToWire, s as eventToWire, t as SOCKET_PING_FRAME, v as socketFrameFor, y as socketSubscribedFor } from "./wire-BO5wWCb1.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
-//#region src/platform.ts
-const SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
-function requestContext() {
-	try {
-		return Reflect.get(globalThis, SYMBOL_FOR_REQ_CONTEXT)?.get?.() ?? {};
-	} catch {
-		return {};
-	}
-}
-/** The current invocation's Vercel deployment identity, when available. */
-function platformVercelOidcToken() {
-	try {
-		const token = requestContext().headers?.["x-vercel-oidc-token"];
-		return typeof token === "string" && token.length > 0 ? token : null;
-	} catch {
-		return null;
-	}
-}
-function platformWaitUntil(promise) {
-	try {
-		requestContext().waitUntil?.(promise);
-	} catch {}
-}
-/** The invocation's termination time in epoch ms, or null if unknowable. */
-function invocationDeadlineMs() {
-	const deadline = requestContext().deadline;
-	if (deadline === void 0 || deadline === null) return null;
-	const ms = new Date(deadline).getTime();
-	return Number.isNaN(ms) ? null : ms;
-}
-//#endregion
 //#region src/push-envelope.ts
 /**
 * The push envelope's trust boundary for `{ sessionId, events, presence? }`,
@@ -116,10 +86,9 @@ async function parsePushBody(req) {
 /**
 * The A2 socket protocol's server half (specs/a2-api.md §13): the
 * per-socket shell — teardown, backpressure, heartbeat, the malformed
-* budget, the in-flight bound — and `sessionsSocket`, the multiplexed
-* frame handler riding it. Internal module: `handle`'s upgrade lane is
-* the sanctioned mount; only `A2Socket` (the structural socket the
-* platform hands over) is re-exported as public surface.
+* 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;
@@ -222,10 +191,103 @@ function socketShell(socket, release, onFrame, deadlineAt) {
 		track
 	};
 }
+const socketSubscription = (target, startAfter, presence) => ({
+	target,
+	iterator: (presence ? target.stream({
+		startAfter,
+		presence: true
+	}) : target.stream({ startAfter }))[Symbol.asyncIterator](),
+	stopped: false
+});
 const stopSubscription = (subscription) => {
 	subscription.stopped = true;
 	subscription.iterator.return?.()?.catch(() => {});
 };
+const pumpSubscription = async (shell, subscription, frameFor) => {
+	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;
+		shell.send(frameFor(value));
+	}
+};
+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, options?.startAfter ?? 0, 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, socketFrameFor).then(() => shell.shutdown(1e3), () => shell.shutdown(1011, "stream failed"));
+}
 const parseSubscribeEntries = (value) => {
 	if (!Array.isArray(value) || value.length === 0) return null;
 	const entries = [];
@@ -259,55 +321,37 @@ function sessionsSocket(resolve, socket, options) {
 	const retire = (id, subscription) => {
 		if (subscriptions.get(id) === subscription) subscriptions.delete(id);
 	};
-	const pump = async (id, subscription) => {
-		for (;;) {
-			for (;;) {
-				if (shell.torn() || subscription.stopped || shell.buffered() <= SOCKET_TIMINGS.highWaterMarkBytes) break;
-				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) return;
-			if (done) return;
-			shell.send(socketFrameFor(value, id));
-		}
-	};
 	const runSubscription = async (id, subscription) => {
 		try {
-			await pump(id, subscription);
+			await pumpSubscription(shell, subscription, (item) => socketFrameFor(item, id));
 			if (shell.torn() || subscription.stopped) return;
 			retire(id, subscription);
 			shell.send(socketUnsubscribedFor(id));
-		} catch {
+		} catch (error) {
 			if (shell.torn() || subscription.stopped) return;
 			retire(id, subscription);
-			shell.send(socketUnsubscribedFor(id, "stream failed"));
+			shell.send(socketUnsubscribedFor(id, "stream failed", asA2Error(error)));
 		}
 	};
 	const startSubscription = async (id, index) => {
+		const existing = subscriptions.get(id);
+		if (existing) {
+			stopSubscription(existing);
+			subscriptions.delete(id);
+		}
 		let session;
 		try {
 			session = await resolve(id, index);
-		} catch {
-			if (!shell.torn()) shell.send(socketUnsubscribedFor(id, "stream failed"));
+		} catch (error) {
+			if (!shell.torn()) shell.send(socketUnsubscribedFor(id, "stream failed", asA2Error(error)));
 			return;
 		}
 		if (shell.torn()) return;
 		if (session === null) {
-			shell.send(socketUnsubscribedFor(id, "subscribe rejected"));
+			shell.send(socketUnsubscribedFor(id, "subscribe rejected", new A2Error("FORBIDDEN", "the subscription is not authorized")));
 			return;
 		}
-		const target = session;
-		const existing = subscriptions.get(id);
-		if (existing) stopSubscription(existing);
-		const subscription = {
-			target,
-			iterator: (presence ? target.stream({
-				startAfter: index,
-				presence: true
-			}) : target.stream({ startAfter: index }))[Symbol.asyncIterator](),
-			stopped: false
-		};
+		const subscription = socketSubscription(session, index, presence);
 		subscriptions.set(id, subscription);
 		shell.send(socketSubscribedFor(id));
 		runSubscription(id, subscription);
@@ -322,45 +366,15 @@ function sessionsSocket(resolve, socket, options) {
 			shell.send(socketErrorAckFor(req, new A2Error("STORE_UNAVAILABLE", "session is not subscribed on this socket"), sessionId));
 			return;
 		}
-		try {
-			const events = parsePushEvents(frame["events"]);
-			const denial = await options?.gatePush?.(sessionId, events, void 0) ?? null;
-			if (denial !== null) {
-				shell.send(socketErrorAckFor(req, denial, sessionId));
-				return;
-			}
-			const appended = await subscription.target.append(...events);
-			shell.send(socketAckFor(req, appended, sessionId));
-		} catch (err) {
-			shell.send(socketErrorAckFor(req, asA2Error(err), sessionId));
-		}
+		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;
-		if (typeof subscription.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 options?.gatePush?.(sessionId, [], patch) ?? null) !== null) return;
-			await subscription.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");
-		}
+		await applySocketPresence(shell, subscription.target, sessionId, frame, options?.gatePush);
 	};
 	const handleFrame = (frame) => {
 		switch (frame["kind"]) {
@@ -456,7 +470,10 @@ function sseResponse(iterable) {
 	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;
@@ -470,6 +487,15 @@ function sseResponse(iterable) {
 	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"));
@@ -591,7 +617,20 @@ function createServerFetch(server) {
 		const validateIngress = async (context) => {
 			await serverFetchHooks.get(fetch)?.validateIngress?.(context);
 		};
-		const attach = (socket) => {
+		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 attachMultiplexed = (socket) => {
 			const deadline = invocationDeadlineMs();
 			sessionsSocket(async (sessionId, startAfter) => {
 				return await authorized({
@@ -603,25 +642,34 @@ function createServerFetch(server) {
 			}, socket, {
 				presence,
 				...deadline === null ? {} : { deadline },
-				gatePush: 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);
-					}
-				}
+				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 });
+					if (options.multiplexWebSocket === true) return await options.upgradeWebSocket(attachMultiplexed);
+					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 startAfter = parseResumeIndex(searchParams.get("index"));
+					await authorize({
+						type: "stream",
+						sessionId,
+						startAfter,
+						transport: "websocket"
+					});
+					const target = server.session(sessionId);
+					const attach = (socket) => {
+						const deadline = invocationDeadlineMs();
+						sessionSocket(sessionId, target, socket, {
+							startAfter,
+							presence,
+							...deadline === null ? {} : { deadline },
+							gatePush: gateSocketPush
+						});
+					};
 					return await options.upgradeWebSocket(attach);
 				}
 				const { searchParams } = new URL(request.url);
@@ -1346,12 +1394,57 @@ function createServer(options) {
 		createdAt: event.createdAt
 	});
 	const streamEvents = (id, startAfter) => {
-		const store = resolveStore();
+		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 inner = (await store).stream(nsId(id), { startAfter });
-			for await (const event of inner) yield toSessionEvent(id, event);
+			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();
+			}
 		};
-		return outer();
+		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);
+			return stream;
+		} };
 	};
 	const requirePresence = (store) => {
 		if (!store.presence) throw presenceNotSupported();
@@ -1403,8 +1496,39 @@ function createServer(options) {
 	*/
 	const streamWithPresence = (id, startAfter) => {
 		const ns = nsId(id);
+		let closed = false;
+		let events;
+		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 {
@@ -1479,8 +1603,9 @@ function createServer(options) {
 				if (fields?.size === 0) painted.delete(patch.participant);
 			};
 			const queue = /* @__PURE__ */ new Map();
-			let wakeQueue = null;
 			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);
@@ -1514,11 +1639,17 @@ function createServer(options) {
 				}
 				return null;
 			};
-			const unsubscribe = api.subscribe?.(ns, enqueue);
-			const events = store.stream(ns, { startAfter })[Symbol.asyncIterator]();
 			let pendingEvent = 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) {
@@ -1533,9 +1664,11 @@ function createServer(options) {
 				}
 				yield { snapshot: foldPresenceRows(snapshotRows) };
 				for (;;) {
+					if (closed) return;
 					for (;;) {
 						const patch = dequeue();
 						if (!patch) break;
+						if (closed) return;
 						paint(patch);
 						yield patch;
 					}
@@ -1547,28 +1680,57 @@ function createServer(options) {
 						});
 						woke = await Promise.race([pendingEvent.then(() => "event"), arrival.then(() => "patch")]);
 						wakeQueue = null;
+						if (closed) return;
 						if (woke === "patch") continue;
 					} else {
-						const sleeper = defaultSleep(POLL_TIMINGS.idleCeilingMs);
+						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 (result.done) return;
+						if (closed || result.done) return;
+						activity.activate();
 						yield toSessionEvent(id, result.value);
 					}
-					if (!unsubscribe) for (const patch of diffRows(await readRows())) yield patch;
+					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 {
-				wakeQueue = null;
-				unsubscribe?.();
 				pendingEvent?.catch(() => {});
-				await events.return?.();
+				await close();
+				wakeQueue = null;
 			}
 		};
-		return outer();
+		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);
+			return stream;
+		} };
 	};
 	const makeSession = (id, append, trigger) => ({
 		id,
@@ -2157,6 +2319,6 @@ function cloneInitial(initial) {
 	}
 }
 //#endregion
-export { parsePresenceSibling as a, sseResponse as i, deliverSchedulerAppend as n, platformVercelOidcToken as o, setServerFetchHooks as r, createServer as t };
+export { parsePresenceSibling as a, sseResponse as i, deliverSchedulerAppend as n, setServerFetchHooks as r, createServer as t };
 
-//# sourceMappingURL=server-CBET-jSz.js.map
+//# sourceMappingURL=server-Dkz2a84E.js.map