devframe 0.9.8 → 0.9.10

package/dist/utils/simple-schema.d.mts

@@ -8,10 +8,10 @@ import { StandardSchemaV1 } from "@standard-schema/spec";
  * best-effort validator that exists only so devframe's own first-party
  * packages (recipes, built-in plugins) can declare `args`/`returns`/flag
  * schemas without taking on a validator dependency. It implements a small
- * subset of primitives and approximates refinements — it is not a
+ * subset of primitives and approximates refinements; it is not a
  * general-purpose validator.
  *
- * For your own code, prefer a real Standard Schema validator — **valibot**,
+ * For your own code, prefer a real Standard Schema validator: **valibot**,
  * **zod**, or **arktype**. Devframe's RPC and CLI-flag layers accept any of
  * them; install the one you like and use it directly:
  *
@@ -46,7 +46,7 @@ declare function string(): SimpleSchema<string>;
 declare function number(): SimpleSchema<number>;
 /** A boolean. */
 declare function boolean(): SimpleSchema<boolean>;
-/** `undefined` — mirrors valibot's `void`. */
+/** `undefined`, mirroring valibot's `void`. */
 declare function voidType(): SimpleSchema<void>;
 /** `null`. */
 declare function nullType(): SimpleSchema<null>;
@@ -64,7 +64,7 @@ declare function array<T extends StandardSchemaV1>(item: T): SimpleSchema<Standa
 type Prettify<T> = { [K in keyof T]: T[K]; } & {};
 /**
  * Map a shape to its object type, turning fields whose type includes
- * `undefined` (i.e. `optional()`) into optional keys — mirroring how
+ * `undefined` (i.e. `optional()`) into optional keys, mirroring how
  * valibot/zod render `optional` object entries.
  */
 type InferField<T extends StandardSchemaV1, Mode extends 'input' | 'output'> = Mode extends 'input' ? StandardSchemaV1.InferInput<T> : StandardSchemaV1.InferOutput<T>;
@@ -78,7 +78,7 @@ declare function nullable<T extends StandardSchemaV1>(inner: T): SimpleSchema<St
 /** Attach a human-readable description (used for CLI option help). */
 declare function describe<T extends SimpleSchema<any, any>>(schema: T, description: string): T;
 /**
- * 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.
  */

package/dist/utils/simple-schema.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.
 */

package/dist/utils/streaming-channel.d.mts

@@ -1,2 +1,2 @@
-import { C as createStreamSink, S as createStreamReader, _ as CreateStreamSinkOptions, b as StreamSink, g as CreateStreamReaderOptions, h as BufferedChunk, v as StreamErrorPayload, x as StreamSinkEvents, y as StreamReader } from "../context-CLF4-8Pp.mjs";
+import { C as createStreamSink, S as createStreamReader, _ as CreateStreamSinkOptions, b as StreamSink, g as CreateStreamReaderOptions, h as BufferedChunk, v as StreamErrorPayload, x as StreamSinkEvents, y as StreamReader } from "../context-CHW4BZOj.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

package/dist/utils/streaming-channel.mjs

@@ -6,7 +6,7 @@ var StreamClosedError = class extends Error {
 	name = "StreamClosedError";
 };
 /**
-* Build a server-side stream sink. RPC-agnostic — the RPC host wires
+* Build a server-side stream sink. RPC-agnostic; the RPC host wires
 * `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
 * for late or reconnecting subscribers.
 */
@@ -77,7 +77,7 @@ function createStreamSink(options = {}) {
 	};
 }
 /**
-* Build a client-side stream reader. RPC-agnostic — the RPC host calls
+* Build a client-side stream reader. RPC-agnostic; the RPC host calls
 * `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
 * terminal frame. Consumers iterate with `for await` or pipe `readable`.
 */

package/dist/utils/when.d.mts

@@ -4,13 +4,13 @@ import { WhenExpression as WhenExpression$1 } from "whenexpr";
  * Context object for evaluating `when` expressions.
  *
  * Built-in variables:
- * - `clientType` — `'embedded' | 'standalone'`
- * - `dockOpen` — whether the dock panel is open
- * - `paletteOpen` — whether the command palette is open
- * - `dockSelectedId` — ID of the selected dock entry (empty string if none)
+ * - `clientType`: `'embedded' | 'standalone'`
+ * - `dockOpen`: whether the dock panel is open
+ * - `paletteOpen`: whether the command palette is open
+ * - `dockSelectedId`: ID of the selected dock entry (empty string if none)
  *
  * Plugins can add namespaced variables using dot or colon separators:
- * - `vite.mode`, `vite:mode` — stored as `{ 'vite.mode': 'development' }` or nested `{ vite: { mode: 'development' } }`
+ * - `vite.mode`, `vite:mode`: stored as `{ 'vite.mode': 'development' }` or nested `{ vite: { mode: 'development' } }`
  *
  * Supported operators: `!`, `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, `>=`,
  * `&&`, `||`, `+`, `-`, `*`, `/`, `%`. Parentheses, number and string literals

package/dist/{validation-YrZH6atx.mjs → validation-CfV1s0SF.mjs}

@@ -1,4 +1,4 @@
-import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
+import { r as diagnostics } from "./serialization-DFg5sUt6.mjs";
 import { createHash } from "node:crypto";
 //#region ../../node_modules/.pnpm/ohash@2.0.12/node_modules/ohash/dist/_chunks/is-equal.mjs
 function serialize(input) {
@@ -220,7 +220,7 @@ async function validateRpcArgs(name, argsSchema, args) {
 /**
 * Validate a handler's resolved return value against its declared schema.
 * Throws `DF0039` when the value fails the schema, otherwise returns the
-* original value unchanged (guard-only, never rewriting the payload — see
+* original value unchanged (guard-only, never rewriting the payload; see
 * {@link validateRpcArgs}). Passes through when no return schema is set.
 *
 * @internal

package/dist/{wire-codec-0K-o5MYW.mjs → wire-codec-BHGt0sSs.mjs}

@@ -1,4 +1,4 @@
-import { n as strictJsonStringify } from "./serialization-BGzEwAdr.mjs";
+import { n as strictJsonStringify } from "./serialization-DFg5sUt6.mjs";
 import { n as structuredCloneStringify, t as structuredCloneParse } from "./structured-clone-CbAV5rFI.mjs";
 //#region src/rpc/wire-codec.ts
 const EMPTY_WIRE_DEFS = /* @__PURE__ */ new Map();
@@ -8,7 +8,7 @@ const EMPTY_WIRE_DEFS = /* @__PURE__ */ new Map();
 * JSON (methods declared `jsonSerializable: true`) and `s:`-prefixed
 * structured-clone (everything else, including all error envelopes), with a
 * request-id → method map so a response independently picks the same
-* encoder as its request. One codec per connection — request-id spaces
+* encoder as its request. One codec per connection; request-id spaces
 * don't collide across connections.
 *
 * @internal
@@ -35,7 +35,7 @@ function createRpcWireCodec(definitions = EMPTY_WIRE_DEFS) {
 }
 /**
 * Peek at a wire frame's birpc envelope without engaging a codec's
-* request-id bookkeeping — used by the SSE transport to route a frame
+* request-id bookkeeping; used by the SSE transport to route a frame
 * (park a POST for its response / answer with a bare 202) before it is
 * handed to birpc proper.
 *

package/dist/{static-DV_qUSRS.mjs → write-BuLCrn9h.mjs}

@@ -1,6 +1,9 @@
-import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-YrZH6atx.mjs";
-import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
-import { DEVFRAME_RPC_DUMP_DIRNAME } from "./constants.mjs";
+import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-CfV1s0SF.mjs";
+import { n as strictJsonStringify, r as diagnostics } from "./serialization-DFg5sUt6.mjs";
+import { DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME } from "./constants.mjs";
+import { n as structuredCloneStringify } from "./structured-clone-CbAV5rFI.mjs";
+import fs from "node:fs/promises";
+import { dirname, resolve } from "pathe";
 //#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {
 	value;
@@ -156,9 +159,9 @@ function serializeWithSeen(error, seen) {
 	};
 	const cause = error.cause;
 	if (cause !== void 0) out.cause = cause instanceof Error ? serializeWithSeen(cause, seen) : cause;
-	for (const key of Object.keys(error)) {
+	for (const [key, value] of Object.entries(error)) {
 		if (key === "name" || key === "message" || key === "cause") continue;
-		out[key] = error[key];
+		out[key] = value;
 	}
 	return out;
 }
@@ -168,13 +171,11 @@ function serializeWithSeen(error, seen) {
 * the original `name`, and re-attaches any custom own properties.
 */
 function reviveDumpError(stored) {
-	const cause = stored.cause instanceof Error ? stored.cause : isPlainErrorShape(stored.cause) ? reviveDumpError(stored.cause) : stored.cause;
-	const error = cause !== void 0 ? new Error(stored.message, { cause }) : new Error(stored.message);
-	error.name = stored.name;
-	for (const key of Object.keys(stored)) {
-		if (key === "name" || key === "message" || key === "cause") continue;
-		error[key] = stored[key];
-	}
+	const { name, message, cause: rawCause, ...extras } = stored;
+	const cause = rawCause instanceof Error ? rawCause : isPlainErrorShape(rawCause) ? reviveDumpError(rawCause) : rawCause;
+	const error = cause !== void 0 ? new Error(message, { cause }) : new Error(message);
+	error.name = name;
+	Object.assign(error, extras);
 	return error;
 }
 function isPlainErrorShape(value) {
@@ -191,15 +192,77 @@ function getDumpFallbackKey(functionName) {
 async function resolveGetter(valueOrGetter) {
 	return typeof valueOrGetter === "function" ? await valueOrGetter() : valueOrGetter;
 }
+/** Run tasks sequentially (`concurrency <= 1`) or through a `p-limit` pool. */
+async function runDumpTasks(tasks, concurrency) {
+	if (concurrency <= 1) {
+		const out = [];
+		for (const task of tasks) out.push(await task());
+		return out;
+	}
+	const limit = pLimit(concurrency);
+	return Promise.all(tasks.map((task) => limit(task)));
+}
 /**
-* Collects pre-computed dumps by executing functions with their defined input combinations.
-* Static functions without dump config automatically get `{ inputs: [[]] }`.
-*
-* @example
-* ```ts
-* const store = await dumpFunctions([greet], context, { concurrency: 10 })
-* ```
+* Resolve one definition's handler + dump config and register it in the store.
+* Returns `undefined` for definitions that carry no dump.
+*/
+async function resolveDumpTask(definition, context, store) {
+	if (definition.type === "event" || definition.type === "action") return void 0;
+	const setupResult = definition.setup ? await Promise.resolve(definition.setup(context)) : {};
+	const handler = setupResult.handler || definition.handler;
+	if (!handler) throw diagnostics.DF0024({ name: definition.name });
+	let dump = setupResult.dump ?? definition.dump;
+	if (!dump && definition.type === "static") dump = { inputs: [[]] };
+	if (!dump && definition.snapshot) dump = async (_ctx, h) => {
+		const output = await Promise.resolve(h());
+		return {
+			records: [{
+				inputs: [],
+				output
+			}],
+			fallback: output
+		};
+	};
+	if (!dump) return void 0;
+	if (typeof dump === "function") dump = await Promise.resolve(dump(context, handler));
+	store.definitions[definition.name] = {
+		name: definition.name,
+		type: definition.type
+	};
+	return {
+		handler,
+		dump,
+		definition
+	};
+}
+/**
+* Write a resolved dump's pre-defined records and fallback into the store, and
+* return the per-input execution tasks that fill in the rest.
 */
+function collectDumpTasks(resolution, store) {
+	const { definition, handler, dump } = resolution;
+	const { inputs, records, fallback } = dump;
+	if (records) for (const record of records) store.records[getDumpRecordKey(definition.name, record.inputs)] = record;
+	if ("fallback" in dump) store.records[getDumpFallbackKey(definition.name)] = {
+		inputs: [],
+		output: fallback
+	};
+	if (!inputs) return [];
+	return inputs.map((input) => async () => {
+		const recordKey = getDumpRecordKey(definition.name, input);
+		try {
+			store.records[recordKey] = {
+				inputs: input,
+				output: await Promise.resolve(handler(...input))
+			};
+		} catch (error) {
+			store.records[recordKey] = {
+				inputs: input,
+				error: serializeDumpError(error)
+			};
+		}
+	});
+}
 async function dumpFunctions(definitions, context, options = {}) {
 	validateDefinitions(definitions);
 	const concurrency = options.concurrency === true ? 5 : options.concurrency === false || options.concurrency == null ? 1 : options.concurrency;
@@ -207,79 +270,7 @@ async function dumpFunctions(definitions, context, options = {}) {
 		definitions: {},
 		records: {}
 	};
-	const tasksResolutions = definitions.map((definition) => async () => {
-		if (definition.type === "event" || definition.type === "action") return;
-		const setupResult = definition.setup ? await Promise.resolve(definition.setup(context)) : {};
-		const handler = setupResult.handler || definition.handler;
-		if (!handler) throw diagnostics.DF0024({ name: definition.name });
-		let dump = setupResult.dump ?? definition.dump;
-		if (!dump && definition.type === "static") dump = { inputs: [[]] };
-		if (!dump && definition.snapshot) dump = async (_ctx, h) => {
-			const output = await Promise.resolve(h(...[]));
-			return {
-				records: [{
-					inputs: [],
-					output
-				}],
-				fallback: output
-			};
-		};
-		if (!dump) return;
-		if (typeof dump === "function") dump = await Promise.resolve(dump(context, handler));
-		store.definitions[definition.name] = {
-			name: definition.name,
-			type: definition.type
-		};
-		return {
-			handler,
-			dump,
-			definition
-		};
-	});
-	let functionsToDump = [];
-	if (concurrency <= 1) for (const task of tasksResolutions) {
-		const resolution = await task();
-		if (resolution) functionsToDump.push(resolution);
-	}
-	else {
-		const limit = pLimit(concurrency);
-		functionsToDump = (await Promise.all(tasksResolutions.map((task) => limit(task)))).filter((x) => !!x);
-	}
-	const dumpTasks = [];
-	for (const { definition, handler, dump } of functionsToDump) {
-		const { inputs, records, fallback } = dump;
-		if (records) for (const record of records) {
-			const recordKey = getDumpRecordKey(definition.name, record.inputs);
-			store.records[recordKey] = record;
-		}
-		if ("fallback" in dump) {
-			const fallbackKey = getDumpFallbackKey(definition.name);
-			store.records[fallbackKey] = {
-				inputs: [],
-				output: fallback
-			};
-		}
-		if (inputs) for (const input of inputs) dumpTasks.push(async () => {
-			const recordKey = getDumpRecordKey(definition.name, input);
-			try {
-				const output = await Promise.resolve(handler(...input));
-				store.records[recordKey] = {
-					inputs: input,
-					output
-				};
-			} catch (error) {
-				store.records[recordKey] = {
-					inputs: input,
-					error: serializeDumpError(error)
-				};
-			}
-		});
-	}
-	if (concurrency <= 1) for (const task of dumpTasks) await task();
-	else {
-		const limit = pLimit(concurrency);
-		await Promise.all(dumpTasks.map((task) => limit(task)));
-	}
+	await runDumpTasks((await runDumpTasks(definitions.map((definition) => () => resolveDumpTask(definition, context, store)), concurrency)).filter((x) => !!x).flatMap((resolution) => collectDumpTasks(resolution, store)), concurrency);
 	return store;
 }
 /**
@@ -359,6 +350,54 @@ function makeQueryFallbackPath(name) {
 async function resolveRecord(record) {
 	return typeof record === "function" ? await record() : record;
 }
+async function collectStaticDefinition(definition, context, serialization, files) {
+	const handler = await getRpcHandler(definition, context);
+	const path = makeStaticPath(definition.name);
+	files[path] = {
+		serialization,
+		fnName: definition.name,
+		data: { output: await Promise.resolve(handler()) }
+	};
+	return {
+		type: "static",
+		path,
+		serialization
+	};
+}
+async function collectQueryDefinition(definition, context, serialization, files) {
+	const store = await dumpFunctions([definition], context);
+	if (!(definition.name in store.definitions)) return void 0;
+	const queryEntry = {
+		type: "query",
+		records: {},
+		serialization
+	};
+	const prefix = `${definition.name}---`;
+	for (const [recordKey, recordOrGetter] of Object.entries(store.records)) {
+		if (!recordKey.startsWith(prefix)) continue;
+		const key = recordKey.slice(prefix.length);
+		const record = await resolveRecord(recordOrGetter);
+		if (key === "fallback") {
+			const path = makeQueryFallbackPath(definition.name);
+			files[path] = {
+				serialization,
+				fnName: definition.name,
+				data: record
+			};
+			queryEntry.fallback = path;
+		} else {
+			const path = makeQueryRecordPath(definition.name, key);
+			files[path] = {
+				serialization,
+				fnName: definition.name,
+				data: record
+			};
+			queryEntry.records[key] = path;
+		}
+	}
+	if (!Object.keys(queryEntry.records).length && !queryEntry.fallback) return void 0;
+	return queryEntry;
+}
 async function collectStaticRpcDump(definitions, context) {
 	const manifest = {};
 	const files = {};
@@ -366,53 +405,12 @@ async function collectStaticRpcDump(definitions, context) {
 		const type = definition.type ?? "query";
 		const serialization = definition.jsonSerializable === true ? "json" : "structured-clone";
 		if (type === "static") {
-			const handler = await getRpcHandler(definition, context);
-			const path = makeStaticPath(definition.name);
-			files[path] = {
-				serialization,
-				fnName: definition.name,
-				data: { output: await Promise.resolve(handler()) }
-			};
-			manifest[definition.name] = {
-				type: "static",
-				path,
-				serialization
-			};
+			manifest[definition.name] = await collectStaticDefinition(definition, context, serialization, files);
 			continue;
 		}
 		if (type !== "query") continue;
-		const store = await dumpFunctions([definition], context);
-		if (!(definition.name in store.definitions)) continue;
-		const queryEntry = {
-			type: "query",
-			records: {},
-			serialization
-		};
-		const prefix = `${definition.name}---`;
-		for (const [recordKey, recordOrGetter] of Object.entries(store.records)) {
-			if (!recordKey.startsWith(prefix)) continue;
-			const key = recordKey.slice(prefix.length);
-			const record = await resolveRecord(recordOrGetter);
-			if (key === "fallback") {
-				const path = makeQueryFallbackPath(definition.name);
-				files[path] = {
-					serialization,
-					fnName: definition.name,
-					data: record
-				};
-				queryEntry.fallback = path;
-			} else {
-				const path = makeQueryRecordPath(definition.name, key);
-				files[path] = {
-					serialization,
-					fnName: definition.name,
-					data: record
-				};
-				queryEntry.records[key] = path;
-			}
-		}
-		if (!Object.keys(queryEntry.records).length && !queryEntry.fallback) continue;
-		manifest[definition.name] = queryEntry;
+		const queryEntry = await collectQueryDefinition(definition, context, serialization, files);
+		if (queryEntry) manifest[definition.name] = queryEntry;
 	}
 	return {
 		manifest,
@@ -420,4 +418,22 @@ async function collectStaticRpcDump(definitions, context) {
 	};
 }
 //#endregion
-export { reviveDumpError as a, getDefinitionsWithDumps as i, createClientFromDump as n, serializeDumpError as o, dumpFunctions as r, collectStaticRpcDump as t };
+//#region src/rpc/dump/write.ts
+/**
+* Write a collected static RPC dump to disk: every sharded record file plus
+* the `__rpc-dump/index.json` manifest, under `outDir`. Shared by the build
+* adapter (`createBuild`) and `@devframes/hub`'s `buildHub`.
+*/
+async function writeStaticRpcDump(dump, outDir, options = {}) {
+	const indent = options.pretty ? 2 : void 0;
+	await fs.mkdir(resolve(outDir, DEVFRAME_RPC_DUMP_DIRNAME), { recursive: true });
+	for (const [filepath, file] of Object.entries(dump.files)) {
+		const fullpath = resolve(outDir, filepath);
+		await fs.mkdir(dirname(fullpath), { recursive: true });
+		const text = file.serialization === "structured-clone" ? structuredCloneStringify(file.data) : strictJsonStringify(file.data, file.fnName);
+		await fs.writeFile(fullpath, file.serialization === "json" && indent != null ? JSON.stringify(JSON.parse(text), null, indent) : text, "utf-8");
+	}
+	await fs.writeFile(resolve(outDir, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME), JSON.stringify(dump.manifest, null, 2), "utf-8");
+}
+//#endregion
+export { getDefinitionsWithDumps as a, dumpFunctions as i, collectStaticRpcDump as n, reviveDumpError as o, createClientFromDump as r, serializeDumpError as s, writeStaticRpcDump as t };

package/dist/{ws-client-7_lZi-B9.d.mts → ws-client-Xpxt0oPA.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-CMdPYhOx.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-Dq4i156u.mjs";
 import { ChannelOptions } from "birpc";
 //#region src/rpc/transports/ws-client.d.ts
 interface WsRpcChannelOptions {
@@ -10,7 +10,7 @@ interface WsRpcChannelOptions {
   /**
    * RPC function definitions (or just the `jsonSerializable` flag per
    * method) used to dispatch the per-call wire serializer. Pass an
-   * empty / partial map on clients that don't have the full registry —
+   * empty / partial map on clients that don't have the full registry;
    * encoding falls back to structured-clone (the safer superset) and
    * decoding still routes correctly via the wire prefix.
    */
@@ -20,7 +20,7 @@ interface WsRpcChannelOptions {
  * 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.
  */
 declare function createWsRpcChannel(options: WsRpcChannelOptions): ChannelOptions & {

package/dist/{ws-server-VyHlanzy.d.mts → ws-server-D2nv68Hg.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-CMdPYhOx.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-Dq4i156u.mjs";
 import { BirpcGroup, ChannelOptions } from "birpc";
 import { Hooks, Peer } from "crossws";
 import { NodeAdapter } from "crossws/adapters/node";
@@ -16,8 +16,8 @@ import { Duplex } from "node:stream";
  */
 type DevframeRpcTransportKind = 'websocket' | 'sse';
 /**
- * Structural view of the connect-time HTTP request behind an RPC connection
- * — the WS upgrade request, or the request opening an SSE stream. Shaped to
+ * Structural view of the connect-time HTTP request behind an RPC connection:
+ * the WS upgrade request, or the request opening an SSE stream. Shaped to
  * match both the web `Request` a crossws peer exposes and a plain
  * `node:http` request wrapper, so auth hooks can read the bearer-token
  * query param and the `Origin` header without caring which transport (or
@@ -38,7 +38,7 @@ interface DevframeRpcConnectionRequest {
  * (`onPeerConnect` / `onPeerDisconnect`, {@link DevframeAuthHandler.onConnect}).
  */
 interface DevframeRpcConnection {
-  /** Session id — the same value as the session meta's `id`. */
+  /** Session id, the same value as the session meta's `id`. */
   id: number;
   /** The transport carrying this connection. */
   transport: DevframeRpcTransportKind;
@@ -49,7 +49,7 @@ interface DevframeRpcConnection {
   /** Terminate the connection from the server side. */
   close?: (code?: number, reason?: string) => void;
   /**
-   * The crossws peer backing a `websocket` connection — the WS-specific
+   * The crossws peer backing a `websocket` connection: the WS-specific
    * escape hatch (pub/sub, raw socket access). Absent on other transports.
    */
   peer?: Peer;
@@ -81,7 +81,7 @@ interface WsRpcTransportOptions {
    * Attach to an existing HTTP(S) server, sharing its port. Combine with
    * `path` to bind the WS endpoint to a single route so it coexists with
    * other upgrade handlers on the same server (e.g. a Vite dev server's HMR
-   * socket). The shared server's lifecycle is owned by the caller — closing
+   * socket). The shared server's lifecycle is owned by the caller; closing
    * this transport detaches the upgrade listener without closing the server.
    */
   server?: Server | Server$1;
@@ -130,7 +130,7 @@ interface WsRpcTransportOptions {
    * dispatch between strict-JSON and structured-clone encoding based
    * on each function's `jsonSerializable` flag.
    *
-   * When omitted, all messages fall back to structured-clone — safe but
+   * When omitted, all messages fall back to structured-clone: safe but
    * loses dev-time validation for `jsonSerializable: true` declarations.
    */
   definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
@@ -164,7 +164,7 @@ interface WsOriginRegistry {
 declare function createWsOriginRegistry(options?: CreateWsOriginRegistryOptions): WsOriginRegistry;
 interface WsRpcTransport {
   /**
-   * The crossws node adapter driving the socket — exposes the connected
+   * The crossws node adapter driving the socket; exposes the connected
    * `peers` and pub/sub. See https://crossws.h3.dev.
    */
   ws: NodeAdapter;
@@ -175,15 +175,15 @@ interface WsRpcTransport {
   /**
    * Complete a `node:http` `upgrade` event on this transport, applying the
    * same `path` filter and origin gate the transport's own listener uses.
-   * Wire it into a host server directly — `server.on('upgrade',
-   * transport.handleUpgrade)` — or call it from an existing listener.
+   * Wire it into a host server directly (`server.on('upgrade',
+   * transport.handleUpgrade)`) or call it from an existing listener.
    */
   handleUpgrade: (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
   /**
    * Route a server's `upgrade` events to this transport, returning a detach
    * function. Use it to bind an `unbound` transport once the host server
    * exists; {@link WsRpcTransport.close} detaches every server attached this
-   * way (without closing them — the caller owns their lifecycle).
+   * way (without closing them, since the caller owns their lifecycle).
    */
   attach: (server: Server | Server$1) => () => void;
   /** Remove the upgrade listener from a shared `server` (a no-op otherwise). */
@@ -195,36 +195,12 @@ interface WsRpcTransport {
    */
   close: () => Promise<void>;
 }
-/**
- * Whether `hostname` names a loopback host: `localhost` (or any `*.localhost`
- * subdomain), the IPv6 loopback `::1`, or an IPv4 literal inside the
- * `127.0.0.0/8` loopback block.
- *
- * The IPv4 case is matched **structurally** — the whole hostname must be a
- * canonical dotted-decimal IPv4 literal whose first octet is `127`. A bare
- * `startsWith('127.')` prefix check would also accept an attacker-controlled
- * DNS name that merely *begins* with `127.` (`127.attacker.example`,
- * `127.0.0.1.attacker.example`), letting a cross-origin browser page defeat
- * the loopback origin gate that guards the RPC/MCP surface (a DNS-rebinding /
- * cross-site WebSocket-hijacking bypass). Requiring a real IPv4 literal keeps
- * genuine loopback addresses (`127.0.0.1`, `127.5.5.5`) allowed while rejecting
- * those DNS names.
- */
-declare function isLoopbackHostname(hostname: string): boolean;
-/**
- * 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.
- */
-declare function isAllowedOrigin(origin: string | undefined, allowedOrigins: readonly string[]): boolean;
 /**
  * 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
+ * identical wire protocol: one birpc channel per peer, per-method
  * `jsonSerializable` dispatch between strict JSON and structured-clone.
  */
 declare function createWsRpcPeerHooks<ClientFunctions extends object, ServerFunctions extends object>(rpcGroup: BirpcGroup<ClientFunctions, ServerFunctions, false>, options?: Pick<WsRpcTransportOptions, 'onConnected' | 'onDisconnected' | 'definitions' | 'serialize' | 'deserialize'>): Partial<Hooks>;
@@ -240,4 +216,4 @@ declare function createWsRpcPeerHooks<ClientFunctions extends object, ServerFunc
  */
 declare function attachWsRpcTransport<ClientFunctions extends object, ServerFunctions extends object>(rpcGroup: BirpcGroup<ClientFunctions, ServerFunctions, false>, options?: WsRpcTransportOptions): WsRpcTransport;
 //#endregion
-export { attachWsRpcTransport as a, isAllowedOrigin as c, DevframeRpcConnection as d, DevframeRpcConnectionRequest as f, WsRpcTransportOptions as i, isLoopbackHostname as l, WsOriginRegistry as n, createWsOriginRegistry as o, DevframeRpcTransportKind as p, WsRpcTransport as r, createWsRpcPeerHooks as s, CreateWsOriginRegistryOptions as t, DevframeNodeRpcSessionMeta as u };
+export { attachWsRpcTransport as a, DevframeNodeRpcSessionMeta as c, DevframeRpcTransportKind as d, WsRpcTransportOptions as i, DevframeRpcConnection as l, WsOriginRegistry as n, createWsOriginRegistry as o, WsRpcTransport as r, createWsRpcPeerHooks as s, CreateWsOriginRegistryOptions as t, DevframeRpcConnectionRequest as u };