devframe 0.9.8 → 0.9.10

package/dist/{state-CK9LjrnT.mjs → state-Mwt6--el.mjs}

@@ -1,5 +1,5 @@
 import { DEVFRAME_OTP_URL_PARAM } from "./constants.mjs";
-import { n as randomToken, r as timingSafeEqual, t as randomDigits } from "./crypto-token-XCqTSMg9.mjs";
+import { n as randomToken, r as timingSafeEqual, t as randomDigits } from "./crypto-token-TVbGGFuj.mjs";
 //#region ../../node_modules/.pnpm/ua-parser-modern@0.1.1/node_modules/ua-parser-modern/dist/index.mjs
 const EMPTY = "";
 const UNKNOWN = "?";
@@ -1169,7 +1169,7 @@ function parseUA(uastringOrExtensions, extensions) {
 *
 * 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
+* the client needs; the client now sends the raw string and parsing
 * happens here, at the server ingress, keeping the persisted label format
 * identical.
 */
@@ -1194,18 +1194,25 @@ const TEMP_AUTH_CODE_LENGTH = 6;
 const TEMP_AUTH_CODE_TTL = 3e5;
 /** Failed attempts allowed against a single code before it is rotated. */
 const TEMP_AUTH_MAX_ATTEMPTS = 5;
-let tempAuthCode = generateTempCode();
-let tempAuthCodeExpiresAt = Date.now() + TEMP_AUTH_CODE_TTL;
+let tempAuthCode;
+let tempAuthCodeExpiresAt = 0;
 let tempAuthFailedAttempts = 0;
 function generateTempCode() {
 	return randomDigits(TEMP_AUTH_CODE_LENGTH);
 }
+function ensureTempAuthCode() {
+	if (tempAuthCode === void 0) {
+		tempAuthCode = generateTempCode();
+		tempAuthCodeExpiresAt = Date.now() + TEMP_AUTH_CODE_TTL;
+	}
+	return tempAuthCode;
+}
 /**
 * 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.
 */
 function getTempAuthCode() {
-	return tempAuthCode;
+	return ensureTempAuthCode();
 }
 /**
 * Rotate the authentication code, resetting its expiry window and failed-attempt
@@ -1221,16 +1228,16 @@ function refreshTempAuthCode() {
 }
 /**
 * 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.
 */
-function buildOtpAuthUrl(baseUrl, code = tempAuthCode) {
+function buildOtpAuthUrl(baseUrl, code = getTempAuthCode()) {
 	const url = new URL(baseUrl);
 	const fragment = new URLSearchParams(url.hash.replace(/^#/, ""));
 	fragment.set(DEVFRAME_OTP_URL_PARAM, code);
@@ -1264,11 +1271,12 @@ function verifyAuthToken(token, session, storage) {
 * attacker cannot keep guessing against the same code.
 */
 function exchangeTempAuthCode(code, session, info, storage) {
+	const currentTempAuthCode = ensureTempAuthCode();
 	if (Date.now() > tempAuthCodeExpiresAt) {
 		refreshTempAuthCode();
 		return null;
 	}
-	if (!timingSafeEqual(code, tempAuthCode)) {
+	if (!timingSafeEqual(code, currentTempAuthCode)) {
 		tempAuthFailedAttempts += 1;
 		if (tempAuthFailedAttempts >= TEMP_AUTH_MAX_ATTEMPTS) refreshTempAuthCode();
 		return null;

package/dist/{storage-BXNVhKyR.mjs → storage-B70AXK64.mjs}

@@ -1,7 +1,7 @@
-import { t as diagnostics } from "./diagnostics-BXWW3VK-.mjs";
+import { t as diagnostics } from "./diagnostics-DZA6KQ_Z.mjs";
+import { dirname } from "pathe";
 import { createSharedState } from "devframe/utils/shared-state";
 import process from "node:process";
-import { dirname } from "pathe";
 import fs from "node:fs";
 //#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
 const DEBOUNCE_DEFAULTS = { trailing: true };

package/dist/types/index.d.mts

@@ -1,6 +1,6 @@
-import { g as RpcFunctionAgentOptions } from "../types-CMdPYhOx.mjs";
-import { d as DevframeRpcConnection, f as DevframeRpcConnectionRequest, p as DevframeRpcTransportKind, u as DevframeNodeRpcSessionMeta } from "../ws-server-VyHlanzy.mjs";
-import { $ as DevframeServicesHost, At as AgentResource, B as DevframeSetupInfo, Bt as EventUnsubscribe, F as DevframeDefinition, Ft as AgentToolProvider, G as McpRouteOptions, H as DevframeSnapshotRpcInputs, I as DevframeDeploymentKind, It as AgentToolProviderHandle, J as DevframeServiceId, K as DevframeServiceDefinition, L as DevframeDockDefaults, Lt as DevframeAgentHost, Mt as AgentResourceInput, Nt as AgentTool, Ot as AgentHandle, P as DevframeCliOptions, Pt as AgentToolInput, Q as DevframeServiceScopeOf, R as DevframeDuplicationStrategy, Rt as DevframeAgentHostEvents, St as DevframeDiagnosticsLogger, U as DevframeSseOptions, V as DevframeSnapshotRpcEntry, Vt as EventsMap, W as DevframeWsOptions, X as DevframeServiceMeta, Y as DevframeServiceInput, Z as DevframeServiceOf, _t as DevframeRpcServerFunctions, a as DevframeConnectionConfigsRegistry, at as DevframeScopedStreamingHost, bt as DevframeStorageScope, c as RpcBroadcastOptions, ct as DevframeSettingsStore, d as RpcSharedStateHost, dt as ScopedRpcFn, et as DevframeServicesRegistry, f as RpcStreamingChannel, ft as ScopedServerFunctions, gt as DevframeRpcClientFunctions, ht as DevframeViewHost, i as DevframeCapabilities, it as DevframeScopedNodeRpc, jt as AgentResourceContent, kt as AgentManifest, l as RpcFunctionsHost, lt as ScopedBroadcastOptions, m as RpcStreamingHost, mt as SettingsForNamespace, n as ConnectionMetaSse, nt as DevframeServicesState, o as DevframeNodeContext, ot as DevframeSettings, p as RpcStreamingChannelOptions, pt as ScopedSharedStates, q as DevframeServiceDescriptor, r as ConnectionMetaWebsocket, rt as DevframeScopedNodeContext, s as DevframeNodeRpcSession, st as DevframeSettingsRegistry, t as ConnectionMeta, tt as DevframeServicesScopeRegistry, u as RpcSharedStateGetOptions, ut as ScopedClientFunctions, vt as DevframeRpcSharedStates, xt as DevframeDiagnosticsHost, yt as DevframeHost, z as DevframeRpcOptions, zt as EventEmitter } from "../context-CLF4-8Pp.mjs";
-import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "../remote-assets-B13_vRkJ.mjs";
-import { i as DevframeDefineDiagnosticsOptions } from "../nostics-SPGDgHEP.mjs";
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, 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, EventEmitter, EventUnsubscribe, EventsMap, McpRouteOptions, RemoteAssets, RemoteAssetsErrorMessage, RemoteAssetsProvider, RemoteAssetsProviderCustom, RemoteAssetsStore, RpcBroadcastOptions, type RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, StaticAssetsSource };
+import { g as RpcFunctionAgentOptions } from "../types-Dq4i156u.mjs";
+import { c as DevframeNodeRpcSessionMeta, d as DevframeRpcTransportKind, l as DevframeRpcConnection, u as DevframeRpcConnectionRequest } from "../ws-server-D2nv68Hg.mjs";
+import { $ as DevframeServiceOf, At as AgentHandle, B as DevframeSetupInfo, Bt as DevframeAgentHostEvents, Ct as DevframeDiagnosticsHost, F as DevframeDefinition, Ft as AgentTool, G as McpAuthorization, H as DevframeSnapshotRpcInputs, Ht as EventUnsubscribe, I as DevframeDeploymentKind, It as AgentToolInput, J as DevframeServiceDefinition, K as McpRouteOptions, L as DevframeDockDefaults, Lt as AgentToolProvider, Mt as AgentResource, Nt as AgentResourceContent, P as DevframeCliOptions, Pt as AgentResourceInput, Q as DevframeServiceMeta, R as DevframeDuplicationStrategy, Rt as AgentToolProviderHandle, St as DevframeStorageScope, U as DevframeSseOptions, Ut as EventsMap, V as DevframeSnapshotRpcEntry, Vt as EventEmitter, W as DevframeWsOptions, X as DevframeServiceId, Y as DevframeServiceDescriptor, Z as DevframeServiceInput, _t as DevframeViewHost, a as DevframeConnectionConfigsRegistry, at as DevframeScopedNodeContext, bt as DevframeRpcSharedStates, c as RpcBroadcastOptions, ct as DevframeSettings, d as RpcSharedStateHost, dt as ScopedBroadcastOptions, et as DevframeServiceScopeOf, f as RpcStreamingChannel, ft as ScopedClientFunctions, gt as SettingsForNamespace, ht as ScopedSharedStates, i as DevframeCapabilities, it as DevframeServicesState, jt as AgentManifest, l as RpcFunctionsHost, lt as DevframeSettingsRegistry, m as RpcStreamingHost, mt as ScopedServerFunctions, n as ConnectionMetaSse, nt as DevframeServicesRegistry, o as DevframeNodeContext, ot as DevframeScopedNodeRpc, p as RpcStreamingChannelOptions, pt as ScopedRpcFn, q as McpSetting, r as ConnectionMetaWebsocket, rt as DevframeServicesScopeRegistry, s as DevframeNodeRpcSession, st as DevframeScopedStreamingHost, t as ConnectionMeta, tt as DevframeServicesHost, u as RpcSharedStateGetOptions, ut as DevframeSettingsStore, vt as DevframeRpcClientFunctions, wt as DevframeDiagnosticsLogger, xt as DevframeHost, yt as DevframeRpcServerFunctions, z as DevframeRpcOptions, zt as DevframeAgentHost } from "../context-CHW4BZOj.mjs";
+import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "../remote-assets-eBvSKZMS.mjs";
+import { i as DevframeDefineDiagnosticsOptions } from "../nostics-0sKe5HIj.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, 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, EventEmitter, EventUnsubscribe, EventsMap, McpAuthorization, McpRouteOptions, 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-CMdPYhOx.d.mts → types-Dq4i156u.d.mts}

@@ -22,12 +22,12 @@ type RpcFunctionType = 'static' | 'action' | 'event' | 'query';
 /**
  * Agent exposure settings for an RPC function. When this field is set,
  * the function is surfaced to agents (e.g. via the devframe MCP adapter)
- * as a callable tool. Functions without an `agent` field are not exposed —
+ * as a callable tool. Functions without an `agent` field are not exposed;
  * default-deny.
  */
 interface RpcFunctionAgentOptions {
   /**
-   * Human-readable description shown to the agent. Required — agents
+   * Human-readable description shown to the agent. Required, since agents
    * rely on this to decide when to invoke the tool. Keep it to ~1–3
    * sentences explaining what the tool does and when to use it.
    */
@@ -40,9 +40,9 @@ interface RpcFunctionAgentOptions {
   /**
    * Safety classification. Drives MCP annotations (`readOnlyHint`,
    * `destructiveHint`) downstream.
-   * - `'read'` — no side effects; safe to call freely.
-   * - `'action'` — mutates state but not destructive.
-   * - `'destructive'` — may perform destructive updates.
+   * - `'read'`: no side effects; safe to call freely.
+   * - `'action'`: mutates state but not destructive.
+   * - `'destructive'`: may perform destructive updates.
    *
    * When omitted it is inferred from the function `type`:
    *   - `'static'` / `'query'` → `'read'`
@@ -158,17 +158,17 @@ interface RpcFunctionDefinitionBase {
   /** Function type (static, action, event, or query) */
   type?: RpcFunctionType;
   /**
-   * Declares whether this function's args/return are JSON-serializable
-   * — i.e. no `Map`, `Set`, `Date`, `BigInt`, class instances, circular
+   * Declares whether this function's args/return are JSON-serializable,
+   * i.e. no `Map`, `Set`, `Date`, `BigInt`, class instances, circular
    * references, `undefined` leaves, `Symbol`, or `Function` values.
    *
-   * - `true` — args and return are encoded with strict `JSON.stringify`
+   * - `true`: args and return are encoded with strict `JSON.stringify`
    *   on the wire and on disk. Misshapen values throw `DF0019` at the
    *   sender, surfacing the bug *during the offending call* rather than
    *   silently coercing to `{}` later. Required for `agent` exposure.
-   * - `false` (default) — payloads use `structured-clone-es`, which
+   * - `false` (default): payloads use `structured-clone-es`, which
    *   round-trips Maps/Sets/cycles. Functions in this mode cannot be
-   *   exposed via the `agent` field — registration throws `DF0018`.
+   *   exposed via the `agent` field; registration throws `DF0018`.
    */
   jsonSerializable?: boolean;
 }
@@ -221,9 +221,9 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * Declares whether this function's args/return are JSON-serializable
    * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
    *
-   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   * - `true`: wire and dump use strict `JSON.stringify`; misshapen
    *   values throw `DF0019` at the call site. Required for `agent`.
-   * - `false` (default) — `structured-clone-es` round-trips fancy
+   * - `false` (default): `structured-clone-es` round-trips fancy
    *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
    */
   jsonSerializable?: boolean;
@@ -244,7 +244,7 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * handler once with no arguments and stores the result as both a
    * no-args record and the fallback so any call variant resolves
    * to the same snapshot. Only valid on `query` (or untyped)
-   * functions — `static` already has equivalent default behavior.
+   * functions; `static` already has equivalent default behavior.
    */
   snapshot?: boolean;
   /** Per-context setup-result cache, populated by `getRpcResolvedSetupResult`. @internal */
@@ -266,9 +266,9 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * Declares whether this function's args/return are JSON-serializable
    * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
    *
-   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   * - `true`: wire and dump use strict `JSON.stringify`; misshapen
    *   values throw `DF0019` at the call site. Required for `agent`.
-   * - `false` (default) — `structured-clone-es` round-trips fancy
+   * - `false` (default): `structured-clone-es` round-trips fancy
    *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
    */
   jsonSerializable?: boolean;
@@ -281,7 +281,7 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
   setup?: (context: CONTEXT) => Thenable<RpcFunctionSetupResult<InferArgsType<AS>, Thenable<InferReturnType<RS>>>>;
   /**
    * Function implementation (required if setup doesn't provide one).
-   * The declared `returns` schema describes the *resolved* value —
+   * The declared `returns` schema describes the *resolved* value:
    * async handlers return a promise of it (the runtime always awaits).
    */
   handler?: (...args: InferArgsType<AS>) => Thenable<InferReturnType<RS>>;
@@ -293,7 +293,7 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * handler once with no arguments and stores the result as both a
    * no-args record and the fallback so any call variant resolves
    * to the same snapshot. Only valid on `query` (or untyped)
-   * functions — `static` already has equivalent default behavior.
+   * functions; `static` already has equivalent default behavior.
    */
   snapshot?: boolean;
   /** Per-context setup-result cache, populated by `getRpcResolvedSetupResult`. @internal */

package/dist/utils/agent-tool-name.d.mts

@@ -2,13 +2,13 @@
 /**
  * Derive the wire-safe agent tool name for an internal tool id.
  *
- * Devframe tool ids are colon-namespaced — `devframe:<area>:<fn>` for
+ * Devframe tool ids are colon-namespaced: `devframe:<area>:<fn>` for
  * built-ins, `devframes:plugin:<slug>:<fn>` for plugin RPCs, and hub
  * command ids for command-derived tools. MCP clients constrain tool names
  * to `^[a-zA-Z0-9_-]{1,128}$`, so the agent/MCP boundary derives the wire
  * name automatically: every run of characters outside `[a-zA-Z0-9_-]`
  * becomes a single `_`, truncated to 128 characters. Internal ids never
- * change — resolution back to the id happens at the boundary.
+ * change; resolution back to the id happens at the boundary.
  *
  * ```
  * devframe:state:read          → devframe_state_read

package/dist/utils/agent-tool-name.mjs

@@ -7,13 +7,13 @@ const MAX_TOOL_NAME_LENGTH = 128;
 /**
 * Derive the wire-safe agent tool name for an internal tool id.
 *
-* Devframe tool ids are colon-namespaced — `devframe:<area>:<fn>` for
+* Devframe tool ids are colon-namespaced: `devframe:<area>:<fn>` for
 * built-ins, `devframes:plugin:<slug>:<fn>` for plugin RPCs, and hub
 * command ids for command-derived tools. MCP clients constrain tool names
 * to `^[a-zA-Z0-9_-]{1,128}$`, so the agent/MCP boundary derives the wire
 * name automatically: every run of characters outside `[a-zA-Z0-9_-]`
 * becomes a single `_`, truncated to 128 characters. Internal ids never
-* change — resolution back to the id happens at the boundary.
+* change; resolution back to the id happens at the boundary.
 *
 * ```
 * devframe:state:read          → devframe_state_read

package/dist/utils/colors.d.mts

@@ -1,6 +1,6 @@
 //#region src/utils/colors.d.ts
 /**
- * A colorizer — callable as a function (`colors.red('foo')`) or as a
+ * A colorizer, callable as a function (`colors.red('foo')`) or as a
  * tagged template (``colors.red`foo ${bar}` ``).
  */
 interface ColorFn {

package/dist/utils/crypto-token.d.mts

@@ -1,7 +1,7 @@
 //#region src/utils/crypto-token.d.ts
 /**
  * Generate a high-entropy, URL-safe (hex) random token suitable for use as a
- * bearer credential — e.g. the persistent client auth token or an ephemeral
+ * bearer credential, e.g. the persistent client auth token or an ephemeral
  * remote-dock token. Defaults to 16 bytes (128 bits) of entropy.
  */
 declare function randomToken(byteLength?: number): string;

package/dist/utils/crypto-token.mjs

@@ -2,7 +2,7 @@
 const HEX = "0123456789abcdef";
 /**
 * Generate a high-entropy, URL-safe (hex) random token suitable for use as a
-* bearer credential — e.g. the persistent client auth token or an ephemeral
+* bearer credential, e.g. the persistent client auth token or an ephemeral
 * remote-dock token. Defaults to 16 bytes (128 bits) of entropy.
 */
 function randomToken(byteLength = 16) {

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { Vt as EventsMap, zt as EventEmitter } from "../context-CLF4-8Pp.mjs";
+import { Ut as EventsMap, Vt as EventEmitter } from "../context-CHW4BZOj.mjs";
 //#region src/utils/events.d.ts
 /**
  * Create event emitter.

package/dist/utils/nostics.d.mts

@@ -1,2 +1,2 @@
-import { a as Diagnostic, c as DiagnosticHandle, d as Diagnostics, f as ansiFormatter, g as formatDiagnostic, h as defineProdDiagnostics, i as DevframeDefineDiagnosticsOptions, l as DiagnosticInit, m as defineDiagnostics, n as ConsoleMethod, o as DiagnosticCallParams, p as createConsoleReporter, r as ConsoleReporterOptions, s as DiagnosticDefinition, t as AnyDiagnosticReporter, u as DiagnosticReporter } from "../nostics-SPGDgHEP.mjs";
+import { a as Diagnostic, c as DiagnosticHandle, d as Diagnostics, f as ansiFormatter, g as formatDiagnostic, h as defineProdDiagnostics, i as DevframeDefineDiagnosticsOptions, l as DiagnosticInit, m as defineDiagnostics, n as ConsoleMethod, o as DiagnosticCallParams, p as createConsoleReporter, r as ConsoleReporterOptions, s as DiagnosticDefinition, t as AnyDiagnosticReporter, u as DiagnosticReporter } from "../nostics-0sKe5HIj.mjs";
 export { type AnyDiagnosticReporter, type ConsoleMethod, type ConsoleReporterOptions, DevframeDefineDiagnosticsOptions, type Diagnostic, type DiagnosticCallParams, type DiagnosticDefinition, type DiagnosticHandle, type DiagnosticInit, type DiagnosticReporter, type Diagnostics, ansiFormatter, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };

package/dist/utils/nostics.mjs

@@ -1,2 +1,2 @@
-import { a as defineProdDiagnostics, i as defineDiagnostics, n as ansiFormatter, o as formatDiagnostic, r as createConsoleReporter, t as Diagnostic } from "../nostics-CzECRXpE.mjs";
+import { a as defineProdDiagnostics, i as defineDiagnostics, n as ansiFormatter, o as formatDiagnostic, r as createConsoleReporter, t as Diagnostic } from "../nostics-D0PvLZsn.mjs";
 export { Diagnostic, ansiFormatter, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };

package/dist/utils/open.mjs

@@ -4,7 +4,7 @@ import { spawn } from "node:child_process";
 //#region src/utils/open.ts
 /**
 * Launches `command` detached from the current process and resolves once
-* the OS has accepted the spawn (not once the launched app exits) — the
+* the OS has accepted the spawn (not once the launched app exits), the
 * same "fire and forget" behavior `open`'s default (`wait: false`) gave us.
 */
 function spawnDetached(command, args) {

package/dist/utils/origin.d.mts

@@ -0,0 +1,2 @@
+import { n as isLoopbackHostname, r as validateOriginCandidate, t as isAllowedOrigin } from "../origin-DGDH8BI9.mjs";
+export { isAllowedOrigin, isLoopbackHostname, validateOriginCandidate };

package/dist/utils/origin.mjs

@@ -0,0 +1,80 @@
+//#region src/utils/origin.ts
+/**
+* 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.
+*/
+function isLoopbackHostname(hostname) {
+	const h = hostname.replace(/^\[|\]$/g, "");
+	if (h === "localhost" || h.endsWith(".localhost") || h === "::1") return true;
+	return isLoopbackIPv4(h);
+}
+/** A canonical dotted-decimal IPv4 literal in `127.0.0.0/8`. */
+function isLoopbackIPv4(hostname) {
+	const octets = hostname.split(".");
+	if (octets.length !== 4 || !octets.every(isDecimalOctet)) return false;
+	return Number(octets[0]) === 127;
+}
+/** A single canonical IPv4 octet: 1–3 digits, no leading zero, value 0–255. */
+function isDecimalOctet(part) {
+	if (!/^\d{1,3}$/.test(part) || part.length > 1 && part[0] === "0") return false;
+	return Number(part) <= 255;
+}
+/**
+* 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.
+*/
+function isAllowedOrigin(origin, allowedOrigins) {
+	if (!origin) return true;
+	if (allowedOrigins.includes(origin)) return true;
+	try {
+		return isLoopbackHostname(new URL(origin).hostname);
+	} catch {
+		return false;
+	}
+}
+/**
+* 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.
+*/
+function validateOriginCandidate(candidate, allowedOrigins) {
+	let url;
+	try {
+		url = new URL(candidate);
+	} catch {
+		return;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+	if (url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "") return void 0;
+	const canonical = url.origin;
+	if (canonical === "null") return void 0;
+	if (isLoopbackHostname(url.hostname) || allowedOrigins?.includes(canonical)) return canonical;
+}
+//#endregion
+export { isAllowedOrigin, isLoopbackHostname, validateOriginCandidate };

package/dist/utils/remote-assets.d.mts

@@ -1,4 +1,4 @@
-import { a as RemoteAssetsStore, o as StaticAssetsSource } from "../remote-assets-B13_vRkJ.mjs";
+import { a as RemoteAssetsStore, o as StaticAssetsSource } from "../remote-assets-eBvSKZMS.mjs";
 //#region src/utils/remote-assets.d.ts
 /**
  * Normalize a {@link StaticAssetsSource} into something servable: a local
@@ -7,7 +7,7 @@ import { a as RemoteAssetsStore, o as StaticAssetsSource } from "../remote-asset
  * {@link RemoteAssetsStore} back-proxy. Remote caches live under
  * `<projectStorageDir>/.remote-assets/<package>@<version>/`.
  *
- * A remote source's `package`/`version` are validated first (`DF0065`) — both
+ * A remote source's `package`/`version` are validated first (`DF0065`); both
  * are interpolated into CDN URLs and the cache path.
  *
  * `defaultResolveFrom` (typically the declaring devframe's `importMetaUrl`)

package/dist/utils/remote-assets.mjs

@@ -1,2 +1,2 @@
-import { t as resolveStaticAssetsSource } from "../remote-assets-DezQmPQU.mjs";
+import { t as resolveStaticAssetsSource } from "../remote-assets-DMFzLSoH.mjs";
 export { resolveStaticAssetsSource };

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

@@ -1,4 +1,4 @@
-import { a as RemoteAssetsStore } from "../remote-assets-B13_vRkJ.mjs";
+import { a as RemoteAssetsStore } from "../remote-assets-eBvSKZMS.mjs";
 import { IncomingMessage, ServerResponse } from "node:http";
 import { EventHandler, H3 } from "h3";
 //#region src/utils/serve-static.d.ts
@@ -14,12 +14,12 @@ interface ServeStaticOptions {
   single?: boolean;
 }
 /**
- * h3 event handler that serves files from `source` with SPA fallback — a
+ * h3 event handler that serves files from `source` with SPA fallback: a
  * local directory, or a {@link RemoteAssetsStore} whose files stream through
  * the CDN back-proxy into the local cache.
  *
  * Drop-in replacement for `fromNodeMiddleware(sirv(dir, { dev: true, single: true }))`
- * when the surrounding server is an h3 app — no `Cache-Control` beyond
+ * when the surrounding server is an h3 app: no `Cache-Control` beyond
  * `no-store`, `Content-Type` resolved via `mrmime`, and a miss with no
  * file extension falls back to `<dir>/index.html` so client-side routing
  * works.
@@ -37,7 +37,7 @@ declare function mountStaticHandler(app: H3, base: string, source: ServableAsset
  * Connect/Express-style Node middleware variant of {@link serveStaticHandler}.
  *
  * Use when mounting onto `viteServer.middlewares.use(base, …)` or any other
- * Connect stack — avoids forcing the host package to depend on h3 just to
+ * Connect stack; avoids forcing the host package to depend on h3 just to
  * adapt an event handler back into Node middleware.
  */
 declare function serveStaticNodeMiddleware(source: ServableAssets, options?: ServeStaticOptions): (req: IncomingMessage, res: ServerResponse, next?: (err?: Error) => void) => void;

package/dist/utils/serve-static.mjs

@@ -1,16 +1,30 @@
-import { t as DEVFRAME_EVENTS } from "../events-4daw0uK9.mjs";
+import { t as DEVFRAME_EVENTS } from "../events-BV4Dj59a.mjs";
+import { realpath, stat } from "node:fs/promises";
 import { extname, join, normalize, resolve, sep } from "pathe";
 import { createReadStream } from "node:fs";
-import { stat } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { lookup } from "mrmime";
 import { H3, defineHandler } from "h3";
 //#region src/utils/serve-static.ts
 const HTML_EXTENSIONS = [".html", ".htm"];
-async function statFile(abs) {
+/**
+* The canonical (symlink-resolved) served root, falling back to the lexical
+* path when the directory doesn't exist yet (an empty deployment then serves
+* nothing rather than throwing).
+*/
+async function canonicalRoot(absDir) {
+	return realpath(absDir).then(normalize, () => absDir);
+}
+/**
+* Stat a candidate file, confirming its canonical target stays inside the
+* canonical served root; a symlink inside the root can only resolve to a
+* file still within it; one escaping the root reads as a miss, not a leak.
+*/
+async function statFile(abs, realRoot) {
 	try {
 		const s = await stat(abs);
-		if (!s.isFile()) return null;
+		const real = normalize(await realpath(abs));
+		if (!s.isFile() || real !== realRoot && !real.startsWith(realRoot + sep)) return null;
 		return {
 			abs,
 			size: s.size,
@@ -20,7 +34,7 @@ async function statFile(abs) {
 		return null;
 	}
 }
-async function resolveTarget(absDir, urlPath, indexNames, single) {
+function cleanUrlPath(urlPath) {
 	let cleaned;
 	try {
 		cleaned = decodeURIComponent(urlPath || "/");
@@ -30,23 +44,44 @@ async function resolveTarget(absDir, urlPath, indexNames, single) {
 	cleaned = cleaned.replace(/[?#].*$/, "");
 	if (cleaned.endsWith("/")) cleaned = cleaned.slice(0, -1);
 	if (cleaned.startsWith("/")) cleaned = cleaned.slice(1);
-	const abs = normalize(join(absDir, cleaned));
-	if (abs !== absDir && !abs.startsWith(absDir + sep)) return null;
-	const direct = await statFile(abs);
-	if (direct) return direct;
+	return cleaned;
+}
+async function resolveDirectoryIndex(abs, realRoot, indexNames) {
 	try {
 		if ((await stat(abs)).isDirectory()) for (const name of indexNames) {
-			const candidate = await statFile(join(abs, name));
+			const candidate = await statFile(join(abs, name), realRoot);
 			if (candidate) return candidate;
 		}
 	} catch {}
-	if (!extname(cleaned)) for (const ext of HTML_EXTENSIONS) {
-		const candidate = await statFile(abs + ext);
+	return null;
+}
+/**
+* Mirror sirv's `extensions: ['html', 'htm']` default: an extension-less
+* request tries `${path}.html` / `${path}.htm` so pretty-URL deployments
+* resolve to the right page before the SPA fallback.
+*/
+async function resolveHtmlExtension(abs, cleaned, realRoot) {
+	if (extname(cleaned)) return null;
+	for (const ext of HTML_EXTENSIONS) {
+		const candidate = await statFile(abs + ext, realRoot);
 		if (candidate) return candidate;
 	}
+	return null;
+}
+async function resolveTarget(absDir, realRoot, urlPath, indexNames, single) {
+	const cleaned = cleanUrlPath(urlPath);
+	if (cleaned === null) return null;
+	const abs = normalize(join(absDir, cleaned));
+	if (abs !== absDir && !abs.startsWith(absDir + sep)) return null;
+	const direct = await statFile(abs, realRoot);
+	if (direct) return direct;
+	const indexed = await resolveDirectoryIndex(abs, realRoot, indexNames);
+	if (indexed) return indexed;
+	const htmlExt = await resolveHtmlExtension(abs, cleaned, realRoot);
+	if (htmlExt) return htmlExt;
 	const fallbackIndex = indexNames[0];
 	if (single && fallbackIndex && !/\.[a-z0-9]+$/i.test(cleaned)) {
-		const indexFile = await statFile(join(absDir, fallbackIndex));
+		const indexFile = await statFile(join(absDir, fallbackIndex), realRoot);
 		if (indexFile) return indexFile;
 	}
 	return null;
@@ -77,7 +112,7 @@ function normalizeOptions(options) {
 /**
 * Drive one request through a {@link RemoteAssetsStore}: the store's
 * `Response` on a hit, a 404 on a miss, or a 502 (styled error page for HTML
-* navigations) on provider failure — shared between the h3 and connect flavors.
+* navigations) on provider failure, shared between the h3 and connect flavors.
 */
 async function remoteResponse(store, urlPath, accept) {
 	try {
@@ -109,12 +144,12 @@ function serveRemoteAssetsHandler(store) {
 	});
 }
 /**
-* h3 event handler that serves files from `source` with SPA fallback — a
+* h3 event handler that serves files from `source` with SPA fallback: a
 * local directory, or a {@link RemoteAssetsStore} whose files stream through
 * the CDN back-proxy into the local cache.
 *
 * Drop-in replacement for `fromNodeMiddleware(sirv(dir, { dev: true, single: true }))`
-* when the surrounding server is an h3 app — no `Cache-Control` beyond
+* when the surrounding server is an h3 app: no `Cache-Control` beyond
 * `no-store`, `Content-Type` resolved via `mrmime`, and a miss with no
 * file extension falls back to `<dir>/index.html` so client-side routing
 * works.
@@ -123,6 +158,7 @@ function serveStaticHandler(source, options) {
 	if (typeof source !== "string") return serveRemoteAssetsHandler(source);
 	const absDir = resolve(source);
 	const opts = normalizeOptions(options);
+	const realRoot = canonicalRoot(absDir);
 	return defineHandler(async (event) => {
 		const method = event.req.method;
 		if (method !== "GET" && method !== "HEAD") {
@@ -130,7 +166,7 @@ function serveStaticHandler(source, options) {
 			event.res.headers.set("Allow", "GET, HEAD");
 			return "";
 		}
-		const file = await resolveTarget(absDir, event.url.pathname, opts.indexNames, opts.single);
+		const file = await resolveTarget(absDir, await realRoot, event.url.pathname, opts.indexNames, opts.single);
 		if (!file) {
 			event.res.status = 404;
 			return "";
@@ -156,12 +192,13 @@ function mountStaticHandler(app, base, source, options) {
 * Connect/Express-style Node middleware variant of {@link serveStaticHandler}.
 *
 * Use when mounting onto `viteServer.middlewares.use(base, …)` or any other
-* Connect stack — avoids forcing the host package to depend on h3 just to
+* Connect stack; avoids forcing the host package to depend on h3 just to
 * adapt an event handler back into Node middleware.
 */
 function serveStaticNodeMiddleware(source, options) {
 	const absDir = typeof source === "string" ? resolve(source) : void 0;
 	const opts = normalizeOptions(options);
+	const realRoot = absDir === void 0 ? void 0 : canonicalRoot(absDir);
 	return (req, res, next) => {
 		(async () => {
 			const method = req.method;
@@ -192,7 +229,7 @@ function serveStaticNodeMiddleware(source, options) {
 				Readable.fromWeb(response.body).pipe(res);
 				return;
 			}
-			const file = await resolveTarget(absDir, url, opts.indexNames, opts.single);
+			const file = await resolveTarget(absDir, await realRoot, url, opts.indexNames, opts.single);
 			if (!file) {
 				if (next) {
 					next();

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-CLF4-8Pp.mjs";
+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-CHW4BZOj.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

package/dist/utils/shared-state.mjs

@@ -1,2 +1,2 @@
-import { t as createSharedState } from "../shared-state--sduc6Xi.mjs";
+import { t as createSharedState } from "../shared-state-CaxB1q0h.mjs";
 export { createSharedState };