devframe 0.5.4 → 0.6.0-beta.1

package/dist/rpc/index.d.mts

@@ -1,3 +1,3 @@
-import { C as RpcFunctionsCollector, S as RpcFunctionType, T as Thenable, _ as RpcFunctionDefinitionAny, a as RpcDefinitionsFilter, b as RpcFunctionDefinitionToFunction, c as RpcDumpClientOptions, d as RpcDumpGetter, f as RpcDumpRecord, g as RpcFunctionDefinition, h as RpcFunctionAgentOptions, i as RpcArgsSchema, l as RpcDumpCollectionOptions, m as RpcDumpStore, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecordError, r as EntriesToObject, s as RpcDump, t as BirpcFn, u as RpcDumpDefinition, v as RpcFunctionDefinitionAnyWithContext, w as RpcReturnSchema, x as RpcFunctionSetupResult, y as RpcFunctionDefinitionBase } from "../types-BkkQ0Txg.mjs";
-import { C as RpcCacheManager, S as RpcFunctionsCollectorBase, _ as strictJsonStringify, a as StaticRpcDumpManifestStaticEntry, b as createDefineWrapperWithContext, c as collectStaticRpcDump, d as getDefinitionsWithDumps, f as reviveDumpError, g as STRUCTURED_CLONE_PREFIX, h as validateDefinitions, i as StaticRpcDumpManifestQueryEntry, l as createClientFromDump, m as validateDefinition, n as StaticRpcDumpFile, o as StaticRpcDumpManifestValue, p as serializeDumpError, r as StaticRpcDumpManifest, s as StaticRpcDumpSerialization, t as StaticRpcDumpCollection, u as dumpFunctions, v as getRpcHandler, w as RpcCacheOptions, x as defineRpcFunction, y as getRpcResolvedSetupResult } from "../index-C7M1hnvL.mjs";
-export { BirpcFn, BirpcReturn, EntriesToObject, RpcArgsSchema, RpcCacheManager, RpcCacheOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcDump, RpcDumpClientOptions, RpcDumpCollectionOptions, RpcDumpDefinition, RpcDumpGetter, RpcDumpRecord, RpcDumpRecordError, RpcDumpStore, RpcFunctionAgentOptions, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcFunctionDefinitionAnyWithContext, RpcFunctionDefinitionBase, RpcFunctionDefinitionToFunction, RpcFunctionSetupResult, RpcFunctionType, RpcFunctionsCollector, RpcFunctionsCollectorBase, RpcReturnSchema, STRUCTURED_CLONE_PREFIX, StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, Thenable, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions };
+import { C as RpcFunctionType, E as Thenable, S as RpcFunctionSetupResult, T as RpcReturnSchema, _ as RpcFunctionDefinition, a as RpcDefinitionsFilter, b as RpcFunctionDefinitionBase, c as RpcDump, d as RpcDumpDefinition, f as RpcDumpGetter, g as RpcFunctionAgentOptions, h as RpcDumpStore, i as RpcArgsSchema, l as RpcDumpClientOptions, m as RpcDumpRecordError, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecord, r as EntriesToObject, s as RpcDefinitionsToFunctionsWithNamespace, t as BirpcFn, u as RpcDumpCollectionOptions, v as RpcFunctionDefinitionAny, w as RpcFunctionsCollector, x as RpcFunctionDefinitionToFunction, y as RpcFunctionDefinitionAnyWithContext } from "../types-DZEx4ffs.mjs";
+import { C as RpcCacheManager, S as RpcFunctionsCollectorBase, _ as strictJsonStringify, a as StaticRpcDumpManifestStaticEntry, b as createDefineWrapperWithContext, c as collectStaticRpcDump, d as getDefinitionsWithDumps, f as reviveDumpError, g as STRUCTURED_CLONE_PREFIX, h as validateDefinitions, i as StaticRpcDumpManifestQueryEntry, l as createClientFromDump, m as validateDefinition, n as StaticRpcDumpFile, o as StaticRpcDumpManifestValue, p as serializeDumpError, r as StaticRpcDumpManifest, s as StaticRpcDumpSerialization, t as StaticRpcDumpCollection, u as dumpFunctions, v as getRpcHandler, w as RpcCacheOptions, x as defineRpcFunction, y as getRpcResolvedSetupResult } from "../index-CxaPKDXX.mjs";
+export { BirpcFn, BirpcReturn, EntriesToObject, RpcArgsSchema, RpcCacheManager, RpcCacheOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcDefinitionsToFunctionsWithNamespace, RpcDump, RpcDumpClientOptions, RpcDumpCollectionOptions, RpcDumpDefinition, RpcDumpGetter, RpcDumpRecord, RpcDumpRecordError, RpcDumpStore, RpcFunctionAgentOptions, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcFunctionDefinitionAnyWithContext, RpcFunctionDefinitionBase, RpcFunctionDefinitionToFunction, RpcFunctionSetupResult, RpcFunctionType, RpcFunctionsCollector, RpcFunctionsCollectorBase, RpcReturnSchema, STRUCTURED_CLONE_PREFIX, StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, Thenable, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions };

package/dist/rpc/index.mjs

@@ -1,7 +1,7 @@
-import { a as dumpFunctions$1, c as serializeDumpError$1, d as hash, i as createClientFromDump$1, l as validateDefinition, n as getRpcHandler, o as getDefinitionsWithDumps$1, r as getRpcResolvedSetupResult, s as reviveDumpError$1, t as collectStaticRpcDump$1, u as validateDefinitions } from "../dump-9lKIJTLh.mjs";
-import { t as diagnostics } from "../diagnostics-GitRGKbr.mjs";
-import { n as defineRpcFunction, t as createDefineWrapperWithContext } from "../define-CW9gLnyG.mjs";
-import { n as strictJsonStringify, t as STRUCTURED_CLONE_PREFIX } from "../serialization-BD_qXGjd.mjs";
+import { a as dumpFunctions$1, c as serializeDumpError$1, d as hash, i as createClientFromDump$1, l as validateDefinition, n as getRpcHandler, o as getDefinitionsWithDumps$1, r as getRpcResolvedSetupResult, s as reviveDumpError$1, t as collectStaticRpcDump$1, u as validateDefinitions } from "../dump-DoXkj4ku.mjs";
+import { t as diagnostics } from "../diagnostics-BXwBQmoN.mjs";
+import { n as defineRpcFunction, t as createDefineWrapperWithContext } from "../define-BLWPsH6y.mjs";
+import { n as strictJsonStringify, t as STRUCTURED_CLONE_PREFIX } from "../serialization-DpLXCy13.mjs";
 //#region src/rpc/cache.ts
 /**
 * @experimental API is expected to change.

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

@@ -1,2 +1,2 @@
-import { n as createWsRpcChannel, t as WsRpcChannelOptions } from "../../ws-client-CVYX9niP.mjs";
+import { n as createWsRpcChannel, t as WsRpcChannelOptions } from "../../ws-client-D0z0pOhn.mjs";
 export { WsRpcChannelOptions, createWsRpcChannel };

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

@@ -1,5 +1,5 @@
-import { n as strictJsonStringify } from "../../serialization-BD_qXGjd.mjs";
-import { n as structuredCloneStringify, t as structuredCloneParse } from "../../structured-clone-jegjz0hM.mjs";
+import { n as strictJsonStringify } from "../../serialization-DpLXCy13.mjs";
+import { n as structuredCloneStringify, t as structuredCloneParse } from "../../structured-clone-XpHLZ8nr.mjs";
 //#region src/rpc/transports/ws-client.ts
 function NOOP() {}
 const EMPTY_DEFS = /* @__PURE__ */ new Map();

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

@@ -1,2 +1,2 @@
-import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevframeNodeRpcSessionMeta } from "../../ws-server-C1LjmRnp.mjs";
-export { DevframeNodeRpcSessionMeta, WsRpcTransportOptions, attachWsRpcTransport };
+import { i as attachWsRpcTransport, n as WsRpcTransport, r as WsRpcTransportOptions, t as DevframeNodeRpcSessionMeta } from "../../ws-server-BVVMDo2n.mjs";
+export { DevframeNodeRpcSessionMeta, WsRpcTransport, WsRpcTransportOptions, attachWsRpcTransport };

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

@@ -1,74 +1,138 @@
-import { n as strictJsonStringify } from "../../serialization-BD_qXGjd.mjs";
-import { n as structuredCloneStringify, t as structuredCloneParse } from "../../structured-clone-jegjz0hM.mjs";
-import { createServer } from "node:https";
-import { WebSocketServer } from "ws";
+import { n as strictJsonStringify } from "../../serialization-DpLXCy13.mjs";
+import { n as structuredCloneStringify, t as structuredCloneParse } from "../../structured-clone-XpHLZ8nr.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
 let sessionId = 0;
 const EMPTY_DEFS = /* @__PURE__ */ new Map();
 function NOOP() {}
+/** 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);
+}
 /**
-* Attach a WebSocket transport to an existing RPC group. Either pass an
-* existing `WebSocketServer` via `wss`, or let this helper create one from
-* `port` / `host` / `https`.
+* Route `upgrade` events on a server 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. Returns a detach function that
+* removes the listener.
+*/
+function routeUpgrades(server, ws, path, destroyUnmatched) {
+	const listener = (req, socket, head) => {
+		if (path) {
+			let pathname = req.url ?? "/";
+			try {
+				pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+			} catch {}
+			if (!pathMatches(pathname, path)) {
+				if (destroyUnmatched) socket.destroy();
+				return;
+			}
+		}
+		ws.handleUpgrade(req, socket, head);
+	};
+	server.on("upgrade", listener);
+	return () => server.off("upgrade", listener);
+}
+/**
+* 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 plus `detach` (remove the upgrade
+* listener from a shared `server`) and `close` (full deterministic
+* teardown).
 */
 function attachWsRpcTransport(rpcGroup, options = {}) {
-	const { wss: externalWss, port, host = "localhost", https, onConnected = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS, serialize: serializeOverride, deserialize: deserializeOverride } = options;
-	let wss;
-	if (externalWss) wss = externalWss;
-	else if (https) {
-		const httpsServer = createServer(https);
-		wss = new WebSocketServer({ server: httpsServer });
-		httpsServer.listen(port, host);
-	} else wss = new WebSocketServer({
-		port,
-		host
-	});
-	wss.on("connection", (ws, req) => {
-		const meta = {
-			id: sessionId++,
-			ws,
-			subscribedStates: /* @__PURE__ */ new Set()
-		};
-		const pendingRequestMethods = /* @__PURE__ */ new Map();
-		const channel = {
-			post: (data) => {
-				ws.send(data);
-			},
-			on: (fn) => {
-				ws.on("message", (data) => {
-					fn(data.toString());
-				});
-			},
-			serialize: serializeOverride ?? ((msg) => {
-				let method;
-				if (msg.t === "q") method = msg.m;
-				else {
-					method = pendingRequestMethods.get(msg.i);
-					pendingRequestMethods.delete(msg.i);
-				}
-				if (!(msg.t === "s" && "e" in msg) && !!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
-				return `s:${structuredCloneStringify(msg)}`;
-			}),
-			deserialize: deserializeOverride ?? ((raw) => {
-				const msg = raw.startsWith("s:") ? structuredCloneParse(raw.slice(2)) : JSON.parse(raw);
-				if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
-				return msg;
-			}),
-			meta
-		};
-		rpcGroup.updateChannels((channels) => {
-			channels.push(channel);
-		});
-		ws.on("close", () => {
+	const { server, port, host = "localhost", path, destroyUnmatched = false, https, onConnected = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS, serialize: serializeOverride, deserialize: deserializeOverride } = options;
+	const states = /* @__PURE__ */ new WeakMap();
+	const ws = crossws({ hooks: {
+		open: (peer) => {
+			const meta = {
+				id: sessionId++,
+				peer,
+				subscribedStates: /* @__PURE__ */ new Set()
+			};
+			const pendingRequestMethods = /* @__PURE__ */ new Map();
+			const state = {
+				meta,
+				channel: void 0
+			};
+			const channel = {
+				post: (data) => {
+					peer.send(data);
+				},
+				on: (fn) => {
+					state.onMessage = fn;
+				},
+				serialize: serializeOverride ?? ((msg) => {
+					let method;
+					if (msg.t === "q") method = msg.m;
+					else {
+						method = pendingRequestMethods.get(msg.i);
+						pendingRequestMethods.delete(msg.i);
+					}
+					if (!(msg.t === "s" && "e" in msg) && !!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
+					return `s:${structuredCloneStringify(msg)}`;
+				}),
+				deserialize: deserializeOverride ?? ((raw) => {
+					const msg = raw.startsWith("s:") ? structuredCloneParse(raw.slice(2)) : JSON.parse(raw);
+					if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
+					return msg;
+				}),
+				meta
+			};
+			state.channel = channel;
+			states.set(peer, state);
+			rpcGroup.updateChannels((channels) => {
+				channels.push(channel);
+			});
+			onConnected(peer, 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 = channels.indexOf(channel);
+				const index = channels.indexOf(state.channel);
 				if (index >= 0) channels.splice(index, 1);
 			});
-			onDisconnected(ws, meta);
+			onDisconnected(peer, state.meta);
+		}
+	} });
+	let detach = NOOP;
+	let ownedServer;
+	if (server) detach = routeUpgrades(server, ws, path, destroyUnmatched);
+	else if (https) {
+		ownedServer = createServer$1(https);
+		detach = routeUpgrades(ownedServer, ws, path, true);
+		ownedServer.listen(port, host);
+	} else {
+		ownedServer = createServer((_req, res) => {
+			res.writeHead(426, { "content-type": "text/plain" });
+			res.end("Upgrade Required");
 		});
-		onConnected(ws, req, meta);
-	});
-	return { wss };
+		detach = routeUpgrades(ownedServer, ws, path, true);
+		ownedServer.listen(port, host);
+	}
+	return {
+		ws,
+		detach,
+		async close() {
+			detach();
+			ws.closeAll(void 0, void 0, true);
+			if (ownedServer) {
+				const srv = ownedServer;
+				await new Promise((r) => srv.close(() => r()));
+			}
+		}
+	};
 }
 //#endregion
 export { attachWsRpcTransport };

package/dist/{serialization-BD_qXGjd.mjs → serialization-DpLXCy13.mjs}

@@ -1,4 +1,4 @@
-import { t as diagnostics } from "./diagnostics-GitRGKbr.mjs";
+import { t as diagnostics } from "./diagnostics-BXwBQmoN.mjs";
 //#region src/rpc/serialization.ts
 /**
 * Wire format used by the WS RPC transport.

package/dist/{server-wHlpcdZ9.d.mts → server-oju7PTi2.d.mts}

@@ -1,6 +1,7 @@
-import { U as DevframeRpcClientFunctions, W as DevframeRpcServerFunctions, d as DevframeNodeContext } from "./devframe-BuR6n9ZD.mjs";
+import { it as DevframeRpcServerFunctions, m as DevframeNodeContext, rt as DevframeRpcClientFunctions } from "./devframe-BwfavB78.mjs";
 import { BirpcGroup } from "birpc";
-import { WebSocketServer } from "ws";
+import { NodeAdapter } from "crossws/adapters/node";
+import { Server } from "node:http";
 import { H3 } from "h3";
 
 //#region src/node/server.d.ts
@@ -14,6 +15,31 @@ interface StartHttpAndWsOptions {
    * auth middleware, etc.) first.
    */
   app?: H3;
+  /**
+   * Bind the WS endpoint to a single upgrade route (e.g. `/__devframe_ws`) instead of
+   * claiming every upgrade on the port. This lets the socket share a server
+   * with other upgrade handlers (Vite HMR, a host framework's own sockets)
+   * and is what the SPA's `__connection.json` points at. When omitted, the WS
+   * server handles every upgrade on the port (legacy behaviour).
+   */
+  path?: string;
+  /**
+   * Bind the WS endpoint on its own port instead of sharing the HTTP server's.
+   * The HTTP/SPA server still listens on `port`; the socket gets a dedicated
+   * `ws` server on `wsPort` (same `host`). Use this for the "different port"
+   * connection scenario. Ignored when a `server` is supplied.
+   */
+  wsPort?: number;
+  /**
+   * Mount the WS endpoint onto an existing HTTP server, sharing its port,
+   * rather than creating and listening on a fresh one. Use this to embed
+   * devframe's RPC socket inside a host server (e.g. a Vite dev server) — pair
+   * it with `path` so it coexists with the host's routes. The caller owns the
+   * server's lifecycle: {@link StartedServer.close} detaches devframe's upgrade
+   * listener but leaves the host server running. When set, `host`/`port` are
+   * only used to report the resolved origin.
+   */
+  server?: Server;
   /**
    * When `false`, the RPC server is started without a trust handshake.
    * Intended for single-user localhost tools where an auth round-trip
@@ -41,7 +67,8 @@ interface StartedServer {
   origin: string;
   port: number;
   app: H3;
-  wss: WebSocketServer;
+  /** The crossws node adapter driving the RPC socket (connected peers, pub/sub). */
+  ws: NodeAdapter;
   rpcGroup: BirpcGroup<DevframeRpcClientFunctions, DevframeRpcServerFunctions, false>;
   close: () => Promise<void>;
 }

package/dist/{server-BBaBJaUL.mjs → server-wyY3zh67.mjs}

@@ -1,9 +1,8 @@
 import { createRpcServer } from "./rpc/server.mjs";
 import { attachWsRpcTransport } from "./rpc/transports/ws-server.mjs";
-import { t as getInternalContext } from "./context-DaKmhhHY.mjs";
-import { WebSocketServer } from "ws";
-import { AsyncLocalStorage } from "node:async_hooks";
+import { t as getInternalContext } from "./context-3x_bgBgZ.mjs";
 import { createServer } from "node:http";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { H3, toNodeHandler } from "h3";
 //#region src/node/server.ts
 /**
@@ -15,8 +14,8 @@ async function startHttpAndWs(options) {
 	const { context, port } = options;
 	const bindHost = options.host ?? "localhost";
 	const app = options.app ?? new H3();
-	const httpServer = createServer(toNodeHandler(app));
-	const wss = new WebSocketServer({ server: httpServer });
+	const ownsHttpServer = !options.server;
+	const httpServer = options.server ?? createServer(toNodeHandler(app));
 	const rpcHost = context.rpc;
 	const asyncStorage = new AsyncLocalStorage();
 	const rpcGroup = createRpcServer(rpcHost.functions, { rpcOptions: { resolver(name, fn) {
@@ -31,9 +30,15 @@ async function startHttpAndWs(options) {
 			});
 		};
 	} } });
-	attachWsRpcTransport(rpcGroup, {
-		wss,
-		onDisconnected: (_ws, meta) => {
+	const separateWsPort = ownsHttpServer && options.wsPort != null && options.wsPort !== port ? options.wsPort : void 0;
+	const { ws, close: closeWs } = attachWsRpcTransport(rpcGroup, {
+		...separateWsPort != null ? {
+			port: separateWsPort,
+			host: bindHost
+		} : { server: httpServer },
+		path: options.path,
+		destroyUnmatched: ownsHttpServer,
+		onDisconnected: (_peer, meta) => {
 			rpcHost._emitSessionDisconnected(meta);
 		}
 	});
@@ -49,14 +54,14 @@ async function startHttpAndWs(options) {
 			return { isTrusted: true };
 		}
 	});
-	await new Promise((resolveListen) => {
+	if (ownsHttpServer) await new Promise((resolveListen) => {
 		httpServer.listen(port, bindHost, () => resolveListen());
 	});
 	const address = httpServer.address();
 	const resolvedPort = typeof address === "object" && address ? address.port : port;
 	const origin = `http://${bindHost}:${resolvedPort}`;
 	const internal = getInternalContext(context);
-	const wsUrl = origin.replace(/^http/, "ws");
+	const wsUrl = `ws://${bindHost}:${separateWsPort ?? resolvedPort}${options.path ?? ""}`;
 	internal.wsEndpoint = { url: wsUrl };
 	if (options.onReady) await options.onReady({
 		origin,
@@ -67,12 +72,11 @@ async function startHttpAndWs(options) {
 		origin,
 		port: resolvedPort,
 		app,
-		wss,
+		ws,
 		rpcGroup,
 		async close() {
-			for (const ws of wss.clients) ws.terminate();
-			await new Promise((r) => wss.close(() => r()));
-			await new Promise((r) => httpServer.close(() => r()));
+			await closeWs();
+			if (ownsHttpServer) await new Promise((r) => httpServer.close(() => r()));
 			if (getInternalContext(context).wsEndpoint?.url === wsUrl) getInternalContext(context).wsEndpoint = void 0;
 		}
 	};

package/dist/{shared-state-u0y123fi.mjs → shared-state-D4PPieA0.mjs}

@@ -836,10 +836,10 @@ function enablePatches() {
 				const parentType = getArchtype(base);
 				let p = path[i];
 				if (typeof p !== "string" && typeof p !== "number") p = "" + p;
-				if ((parentType === 0 || parentType === 1) && (p === "__proto__" || p === CONSTRUCTOR)) die(errorOffset + 3);
-				if (isFunction(base) && p === PROTOTYPE) die(errorOffset + 3);
+				if ((parentType === 0 || parentType === 1) && (p === "__proto__" || p === CONSTRUCTOR)) die(19);
+				if (isFunction(base) && p === PROTOTYPE) die(19);
 				base = get(base, p);
-				if (!isObjectish(base)) die(errorOffset + 2, path.join("/"));
+				if (!isObjectish(base)) die(18, path.join("/"));
 			}
 			const type = getArchtype(base);
 			const value = deepClonePatchValue(patch.value);
@@ -862,7 +862,7 @@ function enablePatches() {
 					case 3: return base.delete(patch.value);
 					default: return delete base[key];
 				}
-				default: die(errorOffset + 1, op);
+				default: die(17, op);
 			}
 		});
 		return draft;

package/dist/{shared-state-BlBNYziY.mjs → storage-l2ezeend.mjs}

@@ -1,5 +1,8 @@
-import { t as devframeReporter } from "./diagnostics-reporter-CBBZwoMv.mjs";
+import { t as devframeReporter } from "./diagnostics-reporter-CsIG85Q5.mjs";
 import { defineDiagnostics } from "nostics";
+import fs from "node:fs";
+import { dirname } from "pathe";
+import { destr } from "destr";
 //#region src/node/diagnostics.ts
 const diagnostics = defineDiagnostics({
 	docsBase: "https://devfra.me/errors",
@@ -39,6 +42,10 @@ const diagnostics = defineDiagnostics({
 		DF0033: {
 			why: (p) => `Failed to start dev RPC bridge for "${p.id}": ${p.reason}`,
 			fix: "Verify the bridge port is free and the devframe setup function does not throw. Pin a port via `cli.port` / `cli.portRange` on the definition, or via `devMiddleware.port` on `viteDevBridge`."
+		},
+		DF0034: {
+			why: (p) => `Scoped RPC registration for namespace "${p.namespace}" received an already-namespaced function name "${p.name}".`,
+			fix: "A scoped context auto-namespaces ids. Pass a bare name without a \":\" separator (e.g. `register({ name: \"get-cwd\" })`), or use the unscoped `ctx.base.rpc.register` for a fully-qualified name."
 		}
 	}
 });
@@ -918,10 +925,10 @@ function enablePatches() {
 				const parentType = getArchtype(base);
 				let p = path[i];
 				if (typeof p !== "string" && typeof p !== "number") p = "" + p;
-				if ((parentType === 0 || parentType === 1) && (p === "__proto__" || p === CONSTRUCTOR)) die(errorOffset + 3);
-				if (isFunction(base) && p === PROTOTYPE) die(errorOffset + 3);
+				if ((parentType === 0 || parentType === 1) && (p === "__proto__" || p === CONSTRUCTOR)) die(19);
+				if (isFunction(base) && p === PROTOTYPE) die(19);
 				base = get(base, p);
-				if (!isObjectish(base)) die(errorOffset + 2, path.join("/"));
+				if (!isObjectish(base)) die(18, path.join("/"));
 			}
 			const type = getArchtype(base);
 			const value = deepClonePatchValue(patch.value);
@@ -944,7 +951,7 @@ function enablePatches() {
 					case 3: return base.delete(patch.value);
 					default: return delete base[key];
 				}
-				default: die(errorOffset + 1, op);
+				default: die(17, op);
 			}
 		});
 		return draft;
@@ -1016,4 +1023,119 @@ function createSharedState(options) {
 	};
 }
 //#endregion
-export { diagnostics as i, nanoid as n, createEventEmitter as r, createSharedState as t };
+//#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+//#endregion
+//#region src/node/storage.ts
+function createStorage(options) {
+	const { mergeInitialValue = (initialValue, savedValue) => ({
+		...initialValue,
+		...savedValue
+	}), debounce: debounceTime = 100 } = options;
+	let initialValue = options.initialValue;
+	if (fs.existsSync(options.filepath)) try {
+		const savedValue = destr(fs.readFileSync(options.filepath, "utf-8"), { strict: true });
+		initialValue = mergeInitialValue ? mergeInitialValue(options.initialValue, savedValue) : savedValue;
+	} catch (error) {
+		diagnostics.DF0012({
+			filepath: options.filepath,
+			cause: error
+		}, { method: "warn" });
+		initialValue = options.initialValue;
+	}
+	const state = createSharedState({
+		initialValue,
+		enablePatches: false
+	});
+	state.on("updated", debounce((newState) => {
+		fs.mkdirSync(dirname(options.filepath), { recursive: true });
+		fs.writeFileSync(options.filepath, `${JSON.stringify(newState, null, 2)}\n`);
+	}, debounceTime));
+	return state;
+}
+//#endregion
+export { diagnostics as a, createEventEmitter as i, createSharedState as n, nanoid as r, createStorage as t };

package/dist/types/index.d.mts

@@ -1,4 +1,4 @@
-import { $ as AgentResource, B as EntriesToObject, G as DevframeRpcSharedStates, H as Thenable, J as DevframeDiagnosticsDefinition, K as DevframeHost, Q as AgentManifest, U as DevframeRpcClientFunctions, V as PartialWithoutId, W as DevframeRpcServerFunctions, X as DevframeDiagnosticsLogger, Y as DevframeDiagnosticsHost, Z as AgentHandle, _ as RpcStreamingChannel, a as DevframeRuntime, at as DevframeAgentHostEvents, c as defineDevframe, ct as EventsMap, d as DevframeNodeContext, et as AgentResourceContent, f as DevframeNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, it as DevframeAgentHost, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, nt as AgentTool, o as DevframeSetupInfo, ot as EventEmitter, p as RpcBroadcastOptions, q as DevframeDefineDiagnosticsOptions, r as DevframeDefinition, rt as AgentToolInput, s as DevframeSpaOptions, st as EventUnsubscribe, t as DevframeBrowserContext, tt as AgentResourceInput, u as DevframeCapabilities, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevframeViewHost } from "../devframe-BuR6n9ZD.mjs";
-import { h as RpcFunctionAgentOptions } from "../types-BkkQ0Txg.mjs";
-import { t as DevframeNodeRpcSessionMeta } from "../ws-server-C1LjmRnp.mjs";
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevframeAgentHost, DevframeAgentHostEvents, DevframeBrowserContext, DevframeCapabilities, DevframeCliOptions, DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsDefinition, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, DevframeRpcServerFunctions, DevframeRpcSharedStates, DevframeRuntime, DevframeSetupInfo, DevframeSpaOptions, DevframeViewHost, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevframe };
+import { $ as ScopedServerFunctions, G as DevframeScopedNodeContext, H as EntriesToObject, J as DevframeSettings, K as DevframeScopedNodeRpc, Q as ScopedClientFunctions, S as RpcStreamingHost, St as EventsMap, U as PartialWithoutId, W as Thenable, X as DevframeSettingsStore, Y as DevframeSettingsRegistry, Z as ScopedBroadcastOptions, _ as RpcFunctionsHost, _t as AgentToolInput, a as DevframeDuplicationStrategy, at as DevframeRpcSharedStates, b as RpcStreamingChannel, bt as EventEmitter, c as DevframeSpaOptions, ct as DevframeDiagnosticsDefinition, d as ConnectionMeta, dt as AgentHandle, et as ScopedSharedStates, f as ConnectionMetaWebsocket, ft as AgentManifest, g as RpcBroadcastOptions, gt as AgentTool, h as DevframeNodeRpcSession, ht as AgentResourceInput, i as DevframeDeploymentKind, it as DevframeRpcServerFunctions, l as DevframeWsOptions, lt as DevframeDiagnosticsHost, m as DevframeNodeContext, mt as AgentResourceContent, n as DevframeCliOptions, nt as DevframeViewHost, o as DevframeRuntime, ot as DevframeHost, p as DevframeCapabilities, pt as AgentResource, q as DevframeScopedStreamingHost, r as DevframeDefinition, rt as DevframeRpcClientFunctions, s as DevframeSetupInfo, st as DevframeDefineDiagnosticsOptions, t as DevframeBrowserContext, tt as SettingsForNamespace, u as defineDevframe, ut as DevframeDiagnosticsLogger, v as RpcSharedStateGetOptions, vt as DevframeAgentHost, x as RpcStreamingChannelOptions, xt as EventUnsubscribe, y as RpcSharedStateHost, yt as DevframeAgentHostEvents } from "../devframe-BwfavB78.mjs";
+import { g as RpcFunctionAgentOptions } from "../types-DZEx4ffs.mjs";
+import { t as DevframeNodeRpcSessionMeta } from "../ws-server-BVVMDo2n.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, ConnectionMetaWebsocket, DevframeAgentHost, DevframeAgentHostEvents, DevframeBrowserContext, DevframeCapabilities, DevframeCliOptions, DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsDefinition, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, DevframeRpcServerFunctions, DevframeRpcSharedStates, DevframeRuntime, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSpaOptions, DevframeViewHost, DevframeWsOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, Thenable, defineDevframe };

package/dist/{types-BkkQ0Txg.d.mts → types-DZEx4ffs.d.mts}

@@ -282,8 +282,16 @@ type RpcFunctionDefinitionToFunction<T extends RpcFunctionDefinitionAny> = T ext
 type RpcFunctionDefinitionAny = RpcFunctionDefinition<string, any, any, any, any, any, any>;
 type RpcFunctionDefinitionAnyWithContext<CONTEXT = undefined> = RpcFunctionDefinition<string, any, any, any, any, any, CONTEXT>;
 type RpcDefinitionsToFunctions<T extends readonly RpcFunctionDefinitionAny[]> = EntriesToObject<{ [K in keyof T]: [T[K]['name'], RpcFunctionDefinitionToFunction<T[K]>] }>;
+/**
+ * Like {@link RpcDefinitionsToFunctions}, but prefixes every (bare)
+ * definition name with `<NS>:`. Use this when functions are defined with
+ * bare names and registered through a scoped context
+ * (`ctx.scope(NS).rpc.register(...)`), so the augmented registry keys
+ * match the namespaced ids stored at runtime.
+ */
+type RpcDefinitionsToFunctionsWithNamespace<NS extends string, T extends readonly RpcFunctionDefinitionAny[]> = EntriesToObject<{ [K in keyof T]: [`${NS}:${T[K]['name'] & string}`, RpcFunctionDefinitionToFunction<T[K]>] }>;
 type RpcDefinitionsFilter<T extends readonly RpcFunctionDefinitionAny[], Type extends RpcFunctionType> = { [K in keyof T]: T[K] extends {
   type: Type;
 } ? T[K] : never };
 //#endregion
-export { RpcFunctionsCollector as C, RpcFunctionType as S, Thenable as T, RpcFunctionDefinitionAny as _, RpcDefinitionsFilter as a, RpcFunctionDefinitionToFunction as b, RpcDumpClientOptions as c, RpcDumpGetter as d, RpcDumpRecord as f, RpcFunctionDefinition as g, RpcFunctionAgentOptions as h, RpcArgsSchema as i, RpcDumpCollectionOptions as l, RpcDumpStore as m, BirpcReturn$1 as n, RpcDefinitionsToFunctions as o, RpcDumpRecordError as p, EntriesToObject as r, RpcDump as s, BirpcFn as t, RpcDumpDefinition as u, RpcFunctionDefinitionAnyWithContext as v, RpcReturnSchema as w, RpcFunctionSetupResult as x, RpcFunctionDefinitionBase as y };
+export { RpcFunctionType as C, Thenable as E, RpcFunctionSetupResult as S, RpcReturnSchema as T, RpcFunctionDefinition as _, RpcDefinitionsFilter as a, RpcFunctionDefinitionBase as b, RpcDump as c, RpcDumpDefinition as d, RpcDumpGetter as f, RpcFunctionAgentOptions as g, RpcDumpStore as h, RpcArgsSchema as i, RpcDumpClientOptions as l, RpcDumpRecordError as m, BirpcReturn$1 as n, RpcDefinitionsToFunctions as o, RpcDumpRecord as p, EntriesToObject as r, RpcDefinitionsToFunctionsWithNamespace as s, BirpcFn as t, RpcDumpCollectionOptions as u, RpcFunctionDefinitionAny as v, RpcFunctionsCollector as w, RpcFunctionDefinitionToFunction as x, RpcFunctionDefinitionAnyWithContext as y };

package/dist/utils/crypto-token.d.mts

@@ -0,0 +1,24 @@
+//#region src/utils/crypto-token.d.ts
+/**
+ * Generate a high-entropy, URL-safe (hex) random token suitable for use as a
+ * bearer credential — e.g. the persistent client auth token or an ephemeral
+ * remote-dock token. Defaults to 16 bytes (128 bits) of entropy.
+ */
+declare function randomToken(byteLength?: number): string;
+/**
+ * Generate a uniformly-distributed string of decimal digits using rejection
+ * sampling to avoid modulo bias. Intended for short, human-typed one-time
+ * codes (e.g. a 6-digit authentication code). Leading zeros are preserved.
+ */
+declare function randomDigits(length: number): string;
+/**
+ * Constant-time string equality. Compares every character so the comparison
+ * time does not depend on the position of the first mismatch, mitigating
+ * timing side-channels when verifying secrets.
+ *
+ * Length is treated as public (it short-circuits on differing lengths), which
+ * is appropriate for fixed-length codes and tokens.
+ */
+declare function timingSafeEqual(a: string, b: string): boolean;
+//#endregion
+export { randomDigits, randomToken, timingSafeEqual };