experimental-a2 0.8.1 → 0.10.0

package/dist/{contract-jIfaR085.d.ts → reducer-DJKWm3cp.d.ts}

@@ -61,43 +61,6 @@ declare namespace StandardSchemaV1 {
   export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
 //#endregion
-//#region src/reducer.d.ts
-/**
- * A pure fold over a session's events — `(state, event) => state` —
- * derived from a contract via `contract.reducer(options).fold(fn)`.
- *
- * The name is the reducer's identity. Cached folds (server snapshots,
- * the browser cache) are keyed by it, which makes it the invalidation
- * knob too: changed the fold's logic? Change the name. Snapshots under
- * the old name are ignored and the next read refolds from raw events.
- * See docs/concepts/04-state.mdx.
- */
-type Reducer<D extends EventDefs = EventDefs, S = unknown, P extends PresenceDefs = Record<never, never>> = {
-  /** Identity and cache key. Rename when the fold's logic changes. */
-  readonly name: string;
-  /** The contract's vocabulary — types every event in the fold. */
-  readonly events: Readonly<D>;
-  /**
-   * The contract's presence vocabulary — carried because the reducer
-   * is the client's typed handle on the contract. The fold never sees
-   * presence.
-   */
-  readonly presence: Readonly<P>;
-  readonly fold: (state: S, event: ContractEvent<D>) => S;
-  readonly initialState: S;
-  /**
-   * When present: `initialState` was validated against it at
-   * definition, and any cached fold a2 rehydrates (server snapshots,
-   * the browser cache) is checked against it — failing snapshots are
-   * discarded and refolded, catching shape drift a stale name can't.
-   */
-  readonly stateSchema: StandardSchemaV1<unknown, S> | undefined;
-};
-/** The second step of `contract.reducer` — see the method's doc. */
-type ReducerBuilder<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>> = {
-  fold(fold: (state: S, event: ContractEvent<D>) => S): Reducer<D, S, P>;
-};
-//#endregion
 //#region src/contract.d.ts
 /** The event vocabulary shape: event name → payload schema. */
 type EventDefs = Record<string, StandardSchemaV1>;
@@ -215,5 +178,42 @@ declare function contract<D extends EventDefs, P extends PresenceDefs = Record<n
   presence?: P;
 }): Contract<D, P>;
 //#endregion
-export { EventDefs as a, PresencePatch as c, WithPresence as d, contract as f, StandardSchemaV1 as h, EventBatchFactory as i, PresenceSnapshot as l, ReducerBuilder as m, Contract as n, PresenceDefs as o, Reducer as p, ContractEvent as r, PresenceMap as s, AppendInput as t, ReducerOptions as u };
-//# sourceMappingURL=contract-jIfaR085.d.ts.map
+//#region src/reducer.d.ts
+/**
+ * A pure fold over a session's events — `(state, event) => state` —
+ * derived from a contract via `contract.reducer(options).fold(fn)`.
+ *
+ * The name is the reducer's identity. Cached folds (server snapshots,
+ * the browser cache) are keyed by it, which makes it the invalidation
+ * knob too: changed the fold's logic? Change the name. Snapshots under
+ * the old name are ignored and the next read refolds from raw events.
+ * See docs/concepts/04-state.mdx.
+ */
+type Reducer<D extends EventDefs = EventDefs, S = unknown, P extends PresenceDefs = Record<never, never>> = {
+  /** Identity and cache key. Rename when the fold's logic changes. */
+  readonly name: string;
+  /** The contract's vocabulary — types every event in the fold. */
+  readonly events: Readonly<D>;
+  /**
+   * The contract's presence vocabulary — carried because the reducer
+   * is the client's typed handle on the contract. The fold never sees
+   * presence.
+   */
+  readonly presence: Readonly<P>;
+  readonly fold: (state: S, event: ContractEvent<D>) => S;
+  readonly initialState: S;
+  /**
+   * When present: `initialState` was validated against it at
+   * definition, and any cached fold a2 rehydrates (server snapshots,
+   * the browser cache) is checked against it — failing snapshots are
+   * discarded and refolded, catching shape drift a stale name can't.
+   */
+  readonly stateSchema: StandardSchemaV1<unknown, S> | undefined;
+};
+/** The second step of `contract.reducer` — see the method's doc. */
+type ReducerBuilder<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>> = {
+  fold(fold: (state: S, event: ContractEvent<D>) => S): Reducer<D, S, P>;
+};
+//#endregion
+export { ContractEvent as a, PresenceDefs as c, PresenceSnapshot as d, ReducerOptions as f, StandardSchemaV1 as h, Contract as i, PresenceMap as l, contract as m, ReducerBuilder as n, EventBatchFactory as o, WithPresence as p, AppendInput as r, EventDefs as s, Reducer as t, PresencePatch as u };
+//# sourceMappingURL=reducer-DJKWm3cp.d.ts.map

package/dist/reducer-DJKWm3cp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer-DJKWm3cp.d.ts","names":[],"sources":["../src/standard-schema.ts","../src/contract.ts","../src/reducer.ts"],"mappings":";;;;;;;;UAQiB,iBAAiB,iBAAiB,SAAS;;WAEjD,aAAa,iBAAiB,MAAM,OAAO;;kBAG7B;;mBAEN,MAAM,iBAAiB,SAAS;;aAEtC;;aAEA;;aAEA,WACP,mBACG,OAAO,UAAU,QAAQ,OAAO;;aAE5B,QAAQ,MAAM,OAAO;;;cAIpB,OAAO,UAAU,cAAc,UAAU;;mBAGpC,cAAc;;aAEpB,OAAO;;aAEP;;;mBAIM;;aAEN,QAAQ,cAAc;;;mBAIhB;;aAEN;;aAEA,OAAO,cAAc,cAAc;;;mBAI7B;;aAEN,KAAK;;;mBAIC,MAAM,iBAAiB,SAAS;;aAEtC,OAAO;;aAEP,QAAQ;;;cAIP,WAAW,eAAe,oBAAoB,YACxD;;cAIU,YAAY,eAAe,oBAAoB,YACzD;;;;;KC1DQ,YAAY,eAAe;;KAG3B,eAAe,eAAe;;KAG9B,cACV,UAAU,WACV,gBAAgB,mBAAmB,iBAElC,WAAW;EACV;EACA,MAAM;EACN,SAAS,iBAAiB,YAAY,EAAE;EACxC;EACA;EACA,WAAW;KAEb;;KAGU,YAAY,UAAU,gBAC/B,WAAW;EACV,MAAM;EACN,SAAS,iBAAiB,WAAW,EAAE;EACvC;WAEI;KAEI,kBAAkB,UAAU,oBAChC,mBAAmB,YAAY,SAElC,QAAQ,MACR;;;;;;KAOO,cAAc,UAAU,eAAe;EACjD;EACA,WACG,WAAW,cAAc,iBAAiB,YAAY,EAAE;EAE3D;EACA,IAAI;;;;;;;;KASM,YAAY,UAAU,eAAe;GAE5C,yBAAA,WAAW;IACV,OAAO,iBAAiB,YAAY,EAAE;IACtC;IACA,IAAI;;;;;;;;KAUE,iBAAiB,UAAU,eAAe;EACpD,UAAU,YAAY;;;;;;;KAQZ,aACV,UAAU,cACV,iBACQ,4BAA4B;KAE1B,eAAe,MAAM;;;;;EAK/B;;;;;;EAMA,cAAc;;;;;;EAMd,cAAc,iBAAiB,MAAM;;KAG3B,SACV,UAAU,YAAY,WACtB,UAAU,eAAe;;WAGhB;;WAEA,QAAQ,SAAS;;WAEjB,UAAU,SAAS;;WAEnB,OAAO,kBAAkB;;;;;;;;;;;EAWlC,QAAQ,MAAM,IAAI,MAChB,SAAS,eAAe,MAAM,KAC7B,eAAe,GAAG,GAAG;;;;;;;iBAQV,SACd,UAAU,WACV,UAAU,eAAe,sBACzB;;EAEA;;EAEA,QAAQ;;;;;;EAMR,WAAW;IACT,SAAS,GAAG;;;;;;;;;;;;;KCxJJ,QACV,UAAU,YAAY,WACtB,aACA,UAAU,eAAe;;WAGhB;;WAEA,QAAQ,SAAS;;;;;;WAMjB,UAAU,SAAS;WACnB,OAAO,OAAO,GAAG,OAAO,cAAc,OAAO;WAC7C,cAAc;;;;;;;WAOd,aAAa,0BAA0B;;;KAItC,eACV,UAAU,WACV,GACA,UAAU,eAAe;EAEzB,KAAK,OAAO,OAAO,GAAG,OAAO,cAAc,OAAO,IAAI,QAAQ,GAAG,GAAG"}

package/dist/scheduler-qstash.d.ts

@@ -1,5 +1,5 @@
-import { r as Clock } from "./store-RJO35BMj.js";
-import { T as SchedulerTask, t as A2Scheduler } from "./server-DjPhHnbI.js";
+import { r as Clock } from "./store-DGHeBtIQ.js";
+import { T as SchedulerTask, t as A2Scheduler } from "./server-DgCrSuhB.js";
 //#region src/scheduler-qstash.d.ts
 type QStashStoreOutage = {
   version: 1;

package/dist/scheduler-qstash.js

@@ -1,6 +1,6 @@
-import { t as A2Error } from "./errors-BQuJpe82.js";
+import { t as A2Error } from "./errors-DCk6ch5n.js";
 import { d as classifySchedulerSendFailure, g as serverInternals, t as DRAIN_TIMINGS, u as assertSchedulerTargets } from "./internal-DRXJ56EI.js";
-import { i as platformVercelOidcToken, n as deliverSchedulerAppend } from "./server-B2XNevQA.js";
+import { n as deliverSchedulerAppend, o as platformVercelOidcToken } from "./server-DlLyvaSH.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 import { n as SYSTEM_CLOCK } from "./store-N8PXxDAS.js";
 import { t as normalizeSchedulerTask } from "./scheduler-task-BpzhPnRS.js";

package/dist/scheduler-vercel.d.ts

@@ -1,5 +1,5 @@
-import { r as Clock } from "./store-RJO35BMj.js";
-import { T as SchedulerTask, t as A2Scheduler } from "./server-DjPhHnbI.js";
+import { r as Clock } from "./store-DGHeBtIQ.js";
+import { T as SchedulerTask, t as A2Scheduler } from "./server-DgCrSuhB.js";
 //#region src/scheduler-vercel.d.ts
 /**
  * The "not settled yet" signal for a stalled handler — an expected state,

package/dist/scheduler-vercel.js

@@ -1,5 +1,5 @@
 import { d as classifySchedulerSendFailure, g as serverInternals, t as DRAIN_TIMINGS, u as assertSchedulerTargets } from "./internal-DRXJ56EI.js";
-import { n as deliverSchedulerAppend } from "./server-B2XNevQA.js";
+import { n as deliverSchedulerAppend } from "./server-DlLyvaSH.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 import { n as SYSTEM_CLOCK } from "./store-N8PXxDAS.js";
 import { t as normalizeSchedulerTask } from "./scheduler-task-BpzhPnRS.js";

package/dist/{server-DjPhHnbI.d.ts → server-DgCrSuhB.d.ts}

@@ -1,5 +1,5 @@
-import { a as EventDefs, c as PresencePatch, d as WithPresence, l as PresenceSnapshot, n as Contract, o as PresenceDefs, p as Reducer, r as ContractEvent, s as PresenceMap, t as AppendInput } from "./contract-jIfaR085.js";
-import { t as A2Store } from "./store-RJO35BMj.js";
+import { a as ContractEvent, c as PresenceDefs, d as PresenceSnapshot, i as Contract, l as PresenceMap, p as WithPresence, r as AppendInput, s as EventDefs, t as Reducer, u as PresencePatch } from "./reducer-DJKWm3cp.js";
+import { t as A2Store } from "./store-DGHeBtIQ.js";
 import { i as A2Telemetry } from "./telemetry-CpeclqB2.js";
 //#region src/session-socket.d.ts
 /**
@@ -56,6 +56,8 @@ type UpgradeWebSocket = (attach: (socket: A2Socket) => void) => Response | Promi
 type ServerFetchOptions<D extends EventDefs = EventDefs, P extends PresenceDefs = Record<never, never>> = {
   authorize?: (operation: A2Operation<D, P>) => boolean | Promise<boolean>;
   upgradeWebSocket?: UpgradeWebSocket;
+  /** Allow one upgraded connection to select more than one session. */
+  multiplexWebSocket?: boolean;
 };
 //#endregion
 //#region src/scheduler-task.d.ts
@@ -279,4 +281,4 @@ type ServerOptions<D extends EventDefs, P extends PresenceDefs = Record<never, n
 declare function createServer<D extends EventDefs, P extends PresenceDefs = Record<never, never>>(options: ServerOptions<D, P>): A2Server<D, P>;
 //#endregion
 export { UpgradeWebSocket as A, SchedulerAppendTask as C, A2PushEvent as D, A2Operation as E, A2PushPresence as O, ScheduledEvent as S, SchedulerTask as T, SessionPresence as _, Handler as a, createServer as b, HandlerEntry as c, ScheduleDelay as d, ScheduleTiming as f, SessionDispatch as g, SessionAppend as h, DrainableServer as i, A2Socket as j, ServerFetchOptions as k, Lane as l, Session as m, A2Server as n, HandlerAppend as o, ServerOptions as p, AbortSpec as r, HandlerContext as s, A2Scheduler as t, LaneContext as u, SessionSchedule as v, SchedulerDrainTask as w, deliverSchedulerAppend as x, StateOptions as y };
-//# sourceMappingURL=server-DjPhHnbI.d.ts.map
+//# sourceMappingURL=server-DgCrSuhB.d.ts.map

package/dist/server-DgCrSuhB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-DgCrSuhB.d.ts","names":[],"sources":["../src/session-socket.ts","../src/server-fetch.ts","../src/scheduler-task.ts","../src/server.ts"],"mappings":"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"}

package/dist/{server-B2XNevQA.js → server-DlLyvaSH.js}

@@ -1,8 +1,8 @@
 import { n as validateSync } from "./validate-XKT4FSNn.js";
-import { n as asStoreUnavailable, t as A2Error } from "./errors-BQuJpe82.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-B6te_wns.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 { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 //#region src/platform.ts
 const SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
@@ -116,10 +116,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 +221,101 @@ 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) => {
+	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;
+		}
+		const appended = await target.append(...events);
+		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));
+				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,22 +349,9 @@ 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));
@@ -300,14 +377,7 @@ function sessionsSocket(resolve, socket, options) {
 		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(target, index, presence);
 		subscriptions.set(id, subscription);
 		shell.send(socketSubscribedFor(id));
 		runSubscription(id, subscription);
@@ -322,45 +392,12 @@ 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 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"]) {
@@ -591,7 +628,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 +653,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);
@@ -1364,7 +1423,7 @@ function createServer(options) {
 		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] : void 0;
+			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;
@@ -1870,7 +1929,7 @@ function createServer(options) {
 						index: event.index,
 						attempt: event.attemptCount,
 						error: describeError(err),
-						maxFailures: MAX_FAILURES
+						maxFailures: err instanceof NonRetriableError ? 1 : MAX_FAILURES
 					});
 					eventSpan.setAttribute("a2.event.outcome", failure.outcome);
 					return {
@@ -2157,6 +2216,6 @@ function cloneInitial(initial) {
 	}
 }
 //#endregion
-export { platformVercelOidcToken as i, deliverSchedulerAppend as n, setServerFetchHooks as r, createServer as t };
+export { parsePresenceSibling as a, sseResponse as i, deliverSchedulerAppend as n, platformVercelOidcToken as o, setServerFetchHooks as r, createServer as t };
 
-//# sourceMappingURL=server-B2XNevQA.js.map
+//# sourceMappingURL=server-DlLyvaSH.js.map