devframe 0.9.7 → 0.9.9

package/dist/{events-4daw0uK9.mjs → events-BV4Dj59a.mjs}

@@ -1,8 +1,8 @@
 //#region src/events.ts
 /**
-* Centralized registry of the core devframe event names — the node-side host
+* Centralized registry of the core devframe event names: the node-side host
 * bus events, the client RPC connection events, and the server→client
-* broadcast notifications — so these names live in one place instead of
+* broadcast notifications, so these names live in one place instead of
 * scattered string literals.
 *
 * **Keep this in sync with [`docs/content/8.references/3.events.md`](../../../docs/content/8.references/3.events.md)**

package/dist/{host-h3-fRbF9yor.mjs → host-h3-BJ4siyz7.mjs}

@@ -3,7 +3,7 @@ import { join } from "pathe";
 import { homedir } from "node:os";
 //#region src/node/host-h3.ts
 /**
-* h3-backed {@link DevframeHost} — used by the standalone CLI adapter.
+* h3-backed {@link DevframeHost}, used by the standalone CLI adapter.
 */
 function createH3DevframeHost(options) {
 	const workspaceRoot = options.workspaceRoot ?? process.cwd();

package/dist/in-page-channel/index.d.mts

@@ -1,11 +1,11 @@
-import { D as InferArgsType, E as Thenable, O as InferReturnType, T as RpcReturnSchema, i as RpcArgsSchema } from "../types-CMdPYhOx.mjs";
-import { k as SharedState, zt as EventEmitter } from "../context-BhBzOXVa.mjs";
+import { D as InferArgsType, E as Thenable, O as InferReturnType, T as RpcReturnSchema, i as RpcArgsSchema } from "../types-Dq4i156u.mjs";
+import { Bt as EventEmitter, k as SharedState } from "../context-4AIVRLYF.mjs";
 import { BirpcReturn } from "birpc";
 //#region src/in-page-channel/types.d.ts
 /**
  * The shared contract of one in-page channel, declared once (usually in a
  * `shared/protocol.ts` both sides import) and passed to both endpoints as a
- * type parameter. Purely a type — the only runtime companion is the
+ * type parameter. Purely a type; the only runtime companion is the
  * channel-name constant declared next to it.
  */
 interface InPageChannelProtocol {
@@ -27,13 +27,19 @@ type SharedStates<P extends InPageChannelProtocol> = P['sharedStates'] extends R
 type FnArgs<F> = F extends ((...args: infer A) => any) ? A : never;
 type FnReturn<F> = F extends ((...args: any[]) => infer R) ? Awaited<R> : never;
 /**
- * Types of an in-page channel function — `RpcFunctionType` minus the
+ * Converts a protocol function to its accepted endpoint handler.
+ *
+ * @internal
+ */
+type ProtocolHandler<F> = F extends ((...args: any[]) => any) ? (...args: FnArgs<F>) => Thenable<FnReturn<F>> : never;
+/**
+ * Types of an in-page channel function: `RpcFunctionType` minus the
  * server-only `static`: `event` is fire-and-forget (the only type valid for
  * fan-out), `action` performs, `query` requests data (the default).
  */
 type InPageFunctionType = 'action' | 'event' | 'query';
 /**
- * An in-page channel function definition — the `defineRpcFunction` authoring
+ * An in-page channel function definition: the `defineRpcFunction` authoring
  * shape (`name`, `type`, Standard-Schema `args`/`returns`,
  * `jsonSerializable`, `handler`) narrowed to the browser: there is no
  * `dump`/`snapshot`/`cacheable`/`agent`. When `jsonSerializable` is `true`,
@@ -58,22 +64,49 @@ type InPageFunctionDefinition<NAME extends string, TYPE extends InPageFunctionTy
   jsonSerializable?: boolean;
   handler: (...args: InferArgsType<AS>) => Thenable<InferReturnType<RS>>;
 };
-/** Loosely-typed definition — the registration unit both endpoints accept. */
-type InPageFunctionDefinitionAny = InPageFunctionDefinition<string, any, any, any, any, any>;
+/**
+ * Function metadata with its handler constrained by a protocol function.
+ *
+ * @internal
+ */
+interface InPageFunctionOption<F> {
+  type?: InPageFunctionType;
+  /** Optional Standard Schema array validating the arguments. */
+  args?: RpcArgsSchema;
+  /** Optional Standard Schema validating the resolved return value. */
+  returns?: RpcReturnSchema;
+  jsonSerializable?: boolean;
+  handler: ProtocolHandler<F>;
+}
+/**
+ * Functions implemented by {@link createPageScriptChannel}.
+ *
+ * @internal
+ */
+type CreatePageScriptChannelOptionsFunctions<P extends InPageChannelProtocol> = { [NAME in keyof PageScriptFunctions<P> & string]: InPageFunctionOption<PageScriptFunctions<P>[NAME]>; };
+/**
+ * Functions implemented by {@link connectPanelChannel}.
+ *
+ * @internal
+ */
+type ConnectPanelChannelOptionsFunctions<P extends InPageChannelProtocol> = { [NAME in keyof PanelFunctions<P> & string]: InPageFunctionOption<PanelFunctions<P>[NAME]>; };
 /**
  * Connection lifecycle of a panel endpoint: `connecting` (handshake retry
  * loop running, outgoing traffic buffered) → `connected` → back to
  * `connecting` on port loss, or `closed` after `close()` (permanent).
  */
 type InPageChannelStatus = 'connecting' | 'connected' | 'closed';
+/**
+ * Options shared by both in-page channel endpoints.
+ *
+ * @internal
+ */
 interface InPageChannelCommonOptions {
   /**
    * Channel name, namespaced with the devframe id by convention
    * (e.g. `devframes:plugin:a11y`). Both endpoints must use the same name.
    */
   name: string;
-  /** Implementations of this endpoint's side of the protocol. */
-  functions?: readonly InPageFunctionDefinitionAny[];
   /**
    * Origins accepted during the handshake (and used as `targetOrigin` when
    * posting handshake messages). The in-page channel is same-origin by
@@ -89,7 +122,7 @@ interface InPageChannelCommonOptions {
   callTimeoutMs?: number;
   /**
    * Liveness heartbeat guarding against silently dead ports. Defaults to a
-   * 5s ping / 12s silence window; pass `false` to disable — on both
+   * 5s ping / 12s silence window; pass `false` to disable, on both
    * endpoints together.
    */
   heartbeat?: {
@@ -97,7 +130,7 @@ interface InPageChannelCommonOptions {
     timeoutMs?: number;
   } | false;
   /**
-   * Applied to each outgoing argument and handler result before posting —
+   * Applied to each outgoing argument and handler result before posting;
    * the place to unwrap framework reactivity (Vue `toRaw`, Solid `unwrap`)
    * into plain structured-cloneable values.
    */
@@ -106,7 +139,9 @@ interface InPageChannelCommonOptions {
   deserialize?: (value: unknown) => unknown;
 }
 /** Options for {@link createPageScriptChannel}. */
-interface CreatePageScriptChannelOptions extends InPageChannelCommonOptions {
+interface CreatePageScriptChannelOptions<Protocol extends InPageChannelProtocol = InPageChannelProtocol> extends InPageChannelCommonOptions {
+  /** Implementations of the protocol's page-script functions. */
+  functions: CreatePageScriptChannelOptionsFunctions<Protocol>;
   /**
    * Window whose `message` events carry panel hellos. Defaults to the
    * global `window`; pass `false` to skip the handshake listener entirely
@@ -115,7 +150,9 @@ interface CreatePageScriptChannelOptions extends InPageChannelCommonOptions {
   window?: Window | false;
 }
 /** Options for {@link connectPanelChannel}. */
-interface ConnectPanelChannelOptions extends InPageChannelCommonOptions {
+interface ConnectPanelChannelOptions<Protocol extends InPageChannelProtocol = InPageChannelProtocol> extends InPageChannelCommonOptions {
+  /** Implementations of the protocol's panel functions. */
+  functions: ConnectPanelChannelOptionsFunctions<Protocol>;
   /**
    * The panel's own window (listens for the handshake grant). Defaults to
    * the global `window`; pass `false` with `transport` to skip the handshake.
@@ -123,7 +160,7 @@ interface ConnectPanelChannelOptions extends InPageChannelCommonOptions {
   window?: Window | false;
   /**
    * Windows the hello is posted to. Defaults to the panel's ancestor chain
-   * plus its `opener` — the places a same-tab page script can live. When
+   * plus its `opener`, the places a same-tab page script can live. When
    * empty and no `transport` is given, the endpoint stays `connecting` and
    * warns once.
    */
@@ -132,7 +169,7 @@ interface ConnectPanelChannelOptions extends InPageChannelCommonOptions {
   transport?: MessagePort;
   /**
    * Pin this panel to one page-script instance id. By default the panel
-   * auto-pairs with the most recent page script that answers — almost
+   * auto-pairs with the most recent page script that answers, almost
    * always "my own tab's page script".
    */
   instanceId?: string;
@@ -151,7 +188,7 @@ interface ConnectPanelChannelOptions extends InPageChannelCommonOptions {
   eventBufferLimit?: number;
 }
 /**
- * The channel shared-state accessor — mirrors `rpc.sharedState`, with the
+ * The channel shared-state accessor, mirroring `rpc.sharedState`, with the
  * page script playing the server's role as rendezvous and authority. The
  * page script's first `get` of a key must provide `initialValue`; a panel's
  * `get` without one resolves once the authority's first replay arrives.
@@ -223,7 +260,7 @@ interface PanelChannel<P extends InPageChannelProtocol> {
   /**
    * Resolves once connected. With `timeoutMs`, rejects with an
    * `InPageChannelError` (code `timeout`) when no page script answered in
-   * time — the hook for a "no page script found" fallback UI.
+   * time; the hook for a "no page script found" fallback UI.
    */
   whenConnected: (timeoutMs?: number) => Promise<void>;
   /**
@@ -271,11 +308,11 @@ declare class InPageChannelError extends Error {
  *
  * It listens for panel hellos on the host page's window and answers each
  * with a dedicated `MessageChannel` port (same-origin enforced both ways),
- * keeping one live peer per panel — dock iframe, popup, and Document-PiP
+ * keeping one live peer per panel: dock iframe, popup, and Document-PiP
  * panels all handshake the same way, and a panel reload is simply a new
  * handshake. No server is involved at any point.
  */
-declare function createPageScriptChannel<P extends InPageChannelProtocol>(options: CreatePageScriptChannelOptions): PageScriptChannel<P>;
+declare function createPageScriptChannel<P extends InPageChannelProtocol>(options: CreatePageScriptChannelOptions<P>): PageScriptChannel<P>;
 //#endregion
 //#region src/in-page-channel/panel.d.ts
 /**
@@ -283,18 +320,18 @@ declare function createPageScriptChannel<P extends InPageChannelProtocol>(option
  *
  * The panel initiates: it posts a versioned hello to every window a
  * same-tab page script can live in (its ancestor chain and its `opener`),
- * retrying with backoff until one answers with a dedicated port — so boot
+ * retrying with backoff until one answers with a dedicated port, so boot
  * order never matters, and a reload of either side is just a re-handshake
  * (`WindowProxy` references survive navigations). While `connecting`,
  * outgoing calls and events are buffered; when no page script exists at all
  * (e.g. the panel opened standalone), the endpoint stays `connecting` and
  * the UI can key a fallback state off `status` / `whenConnected()`.
  */
-declare function connectPanelChannel<P extends InPageChannelProtocol>(options: ConnectPanelChannelOptions): PanelChannel<P>;
+declare function connectPanelChannel<P extends InPageChannelProtocol>(options: ConnectPanelChannelOptions<P>): PanelChannel<P>;
 //#endregion
 //#region src/in-page-channel/index.d.ts
 /**
- * Define one in-page channel function — the `defineRpcFunction` authoring
+ * Define one in-page channel function, the `defineRpcFunction` authoring
  * shape narrowed to the browser (see {@link InPageFunctionDefinition}).
  * Pure identity: it only types the definition. Functions live in
  * side-specific files and are passed to their endpoint via `functions`; the

package/dist/in-page-channel/index.mjs

@@ -1,14 +1,14 @@
-import { t as DEVFRAME_EVENTS } from "../events-4daw0uK9.mjs";
+import { t as DEVFRAME_EVENTS } from "../events-BV4Dj59a.mjs";
 import { createEventEmitter } from "../utils/events.mjs";
-import { t as createSharedState } from "../shared-state-DoXutg_U.mjs";
+import { t as createSharedState } from "../shared-state-CaxB1q0h.mjs";
 import { nanoid } from "../utils/nanoid.mjs";
 import { createBirpc } from "birpc";
 //#region src/in-page-channel/protocol.ts
 /**
 * Wire protocol of the in-page channel handshake and its port-level control
-* frames. The envelope is transport-neutral by design — it identifies the
+* frames. The envelope is transport-neutral by design: it identifies the
 * protocol (`channel` tag + `v`), the user channel (`name`), and the peers
-* (`panelId`, `instanceId`) — so a future cross-tab transport (e.g. a
+* (`panelId`, `instanceId`), so a future cross-tab transport (e.g. a
 * `BroadcastChannel`) can reuse it unchanged.
 */
 /** `postMessage` tag every handshake message carries. */
@@ -26,7 +26,7 @@ let memoryInstanceId;
 /**
 * The page context's instance id: one nanoid per browser tab, persisted in
 * `sessionStorage` so it survives page-script reloads. It scopes handshakes
-* when the same app is open in several tabs — a panel pinned to an instance
+* when the same app is open in several tabs, since a panel pinned to an instance
 * id ignores grants from every other tab's page script.
 */
 function resolveInstanceId(win) {
@@ -52,7 +52,7 @@ function resolveAllowedOrigins(allowedOrigins, win) {
 }
 /**
 * Default handshake targets of a panel: its ancestor chain plus its
-* `opener` — every same-tab window a page script can live in. `WindowProxy`
+* `opener`, every same-tab window a page script can live in. `WindowProxy`
 * references stay valid across navigations, so hellos posted to these reach
 * a page script even after the host page reloads.
 */
@@ -93,7 +93,7 @@ var InPageChannelError = class extends Error {
 };
 const warned = /* @__PURE__ */ new Set();
 /**
-* `console.warn` once per distinct message — handshake noise (foreign
+* `console.warn` once per distinct message, since handshake noise (foreign
 * origins, version mismatches, missing targets) repeats on every retry tick.
 */
 function warnOnce(message) {
@@ -102,19 +102,13 @@ function warnOnce(message) {
 		console.warn(`[devframe] ${message}`);
 	}
 }
-function jsonViolation(value, path, seen) {
-	if (value === null || typeof value === "boolean" || typeof value === "string") return void 0;
-	if (typeof value === "number") return Number.isFinite(value) ? void 0 : `${path} is ${value}`;
-	if (typeof value !== "object") return `${path} is ${value === void 0 ? "`undefined`" : `a ${typeof value}`}`;
-	if (seen.has(value)) return `${path} is circular`;
-	seen.add(value);
-	if (Array.isArray(value)) {
-		for (let i = 0; i < value.length; i++) {
-			const violation = jsonViolation(value[i], `${path}[${i}]`, seen);
-			if (violation) return violation;
-		}
-		return;
+function jsonArrayViolation(value, path, seen) {
+	for (let i = 0; i < value.length; i++) {
+		const violation = jsonViolation(value[i], `${path}[${i}]`, seen);
+		if (violation) return violation;
 	}
+}
+function jsonObjectViolation(value, path, seen) {
 	const proto = Object.getPrototypeOf(value);
 	if (proto !== Object.prototype && proto !== null) return `${path} is an instance of ${value.constructor?.name ?? "an exotic class"}`;
 	for (const [key, entry] of Object.entries(value)) {
@@ -122,10 +116,18 @@ function jsonViolation(value, path, seen) {
 		if (violation) return violation;
 	}
 }
+function jsonViolation(value, path, seen) {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return void 0;
+	if (typeof value === "number") return Number.isFinite(value) ? void 0 : `${path} is ${value}`;
+	if (typeof value !== "object") return `${path} is ${value === void 0 ? "`undefined`" : `a ${typeof value}`}`;
+	if (seen.has(value)) return `${path} is circular`;
+	seen.add(value);
+	return Array.isArray(value) ? jsonArrayViolation(value, path, seen) : jsonObjectViolation(value, path, seen);
+}
 /**
 * Enforce a `jsonSerializable: true` contract: throws code
 * `not-serializable` naming the offending path when the value contains
-* anything strict JSON can't represent — surfacing the bug at the offending
+* anything strict JSON can't represent, surfacing the bug at the offending
 * call instead of a silent coercion later.
 */
 function assertJsonSerializable(value, what, functionName) {
@@ -181,14 +183,35 @@ function createLocalFunctionRegistry(codec) {
 	};
 }
 function wrapPostError(error) {
-	if (error instanceof DOMException && error.name === "DataCloneError") return new InPageChannelError("not-cloneable", `a payload could not be structured-cloned across the in-page channel: ${error.message}. Strip non-cloneable values (functions, DOM nodes, framework reactivity proxies) before sending — declare the function \`jsonSerializable: true\` for a precise error, or provide a \`serialize\` hook.`, { cause: error });
+	if (error instanceof DOMException && error.name === "DataCloneError") return new InPageChannelError("not-cloneable", `a payload could not be structured-cloned across the in-page channel: ${error.message}. Strip non-cloneable values (functions, DOM nodes, framework reactivity proxies) before sending: declare the function \`jsonSerializable: true\` for a precise error, or provide a \`serialize\` hook.`, { cause: error });
 	return error;
 }
 function attachChannelPort(port, options) {
 	let birpcHandler;
 	let disposed = false;
 	const attached = {
-		rpc: void 0,
+		rpc: createBirpc({}, {
+			post: (data) => {
+				try {
+					port.postMessage(data);
+				} catch (error) {
+					throw wrapPostError(error);
+				}
+			},
+			on: (fn) => {
+				birpcHandler = fn;
+			},
+			off: () => {
+				birpcHandler = void 0;
+			},
+			/**
+			* Deadlines live at the endpoint layer (`withCallDeadline`) with
+			* status-aware errors; birpc's own timer stays off.
+			*/
+			timeout: -1,
+			proxify: false,
+			resolver: (name, resolved) => resolved ?? options.resolveLocal(name)
+		}),
 		lastActivity: Date.now(),
 		postControl(kind) {
 			try {
@@ -222,24 +245,6 @@ function attachChannelPort(port, options) {
 	function onClose() {
 		options.onPeerClosed();
 	}
-	attached.rpc = createBirpc({}, {
-		post: (data) => {
-			try {
-				port.postMessage(data);
-			} catch (error) {
-				throw wrapPostError(error);
-			}
-		},
-		on: (fn) => {
-			birpcHandler = fn;
-		},
-		off: () => {
-			birpcHandler = void 0;
-		},
-		timeout: -1,
-		proxify: false,
-		resolver: (name, resolved) => resolved ?? options.resolveLocal(name)
-	});
 	port.addEventListener("message", onMessage);
 	port.addEventListener("close", onClose);
 	port.start?.();
@@ -265,7 +270,7 @@ function withCallDeadline(promise, ms, describeTimeout) {
 //#endregion
 //#region src/in-page-channel/state.ts
 /**
-* The channel shared-state layer — `createSharedState` pumped over the
+* The channel shared-state layer: `createSharedState` pumped over the
 * in-page channel, mirroring the RPC shared-state wire design with the page
 * script playing the server's role: it owns the canonical value, replays a
 * snapshot to every (re)subscribing panel, and fans syncId-deduplicated
@@ -290,7 +295,7 @@ function createPageScriptStateHost(peers) {
 		get: async (key, options) => {
 			const existing = states.get(key);
 			if (existing) return existing;
-			if (options?.initialValue === void 0) throw new InPageChannelError("state-uninitialized", `in-page shared state "${key}" was accessed before initialization — the page script is the authority, so its first \`sharedState.get("${key}")\` must provide \`initialValue\``);
+			if (options?.initialValue === void 0) throw new InPageChannelError("state-uninitialized", `in-page shared state "${key}" was accessed before initialization; the page script is the authority, so its first \`sharedState.get("${key}")\` must provide \`initialValue\``);
 			const state = createSharedState({
 				initialValue: options.initialValue,
 				enablePatches: true
@@ -337,7 +342,7 @@ function createPanelStateHost(options) {
 	const seedWaiters = /* @__PURE__ */ new Map();
 	/**
 	* SyncIds of snapshot adoptions. Adopting the authority's replay must not
-	* echo straight back up as a `set` — the authority already has the value.
+	* echo straight back up as a `set`; the authority already has the value.
 	*/
 	const adoptedSyncIds = /* @__PURE__ */ new Set();
 	function markSeeded(key) {
@@ -381,6 +386,10 @@ function createPanelStateHost(options) {
 			const existing = states.get(key);
 			if (existing) return Promise.resolve(existing);
 			const state = createSharedState({
+				/**
+				* Without an initial value the state stays empty until the
+				* authority's first replay resolves the returned promise.
+				*/
 				initialValue: getOptions?.initialValue,
 				enablePatches: true
 			});
@@ -420,7 +429,7 @@ function createPanelStateHost(options) {
 *
 * It listens for panel hellos on the host page's window and answers each
 * with a dedicated `MessageChannel` port (same-origin enforced both ways),
-* keeping one live peer per panel — dock iframe, popup, and Document-PiP
+* keeping one live peer per panel: dock iframe, popup, and Document-PiP
 * panels all handshake the same way, and a panel reload is simply a new
 * handshake. No server is involved at any point.
 */
@@ -440,7 +449,10 @@ function createPageScriptChannel(options) {
 	let closed = false;
 	let heartbeatTimer;
 	const registry = createLocalFunctionRegistry(codec);
-	for (const definition of options.functions ?? []) registry.register(definition);
+	for (const [fnName, definition] of Object.entries(options.functions ?? {})) registry.register({
+		...definition,
+		name: fnName
+	});
 	const stateHost = createPageScriptStateHost(function* () {
 		for (const peer of peers.values()) yield {
 			subscribedStates: peer.subscribedStates,
@@ -510,7 +522,7 @@ function createPageScriptChannel(options) {
 		const data = event.data;
 		if (!isHandshakeMessage(data) || data.kind !== "hello" || data.name !== name) return;
 		if (data.v !== 1) {
-			warnOnce(`in-page channel "${name}": ignoring a hello with protocol version ${data.v} (this side speaks 1) — align the devframe versions of the page script and the panel`);
+			warnOnce(`in-page channel "${name}": ignoring a hello with protocol version ${data.v} (this side speaks 1); align the devframe versions of the page script and the panel`);
 			return;
 		}
 		if (!allowedOrigins.includes("*") && !allowedOrigins.includes(event.origin)) {
@@ -580,7 +592,7 @@ const DEFAULT_EVENT_BUFFER_LIMIT = 64;
 *
 * The panel initiates: it posts a versioned hello to every window a
 * same-tab page script can live in (its ancestor chain and its `opener`),
-* retrying with backoff until one answers with a dedicated port — so boot
+* retrying with backoff until one answers with a dedicated port, so boot
 * order never matters, and a reload of either side is just a re-handshake
 * (`WindowProxy` references survive navigations). While `connecting`,
 * outgoing calls and events are buffered; when no page script exists at all
@@ -603,7 +615,10 @@ function connectPanelChannel(options) {
 	const canHandshake = !!win && targets.length > 0;
 	const events = createEventEmitter();
 	const registry = createLocalFunctionRegistry(codec);
-	for (const definition of options.functions ?? []) registry.register(definition);
+	for (const [fnName, definition] of Object.entries(options.functions ?? {})) registry.register({
+		...definition,
+		name: fnName
+	});
 	let status = "connecting";
 	let attached;
 	let pageScriptInfo;
@@ -642,7 +657,7 @@ function connectPanelChannel(options) {
 			eventBuffer.shift();
 			if (!droppedEventsWarned) {
 				droppedEventsWarned = true;
-				console.warn(`[devframe] in-page channel "${name}": event buffer overflowed while connecting — oldest events are being dropped (limit ${eventBufferLimit})`);
+				console.warn(`[devframe] in-page channel "${name}": event buffer overflowed while connecting, so the oldest events are being dropped (limit ${eventBufferLimit})`);
 			}
 		}
 		eventBuffer.push({
@@ -651,7 +666,7 @@ function connectPanelChannel(options) {
 		});
 	}
 	function enqueueCall(method, args) {
-		if (status === "closed") return Promise.reject(new InPageChannelError("closed", `in-page channel "${name}": call "${method}" rejected — the channel is closed`));
+		if (status === "closed") return Promise.reject(new InPageChannelError("closed", `in-page channel "${name}": call "${method}" rejected because the channel is closed`));
 		return withCallDeadline(new Promise((resolve, reject) => {
 			const run = () => {
 				attached.rpc.$call(method, ...args).then((result) => resolve(deserializeResult(codec, result)), reject);
@@ -661,7 +676,7 @@ function connectPanelChannel(options) {
 				run,
 				reject
 			});
-		}), callTimeoutMs, () => `in-page channel "${name}": call "${method}" timed out after ${callTimeoutMs}ms (status: ${status}${status === "connecting" ? " — is the page script loaded?" : ""})`);
+		}), callTimeoutMs, () => `in-page channel "${name}": call "${method}" timed out after ${callTimeoutMs}ms (status: ${status}${status === "connecting" ? "; is the page script loaded?" : ""})`);
 	}
 	function adoptPort(port, info) {
 		attached?.dispose({
@@ -706,7 +721,7 @@ function connectPanelChannel(options) {
 		stopTimers();
 		setStatus("connecting");
 		if (canHandshake) startHelloLoop();
-		else warnOnce(`in-page channel "${name}": transport lost (${reason}) and the panel has no handshake targets — staying disconnected`);
+		else warnOnce(`in-page channel "${name}": transport lost (${reason}) and the panel has no handshake targets, so it stays disconnected`);
 	}
 	function startHelloLoop() {
 		if (helloTimer || !canHandshake || status !== "connecting") return;
@@ -733,7 +748,7 @@ function connectPanelChannel(options) {
 		const data = event.data;
 		if (!isHandshakeMessage(data) || data.kind !== "grant" || data.name !== name || data.panelId !== panelId) return;
 		if (data.v !== 1) {
-			warnOnce(`in-page channel "${name}": ignoring a grant with protocol version ${data.v} (this side speaks 1) — align the devframe versions of the page script and the panel`);
+			warnOnce(`in-page channel "${name}": ignoring a grant with protocol version ${data.v} (this side speaks 1); align the devframe versions of the page script and the panel`);
 			return;
 		}
 		if (!allowedOrigins.includes("*") && !allowedOrigins.includes(event.origin)) {
@@ -747,7 +762,7 @@ function connectPanelChannel(options) {
 	win?.addEventListener("message", onWindowMessage);
 	if (options.transport) adoptPort(options.transport);
 	else if (canHandshake) startHelloLoop();
-	else warnOnce(`in-page channel "${name}": the panel has no handshake targets (not embedded, no opener) and no transport — calls will buffer until a transport appears or the channel is closed`);
+	else warnOnce(`in-page channel "${name}": the panel has no handshake targets (not embedded, no opener) and no transport, so calls will buffer until a transport appears or the channel is closed`);
 	return {
 		name,
 		get status() {
@@ -773,7 +788,7 @@ function connectPanelChannel(options) {
 					const index = connectedWaiters.indexOf(waiter);
 					if (index >= 0) {
 						connectedWaiters.splice(index, 1);
-						reject(new InPageChannelError("timeout", `in-page channel "${name}": no page script answered within ${timeoutMs}ms — it may not be loaded in this context (render a fallback state)`));
+						reject(new InPageChannelError("timeout", `in-page channel "${name}": no page script answered within ${timeoutMs}ms; it may not be loaded in this context (render a fallback state)`));
 					}
 				}, timeoutMs);
 			});
@@ -802,7 +817,7 @@ function connectPanelChannel(options) {
 //#endregion
 //#region src/in-page-channel/index.ts
 /**
-* Define one in-page channel function — the `defineRpcFunction` authoring
+* Define one in-page channel function, the `defineRpcFunction` authoring
 * shape narrowed to the browser (see {@link InPageFunctionDefinition}).
 * Pure identity: it only types the definition. Functions live in
 * side-specific files and are passed to their endpoint via `functions`; the

package/dist/{index-BzyopqxV.d.mts → index-pIVt92jP.d.mts}

@@ -1,4 +1,4 @@
-import { C as RpcFunctionType, S as RpcFunctionSetupResult, T as RpcReturnSchema, _ as RpcFunctionDefinition, i as RpcArgsSchema, v as RpcFunctionDefinitionAny, w as RpcFunctionsCollector } from "./types-CMdPYhOx.mjs";
+import { C as RpcFunctionType, S as RpcFunctionSetupResult, T as RpcReturnSchema, _ as RpcFunctionDefinition, i as RpcArgsSchema, v as RpcFunctionDefinitionAny, w as RpcFunctionsCollector } from "./types-Dq4i156u.mjs";
 //#region src/rpc/cache.d.ts
 interface RpcCacheOptions {
   functions: string[];
@@ -66,7 +66,7 @@ declare function getRpcHandler<NAME extends string, TYPE extends RpcFunctionType
  *
  * 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.
  */
 declare const STRUCTURED_CLONE_PREFIX = "s:";
@@ -78,16 +78,16 @@ declare 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.
  */
@@ -110,7 +110,7 @@ declare function validateRpcArgs(name: string, argsSchema: RpcArgsSchema | undef
 /**
  * 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/{index-DcKxIMoI.d.mts → index-pKl67H6w.d.mts}

@@ -1,5 +1,5 @@
-import { k as SharedState, o as DevframeNodeContext, s as DevframeNodeRpcSession } from "./context-BhBzOXVa.mjs";
-import { n as InternalAnonymousAuthStorage } from "./context-HOnG-WvG.mjs";
+import { k as SharedState, o as DevframeNodeContext, s as DevframeNodeRpcSession } from "./context-4AIVRLYF.mjs";
+import { n as InternalAnonymousAuthStorage } from "./context-rgBSPFHS.mjs";
 //#region src/node/auth/revoke.d.ts
 /**
  * Flip `isTrusted` to false on any live WS clients connected with `token`
@@ -29,13 +29,13 @@ declare function getTempAuthCode(): string;
 declare function refreshTempAuthCode(): string;
 /**
  * Build a "magic link" authentication URL that embeds a one-time code (OTP) in
- * the URL **fragment**. Opening it authenticates the client without typing —
+ * the URL **fragment**. Opening it authenticates the client without typing;
  * print it on startup (devframe stays headless, so the host prints its own
  * banner). Defaults to the current code; the link is subject to the same TTL.
  *
  * The code rides the fragment (`#devframe_otp=…`), not the query string, so it
  * is never sent to the server, written to an access log, or leaked in a
- * `Referer` header — the browser client reads it locally (see
+ * `Referer` header; the browser client reads it locally (see
  * `consumeOtpFromUrl`). Any existing fragment parameters are preserved.
  */
 declare function buildOtpAuthUrl(baseUrl: string, code?: string): string;