devframe 0.5.4 → 0.6.0-beta.2

package/dist/{devframe-BuR6n9ZD.d.mts → devframe-D-gr9sBx.d.mts}

@@ -1,5 +1,6 @@
-import { S as RpcFunctionsCollectorBase } from "./index-C7M1hnvL.mjs";
-import { t as DevframeNodeRpcSessionMeta } from "./ws-server-C1LjmRnp.mjs";
+import { _ as RpcFunctionDefinition } from "./types-DZEx4ffs.mjs";
+import { S as RpcFunctionsCollectorBase } from "./index-CxaPKDXX.mjs";
+import { t as DevframeNodeRpcSessionMeta } from "./ws-server-Bc2wBHl-.mjs";
 import { CAC } from "cac";
 import { GenericSchema, InferOutput } from "valibot";
 import { BirpcReturn } from "birpc";
@@ -368,6 +369,19 @@ interface DevframeHost {
    * for build snapshots).
    */
   mountStatic: (base: string, distDir: string) => void | Promise<void>;
+  /**
+   * Serve the host's connection meta (`__connection.json`) at the given URL
+   * base, so a devframe SPA mounted there can discover the RPC/WS endpoint
+   * via `connectDevframe()`'s relative `./__connection.json` fetch.
+   *
+   * Called by `mountDevframe` for each mounted devframe (alongside
+   * `mountStatic`). Without it, an embedded SPA can only discover the
+   * endpoint by inheriting it from a same-origin parent window — which fails
+   * for cross-origin or sandboxed iframes. Implementations serve the same
+   * meta they expose at the hub's own base. Optional: hosts that can't serve
+   * a dynamic route (e.g. static-snapshot builds) may omit it.
+   */
+  mountConnectionMeta?: (base: string) => void | Promise<void>;
   /**
    * Return the public origin the host is reachable at, e.g.
    * `http://localhost:5173`. Used by the dock host to enrich remote
@@ -400,6 +414,14 @@ interface DevframeHost {
  * To be extended
  */
 interface DevframeRpcClientFunctions {
+  /**
+   * Server→client notification that this connection's auth token has been
+   * revoked. The client drops to untrusted on receipt. Broadcast by
+   * `revokeActiveConnectionsForToken`.
+   *
+   * @internal
+   */
+  'devframe:auth:revoked': () => Promise<void>;
   /**
    * Streaming chunk pushed from server to subscribed clients. Wired by
    * `RpcStreamingHost`; do not register manually.
@@ -424,11 +446,54 @@ interface DevframeRpcClientFunctions {
    * @internal
    */
   'devframe:streaming:upload-cancel': (channel: string, id: string) => Promise<void>;
+  /**
+   * Full shared-state snapshot pushed from server to subscribed clients.
+   * Wired by `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:rpc:client-state:updated': (key: string, fullState: any, syncId: string) => Promise<void>;
+  /**
+   * Incremental shared-state patch pushed from server to subscribed clients.
+   * Wired by `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:rpc:client-state:patch': (key: string, patches: any[], syncId: string) => Promise<void>;
 }
 /**
  * To be extended
  */
 interface DevframeRpcServerFunctions {
+  /**
+   * Authenticate a connection with a previously-issued bearer token; resolves
+   * whether the connection is now trusted. The interactive handler is provided
+   * by the host adapter (e.g. Vite DevTools); the standalone server registers
+   * an auto-trust noop when `auth: false`.
+   *
+   * @internal
+   */
+  'devframe:anonymous:auth': (params: {
+    authToken: string;
+    ua: string;
+    origin: string;
+  }) => Promise<{
+    isTrusted: boolean;
+  }>;
+  /**
+   * Exchange a one-time authentication code (shown by the dev server) for a fresh,
+   * node-issued bearer token, returning the token on success or `null`. The
+   * handler is provided by the host adapter on top of `exchangeTempAuthCode`.
+   *
+   * @internal
+   */
+  'devframe:auth:exchange': (params: {
+    code: string;
+    ua: string;
+    origin: string;
+  }) => Promise<{
+    authToken: string | null;
+  }>;
   /**
    * Subscribe a client to a shared-state key. Wired by
    * `RpcSharedStateHost`; do not register manually.
@@ -503,15 +568,6 @@ interface DevframeRpcServerFunctions {
  */
 interface DevframeRpcSharedStates {}
 //#endregion
-//#region src/types/utils.d.ts
-type Thenable<T> = T | Promise<T>;
-type EntriesToObject<T extends readonly [string, any][]> = { [K in T[number] as K[0]]: K[1] };
-type PartialWithoutId<T extends {
-  id: string;
-}> = Partial<Omit<T, 'id'>> & {
-  id: string;
-};
-//#endregion
 //#region src/types/views.d.ts
 interface DevframeViewHost {
   /**
@@ -529,6 +585,188 @@ interface DevframeViewHost {
   hostStatic: (baseUrl: string, distDir: string) => void;
 }
 //#endregion
+//#region src/types/scope.d.ts
+type AnyRpcFn = (...args: any[]) => any;
+/**
+ * Augmentable registry mapping a scope namespace to the shape of its
+ * persisted settings. Tools augment it so `ctx.scope('my-plugin')`
+ * gets a fully-typed `settings.global` / `settings.project`:
+ *
+ * ```ts
+ * declare module 'devframe' {
+ *   interface DevframeSettingsRegistry {
+ *     'my-plugin': { theme: 'light' | 'dark', recentFiles: string[] }
+ *   }
+ * }
+ * ```
+ */
+interface DevframeSettingsRegistry {}
+/**
+ * Resolve the settings shape for a namespace from
+ * {@link DevframeSettingsRegistry}, falling back to an open record when
+ * the namespace hasn't been augmented.
+ */
+type SettingsForNamespace<NS extends string> = NS extends keyof DevframeSettingsRegistry ? DevframeSettingsRegistry[NS] extends Record<string, any> ? DevframeSettingsRegistry[NS] : Record<string, any> : Record<string, any>;
+/**
+ * A persisted key-value settings store for one scope (`global` or
+ * `project`). Backed by a file on the node side and by the shared-state
+ * sync protocol on the client, so a `set` on either side propagates to
+ * every connected peer and survives restarts.
+ *
+ * Every method is async because the underlying shared state is resolved
+ * lazily on first access.
+ */
+interface DevframeSettingsStore<T extends Record<string, any> = Record<string, any>> {
+  /** Read a single setting. Resolves to `undefined` when unset. */
+  get: <K extends keyof T>(key: K) => Promise<T[K] | undefined>;
+  /** Write a single setting. */
+  set: <K extends keyof T>(key: K, value: T[K]) => Promise<void>;
+  /** Remove a single setting. */
+  delete: <K extends keyof T>(key: K) => Promise<void>;
+  /** Read the whole settings object (immutable snapshot). */
+  all: () => Promise<Readonly<T>>;
+  /**
+   * Subscribe to settings changes. Resolves to an unsubscribe function.
+   * Fires on every local or remote mutation with the full snapshot.
+   */
+  onChange: (fn: (value: Readonly<T>) => void) => Promise<() => void>;
+}
+/**
+ * The two settings scopes available on a scoped context.
+ *
+ *   - `project` — per-workspace state, persisted under the host's
+ *     `workspace` storage dir. Project-local settings.
+ *   - `global`  — per-user state, persisted under the host's `global`
+ *     storage dir. Machine-wide preferences.
+ */
+interface DevframeSettings<T extends Record<string, any> = Record<string, any>> {
+  global: DevframeSettingsStore<T>;
+  project: DevframeSettingsStore<T>;
+}
+/**
+ * Map the server-side RPC registry down to the bare names owned by a
+ * namespace, so a scoped `call('get-cwd')` is typed without the
+ * `my-plugin:` prefix.
+ */
+type ScopedServerFunctions<NS extends string> = { [K in keyof DevframeRpcServerFunctions as K extends `${NS}:${infer R}` ? R : never]: DevframeRpcServerFunctions[K] };
+/**
+ * Map the client-side RPC registry down to the bare names owned by a
+ * namespace, used by scoped `broadcast`.
+ */
+type ScopedClientFunctions<NS extends string> = { [K in keyof DevframeRpcClientFunctions as K extends `${NS}:${infer R}` ? R : never]: DevframeRpcClientFunctions[K] };
+/**
+ * Map the shared-state registry down to the bare keys owned by a
+ * namespace, so scoped `sharedState('messages')` is typed without the
+ * `my-plugin:` prefix.
+ */
+type ScopedSharedStates<NS extends string> = { [K in keyof DevframeRpcSharedStates as K extends `${NS}:${infer R}` ? R : never]: DevframeRpcSharedStates[K] };
+/**
+ * Broadcast options for a scoped client method (bare name).
+ */
+interface ScopedBroadcastOptions<METHOD, Args extends any[]> {
+  method: METHOD;
+  args: Args;
+  optional?: boolean;
+  event?: boolean;
+}
+/**
+ * Node-side streaming host scoped to a namespace. Channel names are
+ * auto-prefixed with `<namespace>:`.
+ */
+interface DevframeScopedStreamingHost {
+  /**
+   * Register a streaming channel. The bare `name` is auto-prefixed with
+   * the scope namespace (`<namespace>:<name>`); pass an already-qualified
+   * name (containing `:`) to opt out.
+   */
+  create: <T = unknown>(name: string, opts?: RpcStreamingChannelOptions) => RpcStreamingChannel<T>;
+}
+/**
+ * The scoped node RPC surface exposed on `ctx.scope('my-plugin').rpc`.
+ * IDs and keys you pass are auto-namespaced with `my-plugin:`.
+ */
+interface DevframeScopedNodeRpc<NS extends string = string> {
+  /** The namespace this surface is scoped to. */
+  readonly namespace: NS;
+  /**
+   * Register a server RPC function. The definition's `name` must be bare
+   * (no `:`); it is stored as `<namespace>:<name>`. Throws `DF0034` if an
+   * already-namespaced name is passed.
+   */
+  register: (fn: RpcFunctionDefinition<string, any, any, any, any, any, DevframeNodeContext>, force?: boolean) => void;
+  /**
+   * Update a previously registered server RPC function. Same naming rules
+   * as {@link DevframeScopedNodeRpc.register}.
+   */
+  update: (fn: RpcFunctionDefinition<string, any, any, any, any, any, DevframeNodeContext>, force?: boolean) => void;
+  /**
+   * Invoke a locally registered server RPC function. Bare names are
+   * resolved within this namespace; pass a fully-qualified name
+   * (containing `:`) to call another scope's function.
+   */
+  call: {
+    <T extends keyof ScopedServerFunctions<NS> & string>(method: T, ...args: Parameters<Extract<ScopedServerFunctions<NS>[T], AnyRpcFn>>): Promise<Awaited<ReturnType<Extract<ScopedServerFunctions<NS>[T], AnyRpcFn>>>>;
+    <T extends keyof DevframeRpcServerFunctions & string>(method: T, ...args: Parameters<Extract<DevframeRpcServerFunctions[T], AnyRpcFn>>): Promise<Awaited<ReturnType<Extract<DevframeRpcServerFunctions[T], AnyRpcFn>>>>;
+    (method: string, ...args: any[]): Promise<any>;
+  };
+  /**
+   * Broadcast a client RPC event to every connected client. Bare method
+   * names are resolved within this namespace.
+   */
+  broadcast: {
+    <T extends keyof ScopedClientFunctions<NS> & string>(options: ScopedBroadcastOptions<T, Parameters<Extract<ScopedClientFunctions<NS>[T], AnyRpcFn>>>): Promise<void>;
+    (options: ScopedBroadcastOptions<string, any[]>): Promise<void>;
+  };
+  /**
+   * Resolve a namespaced shared state. Bare keys are resolved within this
+   * namespace; pass a fully-qualified key (containing `:`) to opt out.
+   */
+  sharedState: {
+    <T extends keyof ScopedSharedStates<NS> & string>(key: T, options?: RpcSharedStateGetOptions<ScopedSharedStates<NS>[T]>): Promise<SharedState<ScopedSharedStates<NS>[T]>>;
+    <T extends Record<string, any> = Record<string, any>>(key: string, options?: RpcSharedStateGetOptions<T>): Promise<SharedState<T>>;
+  };
+  /** Streaming host scoped to this namespace. */
+  streaming: DevframeScopedStreamingHost;
+  /** Pass-through to the current RPC session, when called inside a handler. */
+  getCurrentRpcSession: () => DevframeNodeRpcSession | undefined;
+}
+/**
+ * A namespace-scoped view of {@link DevframeNodeContext}. Returned by
+ * `ctx.scope('my-plugin')`. Re-exposes the unscoped surfaces (`views`,
+ * `diagnostics`, `agent`, …), replaces `rpc` with the auto-namespaced
+ * {@link DevframeScopedNodeRpc}, and adds a top-level `settings` store.
+ */
+interface DevframeScopedNodeContext<NS extends string = string, Settings extends Record<string, any> = Record<string, any>> {
+  /** The namespace this context is scoped to. */
+  readonly namespace: NS;
+  /** The underlying unscoped context. */
+  readonly base: DevframeNodeContext;
+  readonly workspaceRoot: string;
+  readonly cwd: string;
+  readonly mode: 'dev' | 'build';
+  host: DevframeHost;
+  rpc: DevframeScopedNodeRpc<NS>;
+  /** Persisted settings for this namespace (`global` + `project`). */
+  settings: DevframeSettings<Settings>;
+  views: DevframeViewHost;
+  diagnostics: DevframeDiagnosticsHost;
+  agent: DevframeAgentHost;
+  /**
+   * Return a new scoped context, replacing the current scope. Pass `null`
+   * or `''` to un-scope and get the base context.
+   */
+  scope: DevframeNodeContext['scope'];
+}
+//#endregion
+//#region src/types/utils.d.ts
+type Thenable<T> = T | Promise<T>;
+type EntriesToObject<T extends readonly [string, any][]> = { [K in T[number] as K[0]]: K[1] };
+type PartialWithoutId<T extends {
+  id: string;
+}> = Partial<Omit<T, 'id'>> & {
+  id: string;
+};
+//#endregion
 //#region src/utils/shared-state.d.ts
 type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
 type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
@@ -755,7 +993,7 @@ interface RpcSharedStateGetOptions<T> {
   initialValue?: T;
 }
 interface RpcSharedStateHost {
-  get: <T extends keyof DevframeRpcSharedStates>(key: T, options?: RpcSharedStateGetOptions<DevframeRpcSharedStates[T]>) => Promise<SharedState<DevframeRpcSharedStates[T]>>;
+  get: <T extends object = any>(key: string, options?: RpcSharedStateGetOptions<T>) => Promise<SharedState<T>>;
   keys: () => string[];
   /**
    * Subscribe to new shared-state keys becoming available. Fires when
@@ -917,10 +1155,55 @@ interface DevframeNodeContext {
    * @experimental
    */
   agent: DevframeAgentHost;
+  /**
+   * Create a namespace-scoped view of this context. The returned
+   * `ctx.scope('my-plugin')` auto-namespaces every RPC id, shared-state
+   * key, and streaming channel with `my-plugin:`, and exposes a typed
+   * top-level `settings` store. This is the preferred way to consume the
+   * context from a single tool's setup code.
+   *
+   * Pass `null` or `''` to un-scope and get the base context.
+   */
+  scope: {
+    <NS extends string>(namespace: NS): DevframeScopedNodeContext<NS, SettingsForNamespace<NS>>;
+    (namespace?: null | ''): DevframeNodeContext;
+  };
+}
+/**
+ * Describes where the browser client should open its RPC WebSocket. The
+ * object form is the proxy-flexible default: `path` is resolved relative to
+ * where `__connection.json` was loaded, and the connection is made to the
+ * page's own origin (only the `http`→`ws` / `https`→`wss` protocol swap is
+ * applied). This survives reverse proxies that change the host/port, because
+ * the client never trusts a server-baked hostname — it reuses its own.
+ *
+ * Set `port` (and/or `host`) only when the WS endpoint genuinely lives on a
+ * different origin than the page, e.g. a side-car server on its own port.
+ */
+interface ConnectionMetaWebsocket {
+  /**
+   * Path to the WS endpoint. Relative paths (the default, e.g. `__devframe_ws`) are
+   * resolved against `__connection.json`'s location; absolute paths (`/__devframe_ws`)
+   * resolve against the page origin.
+   */
+  path?: string;
+  /** Override the port. Combined with the page hostname unless `host` is set. */
+  port?: number;
+  /** Override the host (`hostname[:port]`). Use for a fully cross-origin endpoint. */
+  host?: string;
 }
 interface ConnectionMeta {
   backend: 'websocket' | 'static';
-  websocket?: number | string;
+  /**
+   * WebSocket endpoint, resolved by the client into a `ws(s)://` URL:
+   *
+   *   - {@link ConnectionMetaWebsocket} — the proxy-flexible default; a
+   *     same-origin path relative to `__connection.json`.
+   *   - `number` — a port on the page's hostname (`ws(s)://<host>:<port>`).
+   *   - `string` — a full `ws://`/`wss://` URL used verbatim, an `http(s)://`
+   *     URL with its protocol swapped, or a path resolved same-origin.
+   */
+  websocket?: number | string | ConnectionMetaWebsocket;
   /**
    * Names of RPC functions that have declared `jsonSerializable: true`.
    * Used by the WS / static client to dispatch the per-call wire
@@ -941,6 +1224,51 @@ type DevframeRuntime = 'cli' | 'build' | 'spa' | 'vite' | 'embedded';
  * (`cli`, `spa`, `build`) own the origin and default to `/`.
  */
 type DevframeDeploymentKind = 'standalone' | 'hosted';
+/**
+ * How a hub deduplicates devframes that share an `id` when more than one
+ * is mounted onto the same hub. See {@link DevframeDefinition.duplicationStrategy}.
+ *
+ * - `'warn'` (default) — keep the first registration, drop later
+ *   duplicates, and emit a warning diagnostic (`DF8105`).
+ * - `'silent'` — drop later duplicates without warning.
+ * - `'throw'` — throw when a duplicate is mounted.
+ * - `'duplicate'` — let every instance coexist under a disambiguated
+ *   dock id.
+ */
+type DevframeDuplicationStrategy = 'warn' | 'silent' | 'throw' | 'duplicate';
+/**
+ * Controls where the browser opens the RPC WebSocket — advertised in
+ * `__connection.json` and used to bind the dev server. The three shapes map
+ * to the three connection scenarios; precedence is `url` > `port` > `route`:
+ *
+ *   1. **Same server, different route** (default) — leave `port`/`url` unset.
+ *      The socket shares the HTTP server's port and binds to `route`
+ *      (`__devframe_ws`). The client connects to its own origin, so the link
+ *      survives a reverse proxy that rewrites the host/port/subpath.
+ *
+ *   2. **Different port** — set `port`. The socket binds on its own port on the
+ *      same host; the client targets `ws(s)://<page-host>:<port>/<route>`.
+ *
+ *   3. **Remote, different origin** — set `url` to a full `ws://`/`wss://`
+ *      endpoint (e.g. a public tunnel or relay). The client uses it verbatim.
+ */
+interface DevframeWsOptions {
+  /**
+   * Upgrade route segment the socket binds to and is advertised at, relative
+   * to the SPA base. Default: `__devframe_ws`.
+   */
+  route?: string;
+  /**
+   * Bind the socket on its own port instead of sharing the HTTP port. The
+   * browser connects to this port on the page's hostname.
+   */
+  port?: number;
+  /**
+   * Advertise a fixed, fully-qualified endpoint on another origin (a full
+   * `ws://`/`wss://` URL). Takes precedence over `port`/`route` in the meta.
+   */
+  url?: string;
+}
 interface DevframeCliOptions {
   /** Binary name; default: the devframe's `id`. */
   command?: string;
@@ -969,6 +1297,12 @@ interface DevframeCliOptions {
   auth?: boolean;
   /** Author's SPA dist directory (served as the devframe's UI). */
   distDir?: string;
+  /**
+   * How the browser reaches the RPC WebSocket. Defaults to sharing the HTTP
+   * port on the `__devframe_ws` route. See {@link DevframeWsOptions} for the
+   * different-port and remote-origin variants.
+   */
+  ws?: DevframeWsOptions;
   /**
    * Capability-side CAC hook. Called with the CAC instance after the
    * adapter registers its built-in commands (`build` / `spa` / `mcp`)
@@ -1031,17 +1365,33 @@ interface DevframeSetupInfo {
 interface DevframeDefinition {
   id: string;
   name: string;
+  /** Semver of the tool, surfaced in hub UIs and diagnostics. */
+  version: string;
+  /** npm package name the devframe ships in (e.g. `@scope/my-tool`). */
+  packageName: string;
+  /** Project homepage or documentation URL. */
+  homepage: string;
+  /** One-line summary of what the tool does. */
+  description: string;
   icon?: string | {
     light: string;
     dark: string;
   };
-  version?: string;
   /**
    * Mount path override. Defaults depend on the adapter:
    * `/` for standalone (`cli` / `spa` / `build`), `/__<id>/` for hosted
    * (`vite` / `embedded`).
    */
   basePath?: string;
+  /**
+   * How a hub reacts when another devframe sharing this one's `id` is
+   * mounted onto the same hub. Consulted only by hub adapters
+   * (`mountDevframe`); standalone adapters (`cli` / `spa` / `build`)
+   * ignore it.
+   *
+   * @default 'warn'
+   */
+  duplicationStrategy?: DevframeDuplicationStrategy;
   capabilities?: {
     dev?: boolean | Record<string, boolean>;
     build?: boolean | Record<string, boolean>;
@@ -1056,4 +1406,4 @@ interface DevframeDefinition {
 }
 declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
 //#endregion
-export { AgentResource as $, ImmutableArray as A, EntriesToObject as B, StreamErrorPayload as C, createStreamReader as D, StreamSinkEvents as E, SharedStateEvents as F, DevframeRpcSharedStates as G, Thenable as H, SharedStateOptions as I, DevframeDiagnosticsDefinition as J, DevframeHost as K, SharedStatePatch as L, ImmutableObject as M, ImmutableSet as N, createStreamSink as O, SharedState as P, AgentManifest as Q, createSharedState as R, CreateStreamSinkOptions as S, StreamSink as T, DevframeRpcClientFunctions as U, PartialWithoutId as V, DevframeRpcServerFunctions as W, DevframeDiagnosticsLogger as X, DevframeDiagnosticsHost as Y, AgentHandle as Z, RpcStreamingChannel as _, DevframeRuntime as a, DevframeAgentHostEvents as at, BufferedChunk as b, defineDevframe as c, EventsMap as ct, DevframeNodeContext as d, defineCliFlags as dt, AgentResourceContent as et, DevframeNodeRpcSession as f, parseCliFlags as ft, RpcSharedStateHost as g, RpcSharedStateGetOptions as h, DevframeDeploymentKind as i, DevframeAgentHost as it, ImmutableMap as j, Immutable as k, ConnectionMeta as l, CliFlagsSchema as lt, RpcFunctionsHost as m, DevframeCliOptions as n, AgentTool as nt, DevframeSetupInfo as o, EventEmitter as ot, RpcBroadcastOptions as p, DevframeDefineDiagnosticsOptions as q, DevframeDefinition as r, AgentToolInput as rt, DevframeSpaOptions as s, EventUnsubscribe as st, DevframeBrowserContext as t, AgentResourceInput as tt, DevframeCapabilities as u, InferCliFlags as ut, RpcStreamingChannelOptions as v, StreamReader as w, CreateStreamReaderOptions as x, RpcStreamingHost as y, DevframeViewHost as z };
+export { ScopedServerFunctions as $, createStreamReader as A, SharedStatePatch as B, BufferedChunk as C, CliFlagsSchema as Ct, StreamReader as D, StreamErrorPayload as E, parseCliFlags as Et, ImmutableObject as F, DevframeScopedNodeContext as G, EntriesToObject as H, ImmutableSet as I, DevframeSettings as J, DevframeScopedNodeRpc as K, SharedState as L, Immutable as M, ImmutableArray as N, StreamSink as O, ImmutableMap as P, ScopedClientFunctions as Q, SharedStateEvents as R, RpcStreamingHost as S, EventsMap as St, CreateStreamSinkOptions as T, defineCliFlags as Tt, PartialWithoutId as U, createSharedState as V, Thenable as W, DevframeSettingsStore as X, DevframeSettingsRegistry as Y, ScopedBroadcastOptions as Z, RpcFunctionsHost as _, AgentToolInput as _t, DevframeDuplicationStrategy as a, DevframeRpcSharedStates as at, RpcStreamingChannel as b, EventEmitter as bt, DevframeSpaOptions as c, DevframeDiagnosticsDefinition as ct, ConnectionMeta as d, AgentHandle as dt, ScopedSharedStates as et, ConnectionMetaWebsocket as f, AgentManifest as ft, RpcBroadcastOptions as g, AgentTool as gt, DevframeNodeRpcSession as h, AgentResourceInput as ht, DevframeDeploymentKind as i, DevframeRpcServerFunctions as it, createStreamSink as j, StreamSinkEvents as k, DevframeWsOptions as l, DevframeDiagnosticsHost as lt, DevframeNodeContext as m, AgentResourceContent as mt, DevframeCliOptions as n, DevframeViewHost as nt, DevframeRuntime as o, DevframeHost as ot, DevframeCapabilities as p, AgentResource as pt, DevframeScopedStreamingHost as q, DevframeDefinition as r, DevframeRpcClientFunctions as rt, DevframeSetupInfo as s, DevframeDefineDiagnosticsOptions as st, DevframeBrowserContext as t, SettingsForNamespace as tt, defineDevframe as u, DevframeDiagnosticsLogger as ut, RpcSharedStateGetOptions as v, DevframeAgentHost as vt, CreateStreamReaderOptions as w, InferCliFlags as wt, RpcStreamingChannelOptions as x, EventUnsubscribe as xt, RpcSharedStateHost as y, DevframeAgentHostEvents as yt, SharedStateOptions as z };

package/dist/{diagnostics-GitRGKbr.mjs → diagnostics-BXwBQmoN.mjs}

@@ -1,4 +1,4 @@
-import { t as devframeReporter } from "./diagnostics-reporter-CBBZwoMv.mjs";
+import { t as devframeReporter } from "./diagnostics-reporter-CsIG85Q5.mjs";
 import { defineDiagnostics } from "nostics";
 //#region src/rpc/diagnostics.ts
 const diagnostics = defineDiagnostics({

package/dist/{dump-9lKIJTLh.mjs → dump-DoXkj4ku.mjs}

@@ -1,4 +1,4 @@
-import { t as diagnostics } from "./diagnostics-GitRGKbr.mjs";
+import { t as diagnostics } from "./diagnostics-BXwBQmoN.mjs";
 import { DEVFRAME_RPC_DUMP_DIRNAME } from "./constants.mjs";
 import { createHash } from "node:crypto";
 //#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/shared/ohash.D__AXeF1.mjs

package/dist/helpers/vite.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-BuR6n9ZD.mjs";
+import { r as DevframeDefinition } from "../devframe-D-gr9sBx.mjs";
 
 //#region src/helpers/vite.d.ts
 interface ViteDevBridgeOptions {

package/dist/helpers/vite.mjs

@@ -1,8 +1,8 @@
-import { DEVFRAME_CONNECTION_META_FILENAME } from "../constants.mjs";
-import { i as diagnostics } from "../shared-state-BlBNYziY.mjs";
-import { n as resolveBasePath } from "../_shared-CUFqO4kJ.mjs";
+import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_WS_ROUTE } from "../constants.mjs";
+import { a as diagnostics } from "../storage-l2ezeend.mjs";
+import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-bWRzeSa0.mjs";
 import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-Cv43GfqM.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-BaX8fLH2.mjs";
 import { resolve } from "pathe";
 //#region src/helpers/vite.ts
 /**
@@ -66,7 +66,10 @@ function viteDevBridge(d, options = {}) {
 				res.setHeader("Content-Type", "application/json");
 				res.end(JSON.stringify({
 					backend: "websocket",
-					websocket: port
+					websocket: {
+						port,
+						path: `/${DEVFRAME_WS_ROUTE}`
+					}
 				}));
 			});
 			server.httpServer?.once("close", () => {
@@ -82,14 +85,11 @@ function viteDevBridge(d, options = {}) {
 /**
 * Make `base` safe for `server.middlewares.use(path, …)`. Vite's connect
 * router matches by absolute URL prefix, so relative spellings like
-* `'./'` (commonly used for base-agnostic Nuxt builds) need to be
-* converted to `/` first.
+* `'./'` (commonly used for base-agnostic Nuxt builds) collapse to the
+* origin root before the shared leading/trailing-slash normalization.
 */
 function normalizeMountBase(base) {
-	let out = base.replace(/^\.\/?/, "/");
-	if (!out.startsWith("/")) out = `/${out}`;
-	if (!out.endsWith("/")) out = `${out}/`;
-	return out.replace(/\/+/g, "/");
+	return normalizeBasePath(base.replace(/^\.\/?/, "/"));
 }
 //#endregion
 export { viteDevBridge };