devframe 1.3.2 → 1.3.3

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

@@ -1,4 +1,151 @@
+import { a as ChannelOptions, n as BirpcGroup } from "../../index-BKu9BxcT.mjs";
+import { g as RpcFunctionDefinitionAny } from "../../types-KZOyhez5.mjs";
 import { a as DevframeWsPeer, i as DevframeRpcTransportKind, n as DevframeRpcConnection, r as DevframeRpcConnectionRequest, t as DevframeNodeRpcSessionMeta } from "../../session-Y9R6tqg4.mjs";
-import { r as isLoopbackHostname, t as isAllowedOrigin } from "../../origin-D5i7K_Zb.mjs";
-import { a as attachWsRpcTransport, i as WsRpcTransportOptions, n as WsOriginRegistry, o as createWsOriginRegistry, r as WsRpcTransport, s as createWsRpcPeerHooks, t as CreateWsOriginRegistryOptions } from "../../ws-server-CYHkeyA-.mjs";
-export { CreateWsOriginRegistryOptions, type DevframeNodeRpcSessionMeta, type DevframeRpcConnection, type DevframeRpcConnectionRequest, type DevframeRpcTransportKind, type DevframeWsPeer, WsOriginRegistry, WsRpcTransport, WsRpcTransportOptions, attachWsRpcTransport, createWsOriginRegistry, createWsRpcPeerHooks, isAllowedOrigin, isLoopbackHostname };
+import { isAllowedOrigin, isLoopbackHostname } from "../../utils/origin.mjs";
+import { Hooks } from "crossws";
+import { NodeAdapter } from "crossws/adapters/node";
+import { Buffer } from "node:buffer";
+import { IncomingMessage, Server } from "node:http";
+import { Server as Server$1, ServerOptions } from "node:https";
+import { AddressInfo } from "node:net";
+import { Duplex } from "node:stream";
+export 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
+   * this transport detaches the upgrade listener without closing the server.
+   */
+  server?: Server | Server$1;
+  /**
+   * Port for the standalone WebSocket server. Defaults to `0`, which lets the
+   * operating system assign an available port.
+   */
+  port?: number;
+  /** Host for the standalone WebSocket server. Defaults to `localhost`. */
+  host?: string;
+  /**
+   * Restrict the WS endpoint to a single upgrade route (e.g. `/__ws`). When
+   * sharing a `server`, non-matching upgrade requests are left untouched for
+   * other listeners to handle, so devframe's socket can sit alongside
+   * framework sockets (Vite HMR, etc.).
+   */
+  path?: string;
+  /**
+   * Create the adapter without binding it to anything: no server is created,
+   * no port is bound, no `upgrade` listener is installed. The caller drives
+   * the socket itself through {@link WsRpcTransport.handleUpgrade} (from its
+   * own `upgrade` listener) or {@link WsRpcTransport.attach} (to bind a
+   * server later). Takes precedence over `server` / `port` / `https`.
+   */
+  unbound?: boolean;
+  /**
+   * Destroy upgrade requests that don't match `path` instead of leaving them
+   * for other listeners. Enable this when devframe owns the shared server
+   * outright (nothing else handles its upgrades), so an off-route client is
+   * rejected promptly rather than left hanging. Default: `false`
+   * (coexist-friendly); servers this transport creates itself always
+   * destroy unmatched upgrades.
+   */
+  destroyUnmatched?: boolean;
+  /** When set, a new https.Server is created and the WS endpoint is attached to it. */
+  https?: ServerOptions;
+  /**
+   * Extra origins to accept on the WS upgrade beyond the loopback default.
+   * Add your LAN/tunnel origin here when reaching the tool from another host.
+   * Pass `false` to disable origin checking entirely (not recommended).
+   * Default: loopback-only.
+   */
+  allowedOrigins?: readonly string[] | WsOriginRegistry | false;
+  /**
+   * RPC function definitions, used by the per-call wire serializer to
+   * 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
+   * loses dev-time validation for `jsonSerializable: true` declarations.
+   */
+  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
+  onConnected?: (connection: DevframeRpcConnection, meta: DevframeNodeRpcSessionMeta) => void;
+  onDisconnected?: (connection: DevframeRpcConnection, meta: DevframeNodeRpcSessionMeta) => void;
+  /** Override the default per-call serializer. Most callers should leave this unset. */
+  serialize?: ChannelOptions['serialize'];
+  /** Override the default per-call deserializer. Most callers should leave this unset. */
+  deserialize?: ChannelOptions['deserialize'];
+}
+export interface CreateWsOriginRegistryOptions {
+  /** Origins allowed before any external viewers are registered. */
+  allowedOrigins?: readonly string[];
+  /** Additional validation to run after the registration token is verified. */
+  validateOrigin?: (origin: string) => boolean;
+}
+export interface WsOriginRegistry {
+  /** Registration token to include in connection metadata. */
+  readonly token: string;
+  /** Read and register an origin from a connection bootstrap URL. */
+  registerFromUrl: (url: string) => string | undefined;
+  /** Check whether an origin is currently allowed. */
+  isAllowed: (origin: string | undefined) => boolean;
+}
+/**
+ * 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.
+ */
+export declare function createWsOriginRegistry(options?: CreateWsOriginRegistryOptions): WsOriginRegistry;
+export interface WsRpcTransport {
+  /**
+   * The crossws node adapter driving the socket; exposes the connected
+   * `peers` and pub/sub. See https://crossws.h3.dev.
+   */
+  ws: NodeAdapter;
+  /** Resolves when the transport-owned server is listening. */
+  ready: Promise<void>;
+  /** Returns the bound address, or `null` when the server is not listening. */
+  address: () => AddressInfo | string | null;
+  /**
+   * 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.
+   */
+  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, since the caller owns their lifecycle).
+   */
+  attach: (server: Server | Server$1) => () => void;
+  /** Remove the upgrade listener from a shared `server` (a no-op otherwise). */
+  detach: () => void;
+  /**
+   * Tear the transport down deterministically: detach from a shared server,
+   * force-terminate every connected peer, and close any server this
+   * transport created itself (`port` / `https` modes).
+   */
+  close: () => Promise<void>;
+}
+/**
+ * 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
+ * `jsonSerializable` dispatch between strict JSON and structured-clone.
+ */
+export declare function createWsRpcPeerHooks<ClientFunctions extends object, ServerFunctions extends object>(rpcGroup: BirpcGroup<ClientFunctions, ServerFunctions, false>, options?: Pick<WsRpcTransportOptions, 'onConnected' | 'onDisconnected' | 'definitions' | 'serialize' | 'deserialize'>): Partial<Hooks>;
+/**
+ * Attach a WebSocket transport to an existing RPC group, powered by
+ * [crossws](https://crossws.h3.dev). Either attach to an existing HTTP(S)
+ * `server` (sharing its port, optionally scoped to a `path`), or let this
+ * helper create a standalone server from `port` / `host` / `https`.
+ *
+ * Returns the crossws node adapter, standalone-server readiness/address
+ * accessors, `detach` (remove the upgrade listener from a shared `server`),
+ * and `close` (full deterministic teardown).
+ */
+export declare function attachWsRpcTransport<ClientFunctions extends object, ServerFunctions extends object>(rpcGroup: BirpcGroup<ClientFunctions, ServerFunctions, false>, options?: WsRpcTransportOptions): WsRpcTransport;
+export { type DevframeNodeRpcSessionMeta, type DevframeRpcConnection, type DevframeRpcConnectionRequest, type DevframeRpcTransportKind, type DevframeWsPeer, isAllowedOrigin, isLoopbackHostname };

package/dist/{rpc-core-CDUizUQB.mjs → rpc-core-BmDHiDR6.mjs}

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "./rolldown-runtime-DYf_mQCB.mjs";
+import { n as __exportAll } from "./rolldown-runtime-BVN1G_yT.mjs";
 import { createRpcServer } from "./rpc/server.mjs";
 import { n as getRpcResolvedSetupResult, t as getRpcHandler } from "./handler-DkLlj3-B.mjs";
 import { t as diagnostics } from "./diagnostics-DC1-WcvN.mjs";

package/dist/{rpc-core-CFwyV10r.d.mts → rpc-core-CblgPYJ_.d.mts}

@@ -1,8 +1,8 @@
 import { n as BirpcGroup, o as EventOptions } from "./index-BKu9BxcT.mjs";
-import "./ws-server-CYHkeyA-.mjs";
+import "./rpc/transports/ws-server.mjs";
 import { n as DevframeRpcConnection, t as DevframeNodeRpcSessionMeta } from "./session-Y9R6tqg4.mjs";
-import { Bt as DevframeAuthHandler, o as DevframeNodeContext, s as DevframeNodeRpcSession, vt as DevframeRpcClientFunctions, yt as DevframeRpcServerFunctions } from "./context-WxTq6kqb.mjs";
-import "./index-HMJPlexc.mjs";
+import { B as DevframeNodeRpcSession, J as DevframeRpcClientFunctions, Y as DevframeRpcServerFunctions, k as DevframeAuthHandler, z as DevframeNodeContext } from "./index-BhUqJUHG.mjs";
+import "./node/auth.mjs";
 interface CreateContextRpcServerOptions {
   context: DevframeNodeContext;
   /**

package/dist/types/index.d.mts

@@ -1,6 +1,6 @@
-import { m as RpcFunctionAgentOptions } from "../types-844OBepb.mjs";
-import { $ as DevframeServiceOf, $t as AgentToolProviderHandle, At as McpFetchHandler, B as DevframeSetupInfo, Ct as DevframeStorageScope, Dt as CreateMcpServerOptions, Et as CreateMcpFetchHandlerOptions, F as DevframeDefinition, Ft as McpResourceTemplate, G as McpAuthorization, Gt as AgentHandle, H as DevframeSnapshotRpcInputs, I as DevframeDeploymentKind, It as McpResourceTemplateContent, J as DevframeServiceDefinition, Jt as AgentResourceContent, K as McpRouteOptions, Kt as AgentManifest, L as DevframeDockDefaults, Lt as McpResourceTemplateEntry, Mt as McpPromptArgument, Nt as McpPromptMessage, Ot as McpConnectionInfo, P as DevframeCliOptions, Pt as McpPromptResult, Q as DevframeServiceMeta, Qt as AgentToolProvider, R as DevframeDuplicationStrategy, Rt as McpResourcesChangedHook, St as DevframeHost, Tt as DevframeDiagnosticsLogger, U as DevframeSseOptions, V as DevframeSnapshotRpcEntry, W as DevframeWsOptions, X as DevframeServiceId, Xt as AgentTool, Y as DevframeServiceDescriptor, Yt as AgentResourceInput, Z as DevframeServiceInput, Zt as AgentToolInput, _t as DevframeViewHost, a as DevframeConnectionConfigsRegistry, at as DevframeScopedNodeContext, bt as DevframeRpcSharedStates, c as RpcBroadcastOptions, ct as DevframeSettings, d as RpcSharedStateHost, dt as ScopedBroadcastOptions, en as DevframeAgentHost, et as DevframeServiceScopeOf, f as RpcStreamingChannel, ft as ScopedClientFunctions, gt as SettingsForNamespace, ht as ScopedSharedStates, i as DevframeCapabilities, in as EventsMap, it as DevframeServicesState, jt as McpPrompt, kt as McpContentBlock, l as RpcFunctionsHost, lt as DevframeSettingsRegistry, m as RpcStreamingHost, mt as ScopedServerFunctions, n as ConnectionMetaSse, nn as EventEmitter, nt as DevframeServicesRegistry, o as DevframeNodeContext, ot as DevframeScopedNodeRpc, p as RpcStreamingChannelOptions, pt as ScopedRpcFn, q as McpSetting, qt as AgentResource, r as ConnectionMetaWebsocket, rn as EventUnsubscribe, rt as DevframeServicesScopeRegistry, s as DevframeNodeRpcSession, st as DevframeScopedStreamingHost, t as ConnectionMeta, tn as DevframeAgentHostEvents, tt as DevframeServicesHost, u as RpcSharedStateGetOptions, ut as DevframeSettingsStore, vt as DevframeRpcClientFunctions, wt as DevframeDiagnosticsHost, yt as DevframeRpcServerFunctions, z as DevframeRpcOptions, zt as McpServerHandle } from "../context-WxTq6kqb.mjs";
+import { m as RpcFunctionAgentOptions } from "../types-KZOyhez5.mjs";
+import { $ as DevframeServiceId, $t as AgentToolProviderHandle, B as DevframeNodeRpcSession, C as McpPromptResult, Ct as DevframeDiagnosticsHost, D as McpResourcesChangedHook, E as McpResourceTemplateEntry, F as ConnectionMetaSse, G as RpcStreamingChannel, Gt as AgentHandle, H as RpcFunctionsHost, I as ConnectionMetaWebsocket, J as DevframeRpcClientFunctions, Jt as AgentResourceContent, K as RpcStreamingChannelOptions, Kt as AgentManifest, L as DevframeCapabilities, O as McpServerHandle, P as ConnectionMeta, Q as DevframeServiceDescriptor, Qt as AgentToolProvider, R as DevframeConnectionConfigsRegistry, S as McpPromptMessage, St as DevframeStorageScope, T as McpResourceTemplateContent, U as RpcSharedStateGetOptions, V as RpcBroadcastOptions, W as RpcSharedStateHost, X as DevframeRpcSharedStates, Xt as AgentTool, Y as DevframeRpcServerFunctions, Yt as AgentResourceInput, Z as DevframeServiceDefinition, Zt as AgentToolInput, _ as McpConnectionInfo, _t as ScopedServerFunctions, a as DevframeDuplicationStrategy, at as DevframeServicesRegistry, b as McpPrompt, bt as DevframeViewHost, c as DevframeSnapshotRpcEntry, ct as DevframeScopedNodeContext, d as DevframeWsOptions, dt as DevframeSettings, en as DevframeAgentHost, et as DevframeServiceInput, f as McpAuthorization, ft as DevframeSettingsRegistry, g as CreateMcpServerOptions, gt as ScopedRpcFn, h as CreateMcpFetchHandlerOptions, ht as ScopedClientFunctions, i as DevframeDockDefaults, in as EventsMap, it as DevframeServicesHost, l as DevframeSnapshotRpcInputs, lt as DevframeScopedNodeRpc, m as McpSetting, mt as ScopedBroadcastOptions, n as DevframeDefinition, nn as EventEmitter, nt as DevframeServiceOf, o as DevframeRpcOptions, ot as DevframeServicesScopeRegistry, p as McpRouteOptions, pt as DevframeSettingsStore, q as RpcStreamingHost, qt as AgentResource, r as DevframeDeploymentKind, rn as EventUnsubscribe, rt as DevframeServiceScopeOf, s as DevframeSetupInfo, st as DevframeServicesState, t as DevframeCliOptions, tn as DevframeAgentHostEvents, tt as DevframeServiceMeta, u as DevframeSseOptions, ut as DevframeScopedStreamingHost, v as McpContentBlock, vt as ScopedSharedStates, w as McpResourceTemplate, wt as DevframeDiagnosticsLogger, x as McpPromptArgument, xt as DevframeHost, y as McpFetchHandler, yt as SettingsForNamespace, z as DevframeNodeContext } from "../index-BhUqJUHG.mjs";
 import { a as DevframeWsPeer, i as DevframeRpcTransportKind, n as DevframeRpcConnection, r as DevframeRpcConnectionRequest, t as DevframeNodeRpcSessionMeta } from "../session-Y9R6tqg4.mjs";
+import { DevframeDefineDiagnosticsOptions } from "../utils/nostics.mjs";
 import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "../remote-assets-5AQMHZnV.mjs";
-import { i as DevframeDefineDiagnosticsOptions } from "../nostics-Dgwh7ytT.mjs";
 export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, CreateMcpFetchHandlerOptions, CreateMcpServerOptions, DevframeAgentHost, DevframeAgentHostEvents, DevframeCapabilities, DevframeCliOptions, DevframeConnectionConfigsRegistry, type DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, type DevframeRpcConnection, type DevframeRpcConnectionRequest, DevframeRpcOptions, DevframeRpcServerFunctions, DevframeRpcSharedStates, type DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceDefinition, DevframeServiceDescriptor, DevframeServiceId, DevframeServiceInput, DevframeServiceMeta, DevframeServiceOf, DevframeServiceScopeOf, DevframeServicesHost, DevframeServicesRegistry, DevframeServicesScopeRegistry, DevframeServicesState, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSnapshotRpcEntry, DevframeSnapshotRpcInputs, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, type DevframeWsPeer, EventEmitter, EventUnsubscribe, EventsMap, McpAuthorization, McpConnectionInfo, McpContentBlock, McpFetchHandler, McpPrompt, McpPromptArgument, McpPromptMessage, McpPromptResult, McpResourceTemplate, McpResourceTemplateContent, McpResourceTemplateEntry, McpResourcesChangedHook, McpRouteOptions, McpServerHandle, McpSetting, RemoteAssets, RemoteAssetsErrorMessage, RemoteAssetsProvider, RemoteAssetsProviderCustom, RemoteAssetsStore, RpcBroadcastOptions, type RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, StaticAssetsSource };

package/dist/{types-844OBepb.d.mts → types-KZOyhez5.d.mts}

@@ -1,4 +1,5 @@
 import { t as StandardSchemaV1 } from "./index-BIRF0E5l.mjs";
+import "./index-BKu9BxcT.mjs";
 /** Infers a TypeScript argument tuple from a Standard Schema array */
 type InferArgsType<S extends RpcArgsSchema | undefined> = S extends readonly [] ? [] : S extends readonly [infer H, ...infer T] ? H extends StandardSchemaV1 ? T extends readonly StandardSchemaV1[] ? [StandardSchemaV1.InferInput<H>, ...InferArgsType<T>] : never : never : never;
 /** Infers a TypeScript return type from a Standard Schema */

package/dist/utils/debounce.d.mts

@@ -1,3 +1,9 @@
+/**
+ * Promise-aware debounce, bundled in so any integration can reuse it through
+ * `devframe/utils/debounce` without adding its own `perfect-debounce`
+ * dependency. Thin re-export of `perfect-debounce`'s `debounce`; the bytes
+ * live once in devframe's dist.
+ */
 //#region src/index.d.ts
 interface DebounceOptions {
   /**

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { in as EventsMap, nn as EventEmitter } from "../context-WxTq6kqb.mjs";
+import { in as EventsMap, nn as EventEmitter } from "../index-BhUqJUHG.mjs";
 /**
  * Create event emitter.
  */

package/dist/utils/get-port.mjs

@@ -1 +1 @@
-export { n as getPort } from "../dist-DJydMELP.mjs";
+export { n as getPort } from "../dist-CZ-TySHD.mjs";

package/dist/utils/launch-editor.mjs

@@ -1,4 +1,4 @@
-import { i as __toESM, r as __require, t as __commonJSMin } from "../rolldown-runtime-DYf_mQCB.mjs";
+import { i as __toESM, r as __require, t as __commonJSMin } from "../rolldown-runtime-BVN1G_yT.mjs";
 // ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
 var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	let p = process || {};

package/dist/utils/nostics.d.mts

@@ -1,2 +1,40 @@
-import { _ as formatDiagnostic, a as DevframeDiagnostics, c as DiagnosticDefinition, d as DiagnosticReporter, f as Diagnostics, g as defineProdDiagnostics, h as defineDiagnostics, i as DevframeDefineDiagnosticsOptions, l as DiagnosticHandle, m as createConsoleReporter, n as ConsoleMethod, o as Diagnostic, p as ansiFormatter, r as ConsoleReporterOptions, s as DiagnosticCallParams, t as AnyDiagnosticReporter, u as DiagnosticInit } from "../nostics-Dgwh7ytT.mjs";
-export { type AnyDiagnosticReporter, type ConsoleMethod, type ConsoleReporterOptions, DevframeDefineDiagnosticsOptions, DevframeDiagnostics, type Diagnostic, type DiagnosticCallParams, type DiagnosticDefinition, type DiagnosticHandle, type DiagnosticInit, type DiagnosticReporter, type Diagnostics, ansiFormatter, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };
+import { AnyDiagnosticReporter, AnyDiagnosticReporter as AnyDiagnosticReporter$1, ConsoleMethod, ConsoleReporterOptions, Diagnostic, Diagnostic as Diagnostic$1, DiagnosticCallParams, DiagnosticDefinition, DiagnosticDefinition as DiagnosticDefinition$1, DiagnosticHandle, DiagnosticInit, DiagnosticReporter, Diagnostics, Diagnostics as Diagnostics$1, createConsoleReporter, defineProdDiagnostics, formatDiagnostic } from "nostics";
+import { ansiFormatter } from "nostics/formatters/ansi";
+/**
+ * The reporter every {@link defineDiagnostics} call below wires in ahead of
+ * any caller-supplied ones: prints the diagnostic through devframe's own
+ * ANSI colors via `console[method]` (default `'warn'`).
+ */
+declare function devframeReporter(d: Diagnostic$1, { method }?: {
+  method?: 'log' | 'warn' | 'error';
+}): void;
+/**
+ * Options accepted by {@link defineDiagnostics}, identical to `nostics`'s
+ * own `DefineDiagnosticsOptions`, minus the reporter devframe already
+ * prepends.
+ */
+export type DevframeDefineDiagnosticsOptions<Codes extends Record<string, DiagnosticDefinition$1>, Reporters extends readonly AnyDiagnosticReporter$1[] = []> = Parameters<typeof defineDiagnostics<Codes, Reporters>>[0];
+/**
+ * Drop-in replacement for `nostics`'s `defineDiagnostics()` with devframe's
+ * ANSI console reporter pre-wired ahead of any `reporters` passed in. Every
+ * `diagnostics.ts` in devframe core, `@devframes/hub`, `@devframes/json-render`,
+ * and the built-in plugins defines its codes through this instead of
+ * `nostics`'s own `defineDiagnostics`; the reporter registration lives
+ * here, once, so none of them need to build their own reporter (`colors`,
+ * `ansiFormatter`) or take a direct dependency on `nostics` themselves.
+ */
+export declare function defineDiagnostics<const Codes extends Record<string, DiagnosticDefinition$1>, const Reporters extends readonly AnyDiagnosticReporter$1[] = []>(options: {
+  docsBase?: string | ((code: keyof Codes) => string | undefined);
+  codes: Codes;
+  reporters?: Reporters;
+}): DevframeDiagnostics<Codes, Reporters>;
+/**
+ * The `Diagnostics` object returned by devframe's {@link defineDiagnostics}
+ * (devframe's ANSI console reporter is always prepended). Integrations that
+ * export their own `defineDiagnostics(...)` result as public API annotate it
+ * with this type, so the reference resolves through `devframe/utils/nostics`
+ * rather than inlining `nostics`'s types or taking a direct `nostics`
+ * dependency.
+ */
+export type DevframeDiagnostics<Codes extends Record<string, DiagnosticDefinition$1>, Reporters extends readonly AnyDiagnosticReporter$1[] = []> = Diagnostics$1<Codes, readonly [typeof devframeReporter, ...Reporters]>;
+export { type AnyDiagnosticReporter, type ConsoleMethod, type ConsoleReporterOptions, type Diagnostic, type DiagnosticCallParams, type DiagnosticDefinition, type DiagnosticHandle, type DiagnosticInit, type DiagnosticReporter, type Diagnostics, ansiFormatter, createConsoleReporter, defineProdDiagnostics, formatDiagnostic };

package/dist/utils/origin.d.mts

@@ -1,2 +1,55 @@
-import { i as validateOriginCandidate, n as isLoopbackAddress, r as isLoopbackHostname, t as isAllowedOrigin } from "../origin-D5i7K_Zb.mjs";
-export { isAllowedOrigin, isLoopbackAddress, isLoopbackHostname, validateOriginCandidate };
+/**
+ * Origin and hostname predicates shared by the RPC transports (the WS upgrade,
+ * SSE, and MCP origin gates) and the instance shell's authentication-link
+ * origin validation. Kept dependency-free and runtime-agnostic so any consumer
+ * can pull in a single check without dragging in a transport's `crossws`
+ * import.
+ */
+/**
+ * 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.
+ */
+export declare function isLoopbackHostname(hostname: string): boolean;
+/**
+ * Whether `address` is a loopback peer address as reported by a socket
+ * (`net.Socket.remoteAddress`): the IPv6 loopback `::1`, an IPv4 literal in
+ * `127.0.0.0/8`, or an IPv4-mapped IPv6 form of one (`::ffff:127.0.0.1`).
+ *
+ * Unlike {@link isLoopbackHostname} this takes a raw address, not a hostname:
+ * it never accepts a `localhost`-style name (a socket peer is always a literal
+ * address) and understands the IPv4-mapped IPv6 form the OS hands back on a
+ * dual-stack listener. Used to prove a same-machine caller from the connected
+ * peer, which a client cannot forge, rather than from the `Origin` header,
+ * which it can.
+ */
+export declare function isLoopbackAddress(address: 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, such as a real remote page in the dev's
+ * browser, is rejected.
+ */
+export declare function isAllowedOrigin(origin: string | undefined, allowedOrigins: readonly string[]): boolean;
+/**
+ * Decide whether a request-derived origin candidate may back a devframe's
+ * advertised public origin, the destination of the OTP magic link. Stricter
+ * than {@link isAllowedOrigin}: it rejects credentials, a path, a query, a
+ * fragment, a malformed port, and non-HTTP(S) schemes, and adopts a candidate
+ * only when its hostname is loopback or its canonical origin exactly matches
+ * an `allowedOrigins` entry (a caller with no static list passes none, so only
+ * loopback qualifies). Returns the canonical origin to adopt, or `undefined`
+ * to reject. Forwarded headers are never consulted.
+ */
+export declare function validateOriginCandidate(candidate: string, allowedOrigins?: readonly string[]): string | undefined;

package/dist/utils/serve-static.d.mts

@@ -1,6 +1,6 @@
 import { a as RemoteAssetsStore } from "../remote-assets-5AQMHZnV.mjs";
-import { EventHandler, H3 } from "h3";
 import { IncomingMessage, ServerResponse } from "node:http";
+import { EventHandler, H3 } from "h3";
 /**
  * What the static-serving engine accepts: a local directory, or a resolved
  * {@link RemoteAssetsStore} back-proxy (from `devframe/utils/remote-assets`).

package/dist/utils/shared-state.d.mts

@@ -1,2 +1,2 @@
-import { A as SharedStateEvents, D as ImmutableObject, E as ImmutableMap, M as SharedStatePatch, N as createSharedState, O as ImmutableSet, T as ImmutableArray, j as SharedStateOptions, k as SharedState, w as Immutable } from "../context-WxTq6kqb.mjs";
+import { Bt as SharedState, Ft as Immutable, Ht as SharedStateOptions, It as ImmutableArray, Lt as ImmutableMap, Rt as ImmutableObject, Ut as SharedStatePatch, Vt as SharedStateEvents, Wt as createSharedState, zt as ImmutableSet } from "../index-BhUqJUHG.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

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-WxTq6kqb.mjs";
+import { At as StreamReader, Dt as CreateStreamReaderOptions, Et as BufferedChunk, Mt as StreamSinkEvents, Nt as createStreamReader, Ot as CreateStreamSinkOptions, Pt as createStreamSink, jt as StreamSink, kt as StreamErrorPayload } from "../index-BhUqJUHG.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devframe",
   "type": "module",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Framework for building one portable devtool integration that runs in any viewer.",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -77,7 +77,7 @@
     "skills"
   ],
   "peerDependencies": {
-    "@devframes/agentic": "1.3.2",
+    "@devframes/agentic": "1.3.3",
     "cac": "^7.0.0"
   },
   "peerDependenciesMeta": {
@@ -95,7 +95,7 @@
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@devframes/agentic": "1.3.2",
+    "@devframes/agentic": "1.3.3",
     "@standard-schema/spec": "^1.1.0",
     "birpc": "^4.2.0",
     "cac": "^7.1.0",
@@ -110,12 +110,12 @@
     "perfect-debounce": "^2.1.0",
     "structured-clone-es": "^2.0.1",
     "tinyglobby": "^0.2.17",
-    "tsdown": "^0.23.4",
+    "tsdown": "^0.23.7",
     "typescript": "^6.0.3",
     "ua-parser-modern": "^0.1.1",
     "valibot": "^1.5.0",
     "whenexpr": "^0.1.2",
-    "ws": "^8.22.1"
+    "ws": "^8.22.2"
   },
   "scripts": {
     "build": "tsdown",

package/dist/index-D0qrBkhO.d.mts

@@ -1,121 +0,0 @@
-import { C as RpcFunctionType, S as RpcFunctionSetupResult, T as RpcReturnSchema, g as RpcFunctionDefinitionAny, h as RpcFunctionDefinition, n as RpcArgsSchema, w as RpcFunctionsCollector } from "./types-844OBepb.mjs";
-interface RpcCacheOptions {
-  functions: string[];
-  keySerializer?: (args: unknown[]) => string;
-}
-/**
- * @experimental API is expected to change.
- */
-declare class RpcCacheManager {
-  private cacheMap;
-  private options;
-  private keySerializer;
-  constructor(options: RpcCacheOptions);
-  updateOptions(options: Partial<RpcCacheOptions>): void;
-  cached<T>(m: string, a: unknown[]): T | undefined;
-  has(m: string, a: unknown[]): boolean;
-  apply(req: {
-    m: string;
-    a: unknown[];
-  }, res: unknown): void;
-  validate(m: string): boolean;
-  clear(fn?: string): void;
-}
-declare class RpcFunctionsCollectorBase<LocalFunctions extends Record<string, any>, SetupContext> implements RpcFunctionsCollector<LocalFunctions, SetupContext> {
-  readonly context: SetupContext;
-  readonly definitions: Map<string, RpcFunctionDefinition<string, any, any, any, any, any, SetupContext>>;
-  readonly functions: LocalFunctions;
-  private readonly _onChanged;
-  constructor(context: SetupContext);
-  register(fnDef: RpcFunctionDefinition<string, any, any, any, any, any, SetupContext>, force?: boolean): void;
-  update(fn: RpcFunctionDefinition<string, any, any, any, any, any, SetupContext>, force?: boolean): void;
-  onChanged(fn: (id?: string) => void): () => void;
-  getHandler<T extends keyof LocalFunctions>(name: T): Promise<LocalFunctions[T]>;
-  getSchema<T extends keyof LocalFunctions>(name: T): {
-    args: RpcArgsSchema | undefined;
-    returns: RpcReturnSchema | undefined;
-  };
-  has(name: string): boolean;
-  get(name: string): RpcFunctionDefinition<string, any, any, any, any, any, SetupContext> | undefined;
-  list(): string[];
-}
-declare function defineRpcFunction<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS>): RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS>;
-declare function createDefineWrapperWithContext<CONTEXT>(): <NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, CONTEXT>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, CONTEXT>;
-declare function getRpcResolvedSetupResult<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, CONTEXT = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, any, any, CONTEXT>, context: CONTEXT): Promise<RpcFunctionSetupResult<ARGS, RETURN>>;
-declare function getRpcHandler<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, CONTEXT = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, any, any, CONTEXT>, context: CONTEXT): Promise<(...args: ARGS) => RETURN>;
-/**
- * Wire format used by the live RPC transports (WebSocket and SSE).
- *
- * - **JSON (default, unprefixed):** payload is plain JSON text. Used when
- *   the dispatched method is declared `jsonSerializable: true`. Encoded
- *   via {@link strictJsonStringify} (rejects non-JSON values), decoded
- *   via `JSON.parse`.
- * - **Structured-clone (`s:` prefix):** payload is `s:` followed by
- *   `structured-clone-es` text. Used when the method is declared
- *   `jsonSerializable: false` (or omitted, the default). Round-trips
- *   `Map`, `Set`, `Date`, `BigInt`, cycles, and class instances.
- *
- * 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
- * coupled by a mirror rule.
- */
-declare const STRUCTURED_CLONE_PREFIX = "s:";
-/**
- * `JSON.stringify` with a single-pass strict replacer.
- *
- * Throws `DF0020` synchronously when the value contains a type JSON
- * cannot round-trip losslessly: `Map`, `Set`, `Date`, `BigInt`, class
- * 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.
- *
- * Lenient cases (allowed without throwing):
- *   - `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.
- *
- * `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.
- */
-declare function strictJsonStringify(value: unknown, fnName?: string): string;
-/**
- * Validate positional arguments against their declared schemas. Only
- * indices with a schema are checked; extra arguments pass through
- * untouched. Throws `DF0038` on the first failing argument.
- *
- * Validation guards the payload without rewriting it: the original values
- * are handed to the handler unchanged, so a schema that describes a subset
- * of an object never silently strips the sender's extra fields (and any
- * declared transforms stay a purely type-level concern).
- *
- * @internal
- */
-declare function validateRpcArgs(name: string, argsSchema: RpcArgsSchema | undefined, args: readonly unknown[]): Promise<unknown[]>;
-/**
- * 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
- * {@link validateRpcArgs}). Passes through when no return schema is set.
- *
- * @internal
- */
-declare function validateRpcReturn(name: string, returnSchema: RpcReturnSchema | undefined, value: unknown): Promise<unknown>;
-/**
- * Validates RPC function definitions.
- * Action and event functions cannot have dumps (side effects should not be cached).
- *
- * @throws {Error} If an action or event function has a dump configuration
- */
-declare function validateDefinitions(definitions: readonly RpcFunctionDefinitionAny[]): void;
-/**
- * Validates a single RPC function definition.
- *
- * @throws {Error} If an action or event function has a dump configuration
- */
-declare function validateDefinition(definition: RpcFunctionDefinitionAny): void;
-export { STRUCTURED_CLONE_PREFIX as a, getRpcResolvedSetupResult as c, RpcFunctionsCollectorBase as d, RpcCacheManager as f, validateRpcReturn as i, createDefineWrapperWithContext as l, validateDefinitions as n, strictJsonStringify as o, RpcCacheOptions as p, validateRpcArgs as r, getRpcHandler as s, validateDefinition as t, defineRpcFunction as u };

package/dist/index-HMJPlexc.d.mts

@@ -1,84 +0,0 @@
-import { k as SharedState, o as DevframeNodeContext, s as DevframeNodeRpcSession } from "./context-WxTq6kqb.mjs";
-import { n as InternalAnonymousAuthStorage } from "./context-CsdPs3po.mjs";
-/**
- * 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.
- */
-declare function revokeActiveConnectionsForToken(context: DevframeNodeContext, token: string): Promise<void>;
-/**
- * Revoke an auth token: remove from storage and notify all connected clients
- * using this token that they are no longer trusted.
- */
-declare function revokeAuthToken(context: DevframeNodeContext, storage: SharedState<InternalAnonymousAuthStorage>, token: string): Promise<void>;
-/**
- * Format a raw `navigator.userAgent` string into the short display label
- * shown for a trusted device (e.g. "Chrome 120 | macOS 14 desktop").
- *
- * The client used to parse+format this itself, but that pulled
- * `ua-parser-modern` into the browser bundle for a label nothing else on
- * the client needs; the client now sends the raw string and parsing
- * happens here, at the server ingress, keeping the persisted label format
- * identical.
- */
-declare function describeUA(userAgent: string): string;
-/**
- * The current one-time authentication code. Display this to the user (e.g. in
- * the dev-server terminal) so they can type it into the browser to authenticate.
- */
-declare function getTempAuthCode(): string;
-/**
- * The current code plus its expiry timestamp, for display (e.g. the auth
- * banner). An already-expired code is rotated first, so the returned code is
- * always redeemable for its remaining lifetime.
- */
-declare function getTempAuthCodeInfo(): {
-  code: string;
-  expireAt: number;
-};
-/**
- * Rotate the authentication code, resetting its expiry window and failed-attempt
- * counter. Call this when a new authentication flow begins (e.g. when an
- * untrusted client starts authenticating) so the displayed code is freshly
- * valid for its full TTL.
- */
-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;
- * 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
- * `consumeOtpFromUrl`). Any existing fragment parameters are preserved.
- */
-declare function buildOtpAuthUrl(baseUrl: string, code?: string): string;
-/**
- * Re-authenticate a connection that presents a previously-issued bearer token.
- * Returns `true` and marks the session trusted when the token is known.
- *
- * Used by the `anonymous:devframe:auth` handler so a client that already
- * authenticated (token persisted in the browser) is trusted on reconnect
- * without entering the code again.
- */
-declare function verifyAuthToken(token: string, session: DevframeNodeRpcSession, storage: SharedState<InternalAnonymousAuthStorage>): boolean;
-/**
- * Exchange a one-time authentication code for a fresh, node-issued bearer token.
- *
- * On success this mints a high-entropy token, records it in the trusted store,
- * marks the calling session trusted, rotates the code, and returns the token
- * for the client to persist. Returns `null` on any failure.
- *
- * Because the code is short and human-typed, verification is hardened against
- * brute force: it enforces a time-to-live, compares in constant time, and
- * rotates the code after {@link TEMP_AUTH_MAX_ATTEMPTS} failed attempts so an
- * attacker cannot keep guessing against the same code.
- */
-declare function exchangeTempAuthCode(code: string, session: DevframeNodeRpcSession, info: {
-  ua: string;
-  origin: string;
-}, storage: SharedState<InternalAnonymousAuthStorage>): string | null;
-export { getTempAuthCodeInfo as a, revokeActiveConnectionsForToken as c, getTempAuthCode as i, revokeAuthToken as l, describeUA as n, refreshTempAuthCode as o, exchangeTempAuthCode as r, verifyAuthToken as s, buildOtpAuthUrl as t };