devframe 0.7.16 → 0.8.1

package/dist/node/index.d.mts

@@ -1,8 +1,38 @@
-import { C as DevframeServicesHost, Ct as AgentResourceContent, Dt as DevframeAgentHost$1, Et as AgentToolInput, H as DevframeDiagnosticsHost$1, J as RpcSharedStateHost, K as RpcFunctionsHost, L as DevframeViewHost$1, O as DevframeSettings, Ot as DevframeAgentHostEvents, R as DevframeHost, S as DevframeServiceOf, St as AgentResource, T as DevframeScopedNodeContext, Tt as AgentTool, U as DevframeDiagnosticsLogger, Z as RpcStreamingHost, b as DevframeNodeContext, bt as AgentHandle, ht as SharedState, kt as EventEmitter, wt as AgentResourceInput, x as DevframeServiceId, xt as AgentManifest } from "../devframe-Ckhf3kFw.mjs";
-import { v as RpcFunctionDefinitionAny } from "../types-CrzNxXKq.mjs";
-import "../index-DgsLFhZg.mjs";
-import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-B0wiP_Oi.mjs";
+import { At as DevframeAgentHostEvents, C as DevframeServicesHost, Ct as AgentResourceContent, Dt as AgentToolProvider, Et as AgentToolInput, H as DevframeDiagnosticsHost$1, J as RpcSharedStateHost, K as RpcFunctionsHost, L as DevframeViewHost$1, O as DevframeSettings, Ot as AgentToolProviderHandle, R as DevframeHost, S as DevframeServiceOf, St as AgentResource, T as DevframeScopedNodeContext, Tt as AgentTool, U as DevframeDiagnosticsLogger, Z as RpcStreamingHost, b as DevframeNodeContext, bt as AgentHandle, ht as SharedState, jt as EventEmitter, kt as DevframeAgentHost$1, wt as AgentResourceInput, x as DevframeServiceId, xt as AgentManifest } from "../devframe-qgCKL683.mjs";
+import { v as RpcFunctionDefinitionAny } from "../types-CnJSgRVa.mjs";
+import "../index-Dbw1p5ch.mjs";
+import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-E9z4ZWbd.mjs";
 import { BirpcGroup } from "birpc";
+//#region src/node/agent-args.d.ts
+/**
+ * How {@link coerceAgentPositionalArgs} treats an args object that carries
+ * neither declared schemas nor `arg0`/`arg1`/… keys:
+ *
+ * - `'wrap'` — pass the object itself as the single positional argument.
+ *   RPC-backed tools use this: an untyped RPC may take one raw object.
+ * - `'drop'` — call with zero arguments. Command-backed tools use this:
+ *   a handler's positional parameters come solely from its declared
+ *   `agent.args` schemas, so undeclared payload is ignored.
+ */
+type AgentArgsFallback = 'wrap' | 'drop';
+/**
+ * Map the args payload an agent surface receives (MCP sends an object
+ * keyed `arg0`/`arg1`/…, matching the schema the adapter advertises) onto
+ * a handler's positional parameters. Shared by the agent host's RPC
+ * bridge and the hub's command-derived tools so the coercion cannot
+ * drift between them.
+ *
+ * - an array passes through as-is
+ * - `null`/`undefined` become a zero-argument call
+ * - with declared schemas, each schema reads its own `argN` key, in order
+ * - without schemas, `arg0`/`arg1`/… keys are collected when present
+ * - an empty object becomes a zero-argument call
+ * - anything else follows the {@link AgentArgsFallback}
+ *
+ * @experimental
+ */
+declare function coerceAgentPositionalArgs(args: unknown, schemas: readonly unknown[] | undefined, fallback?: AgentArgsFallback): unknown[];
+//#endregion
 //#region src/node/context.d.ts
 interface CreateHostContextOptions {
   cwd: string;
@@ -40,10 +70,12 @@ declare class DevframeAgentHost implements DevframeAgentHost$1 {
   readonly events: EventEmitter<DevframeAgentHostEvents>;
   private readonly tools;
   private readonly resources;
+  private readonly providers;
   private _rpcUnsubscribe;
   constructor(context: DevframeNodeContext);
   registerTool(input: AgentToolInput): AgentHandle;
   unregisterTool(id: string): boolean;
+  registerToolProvider(provider: AgentToolProvider): AgentToolProviderHandle;
   registerResource(input: AgentResourceInput): AgentHandle;
   unregisterResource(id: string): boolean;
   list(): AgentManifest;
@@ -55,9 +87,10 @@ declare class DevframeAgentHost implements DevframeAgentHost$1 {
   _dispose(): void;
   private _validateToolId;
   private _projectTool;
+  /** Query every registered provider, projecting inputs to serializable tools. */
+  private _collectProviderTools;
   private _collectRpcTools;
   private _findRpcDefinition;
-  private _coercePositionalArgs;
 }
 //#endregion
 //#region src/node/host-diagnostics.d.ts
@@ -135,6 +168,91 @@ declare class DevframeViewHost implements DevframeViewHost$1 {
   hostStatic(baseUrl: string, distDir: string): void;
 }
 //#endregion
+//#region src/node/instance-registry.d.ts
+/**
+ * One running devframe instance, as recorded in the instance registry.
+ * Records are self-describing JSON — additive fields are safe.
+ *
+ * @experimental The agent-native surface is experimental and may change
+ * without a major version bump until it stabilizes.
+ */
+interface DevframeInstanceRecord {
+  /** Process id of the dev server. */
+  pid: number;
+  /** Listening port. */
+  port: number;
+  /** Dialable HTTP origin, e.g. `http://127.0.0.1:9876`. */
+  origin: string;
+  /** Base path the devframe is mounted at (trailing slash). */
+  basePath: string;
+  /** Definition id. */
+  id: string;
+  /** Definition display name. */
+  name?: string;
+  /** Working directory the instance was started from. */
+  rootDir: string;
+  /**
+   * Absolute URL path of the MCP Streamable-HTTP endpoint on `origin`, or
+   * `null` when the instance runs without an MCP route.
+   */
+  mcp: {
+    path: string;
+  } | null;
+  /** Epoch-ms timestamp of registration. */
+  startedAt: number;
+}
+/**
+ * Handle returned by {@link registerDevframeInstance}.
+ *
+ * @experimental
+ */
+interface DevframeInstanceRegistration {
+  /** The registry file backing this registration. */
+  readonly file: string;
+  /** Remove the record (idempotent). Call on server close. */
+  unregister: () => void;
+}
+/**
+ * Record a running devframe instance in the global instance registry so
+ * discovery tooling (`devframe connect`, editor integrations) can find it
+ * without port guessing.
+ *
+ * `createDevServer` registers automatically; custom hosts that serve a
+ * devframe in-process (e.g. `@devframes/next`'s host inside a Next dev
+ * server) call this explicitly with the origin they are reachable at.
+ *
+ * The record is written atomically to `<dir>/<pid>-<port>.json` and removed
+ * by {@link DevframeInstanceRegistration.unregister}. Records surviving a
+ * crash are pruned by readers whose liveness probe fails. Registration never
+ * throws — a write failure degrades to a coded warning (`DF0045`), since a
+ * dev server must not die over discovery metadata.
+ *
+ * @experimental
+ */
+declare function registerDevframeInstance(record: DevframeInstanceRecord, options?: {
+  instancesDir?: string;
+}): DevframeInstanceRegistration;
+/**
+ * Read the registry and split records into live and dead by probing each
+ * one's `__connection.json`, deleting dead records (prune-on-read). Live
+ * records carry the dialable origin the probe confirmed (a `localhost`
+ * record may come back as `127.0.0.1` / `[::1]`).
+ *
+ * A liveness probe only proves *something* answers on the record's port, so
+ * records left behind by killed processes shadow the server currently bound
+ * there: per `(port, basePath)` only the newest record survives, older
+ * ghosts are pruned with the dead.
+ *
+ * @experimental
+ */
+declare function listLiveDevframeInstances(options?: {
+  instancesDir?: string;
+  timeoutMs?: number;
+}): Promise<{
+  live: DevframeInstanceRecord[];
+  pruned: DevframeInstanceRecord[];
+}>;
+//#endregion
 //#region src/node/rpc-shared-state.d.ts
 declare function createRpcSharedStateServerHost(rpc: RpcFunctionsHost): RpcSharedStateHost;
 //#endregion
@@ -180,4 +298,4 @@ declare function toDialableHost(host: string): string;
 declare function formatHostForUrl(host: string): string;
 declare function normalizeHttpServerUrl(host: string, port: number | string): string;
 //#endregion
-export { CreateH3DevframeHostOptions, CreateHostContextOptions, CreateStorageOptions, DevframeAgentHost, DevframeDiagnosticsHost, DevframeServicesHostImpl, DevframeViewHost, type RpcFunctionsHost, StartHttpAndWsOptions, StartedServer, createH3DevframeHost, createHostContext, createNodeSettings, createRpcSharedStateServerHost, createRpcStreamingServerHost, createScopedNodeContext, createStorage, formatHostForUrl, isObject, normalizeHttpServerUrl, startHttpAndWs, toDialableHost };
+export { AgentArgsFallback, CreateH3DevframeHostOptions, CreateHostContextOptions, CreateStorageOptions, DevframeAgentHost, DevframeDiagnosticsHost, type DevframeInstanceRecord, type DevframeInstanceRegistration, DevframeServicesHostImpl, DevframeViewHost, type RpcFunctionsHost, StartHttpAndWsOptions, StartedServer, coerceAgentPositionalArgs, createH3DevframeHost, createHostContext, createNodeSettings, createRpcSharedStateServerHost, createRpcStreamingServerHost, createScopedNodeContext, createStorage, formatHostForUrl, isObject, listLiveDevframeInstances, normalizeHttpServerUrl, registerDevframeInstance, startHttpAndWs, toDialableHost };

package/dist/node/index.mjs

@@ -1,4 +1,5 @@
-import { t as createStorage } from "../storage-gEnj9ASQ.mjs";
-import { a as DevframeViewHost, c as createRpcSharedStateServerHost, i as createNodeSettings, l as DevframeDiagnosticsHost, n as createHostContext, o as DevframeServicesHostImpl, r as createScopedNodeContext, s as createRpcStreamingServerHost, t as createH3DevframeHost, u as DevframeAgentHost } from "../host-h3-CgOetlNE.mjs";
-import { a as toDialableHost, i as normalizeHttpServerUrl, n as formatHostForUrl, r as isObject, t as startHttpAndWs } from "../server-DykHCza_.mjs";
-export { DevframeAgentHost, DevframeDiagnosticsHost, DevframeServicesHostImpl, DevframeViewHost, createH3DevframeHost, createHostContext, createNodeSettings, createRpcSharedStateServerHost, createRpcStreamingServerHost, createScopedNodeContext, createStorage, formatHostForUrl, isObject, normalizeHttpServerUrl, startHttpAndWs, toDialableHost };
+import { a as DevframeViewHost, c as createRpcSharedStateServerHost, d as coerceAgentPositionalArgs, i as createNodeSettings, l as DevframeDiagnosticsHost, n as createHostContext, o as DevframeServicesHostImpl, r as createScopedNodeContext, s as createRpcStreamingServerHost, t as createH3DevframeHost, u as DevframeAgentHost } from "../host-h3-Kz7t5Xab.mjs";
+import { t as createStorage } from "../storage-Dzoc3NVC.mjs";
+import { r as registerDevframeInstance, t as listLiveDevframeInstances } from "../instance-registry-D6fxYu36.mjs";
+import { a as toDialableHost, i as normalizeHttpServerUrl, n as formatHostForUrl, r as isObject, t as startHttpAndWs } from "../server-CXaDDUl0.mjs";
+export { DevframeAgentHost, DevframeDiagnosticsHost, DevframeServicesHostImpl, DevframeViewHost, coerceAgentPositionalArgs, createH3DevframeHost, createHostContext, createNodeSettings, createRpcSharedStateServerHost, createRpcStreamingServerHost, createScopedNodeContext, createStorage, formatHostForUrl, isObject, listLiveDevframeInstances, normalizeHttpServerUrl, registerDevframeInstance, startHttpAndWs, toDialableHost };

package/dist/recipes/common-rpc-functions.d.mts

@@ -1,7 +1,7 @@
-import "../devframe-Ckhf3kFw.mjs";
-import { E as Thenable, S as RpcFunctionSetupResult, c as RpcDump, g as RpcFunctionAgentOptions } from "../types-CrzNxXKq.mjs";
-import "../index-DgsLFhZg.mjs";
-import * as v from "valibot";
+import "../devframe-qgCKL683.mjs";
+import { E as Thenable, S as RpcFunctionSetupResult, c as RpcDump, g as RpcFunctionAgentOptions } from "../types-CnJSgRVa.mjs";
+import "../index-Dbw1p5ch.mjs";
+import { t as SimpleSchema } from "../simple-schema-BDzLeJDk.mjs";
 //#region src/recipes/common-rpc-functions.d.ts
 /**
  * Editor commands that `launch-editor` (the library behind
@@ -11,7 +11,7 @@ import * as v from "valibot";
  * arbitrary command.
  */
 type KnownEditor = 'atom' | 'subl' | 'sublime' | 'sublime_text' | 'wstorm' | 'charm' | 'zed' | 'notepad++' | 'vim' | 'mvim' | 'joe' | 'gvim' | 'emacs' | 'emacsclient' | 'rmate' | 'mate' | 'code' | 'code-insiders' | 'codium' | 'vscodium' | 'trae' | 'antigravity' | 'cursor' | 'appcode' | 'clion' | 'idea' | 'phpstorm' | 'pycharm' | 'rubymine' | 'webstorm' | 'goland' | 'rider';
-/** Runtime list of every {@link KnownEditor}, in the order `v.picklist` reports them. */
+/** Runtime list of every {@link KnownEditor}. */
 declare const KNOWN_EDITORS: KnownEditor[];
 /**
  * Prebuilt RPC action that opens a file in the user's configured editor.
@@ -38,16 +38,16 @@ declare const openInEditor: {
   name: "devframe:open-in-editor";
   type?: "action" | undefined;
   cacheable?: boolean;
-  args: readonly [v.StringSchema<undefined>, v.OptionalSchema<v.PicklistSchema<KnownEditor[], undefined>, undefined>];
-  returns: v.VoidSchema<undefined>;
+  args: readonly [SimpleSchema<string, string>, SimpleSchema<KnownEditor | undefined, KnownEditor | undefined>];
+  returns: SimpleSchema<void, void>;
   jsonSerializable?: boolean;
   agent?: RpcFunctionAgentOptions;
-  setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], void>>) | undefined;
-  handler?: ((args_0: string, args_1: KnownEditor | undefined) => void) | undefined;
-  dump?: RpcDump<[string, KnownEditor | undefined], void, undefined> | undefined;
+  setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], Thenable<void>>>) | undefined;
+  handler?: ((args_0: string, args_1: KnownEditor | undefined) => Thenable<void>) | undefined;
+  dump?: RpcDump<[string, KnownEditor | undefined], Thenable<void>, undefined> | undefined;
   snapshot?: boolean;
-  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], void>>> | undefined;
-  __promise?: Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], void>> | undefined;
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], Thenable<void>>>> | undefined;
+  __promise?: Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], Thenable<void>>> | undefined;
 };
 /**
  * Prebuilt RPC action that reveals a path in the OS file explorer.
@@ -64,16 +64,16 @@ declare const openInFinder: {
   name: "devframe:open-in-finder";
   type?: "action" | undefined;
   cacheable?: boolean;
-  args: readonly [v.StringSchema<undefined>];
-  returns: v.VoidSchema<undefined>;
+  args: readonly [SimpleSchema<string, string>];
+  returns: SimpleSchema<void, void>;
   jsonSerializable?: boolean;
   agent?: RpcFunctionAgentOptions;
-  setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string], void>>) | undefined;
-  handler?: ((args_0: string) => void) | undefined;
-  dump?: RpcDump<[string], void, undefined> | undefined;
+  setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string], Thenable<void>>>) | undefined;
+  handler?: ((args_0: string) => Thenable<void>) | undefined;
+  dump?: RpcDump<[string], Thenable<void>, undefined> | undefined;
   snapshot?: boolean;
-  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string], void>>> | undefined;
-  __promise?: Thenable<RpcFunctionSetupResult<[string], void>> | undefined;
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string], Thenable<void>>>> | undefined;
+  __promise?: Thenable<RpcFunctionSetupResult<[string], Thenable<void>>> | undefined;
 };
 /**
  * Convenience array bundling both helpers so callers can register them
@@ -89,30 +89,30 @@ declare const commonRpcFunctions: readonly [{
   name: "devframe:open-in-editor";
   type?: "action" | undefined;
   cacheable?: boolean;
-  args: readonly [v.StringSchema<undefined>, v.OptionalSchema<v.PicklistSchema<KnownEditor[], undefined>, undefined>];
-  returns: v.VoidSchema<undefined>;
+  args: readonly [SimpleSchema<string, string>, SimpleSchema<KnownEditor | undefined, KnownEditor | undefined>];
+  returns: SimpleSchema<void, void>;
   jsonSerializable?: boolean;
   agent?: RpcFunctionAgentOptions;
-  setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], void>>) | undefined;
-  handler?: ((args_0: string, args_1: KnownEditor | undefined) => void) | undefined;
-  dump?: RpcDump<[string, KnownEditor | undefined], void, undefined> | undefined;
+  setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], Thenable<void>>>) | undefined;
+  handler?: ((args_0: string, args_1: KnownEditor | undefined) => Thenable<void>) | undefined;
+  dump?: RpcDump<[string, KnownEditor | undefined], Thenable<void>, undefined> | undefined;
   snapshot?: boolean;
-  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], void>>> | undefined;
-  __promise?: Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], void>> | undefined;
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], Thenable<void>>>> | undefined;
+  __promise?: Thenable<RpcFunctionSetupResult<[string, KnownEditor | undefined], Thenable<void>>> | undefined;
 }, {
   name: "devframe:open-in-finder";
   type?: "action" | undefined;
   cacheable?: boolean;
-  args: readonly [v.StringSchema<undefined>];
-  returns: v.VoidSchema<undefined>;
+  args: readonly [SimpleSchema<string, string>];
+  returns: SimpleSchema<void, void>;
   jsonSerializable?: boolean;
   agent?: RpcFunctionAgentOptions;
-  setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string], void>>) | undefined;
-  handler?: ((args_0: string) => void) | undefined;
-  dump?: RpcDump<[string], void, undefined> | undefined;
+  setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string], Thenable<void>>>) | undefined;
+  handler?: ((args_0: string) => Thenable<void>) | undefined;
+  dump?: RpcDump<[string], Thenable<void>, undefined> | undefined;
   snapshot?: boolean;
-  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string], void>>> | undefined;
-  __promise?: Thenable<RpcFunctionSetupResult<[string], void>> | undefined;
+  __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string], Thenable<void>>>> | undefined;
+  __promise?: Thenable<RpcFunctionSetupResult<[string], Thenable<void>>> | undefined;
 }];
 //#endregion
 export { KNOWN_EDITORS, KnownEditor, commonRpcFunctions, openInEditor, openInFinder };

package/dist/recipes/common-rpc-functions.mjs

@@ -1,7 +1,7 @@
 import { n as defineRpcFunction } from "../define-BLWPsH6y.mjs";
-import * as v from "valibot";
+import { t as s } from "../simple-schema-DQPZrAaZ.mjs";
 //#region src/recipes/common-rpc-functions.ts
-/** Runtime list of every {@link KnownEditor}, in the order `v.picklist` reports them. */
+/** Runtime list of every {@link KnownEditor}. */
 const KNOWN_EDITORS = [
 	"atom",
 	"subl",
@@ -61,8 +61,8 @@ const openInEditor = defineRpcFunction({
 	name: "devframe:open-in-editor",
 	type: "action",
 	jsonSerializable: true,
-	args: [v.string(), v.optional(v.picklist(KNOWN_EDITORS))],
-	returns: v.void(),
+	args: [s.string(), s.optional(s.picklist(KNOWN_EDITORS))],
+	returns: s.void(),
 	async handler(filename, editor) {
 		const { launchEditor } = await import("../utils/launch-editor.mjs");
 		launchEditor(filename, editor);
@@ -83,8 +83,8 @@ const openInFinder = defineRpcFunction({
 	name: "devframe:open-in-finder",
 	type: "action",
 	jsonSerializable: true,
-	args: [v.string()],
-	returns: v.void(),
+	args: [s.string()],
+	returns: s.void(),
 	async handler(path) {
 		const { open } = await import("../utils/open.mjs");
 		await open(path);

package/dist/recipes/interactive-auth.d.mts

@@ -1,5 +1,5 @@
-import { b as DevframeNodeContext, p as DevframeAuthHandler } from "../devframe-Ckhf3kFw.mjs";
-import "../index-8dndvIxR.mjs";
+import { b as DevframeNodeContext, p as DevframeAuthHandler } from "../devframe-qgCKL683.mjs";
+import "../index-B7RgLw--.mjs";
 //#region src/recipes/interactive-auth.d.ts
 interface CreateInteractiveAuthOptions {
   /**

package/dist/recipes/interactive-auth.mjs

@@ -1,9 +1,9 @@
 import { n as colors } from "../diagnostics-reporter-CsIG85Q5.mjs";
 import { isAnonymousRpcMethod } from "../constants.mjs";
 import { n as defineRpcFunction } from "../define-BLWPsH6y.mjs";
-import { t as getInternalContext } from "../context-DY72brRI.mjs";
-import { a as verifyAuthToken, n as exchangeTempAuthCode, r as getTempAuthCode, t as buildOtpAuthUrl } from "../state-WX3HT5a3.mjs";
-import * as v from "valibot";
+import { t as getInternalContext } from "../context-CQefP2jR.mjs";
+import { a as verifyAuthToken, n as exchangeTempAuthCode, r as getTempAuthCode, t as buildOtpAuthUrl } from "../state-BeUHDDjk.mjs";
+import { t as s } from "../simple-schema-DQPZrAaZ.mjs";
 //#region src/recipes/interactive-auth.ts
 function defaultBanner(info) {
 	console.log(`\n  ${colors.dim("devframe auth code")}  ${colors.bold(info.code)}\n  ${colors.dim("or open")}       ${colors.cyan(info.url)}\n`);
@@ -54,12 +54,12 @@ function createInteractiveAuth(context, options = {}) {
 		name: "anonymous:devframe:auth",
 		type: "action",
 		jsonSerializable: true,
-		args: [v.object({
-			authToken: v.string(),
-			ua: v.string(),
-			origin: v.string()
+		args: [s.object({
+			authToken: s.string(),
+			ua: s.string(),
+			origin: s.string()
 		})],
-		returns: v.object({ isTrusted: v.boolean() }),
+		returns: s.object({ isTrusted: s.boolean() }),
 		handler(params) {
 			const session = context.rpc.getCurrentRpcSession();
 			if (!session) return { isTrusted: false };
@@ -76,12 +76,12 @@ function createInteractiveAuth(context, options = {}) {
 		name: "anonymous:devframe:auth:exchange",
 		type: "action",
 		jsonSerializable: true,
-		args: [v.object({
-			code: v.string(),
-			ua: v.string(),
-			origin: v.string()
+		args: [s.object({
+			code: s.string(),
+			ua: s.string(),
+			origin: s.string()
 		})],
-		returns: v.object({ authToken: v.nullable(v.string()) }),
+		returns: s.object({ authToken: s.nullable(s.string()) }),
 		handler(params) {
 			const session = context.rpc.getCurrentRpcSession();
 			if (!session) return { authToken: null };
@@ -95,7 +95,7 @@ function createInteractiveAuth(context, options = {}) {
 		type: "action",
 		jsonSerializable: true,
 		args: [],
-		returns: v.void(),
+		returns: s.void(),
 		async handler() {
 			const token = context.rpc.getCurrentRpcSession()?.meta.clientAuthToken;
 			if (token) await internal.revokeAuthToken(token);
@@ -107,16 +107,24 @@ function createInteractiveAuth(context, options = {}) {
 	}
 	function onConnect(peer, session) {
 		let token;
+		let requestOrigin;
 		try {
 			token = new URL(peer.request?.url ?? "", "http://localhost").searchParams.get("devframe_auth_token") ?? void 0;
 		} catch {}
+		try {
+			requestOrigin = peer.request?.headers?.get?.("origin") ?? void 0;
+		} catch {}
 		if (!token) return;
 		if (isStaticToken(token)) {
 			session.meta.clientAuthToken = token;
 			session.meta.isTrusted = true;
 			return;
 		}
-		verifyAuthToken(token, session, storage);
+		if (verifyAuthToken(token, session, storage)) return;
+		if (internal.isRemoteTokenTrusted(token, requestOrigin)) {
+			session.meta.clientAuthToken = token;
+			session.meta.isTrusted = true;
+		}
 	}
 	function buildOpenUrl(url) {
 		return buildOtpAuthUrl(url);

package/dist/revoke-DZbJ7Cl0.mjs

@@ -0,0 +1,35 @@
+//#region src/node/auth/revoke.ts
+/**
+* Flip `isTrusted` to false on any live WS clients connected with `token`
+* and broadcast the `auth:revoked` event so they can react.
+*
+* Shared between persisted-auth revocation and remote-dock token revocation.
+*/
+async function revokeActiveConnectionsForToken(context, token) {
+	const rpcHost = context.rpc;
+	if (!rpcHost?._rpcGroup) return;
+	const affectedSessionIds = /* @__PURE__ */ new Set();
+	for (const client of rpcHost._rpcGroup.clients) if (client.$meta.clientAuthToken === token) {
+		affectedSessionIds.add(client.$meta.id);
+		client.$meta.isTrusted = false;
+		client.$meta.clientAuthToken = void 0;
+	}
+	if (affectedSessionIds.size === 0) return;
+	await rpcHost.broadcast({
+		method: "devframe:auth:revoked",
+		args: [],
+		filter: (client) => affectedSessionIds.has(client.$meta.id)
+	});
+}
+/**
+* Revoke an auth token: remove from storage and notify all connected clients
+* using this token that they are no longer trusted.
+*/
+async function revokeAuthToken(context, storage, token) {
+	storage.mutate((state) => {
+		delete state.trusted[token];
+	});
+	await revokeActiveConnectionsForToken(context, token);
+}
+//#endregion
+export { revokeAuthToken as n, revokeActiveConnectionsForToken as t };

package/dist/rpc/dump.d.mts

@@ -1,2 +1,2 @@
-import { a as getDefinitionsWithDumps, c as StaticRpcDumpManifest, d as StaticRpcDumpManifestValue, f as StaticRpcDumpSerialization, i as dumpFunctions, l as StaticRpcDumpManifestQueryEntry, n as serializeDumpError, o as StaticRpcDumpCollection, p as collectStaticRpcDump, r as createClientFromDump, s as StaticRpcDumpFile, t as reviveDumpError, u as StaticRpcDumpManifestStaticEntry } from "../index-YDSJgsyG.mjs";
+import { a as getDefinitionsWithDumps, c as StaticRpcDumpManifest, d as StaticRpcDumpManifestValue, f as StaticRpcDumpSerialization, i as dumpFunctions, l as StaticRpcDumpManifestQueryEntry, n as serializeDumpError, o as StaticRpcDumpCollection, p as collectStaticRpcDump, r as createClientFromDump, s as StaticRpcDumpFile, t as reviveDumpError, u as StaticRpcDumpManifestStaticEntry } from "../index-vAX6bYuc.mjs";
 export { StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError };

package/dist/rpc/dump.mjs

@@ -1,2 +1,2 @@
-import { a as dumpFunctions, c as serializeDumpError, i as createClientFromDump, o as getDefinitionsWithDumps, s as reviveDumpError, t as collectStaticRpcDump } from "../dump-Cz7yVvsB.mjs";
+import { c as getDefinitionsWithDumps, l as reviveDumpError, o as createClientFromDump, s as dumpFunctions, t as collectStaticRpcDump, u as serializeDumpError } from "../dump-CgZShDRB.mjs";
 export { collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError };

package/dist/rpc/index.d.mts

@@ -1,3 +1,3 @@
-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-CrzNxXKq.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-DgsLFhZg.mjs";
-export { type BirpcFn, type 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 };
+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-CnJSgRVa.mjs";
+import { C as defineRpcFunction, E as RpcCacheOptions, S as createDefineWrapperWithContext, T as RpcCacheManager, _ as validateRpcReturn, a as StaticRpcDumpManifestStaticEntry, b as getRpcHandler, c as collectStaticRpcDump, d as getDefinitionsWithDumps, f as reviveDumpError, g as validateRpcArgs, 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 STRUCTURED_CLONE_PREFIX, w as RpcFunctionsCollectorBase, x as getRpcResolvedSetupResult, y as strictJsonStringify } from "../index-Dbw1p5ch.mjs";
+export { type BirpcFn, type 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, validateRpcArgs, validateRpcReturn };

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-Cz7yVvsB.mjs";
-import { t as diagnostics } from "../diagnostics-BXwBQmoN.mjs";
+import { a as validateRpcReturn, c as getDefinitionsWithDumps$1, d as validateDefinition, f as validateDefinitions, i as validateRpcArgs, l as reviveDumpError$1, n as getRpcHandler, o as createClientFromDump$1, p as hash, r as getRpcResolvedSetupResult, s as dumpFunctions$1, t as collectStaticRpcDump$1, u as serializeDumpError$1 } from "../dump-CgZShDRB.mjs";
+import { t as diagnostics } from "../diagnostics-hwjXp_UV.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";
+import { n as strictJsonStringify, t as STRUCTURED_CLONE_PREFIX } from "../serialization-C8Mnw9hK.mjs";
 //#region src/rpc/cache.ts
 /**
 * @experimental API is expected to change.
@@ -130,4 +130,4 @@ const reviveDumpError = reviveDumpError$1;
 /** @deprecated Import from `devframe/rpc/dump` instead. */
 const serializeDumpError = serializeDumpError$1;
 //#endregion
-export { RpcCacheManager, RpcFunctionsCollectorBase, STRUCTURED_CLONE_PREFIX, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions };
+export { RpcCacheManager, RpcFunctionsCollectorBase, STRUCTURED_CLONE_PREFIX, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions, validateRpcArgs, validateRpcReturn };

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

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

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

@@ -1,5 +1,5 @@
 import { DEVFRAME_AUTH_TOKEN_QUERY_PARAM } from "../../constants.mjs";
-import { n as strictJsonStringify } from "../../serialization-DpLXCy13.mjs";
+import { n as strictJsonStringify } from "../../serialization-C8Mnw9hK.mjs";
 import { n as structuredCloneStringify, t as structuredCloneParse } from "../../structured-clone-CbAV5rFI.mjs";
 //#region src/rpc/transports/ws-client.ts
 function NOOP() {}

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

@@ -1,2 +1,2 @@
-import { a as isAllowedOrigin, i as attachWsRpcTransport, n as WsRpcTransport, o as isLoopbackHostname, r as WsRpcTransportOptions, t as DevframeNodeRpcSessionMeta } from "../../ws-server-9-wn7MNQ.mjs";
-export { DevframeNodeRpcSessionMeta, WsRpcTransport, WsRpcTransportOptions, attachWsRpcTransport, isAllowedOrigin, isLoopbackHostname };
+import { a as WsRpcTransportOptions, c as isAllowedOrigin, i as WsRpcTransport, l as isLoopbackHostname, n as DevframeNodeRpcSessionMeta, o as attachWsRpcTransport, r as WsOriginRegistry, s as createWsOriginRegistry, t as CreateWsOriginRegistryOptions } from "../../ws-server-J-zkiOyp.mjs";
+export { CreateWsOriginRegistryOptions, DevframeNodeRpcSessionMeta, WsOriginRegistry, WsRpcTransport, WsRpcTransportOptions, attachWsRpcTransport, createWsOriginRegistry, isAllowedOrigin, isLoopbackHostname };

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

@@ -1,9 +1,52 @@
-import { n as strictJsonStringify } from "../../serialization-DpLXCy13.mjs";
+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() {}
@@ -32,6 +75,9 @@ function isAllowedOrigin(origin, allowedOrigins) {
 		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
@@ -55,7 +101,8 @@ function routeUpgrades(server, ws, path, destroyUnmatched, allowedOrigins) {
 				return;
 			}
 		}
-		if (allowedOrigins !== false && !isAllowedOrigin(req.headers.origin, allowedOrigins ?? [])) {
+		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;
@@ -164,4 +211,4 @@ function attachWsRpcTransport(rpcGroup, options = {}) {
 	};
 }
 //#endregion
-export { attachWsRpcTransport, isAllowedOrigin, isLoopbackHostname };
+export { attachWsRpcTransport, createWsOriginRegistry, isAllowedOrigin, isLoopbackHostname };

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

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

package/dist/{server-DykHCza_.mjs → server-CXaDDUl0.mjs}

@@ -1,7 +1,7 @@
 import { createRpcServer } from "./rpc/server.mjs";
 import { attachWsRpcTransport } from "./rpc/transports/ws-server.mjs";
-import { a as diagnostics } from "./storage-gEnj9ASQ.mjs";
-import { t as getInternalContext } from "./context-DY72brRI.mjs";
+import { t as diagnostics } from "./diagnostics-B5-qHeqD.mjs";
+import { t as getInternalContext } from "./context-CQefP2jR.mjs";
 import { createServer } from "node:http";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { H3, toNodeHandler } from "h3";