devframe 0.8.2 → 0.9.0-beta.1

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

@@ -1,235 +1,2 @@
-import "../../constants.mjs";
-import { n as strictJsonStringify } from "../../serialization-C8Mnw9hK.mjs";
-import { n as structuredCloneStringify, t as structuredCloneParse } from "../../structured-clone-CbAV5rFI.mjs";
-import { n as randomToken, r as timingSafeEqual } from "../../crypto-token-XCqTSMg9.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]);
-		}
-	};
-}
-let sessionId = 0;
-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 isLoopbackHostname(hostname) {
-	const h = hostname.replace(/^\[|\]$/g, "");
-	return h === "localhost" || h === "127.0.0.1" || h === "::1" || h.endsWith(".localhost") || h.startsWith("127.");
-}
-/**
-* Default origin policy for a localhost dev tool: allow requests with no
-* `Origin` header (native, non-browser clients), allow any loopback origin
-* (so cross-port localhost dev setups keep working), and allow explicitly
-* configured origins. Everything else — a real remote page in the dev's
-* browser — is rejected.
-*/
-function isAllowedOrigin(origin, allowedOrigins) {
-	if (!origin) return true;
-	if (allowedOrigins.includes(origin)) return true;
-	try {
-		return isLoopbackHostname(new URL(origin).hostname);
-	} catch {
-		return false;
-	}
-}
-function isWsOriginRegistry(value) {
-	return !!value && !Array.isArray(value);
-}
-/**
-* 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, allowedOrigins) {
-	const listener = (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);
-	};
-	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, 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, https, allowedOrigins, 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(state.channel);
-				if (index >= 0) channels.splice(index, 1);
-			});
-			onDisconnected(peer, state.meta);
-		}
-	} });
-	let detach = NOOP;
-	let ready = Promise.resolve();
-	let ownedServer;
-	if (server) detach = routeUpgrades(server, ws, path, destroyUnmatched, allowedOrigins);
-	else if (https) {
-		ownedServer = createServer$1(https);
-		detach = routeUpgrades(ownedServer, ws, path, true, allowedOrigins);
-		ready = listen(ownedServer, port ?? 0, host);
-	} else {
-		ownedServer = createServer((_req, res) => {
-			res.writeHead(426, { "content-type": "text/plain" });
-			res.end("Upgrade Required");
-		});
-		detach = routeUpgrades(ownedServer, ws, path, true, allowedOrigins);
-		ready = listen(ownedServer, port ?? 0, host);
-	}
-	const activeServer = server ?? ownedServer;
-	return {
-		ws,
-		ready,
-		address: () => activeServer?.address() ?? null,
-		detach,
-		async close() {
-			detach();
-			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, isAllowedOrigin, isLoopbackHostname };
+import { a as isLoopbackHostname, i as isAllowedOrigin, n as createWsOriginRegistry, r as createWsRpcPeerHooks, t as attachWsRpcTransport } from "../../ws-server-Bk1hOG3X.mjs";
+export { attachWsRpcTransport, createWsOriginRegistry, createWsRpcPeerHooks, isAllowedOrigin, isLoopbackHostname };

package/dist/rpc-core-CGctXToO.d.mts

@@ -0,0 +1,48 @@
+import { $ as DevframeRpcClientFunctions, G as DevframeNodeRpcSession, et as DevframeRpcServerFunctions, p as DevframeAuthHandler, x as DevframeNodeContext } from "./devframe-Bdd9YXTy.mjs";
+import { d as DevframeRpcConnection, u as DevframeNodeRpcSessionMeta } from "./ws-server-Ces08fjP.mjs";
+import "./index-CZRd2K1C.mjs";
+import { BirpcGroup, EventOptions } from "birpc";
+//#region src/node/rpc-core.d.ts
+interface CreateContextRpcServerOptions {
+  context: DevframeNodeContext;
+  /**
+   * Auth intent: `true`/omitted gates by default, `false` opts out (auto-trust
+   * handshake shim), a {@link DevframeAuthHandler} installs a custom scheme.
+   */
+  auth?: boolean | DevframeAuthHandler;
+  /** Lower-level per-call gate by method name and session, without a full handler. */
+  authorize?: (methodName: string, session: DevframeNodeRpcSession) => boolean;
+  /** Called once per new RPC connection, right after its session is created. */
+  onPeerConnect?: (connection: DevframeRpcConnection, session: DevframeNodeRpcSession) => void;
+  /** Called once per closed RPC connection, after the transport's disconnect bookkeeping. */
+  onPeerDisconnect?: (connection: DevframeRpcConnection, meta: DevframeNodeRpcSessionMeta) => void;
+  /** Forwarded verbatim to birpc's `rpcOptions` so a host keeps seeing RPC failures. */
+  rpcOptions?: Pick<EventOptions<DevframeRpcClientFunctions, DevframeRpcServerFunctions, false>, 'onFunctionError' | 'onGeneralError'>;
+}
+interface ContextRpcServer {
+  rpcGroup: BirpcGroup<DevframeRpcClientFunctions, DevframeRpcServerFunctions, false>;
+  /** The resolved auth handler when `auth` was passed as one. */
+  authHandler?: DevframeAuthHandler;
+  /**
+   * Connection lifecycle handlers to wire into a transport binding
+   * (`attachWsRpcTransport`'s `onConnected` / `onDisconnected`, or any other
+   * crossws adapter's peer hooks via `createWsRpcPeerHooks`).
+   */
+  onConnected?: (connection: DevframeRpcConnection, meta: DevframeNodeRpcSessionMeta) => void;
+  onDisconnected: (connection: DevframeRpcConnection, meta: DevframeNodeRpcSessionMeta) => void;
+}
+/**
+ * Bind a devframe context's registered RPC functions to a birpc group,
+ * 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`.
+ *
+ * Owns everything about serving RPC that is independent of *how* peers
+ * connect: the auth handler's function registration, the
+ * `AsyncLocalStorage`-based session resolver (so
+ * `ctx.rpc.getCurrentRpcSession()` works inside handlers), the
+ * `authorize` gate, and the `auth: false` auto-trust handshake shim.
+ */
+declare function createContextRpcServer(options: CreateContextRpcServerOptions): ContextRpcServer;
+//#endregion
+export { CreateContextRpcServerOptions as n, createContextRpcServer as r, ContextRpcServer as t };

package/dist/rpc-core-CqcJkAu9.mjs

@@ -0,0 +1,81 @@
+import { n as __exportAll } from "./rolldown-runtime-JspESFgx.mjs";
+import { createRpcServer } from "./rpc/server.mjs";
+import { t as diagnostics } from "./diagnostics-DLYH5oD3.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
+* HTTP+WS binding (Node http + WS) and the Bun fetch-upgrade tier of
+* `createHandler`.
+*
+* Owns everything about serving RPC that is independent of *how* peers
+* connect: the auth handler's function registration, the
+* `AsyncLocalStorage`-based session resolver (so
+* `ctx.rpc.getCurrentRpcSession()` works inside handlers), the
+* `authorize` gate, and the `auth: false` auto-trust handshake shim.
+*/
+function createContextRpcServer(options) {
+	const { context } = options;
+	const rpcHost = context.rpc;
+	const asyncStorage = new AsyncLocalStorage();
+	const authHandler = typeof options.auth === "object" ? options.auth : void 0;
+	const effectiveAuthorize = options.authorize ?? authHandler?.authorize;
+	if (authHandler) {
+		for (const fn of authHandler.rpcFunctions) if (!rpcHost.definitions.has(fn.name)) rpcHost.register(fn);
+	}
+	const rpcGroup = createRpcServer(rpcHost.functions, { rpcOptions: {
+		onFunctionError: options.rpcOptions?.onFunctionError,
+		onGeneralError: options.rpcOptions?.onGeneralError,
+		resolver(name, fn) {
+			const rpc = this;
+			if (!fn) return void 0;
+			return async function(...args) {
+				const meta = rpc.$meta;
+				if (effectiveAuthorize && !effectiveAuthorize(name, {
+					meta,
+					rpc
+				})) throw diagnostics.DF0036({ name });
+				return await asyncStorage.run({
+					rpc,
+					meta
+				}, async () => {
+					return (await fn).apply(this, args);
+				});
+			};
+		}
+	} });
+	rpcHost._rpcGroup = rpcGroup;
+	rpcHost._asyncStorage = asyncStorage;
+	rpcHost._authDisabled = options.auth === false;
+	if (options.auth === false && !rpcHost.definitions.has("anonymous:devframe:auth")) rpcHost.register({
+		name: "anonymous:devframe:auth",
+		type: "action",
+		handler: () => {
+			const session = rpcHost.getCurrentRpcSession();
+			if (session) session.meta.isTrusted = true;
+			return { isTrusted: true };
+		}
+	});
+	const onConnected = authHandler || options.onPeerConnect ? (connection, meta) => {
+		const session = {
+			meta,
+			rpc: rpcGroup.clients.find((client) => client.$meta === meta)
+		};
+		authHandler?.onConnect(connection, session);
+		options.onPeerConnect?.(connection, session);
+	} : void 0;
+	const onDisconnected = (connection, meta) => {
+		options.onPeerDisconnect?.(connection, meta);
+		rpcHost._emitSessionDisconnected(meta);
+	};
+	return {
+		rpcGroup,
+		authHandler,
+		onConnected,
+		onDisconnected
+	};
+}
+//#endregion
+export { rpc_core_exports as n, createContextRpcServer as t };

package/dist/{serialization-C8Mnw9hK.mjs → serialization-BHY8M5NQ.mjs}

@@ -1,7 +1,7 @@
 import { t as diagnostics } from "./diagnostics-hwjXp_UV.mjs";
 //#region src/rpc/serialization.ts
 /**
-* Wire format used by the WS RPC transport.
+* Wire format used by the live RPC transports (WebSocket and SSE).
 *
 * - **JSON (default, unprefixed):** payload is plain JSON text. Used when
 *   the dispatched method is declared `jsonSerializable: true`. Encoded

package/dist/{shared-state-6kHolYZy.mjs → shared-state-fRRbRUtD.mjs}

@@ -1,6 +1,6 @@
 import { createEventEmitter } from "./utils/events.mjs";
 import { nanoid } from "./utils/nanoid.mjs";
-//#region ../../node_modules/.pnpm/immer@11.1.15/node_modules/immer/dist/immer.mjs
+//#region ../../node_modules/.pnpm/immer@11.1.16/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");

package/dist/sse-client-BsIK3hMD.d.mts

@@ -0,0 +1,37 @@
+import { v as RpcFunctionDefinitionAny } from "./types-CnJSgRVa.mjs";
+import { ChannelOptions } from "birpc";
+//#region src/rpc/transports/sse-client.d.ts
+interface SseRpcChannelOptions {
+  /** Resolved `http(s)://` URL of the SSE endpoint. */
+  url: string;
+  onConnected?: () => void;
+  onError?: (e: Error) => void;
+  onDisconnected?: () => void;
+  authToken?: string;
+  /**
+   * RPC function definitions (or just the `jsonSerializable` flag per
+   * method) used to dispatch the per-call wire serializer — same contract
+   * as the WS channel.
+   */
+  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
+  /** Fetch implementation. Default: `globalThis.fetch`. */
+  fetch?: typeof globalThis.fetch;
+}
+/**
+ * Build a birpc `ChannelOptions` object backed by an SSE stream (server →
+ * client) and HTTP `POST` (client → server) — the WebSocket-free counterpart
+ * to `createWsRpcChannel`, wire-compatible with `attachSseRpcTransport`.
+ *
+ * The stream is consumed via `fetch` streaming (not `EventSource`), so it
+ * works in browsers and server runtimes alike. The server's first frame
+ * (`event: session`) carries the session id; every `POST` echoes it in the
+ * `x-birpc-session` header. A response to a client-initiated request comes
+ * back in the `POST`'s own body and is re-injected into the channel; a
+ * dropped stream terminates the channel — there is no reconnect, matching
+ * the WS channel's closed-is-done semantics.
+ */
+declare function createSseRpcChannel(options: SseRpcChannelOptions): ChannelOptions & {
+  close: () => void;
+};
+//#endregion
+export { createSseRpcChannel as n, SseRpcChannelOptions as t };