devframe 0.9.7 → 0.9.9

package/dist/rpc/transports/ws-bun.d.mts

@@ -1,5 +1,5 @@
-import { n as WsOriginRegistry } from "../../ws-server-Di2oqr4q.mjs";
-import { t as ContextRpcServer } from "../../rpc-core-BHUsDl7s.mjs";
+import { n as WsOriginRegistry } from "../../ws-server-D2nv68Hg.mjs";
+import { t as ContextRpcServer } from "../../rpc-core-Ceu6AUz8.mjs";
 //#region src/rpc/transports/ws-bun.d.ts
 interface AttachBunWsTransportOptions {
   /** Same contract as `WsRpcTransportOptions.allowedOrigins`. */
@@ -7,7 +7,7 @@ interface AttachBunWsTransportOptions {
 }
 /**
  * Structural view of the Bun `Bun.serve({ websocket })` handler object the
- * crossws Bun adapter produces — typed loosely so devframe carries no
+ * crossws Bun adapter produces, typed loosely so devframe carries no
  * dependency on Bun's own types.
  */
 interface BunWsTierWebSocket {
@@ -17,14 +17,14 @@ interface BunWsTierWebSocket {
   drain?: (ws: unknown) => unknown;
 }
 interface BunWsTier {
-  /** Complete a WS upgrade request — `Bun.serve`'s server as 2nd argument. */
+  /** Complete a WS upgrade request; `Bun.serve`'s server as 2nd argument. */
   handleUpgrade: (request: Request, server: unknown) => Promise<Response | undefined>;
   /** The handlers to spread into `Bun.serve({ websocket })`. */
   websocket: BunWsTierWebSocket;
   close: () => Promise<void>;
 }
 /**
- * The Bun fetch-upgrade WebSocket tier for `initDevframe` / `initHub` — the
+ * The Bun fetch-upgrade WebSocket tier for `initDevframe` / `initHub`: the
  * same RPC peer wiring as `attachWsRpcTransport`, driven by crossws's Bun
  * adapter so upgrades complete through `handler(request, server)` on the
  * app's own origin, with no side-car server. Load it dynamically so the Bun

package/dist/rpc/transports/ws-bun.mjs

@@ -1,7 +1,8 @@
-import { i as isAllowedOrigin, r as createWsRpcPeerHooks } from "../../ws-server-BdSLrhxE.mjs";
+import { t as isAllowedOrigin } from "../../origin-DZit9g29.mjs";
+import { createWsRpcPeerHooks } from "./ws-server.mjs";
 //#region src/rpc/transports/ws-bun.ts
 /**
-* The Bun fetch-upgrade WebSocket tier for `initDevframe` / `initHub` — the
+* The Bun fetch-upgrade WebSocket tier for `initDevframe` / `initHub`: the
 * same RPC peer wiring as `attachWsRpcTransport`, driven by crossws's Bun
 * adapter so upgrades complete through `handler(request, server)` on the
 * app's own origin, with no side-car server. Load it dynamically so the Bun
@@ -15,6 +16,11 @@ async function attachBunWsTransport(core, options = {}) {
 			onConnected: core.onConnected,
 			onDisconnected: core.onDisconnected
 		}),
+		/**
+		* The same origin policy `routeUpgrades` applies for the Node
+		* transport, enforced at the upgrade hook since Bun upgrades arrive
+		* as fetch requests rather than `upgrade` socket events.
+		*/
 		upgrade(request) {
 			const origin = request.headers.get("origin") ?? void 0;
 			const allowed = allowedOrigins && !Array.isArray(allowedOrigins) ? allowedOrigins.isAllowed(origin) : isAllowedOrigin(origin, allowedOrigins || []);

package/dist/rpc/transports/ws-client.d.mts

@@ -1,2 +1,2 @@
-import { n as createWsRpcChannel, t as WsRpcChannelOptions } from "../../ws-client-7_lZi-B9.mjs";
+import { n as createWsRpcChannel, t as WsRpcChannelOptions } from "../../ws-client-Xpxt0oPA.mjs";
 export { WsRpcChannelOptions, createWsRpcChannel };

package/dist/rpc/transports/ws-client.mjs

@@ -1,5 +1,5 @@
 import { DEVFRAME_AUTH_TOKEN_QUERY_PARAM } from "../../constants.mjs";
-import { t as createRpcWireCodec } from "../../wire-codec-0K-o5MYW.mjs";
+import { t as createRpcWireCodec } from "../../wire-codec-dcCeXcSo.mjs";
 //#region src/rpc/transports/ws-client.ts
 function NOOP() {}
 const EMPTY_DEFS = /* @__PURE__ */ new Map();
@@ -7,7 +7,7 @@ const EMPTY_DEFS = /* @__PURE__ */ new Map();
 * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
 * Pass the result straight to `createRpcClient`'s `channel` option.
 *
-* Also returns `close()`, closing the underlying socket — mirroring the server transport's
+* Also returns `close()`, closing the underlying socket, mirroring the server transport's
 * existing `WsRpcTransport.close()`. `birpc`'s own `ChannelOptions` has no teardown of its own.
 */
 function createWsRpcChannel(options) {

package/dist/rpc/transports/ws-deno.d.mts

@@ -1,5 +1,5 @@
-import { n as WsOriginRegistry } from "../../ws-server-Di2oqr4q.mjs";
-import { t as ContextRpcServer } from "../../rpc-core-BHUsDl7s.mjs";
+import { n as WsOriginRegistry } from "../../ws-server-D2nv68Hg.mjs";
+import { t as ContextRpcServer } from "../../rpc-core-Ceu6AUz8.mjs";
 //#region src/rpc/transports/ws-deno.d.ts
 interface AttachDenoWsTransportOptions {
   /** Same contract as `WsRpcTransportOptions.allowedOrigins`. */
@@ -7,7 +7,7 @@ interface AttachDenoWsTransportOptions {
 }
 interface DenoWsTier {
   /**
-   * Complete a WS upgrade request — `Deno.serve`'s handler info as the 2nd
+   * Complete a WS upgrade request; `Deno.serve`'s handler info as the 2nd
    * argument. Unlike Bun, Deno's adapter attaches the socket to the returned
    * `Response` itself, so there is no `websocket` handler object to register.
    */
@@ -15,7 +15,7 @@ interface DenoWsTier {
   close: () => Promise<void>;
 }
 /**
- * The Deno fetch-upgrade WebSocket tier for `initDevframe` / `initHub` — the
+ * The Deno fetch-upgrade WebSocket tier for `initDevframe` / `initHub`: the
  * same RPC peer wiring as `attachWsRpcTransport`, driven by crossws's Deno
  * adapter so upgrades complete through `handleUpgrade(request, info)` on the
  * app's own origin, with no side-car server. Load it dynamically so the Deno

package/dist/rpc/transports/ws-deno.mjs

@@ -1,7 +1,8 @@
-import { i as isAllowedOrigin, r as createWsRpcPeerHooks } from "../../ws-server-BdSLrhxE.mjs";
+import { t as isAllowedOrigin } from "../../origin-DZit9g29.mjs";
+import { createWsRpcPeerHooks } from "./ws-server.mjs";
 //#region src/rpc/transports/ws-deno.ts
 /**
-* The Deno fetch-upgrade WebSocket tier for `initDevframe` / `initHub` — the
+* The Deno fetch-upgrade WebSocket tier for `initDevframe` / `initHub`: the
 * same RPC peer wiring as `attachWsRpcTransport`, driven by crossws's Deno
 * adapter so upgrades complete through `handleUpgrade(request, info)` on the
 * app's own origin, with no side-car server. Load it dynamically so the Deno
@@ -15,6 +16,11 @@ async function attachDenoWsTransport(core, options = {}) {
 			onConnected: core.onConnected,
 			onDisconnected: core.onDisconnected
 		}),
+		/**
+		* The same origin policy `routeUpgrades` applies for the Node
+		* transport, enforced at the upgrade hook since Deno upgrades arrive
+		* as fetch requests rather than `upgrade` socket events.
+		*/
 		upgrade(request) {
 			const origin = request.headers.get("origin") ?? void 0;
 			const allowed = allowedOrigins && !Array.isArray(allowedOrigins) ? allowedOrigins.isAllowed(origin) : isAllowedOrigin(origin, allowedOrigins || []);

package/dist/rpc/transports/ws-server.d.mts

@@ -1,2 +1,3 @@
-import { a as attachWsRpcTransport, c as isAllowedOrigin, d as DevframeRpcConnection, f as DevframeRpcConnectionRequest, i as WsRpcTransportOptions, l as isLoopbackHostname, n as WsOriginRegistry, o as createWsOriginRegistry, p as DevframeRpcTransportKind, r as WsRpcTransport, s as createWsRpcPeerHooks, t as CreateWsOriginRegistryOptions, u as DevframeNodeRpcSessionMeta } from "../../ws-server-Di2oqr4q.mjs";
+import { a as attachWsRpcTransport, c as DevframeNodeRpcSessionMeta, d as DevframeRpcTransportKind, i as WsRpcTransportOptions, l as DevframeRpcConnection, n as WsOriginRegistry, o as createWsOriginRegistry, r as WsRpcTransport, s as createWsRpcPeerHooks, t as CreateWsOriginRegistryOptions, u as DevframeRpcConnectionRequest } from "../../ws-server-D2nv68Hg.mjs";
+import { n as isLoopbackHostname, t as isAllowedOrigin } from "../../origin-DGDH8BI9.mjs";
 export { CreateWsOriginRegistryOptions, type DevframeNodeRpcSessionMeta, type DevframeRpcConnection, type DevframeRpcConnectionRequest, type DevframeRpcTransportKind, WsOriginRegistry, WsRpcTransport, WsRpcTransportOptions, attachWsRpcTransport, createWsOriginRegistry, createWsRpcPeerHooks, isAllowedOrigin, isLoopbackHostname };

package/dist/rpc/transports/ws-server.mjs

@@ -1,2 +1,233 @@
-import { a as isLoopbackHostname, i as isAllowedOrigin, n as createWsOriginRegistry, r as createWsRpcPeerHooks, t as attachWsRpcTransport } from "../../ws-server-BdSLrhxE.mjs";
+import "../../constants.mjs";
+import { t as createRpcWireCodec } from "../../wire-codec-dcCeXcSo.mjs";
+import { n as isLoopbackHostname, t as isAllowedOrigin } from "../../origin-DZit9g29.mjs";
+import { t as createRpcSessionMeta } from "../../session-DPfj6zQG.mjs";
+import { n as randomToken, r as timingSafeEqual } from "../../crypto-token-TVbGGFuj.mjs";
+import { createServer } from "node:http";
+import { createServer as createServer$1 } from "node:https";
+import crossws from "crossws/adapters/node";
+//#region src/rpc/transports/ws-server.ts
+/**
+* Create a live, token-protected origin allowlist for external browser
+* viewers. Pass it to {@link WsRpcTransportOptions.allowedOrigins}, then use
+* `registerFromUrl()` in the connection metadata handler to authorize a
+* viewer without sharing a mutable array or disabling DNS-rebinding protection.
+*/
+function createWsOriginRegistry(options = {}) {
+	const token = randomToken();
+	const origins = new Set(options.allowedOrigins ?? []);
+	function normalizeOrigin(origin) {
+		if (!origin) return;
+		try {
+			const url = new URL(origin);
+			const normalized = url.origin === "null" ? `${url.protocol}//${url.host}` : url.origin;
+			return origin === normalized ? normalized : void 0;
+		} catch {}
+	}
+	function registerOrigin(origin, candidateToken) {
+		const normalized = normalizeOrigin(origin);
+		if (!normalized || !candidateToken || !timingSafeEqual(token, candidateToken)) return false;
+		if (options.validateOrigin && !options.validateOrigin(normalized)) return false;
+		origins.add(normalized);
+		return true;
+	}
+	return {
+		token,
+		registerFromUrl(url) {
+			let parsed;
+			try {
+				parsed = new URL(url, "http://localhost");
+			} catch {
+				return;
+			}
+			const origin = parsed.searchParams.get("devframe_viewer_origin") ?? void 0;
+			return registerOrigin(origin, parsed.searchParams.get("devframe_viewer_origin_token") ?? void 0) ? origin : void 0;
+		},
+		isAllowed(origin) {
+			return isAllowedOrigin(origin, [...origins]);
+		}
+	};
+}
+const EMPTY_DEFS = /* @__PURE__ */ new Map();
+function NOOP() {}
+function listen(server, port, host) {
+	return new Promise((resolve, reject) => {
+		const onError = (error) => reject(error);
+		server.once("error", onError);
+		try {
+			server.listen(port, host, () => {
+				server.off("error", onError);
+				resolve();
+			});
+		} catch (error) {
+			server.off("error", onError);
+			reject(error);
+		}
+	});
+}
+/** Compare two URL paths ignoring a trailing slash. */
+function pathMatches(a, b) {
+	const strip = (p) => p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
+	return strip(a) === strip(b);
+}
+function isWsOriginRegistry(value) {
+	return !!value && !Array.isArray(value);
+}
+/**
+* Build the `upgrade` listener that hands a request to the crossws adapter,
+* optionally filtered to a single `path`. Non-matching requests are left
+* untouched so other upgrade listeners (e.g. a Vite dev server's HMR socket)
+* can claim them, unless `destroyUnmatched` is set.
+*/
+function createUpgradeListener(ws, path, destroyUnmatched, allowedOrigins) {
+	return (req, socket, head) => {
+		socket.on("error", () => {});
+		if (path) {
+			let pathname = req.url ?? "/";
+			try {
+				pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+			} catch {}
+			if (!pathMatches(pathname, path)) {
+				if (destroyUnmatched) {
+					socket.write("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+					socket.destroy();
+				}
+				return;
+			}
+		}
+		const originAllowed = isWsOriginRegistry(allowedOrigins) ? allowedOrigins.isAllowed(req.headers.origin) : isAllowedOrigin(req.headers.origin, allowedOrigins || []);
+		if (allowedOrigins !== false && !originAllowed) {
+			socket.write("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+			socket.destroy();
+			return;
+		}
+		ws.handleUpgrade(req, socket, head);
+	};
+}
+/**
+* The per-peer lifecycle hooks driving a devframe RPC WebSocket, shaped for
+* any [crossws](https://crossws.h3.dev) adapter. {@link attachWsRpcTransport}
+* feeds them to the Node adapter; runtime-specific attachments (e.g. Bun's
+* fetch-upgrade adapter) reuse the same hooks so every transport speaks the
+* identical wire protocol: one birpc channel per peer, per-method
+* `jsonSerializable` dispatch between strict JSON and structured-clone.
+*/
+function createWsRpcPeerHooks(rpcGroup, options = {}) {
+	const { onConnected = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS, serialize: serializeOverride, deserialize: deserializeOverride } = options;
+	const states = /* @__PURE__ */ new WeakMap();
+	return {
+		open: (peer) => {
+			const meta = createRpcSessionMeta();
+			meta.peer = peer;
+			const connection = {
+				id: meta.id,
+				transport: "websocket",
+				request: peer.request,
+				send: (data) => peer.send(data),
+				close: (code, reason) => peer.close(code, reason),
+				peer
+			};
+			const codec = createRpcWireCodec(definitions);
+			const state = {
+				meta,
+				connection
+			};
+			const channel = {
+				post: (data) => {
+					peer.send(data);
+				},
+				on: (fn) => {
+					state.onMessage = fn;
+				},
+				serialize: serializeOverride ?? codec.serialize,
+				deserialize: deserializeOverride ?? codec.deserialize,
+				meta
+			};
+			state.channel = channel;
+			states.set(peer, state);
+			rpcGroup.updateChannels((channels) => {
+				channels.push(channel);
+			});
+			onConnected(connection, meta);
+		},
+		message: (peer, message) => {
+			states.get(peer)?.onMessage?.(message.text());
+		},
+		close: (peer) => {
+			const state = states.get(peer);
+			if (!state) return;
+			states.delete(peer);
+			rpcGroup.updateChannels((channels) => {
+				const index = state.channel ? channels.indexOf(state.channel) : -1;
+				if (index >= 0) channels.splice(index, 1);
+			});
+			onDisconnected(state.connection, state.meta);
+		}
+	};
+}
+/**
+* Attach a WebSocket transport to an existing RPC group, powered by
+* [crossws](https://crossws.h3.dev). Either attach to an existing HTTP(S)
+* `server` (sharing its port, optionally scoped to a `path`), or let this
+* helper create a standalone server from `port` / `host` / `https`.
+*
+* Returns the crossws node adapter, standalone-server readiness/address
+* accessors, `detach` (remove the upgrade listener from a shared `server`),
+* and `close` (full deterministic teardown).
+*/
+function attachWsRpcTransport(rpcGroup, options = {}) {
+	const { server, port, host = "localhost", path, destroyUnmatched = false, unbound, https, allowedOrigins } = options;
+	const ws = crossws({ hooks: createWsRpcPeerHooks(rpcGroup, options) });
+	const sharedUpgradeListener = createUpgradeListener(ws, path, destroyUnmatched, allowedOrigins);
+	const ownedUpgradeListener = createUpgradeListener(ws, path, true, allowedOrigins);
+	/** Bind a server's `upgrade` events, tracked so `close()` detaches them. */
+	const attachments = /* @__PURE__ */ new Set();
+	function attachTo(target, listener) {
+		target.on("upgrade", listener);
+		const detachOne = () => {
+			target.off("upgrade", listener);
+			attachments.delete(detachOne);
+		};
+		attachments.add(detachOne);
+		return detachOne;
+	}
+	let ready = Promise.resolve();
+	let ownedServer;
+	if (unbound) {} else if (server) attachTo(server, sharedUpgradeListener);
+	else if (https) {
+		ownedServer = createServer$1(https);
+		attachTo(ownedServer, ownedUpgradeListener);
+		ready = listen(ownedServer, port ?? 0, host);
+	} else {
+		ownedServer = createServer((_req, res) => {
+			res.writeHead(426, { "content-type": "text/plain" });
+			res.end("Upgrade Required");
+		});
+		attachTo(ownedServer, ownedUpgradeListener);
+		ready = listen(ownedServer, port ?? 0, host);
+	}
+	const activeServer = server ?? ownedServer;
+	function detachAll() {
+		for (const detachOne of [...attachments]) detachOne();
+	}
+	return {
+		ws,
+		ready,
+		address: () => activeServer?.address() ?? null,
+		handleUpgrade: sharedUpgradeListener,
+		attach: (target) => attachTo(target, sharedUpgradeListener),
+		detach: detachAll,
+		async close() {
+			detachAll();
+			ws.closeAll(void 0, void 0, true);
+			if (ownedServer) {
+				const srv = ownedServer;
+				await ready.catch(() => {});
+				if (!srv.listening) return;
+				await new Promise((r) => srv.close(() => r()));
+			}
+		}
+	};
+}
+//#endregion
 export { attachWsRpcTransport, createWsOriginRegistry, createWsRpcPeerHooks, isAllowedOrigin, isLoopbackHostname };

package/dist/{rpc-core-BHUsDl7s.d.mts → rpc-core-Ceu6AUz8.d.mts}

@@ -1,6 +1,6 @@
-import { d as DevframeRpcConnection, u as DevframeNodeRpcSessionMeta } from "./ws-server-Di2oqr4q.mjs";
-import { Ct as DevframeAuthHandler, _t as DevframeRpcServerFunctions, gt as DevframeRpcClientFunctions, o as DevframeNodeContext, s as DevframeNodeRpcSession } from "./context-BhBzOXVa.mjs";
-import "./index-DcKxIMoI.mjs";
+import { c as DevframeNodeRpcSessionMeta, l as DevframeRpcConnection } from "./ws-server-D2nv68Hg.mjs";
+import { _t as DevframeRpcClientFunctions, o as DevframeNodeContext, s as DevframeNodeRpcSession, vt as DevframeRpcServerFunctions, wt as DevframeAuthHandler } from "./context-4AIVRLYF.mjs";
+import "./index-pKl67H6w.mjs";
 import { BirpcGroup, EventOptions } from "birpc";
 //#region src/node/rpc-core.d.ts
 interface CreateContextRpcServerOptions {
@@ -33,7 +33,7 @@ interface ContextRpcServer {
 }
 /**
  * Bind a devframe context's registered RPC functions to a birpc group,
- * transport-agnostically — the shared core under the instance shell's own
+ * transport-agnostically: the shared core under the instance shell's own
  * HTTP+WS binding (Node http + WS) and the Bun fetch-upgrade tier of
  * `createHandler`.
  *

package/dist/{rpc-core-DlHd276T.mjs → rpc-core-DVQ7xi89.mjs}

@@ -1,12 +1,12 @@
 import { n as __exportAll } from "./rolldown-runtime-B4iAMlE-.mjs";
 import { createRpcServer } from "./rpc/server.mjs";
-import { t as diagnostics } from "./diagnostics-BXWW3VK-.mjs";
+import { t as diagnostics } from "./diagnostics-BMfN8mb1.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/node/rpc-core.ts
 var rpc_core_exports = /* @__PURE__ */ __exportAll({ createContextRpcServer: () => createContextRpcServer });
 /**
 * Bind a devframe context's registered RPC functions to a birpc group,
-* transport-agnostically — the shared core under the instance shell's own
+* transport-agnostically: the shared core under the instance shell's own
 * HTTP+WS binding (Node http + WS) and the Bun fetch-upgrade tier of
 * `createHandler`.
 *
@@ -26,8 +26,20 @@ function createContextRpcServer(options) {
 		for (const fn of authHandler.rpcFunctions) if (!rpcHost.definitions.has(fn.name)) rpcHost.register(fn);
 	}
 	const rpcGroup = createRpcServer(rpcHost.functions, { rpcOptions: {
+		/**
+		* Forwarded as-is so a host with its own structured diagnostics
+		* keeps seeing RPC failures.
+		*/
 		onFunctionError: options.rpcOptions?.onFunctionError,
 		onGeneralError: options.rpcOptions?.onGeneralError,
+		/**
+		* Wrap each RPC handler in an AsyncLocalStorage context so
+		* `ctx.rpc.getCurrentRpcSession()` works inside handlers (used
+		* by streaming subscribe/unsubscribe/cancel and shared-state
+		* sync), and (when an `authorize` gate is configured) reject
+		* the call before it ever reaches the handler. Mirrors
+		* `packages/core/src/node/ws.ts`'s resolver.
+		*/
 		resolver(name, fn) {
 			const rpc = this;
 			if (!fn) return void 0;

package/dist/{serialization-BGzEwAdr.mjs → serialization-DTZnPQ1-.mjs}

@@ -1,4 +1,4 @@
-import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
+import { t as diagnostics } from "./diagnostics-D0EVm5M6.mjs";
 //#region src/rpc/serialization.ts
 /**
 * Wire format used by the live RPC transports (WebSocket and SSE).
@@ -14,7 +14,7 @@ import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
 *
 * birpc envelopes always start with `{`, so a leading byte that is not
 * `s` is unambiguously JSON. Each direction independently chooses its
-* encoding from local definitions — request and response are not
+* encoding from local definitions; request and response are not
 * coupled by a mirror rule.
 */
 const STRUCTURED_CLONE_PREFIX = "s:";
@@ -26,16 +26,16 @@ const STRUCTURED_CLONE_PREFIX = "s:";
 * instances, or `undefined` inside an array (silently becomes `null`).
 *
 * Native pass-throughs (no extra work needed):
-*   - circular references — `JSON.stringify` raises `TypeError`.
-*   - `BigInt` at top level — caught here for a friendlier error path.
+*   - circular references: `JSON.stringify` raises `TypeError`.
+*   - `BigInt` at top level: caught here for a friendlier error path.
 *
 * Lenient cases (allowed without throwing):
-*   - `undefined` as an object property — legitimate optional field;
+*   - `undefined` as an object property: legitimate optional field;
 *     JSON.stringify just omits it.
-*   - `undefined` at the root — legitimate "action returned nothing".
-*   - `Symbol` / `Function` values — semantically "drop me" in JSON.
+*   - `undefined` at the root: legitimate "action returned nothing".
+*   - `Symbol` / `Function` values: semantically "drop me" in JSON.
 *
-* `fnName` is used only for the diagnostic message — pass the RPC
+* `fnName` is used only for the diagnostic message; pass the RPC
 * function name when calling from a wire serializer / dump writer so
 * the error points at the offending function.
 */
@@ -47,19 +47,21 @@ function strictJsonStringify(value, fnName = "") {
 			if (Array.isArray(holder)) throw nonJsonAt(fnName, "undefined", holder, key);
 			return val;
 		}
-		if (original === null) return val;
-		if (typeof original === "bigint") throw nonJsonAt(fnName, "BigInt", holder, key);
-		if (typeof original === "object") {
-			if (original instanceof Map) throw nonJsonAt(fnName, "Map", holder, key);
-			if (original instanceof Set) throw nonJsonAt(fnName, "Set", holder, key);
-			if (original instanceof Date) throw nonJsonAt(fnName, "Date", holder, key);
-			if (Array.isArray(original)) return val;
-			const proto = Object.getPrototypeOf(original);
-			if (proto !== null && proto !== Object.prototype) throw nonJsonAt(fnName, original.constructor?.name ?? "class instance", holder, key);
-		}
+		if (original !== null) assertJsonSafe(original, holder, key, fnName);
 		return val;
 	});
 }
+/** Throw `DF0020` when `original` is a type JSON can't round-trip losslessly. */
+function assertJsonSafe(original, holder, key, fnName) {
+	if (typeof original === "bigint") throw nonJsonAt(fnName, "BigInt", holder, key);
+	if (typeof original !== "object") return;
+	if (original instanceof Map) throw nonJsonAt(fnName, "Map", holder, key);
+	if (original instanceof Set) throw nonJsonAt(fnName, "Set", holder, key);
+	if (original instanceof Date) throw nonJsonAt(fnName, "Date", holder, key);
+	if (Array.isArray(original)) return;
+	const proto = Object.getPrototypeOf(original);
+	if (proto !== null && proto !== Object.prototype) throw nonJsonAt(fnName, original.constructor?.name ?? "class instance", holder, key);
+}
 function nonJsonAt(fnName, type, parent, key) {
 	const path = formatPath(parent, key);
 	return diagnostics.DF0020({

package/dist/{services-install-CqqQVls5.mjs → services-install-P_DV7VYL.mjs}

@@ -1,5 +1,5 @@
-import { t as DEVFRAME_EVENTS } from "./events-4daw0uK9.mjs";
-import { t as diagnostics } from "./diagnostics-BXWW3VK-.mjs";
+import { t as DEVFRAME_EVENTS } from "./events-BV4Dj59a.mjs";
+import { t as diagnostics } from "./diagnostics-BMfN8mb1.mjs";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
 import { isAbsolute, join } from "pathe";
@@ -219,6 +219,12 @@ var DevframeAgentHost = class {
 			description: input.description,
 			safety: input.safety ?? "action",
 			tags: input.tags,
+			/**
+			* Standard Schema `args` are carried raw (mirroring how an RPC-backed
+			* tool defers to `ctx.rpc.definitions`); consumers (the MCP adapter)
+			* convert to JSON Schema on demand. An explicit `inputSchema` override
+			* wins when given.
+			*/
 			args: input.args,
 			inputSchema: input.inputSchema,
 			outputSchema: input.outputSchema,
@@ -268,7 +274,7 @@ function inferSafety(type) {
 //#region src/node/services-install.ts
 /**
 * Turn a `resolveFrom` value (a file path, a file URL like `import.meta.url`,
-* or a directory) into something `createRequire` accepts — a directory gets a
+* or a directory) into something `createRequire` accepts; a directory gets a
 * synthetic filename appended so resolution starts inside it.
 */
 function toRequireBase(resolveFrom) {
@@ -341,6 +347,24 @@ function compareVersions(a, b) {
 	if (a.prerelease && b.prerelease) return a.prerelease < b.prerelease ? -1 : a.prerelease > b.prerelease ? 1 : 0;
 	return 0;
 }
+/** Whether `version` and `base` share their first `lockUpTo + 1` parts. */
+function partsMatchUpTo(version, base, lockUpTo) {
+	for (let i = 0; i <= lockUpTo; i++) if ((version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
+	return true;
+}
+function satisfiesCaret(version, base) {
+	if (compareVersions(version, base) < 0) return false;
+	const fixedIndex = base.parts.findIndex((part) => part !== 0);
+	return partsMatchUpTo(version, base, fixedIndex === -1 ? base.parts.length - 1 : fixedIndex);
+}
+function satisfiesTilde(version, base, segments) {
+	if (compareVersions(version, base) < 0) return false;
+	return partsMatchUpTo(version, base, segments.length >= 2 ? 1 : 0);
+}
+function satisfiesExactOrPrefix(version, base, segments) {
+	for (let i = 0; i < Math.max(segments.length, 3); i++) if (i < segments.length && (version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
+	return segments.length >= 3 ? compareVersions(version, base) === 0 : true;
+}
 function satisfiesComparator(version, comparator) {
 	const raw = comparator.trim();
 	if (!raw || raw === "*" || raw === "x") return true;
@@ -356,26 +380,13 @@ function satisfiesComparator(version, comparator) {
 		case ">=": return compareVersions(version, base) >= 0;
 		case "<": return compareVersions(version, base) < 0;
 		case "<=": return compareVersions(version, base) <= 0;
-		case "^": {
-			if (compareVersions(version, base) < 0) return false;
-			const fixedIndex = base.parts.findIndex((part) => part !== 0);
-			const lockUpTo = fixedIndex === -1 ? base.parts.length - 1 : fixedIndex;
-			for (let i = 0; i <= lockUpTo; i++) if ((version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
-			return true;
-		}
-		case "~": {
-			if (compareVersions(version, base) < 0) return false;
-			const lockUpTo = segments.length >= 2 ? 1 : 0;
-			for (let i = 0; i <= lockUpTo; i++) if ((version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
-			return true;
-		}
-		default:
-			for (let i = 0; i < Math.max(segments.length, 3); i++) if (i < segments.length && (version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
-			return segments.length >= 3 ? compareVersions(version, base) === 0 : true;
+		case "^": return satisfiesCaret(version, base);
+		case "~": return satisfiesTilde(version, base, segments);
+		default: return satisfiesExactOrPrefix(version, base, segments);
 	}
 }
 /**
-* Pragmatic semver range check for service version declarations — supports
+* Pragmatic semver range check for service version declarations; supports
 * the common forms (`1.2.3`, `^1.2.3`, `~1.2`, `>=1 <3`, `1.x`, `*`, and
 * `||`-joined alternatives) without pulling in a semver dependency. An
 * unparseable version or range reads as **not satisfied**.
@@ -402,7 +413,7 @@ function deepMergeTwo(a, b) {
 }
 /**
 * Default option-set merge when a service declares no `mergeOptions`:
-* deep-merge in declaration order — objects recurse, arrays union-dedupe,
+* deep-merge in declaration order: objects recurse, arrays union-dedupe,
 * scalars take the later value. Covers the built-in services (`roots` /
 * `langs` union, `themes` per-key last-wins) without a custom hook.
 */

package/dist/session-DPfj6zQG.mjs

@@ -0,0 +1,16 @@
+//#region src/rpc/transports/session.ts
+let sessionId = 0;
+/**
+* Mint the per-connection session meta every transport binding shares:
+* one id space across transports, so session bookkeeping (streaming
+* subscriptions, shared-state sync, auth trust) never collides between a
+* WS peer and an SSE session on the same server.
+*/
+function createRpcSessionMeta() {
+	return {
+		id: sessionId++,
+		subscribedStates: /* @__PURE__ */ new Set()
+	};
+}
+//#endregion
+export { createRpcSessionMeta as t };

package/dist/{shared-state-DoXutg_U.mjs → shared-state-CaxB1q0h.mjs}

@@ -1,6 +1,6 @@
 import { createEventEmitter } from "./utils/events.mjs";
 import { nanoid } from "./utils/nanoid.mjs";
-//#region ../../node_modules/.pnpm/immer@11.1.17/node_modules/immer/dist/immer.mjs
+//#region ../../node_modules/.pnpm/immer@11.1.18/node_modules/immer/dist/immer.mjs
 var NOTHING = Symbol.for("immer-nothing");
 var DRAFTABLE = Symbol.for("immer-draftable");
 var DRAFT_STATE = Symbol.for("immer-state");
@@ -891,6 +891,7 @@ function enablePatches() {
 		getPath
 	});
 }
+globalThis.Iterator?.from;
 var immer = new Immer2();
 var produce = immer.produce;
 var produceWithPatches = /* @__PURE__ */ immer.produceWithPatches.bind(immer);
@@ -930,8 +931,8 @@ function createSharedState(options) {
 			if (syncIds.has(syncId)) return;
 			rememberSyncId(syncIds, syncId);
 			if (enablePatches$1) {
-				const [newState, patches] = produceWithPatches(state, fn);
-				state = newState;
+				const [nextState, patches] = produceWithPatches(state, fn);
+				state = nextState;
 				events.emit("updated", state, patches, syncId);
 			} else {
 				state = produce(state, fn);

package/dist/{simple-schema-DQPZrAaZ.mjs → simple-schema-Bi40l-P6.mjs}

@@ -37,7 +37,7 @@ function number() {
 function boolean() {
 	return make("boolean", (v) => typeof v === "boolean" ? ok(v) : fail("Expected a boolean"));
 }
-/** `undefined` — mirrors valibot's `void`. */
+/** `undefined`, mirroring valibot's `void`. */
 function voidType() {
 	return make("void", (v) => v === void 0 ? ok(void 0) : fail("Expected undefined"));
 }
@@ -130,7 +130,7 @@ function describe(schema, description) {
 	};
 }
 /**
-* Grouped access to every builder — `s.string()`, `s.object({ ... })`,
+* Grouped access to every builder: `s.string()`, `s.object({ ... })`,
 * `s.void()`, etc. Handy for a valibot-like `import { s } from
 * 'devframe/utils/simple-schema'` call site.
 */