devframe 0.8.2 → 0.9.0-beta.10

package/dist/{devframe-mQ4qZAuo.d.mts → devframe-DJMg0WLe.d.mts}

@@ -1,11 +1,11 @@
-import { _ as RpcFunctionDefinition, v as RpcFunctionDefinitionAny } from "./types-CnJSgRVa.mjs";
-import { w as RpcFunctionsCollectorBase } from "./index-Dbw1p5ch.mjs";
-import { n as DevframeNodeRpcSessionMeta } from "./ws-server-uKQcClcJ.mjs";
+import { d as RpcFunctionsCollectorBase } from "./index-tdrk1bzV.mjs";
+import { _ as RpcFunctionDefinition, v as RpcFunctionDefinitionAny } from "./types-Djq7CBXh.mjs";
+import { d as DevframeRpcConnection, u as DevframeNodeRpcSessionMeta } from "./ws-server-D1d3QM9f.mjs";
+import { m as defineDiagnostics } from "./nostics-SPGDgHEP.mjs";
+import { a as RemoteAssetsStore, o as StaticAssetsSource } from "./remote-assets-Bg4gCUZ_.mjs";
 import { CAC } from "cac";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-import { Peer } from "crossws";
 import { BirpcReturn } from "birpc";
-import { Diagnostic, DiagnosticDefinition, defineDiagnostics } from "nostics";
 //#region src/adapters/flags.d.ts
 /**
  * Schema map for typed CLI flags. Keys are flag names in camelCase —
@@ -120,9 +120,6 @@ interface EventEmitter<Events extends EventsMap> {
  * Serializable description of an agent-exposed tool. This is the shape
  * returned by the agent host manifest and surfaced over the wire by
  * the `devframe:agent:list-tools` introspection RPC.
- *
- * @experimental The agent-native surface is experimental and may change
- * without a major version bump until it stabilizes.
  */
 interface AgentTool {
   /** Stable identifier. For RPC-backed tools, matches the RPC name. */
@@ -160,8 +157,6 @@ interface AgentTool {
 /**
  * Input accepted by `DevframeAgentHost.registerTool()`. Handler is
  * stripped from the serializable `AgentTool` projection.
- *
- * @experimental
  */
 interface AgentToolInput {
   id: string;
@@ -192,8 +187,6 @@ interface AgentToolInput {
 /**
  * Serializable description of an agent-readable resource. Resources
  * surface structured or textual snapshots of devframe state.
- *
- * @experimental
  */
 interface AgentResource {
   id: string;
@@ -206,8 +199,6 @@ interface AgentResource {
 }
 /**
  * Input accepted by `DevframeAgentHost.registerResource()`.
- *
- * @experimental
  */
 interface AgentResourceInput {
   id: string;
@@ -221,8 +212,6 @@ interface AgentResourceInput {
 }
 /**
  * Payload returned by `AgentResourceInput.read`. Either `text` or `json` must be set.
- *
- * @experimental
  */
 interface AgentResourceContent {
   text?: string;
@@ -232,8 +221,6 @@ interface AgentResourceContent {
 }
 /**
  * Unified view of the agent-exposed surface.
- *
- * @experimental
  */
 interface AgentManifest {
   tools: readonly AgentTool[];
@@ -241,8 +228,6 @@ interface AgentManifest {
 }
 /**
  * Handle returned by `registerTool` / `registerResource`.
- *
- * @experimental
  */
 interface AgentHandle {
   unregister: () => void;
@@ -257,14 +242,10 @@ interface AgentHandle {
  * Providers should namespace tool ids like any other tool; on an id
  * collision the earlier source wins (registered tools, then RPC tools,
  * then providers in registration order).
- *
- * @experimental
  */
 type AgentToolProvider = () => readonly AgentToolInput[];
 /**
  * Handle returned by `registerToolProvider`.
- *
- * @experimental
  */
 interface AgentToolProviderHandle extends AgentHandle {
   /**
@@ -276,8 +257,6 @@ interface AgentToolProviderHandle extends AgentHandle {
 }
 /**
  * Events emitted by `DevframeAgentHost`.
- *
- * @experimental
  */
 interface DevframeAgentHostEvents {
   'agent:tool:registered': (tool: AgentTool) => void;
@@ -295,9 +274,6 @@ interface DevframeAgentHostEvents {
  * RPC functions flagged with `agent` and plugin-registered tools /
  * resources. Consumed by protocol adapters such as the devframe MCP
  * adapter.
- *
- * @experimental The agent-native surface is experimental and may change
- * without a major version bump until it stabilizes.
  */
 interface DevframeAgentHost {
   readonly events: EventEmitter<DevframeAgentHostEvents>;
@@ -852,7 +828,7 @@ interface RpcStreamingHost {
   /**
    * Adapters call this when a session disconnects so the host can drop
    * subscribers and abort orphaned streams. Most users do not need this;
-   * it's wired by `startHttpAndWs` automatically.
+   * it's wired by the RPC server binding automatically.
    *
    * @internal
    */
@@ -860,14 +836,6 @@ interface RpcStreamingHost {
 }
 //#endregion
 //#region src/types/diagnostics.d.ts
-/**
- * A diagnostics definition object built with `defineDiagnostics`. Typed as
- * `unknown` because each integration's definition has a distinct narrow shape
- * (e.g. specific code keys like `DF0001` / `MYP0001`), and TypeScript's mapped
- * types don't allow assigning a narrow-keyed result to a generically-keyed
- * one. The host stores them in a heterogeneous registry.
- */
-type DevframeDiagnosticsDefinition = ReturnType<typeof defineDiagnostics<any, any>>;
 /**
  * The shared diagnostics lookup exposed by the host. A `Proxy` that resolves
  * any registered code name to its `nostics` handle (a callable that builds
@@ -876,16 +844,6 @@ type DevframeDiagnosticsDefinition = ReturnType<typeof defineDiagnostics<any, an
  * integrations.
  */
 type DevframeDiagnosticsLogger = Record<string, any>;
-/**
- * Options accepted by the host's `defineDiagnostics()` factory — mirrors
- * `nostics`'s shape but the host pre-wires its ANSI console reporter, so
- * plugins typically omit `reporters`.
- */
-interface DevframeDefineDiagnosticsOptions<Codes extends Record<string, DiagnosticDefinition>> {
-  docsBase?: string | ((code: keyof Codes) => string | undefined);
-  codes: Codes;
-  reporters?: ReadonlyArray<(d: Diagnostic, o?: any) => void>;
-}
 /**
  * Host for structured diagnostics — a thin layer over `nostics` that lets
  * integrations register their own coded errors/warnings into a shared
@@ -928,27 +886,31 @@ interface DevframeDiagnosticsHost {
   register: (definitions: Record<string, unknown>) => void;
   /**
    * Build a typed diagnostics object with the host's ANSI console reporter
-   * pre-wired. Mirrors `nostics`'s `defineDiagnostics` so integrations don't
-   * need to take a direct dependency on `nostics`.
+   * pre-wired. The same `devframe/utils/nostics` `defineDiagnostics` every
+   * built-in plugin's module-level `diagnostics.ts` uses, so integrations
+   * don't need to take a direct dependency on `nostics`.
    */
-  defineDiagnostics: <const Codes extends Record<string, DiagnosticDefinition>>(options: DevframeDefineDiagnosticsOptions<Codes>) => ReturnType<typeof defineDiagnostics<Codes, any>>;
+  defineDiagnostics: typeof defineDiagnostics;
 }
 //#endregion
 //#region src/types/host.d.ts
 interface DevframeHost {
   /**
-   * Serve a static directory at the given URL base. Called by
-   * `DevframeViewHost.hostStatic`. Implementations map this to whatever
+   * Serve static assets at the given URL base — a local directory, or a
+   * resolved {@link RemoteAssetsStore} back-proxy. Called by
+   * `DevframeViewHost.hostStatic` (which normalizes `RemoteAssets`
+   * declarations into stores first). Implementations map this to whatever
    * the underlying runtime expects (Vite middleware, h3 handler, no-op
-   * for build snapshots).
+   * for build snapshots) — the shared engine in
+   * `devframe/utils/serve-static` accepts either shape.
    */
-  mountStatic: (base: string, distDir: string) => void | Promise<void>;
+  mountStatic: (base: string, source: string | RemoteAssetsStore) => 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
+   * Called by `ctx.install` 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
@@ -1007,14 +969,17 @@ interface DevframeViewHost {
    */
   buildStaticDirs: {
     baseUrl: string;
-    distDir: string;
+    source: StaticAssetsSource;
   }[];
   /**
    * Helper to host static files
    * - In `dev` mode, it will register middleware to `viteServer.middlewares` to host the static files
    * - In `build` mode, it will copy the static files to the dist directory
+   *
+   * Accepts a local dist directory, or a {@link StaticAssetsSource} remote
+   * declaration served through devframe's caching CDN back-proxy.
    */
-  hostStatic: (baseUrl: string, distDir: string) => void;
+  hostStatic: (baseUrl: string, source: StaticAssetsSource) => void;
 }
 //#endregion
 //#region src/types/scope.d.ts
@@ -1304,8 +1269,6 @@ interface DevframeNodeContext {
   diagnostics: DevframeDiagnosticsHost;
   /**
    * Agent host — aggregates the agent-exposed surface of this devtool.
-   *
-   * @experimental
    */
   agent: DevframeAgentHost;
   /**
@@ -1317,6 +1280,22 @@ interface DevframeNodeContext {
    * absorb setup-order differences between provider and consumer.
    */
   services: DevframeServicesHost;
+  /**
+   * This context's own {@link ConnectionMeta.configs} — static, boot-time
+   * config a host publishes once through the connection handshake and every
+   * client reads read-only. A plain, **non-reactive** object: mutate it
+   * during `setup(ctx)` (a plugin sets its keys, a hub aggregates across
+   * every installed devframe), never during the session — it's serialized
+   * once, after setup, and changing it afterwards reaches no client.
+   *
+   * ```ts
+   * ctx.staticConfig.dock = {
+   *   ...ctx.staticConfig.dock,
+   *   categoryOrder: { ...ctx.staticConfig.dock?.categoryOrder, ...myOrder },
+   * }
+   * ```
+   */
+  staticConfig: Partial<DevframeConnectionConfigsRegistry>;
   /**
    * Create a namespace-scoped view of this context. The returned
    * `ctx.scope('my-plugin')` auto-namespaces every RPC id, shared-state
@@ -1344,8 +1323,8 @@ interface DevframeNodeContext {
  */
 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`)
+   * Path to the WS endpoint. Relative paths (the default, e.g. `__ws`) are
+   * resolved against `__connection.json`'s location; absolute paths (`/__ws`)
    * resolve against the page origin.
    */
   path?: string;
@@ -1354,8 +1333,32 @@ interface ConnectionMetaWebsocket {
   /** Override the host (`hostname[:port]`). Use for a fully cross-origin endpoint. */
   host?: string;
 }
+/**
+ * Object form of {@link ConnectionMeta.sse} — the same proxy-safe shape and
+ * resolution rules as {@link ConnectionMetaWebsocket}, producing an
+ * `http(s)://` endpoint instead of a `ws(s)://` one. Set `port` (and/or
+ * `host`) only when the SSE endpoint genuinely lives on a different origin
+ * than the page, e.g. a side-car server on its own port.
+ */
+interface ConnectionMetaSse {
+  /**
+   * Path to the SSE endpoint. Relative paths (the default, e.g. `__sse`)
+   * are resolved against `__connection.json`'s location; absolute paths
+   * (`/__sse`) 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';
+  /**
+   * The server's primary live-RPC transport (`websocket` / `sse`), `static`
+   * for a pre-computed RPC dump with no live server, or `none` for a server
+   * exposing no RPC transport at all (e.g. an MCP-only deployment).
+   */
+  backend: 'websocket' | 'sse' | 'static' | 'none';
   /**
    * WebSocket endpoint, resolved by the client into a `ws(s)://` URL:
    *
@@ -1366,13 +1369,24 @@ interface ConnectionMeta {
    *     URL with its protocol swapped, or a path resolved same-origin.
    */
   websocket?: number | string | ConnectionMetaWebsocket;
+  /**
+   * SSE endpoint (`GET` opens the event stream, `POST` carries RPC calls),
+   * resolved by the client into an `http(s)://` URL with the same
+   * proxy-safe rules as {@link ConnectionMeta.websocket}:
+   *
+   *   - {@link ConnectionMetaSse} — the proxy-flexible default; a
+   *     same-origin path relative to `__connection.json`.
+   *   - `string` — a full `http(s)://` URL used verbatim, or a path
+   *     resolved same-origin.
+   */
+  sse?: string | ConnectionMetaSse;
   /**
    * Present when the dev server exposes a route-based MCP endpoint
    * (`cli.mcp`). Advertises the MCP Streamable-HTTP route so in-browser
    * tooling (e.g. an MCP inspector) can discover it without guessing the
    * path. `path` is relative to `__connection.json`'s location, like the
    * WebSocket `path`. `port` is set when the endpoint lives on a side-car
-   * server on its own port (bridge mode — `viteDevBridge`,
+   * server on its own port (bridge mode — `devframeViteBridge`,
    * `@devframes/next`): the client combines the page hostname with `port`
    * and resolves `path` against that origin, mirroring
    * {@link ConnectionMetaWebsocket.port}.
@@ -1423,16 +1437,38 @@ interface ConnectionMeta {
    * token same-origin until the requesting origin has been verified.
    */
   viewerOriginToken?: string;
+  /**
+   * Static, host-declared configuration — baked in once at connect time and
+   * fixed for the life of the server (e.g. a hub's UI rebrand, or its
+   * aggregated dock-bar layout preferences). Read-only from the browser: a
+   * client only ever reads `rpc.connectionMeta.configs`, never writes to it.
+   *
+   * Contrast this with {@link DevframeSettingsRegistry} (`ctx.scope(ns).settings`)
+   * and a hub's `devframe:user-settings` shared-state key — both are
+   * mutable, user-editable, and synced bidirectionally over RPC for the
+   * life of the session. `configs` is the opposite: one-way, immutable,
+   * decided by whoever assembled the server.
+   *
+   * Each key is owned by one package, contributed via declaration merging:
+   *
+   * ```ts
+   * declare module 'devframe/types' {
+   *   interface DevframeConnectionConfigsRegistry {
+   *     'my-key': { some: 'shape' }
+   *   }
+   * }
+   * ```
+   */
+  configs?: Partial<DevframeConnectionConfigsRegistry>;
 }
-//#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;
-};
+/**
+ * Augmentation point for {@link ConnectionMeta.configs}. Empty by default —
+ * a package that wants to publish static, boot-time config through the
+ * connection handshake augments this interface with its own key (see
+ * {@link ConnectionMeta.configs} for the pattern). `@devframes/hub`
+ * augments it with `dock`; `@devframes/hub-ui` augments it with `ui`.
+ */
+interface DevframeConnectionConfigsRegistry {}
 //#endregion
 //#region src/node/auth/handler.d.ts
 /**
@@ -1442,7 +1478,7 @@ type PartialWithoutId<T extends {
  * the handshake RPC functions, the resolver gate, the connect-time trust
  * hook, and the startup banner.
  *
- * `startHttpAndWs` accepts one of these directly via its `auth` option —
+ * `initDevframe` / `initHub` accept one of these directly via their `auth` option —
  * see {@link https://devfra.me | devframe}'s server docs — or a host can
  * wire the four pieces itself against a lower-level transport.
  */
@@ -1461,12 +1497,12 @@ interface DevframeAuthHandler {
    */
   authorize: (methodName: string, session: DevframeNodeRpcSession) => boolean;
   /**
-   * Connect-time trust: reads a bearer token off the peer's upgrade request
-   * (an `Authorization: Bearer <token>` header, or a static/pre-shared
-   * token from `clientAuthTokens`) and, when valid, marks the session
+   * Connect-time trust: reads a bearer token off the connection's initial
+   * request (a static/pre-shared token from `clientAuthTokens`, or a token
+   * minted by the code exchange) and, when valid, marks the session
    * trusted immediately — before the client's own handshake call.
    */
-  onConnect: (peer: Peer, session: DevframeNodeRpcSession) => void;
+  onConnect: (connection: DevframeRpcConnection, session: DevframeNodeRpcSession) => void;
   /**
    * Print the current one-time code and its magic-link URL. Devframe stays
    * headless — call this yourself once the server is listening. Safe to
@@ -1485,12 +1521,11 @@ interface DevframeAuthHandler {
 }
 //#endregion
 //#region src/types/devframe.d.ts
-type DevframeRuntime = 'cli' | 'build' | 'spa' | 'vite' | 'embedded';
 /**
  * Classification of how a devframe is being deployed. Hosted adapters
  * (`vite`, `embedded`) share their origin with a host app and must
  * namespace their mount path under `/__<id>/`. Standalone adapters
- * (`cli`, `spa`, `build`) own the origin and default to `/`.
+ * (`cli`, `build`) own the origin and default to `/`.
  */
 type DevframeDeploymentKind = 'standalone' | 'hosted';
 /**
@@ -1512,7 +1547,7 @@ type DevframeDuplicationStrategy = 'warn' | 'silent' | 'throw' | 'duplicate';
  *
  *   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
+ *      (`__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
@@ -1524,29 +1559,49 @@ type DevframeDuplicationStrategy = 'warn' | 'silent' | 'throw' | 'duplicate';
 interface DevframeWsOptions {
   /**
    * Upgrade route segment the socket binds to and is advertised at, relative
-   * to the SPA base. Default: `__devframe_ws`.
+   * to the SPA base. Default: `__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.
+   * browser connects to this port on the page's hostname. Implies
+   * {@link DevframeWsOptions.sidecar}.
    */
   port?: number;
+  /**
+   * Start a side-car WebSocket server on a free port, for hosts whose request
+   * handlers can't accept upgrades (Next.js route handlers, Nitro, Rsbuild).
+   * The resolved port is advertised in `__connection.json`, so the browser
+   * finds it without any further wiring. Set `port` instead to pin it.
+   */
+  sidecar?: boolean;
   /**
    * Advertise a fixed, fully-qualified endpoint on another origin (a full
    * `ws://`/`wss://` URL). Takes precedence over `port`/`route` in the meta.
    */
   url?: string;
 }
+/**
+ * Controls the SSE RPC endpoint — the WebSocket-free transport for hosts
+ * and proxies where the upgrade isn't available. It rides whatever HTTP
+ * surface serves the instance (the same one serving `__connection.json`),
+ * so a relative `route` always resolves; there is no port plumbing of its
+ * own. Enabled by default alongside the WebSocket; pass `sse: false` to
+ * disable, or `ws: false` to run SSE-only (`backend: 'sse'`).
+ */
+interface DevframeSseOptions {
+  /**
+   * Route segment the SSE endpoint binds to and is advertised at, relative
+   * to the SPA base. Default: `__sse`.
+   */
+  route?: string;
+}
 /**
  * Configuration for the route-based MCP server mounted alongside the dev
  * server (opt-in via {@link DevframeCliOptions.mcp}). The endpoint speaks
  * the MCP Streamable-HTTP transport over the same origin as the SPA,
  * exposing the definition's `ctx.agent` tools + shared-state resources to
  * external MCP clients connected to the *running* server.
- *
- * @experimental The agent-native surface is experimental and may change
- * without a major version bump until it stabilizes.
  */
 interface McpRouteOptions {
   /**
@@ -1588,7 +1643,7 @@ interface DevframeCliOptions {
   /**
    * Authentication for the standalone dev server.
    *
-   *   - `undefined` / `true` — the standalone adapters (`cli` / `spa` /
+   *   - `undefined` / `true` — the standalone adapters (`cli` /
    *     served `build`) auto-wire devframe's interactive OTP auth
    *     (`createInteractiveAuth`): an untrusted client can only reach
    *     `anonymous:` methods until it exchanges the printed one-time code.
@@ -1599,7 +1654,7 @@ interface DevframeCliOptions {
    *     The `--no-auth` CLI flag maps here for one-off runs.
    *   - A {@link DevframeAuthHandler} — a custom handler (e.g. a tuned
    *     `createInteractiveAuth`, or an entirely different scheme) passed
-   *     straight through to `startHttpAndWs`.
+   *     straight through to the RPC transport binding.
    *
    * Hosted adapters (`vite`, `embedded`) ignore this and defer to the host's
    * auth; `@vitejs/devtools` honors the equivalent `devtools.clientAuth`.
@@ -1619,21 +1674,31 @@ interface DevframeCliOptions {
    * - {@link McpRouteOptions} — customise the route path / allowed origins.
    *
    * The `--mcp` / `--no-mcp` CLI flags override this per run.
-   *
-   * @experimental
    */
   mcp?: boolean | McpRouteOptions;
-  /** Author's SPA dist directory (served as the devframe's UI). */
-  distDir?: string;
+  /**
+   * Author's SPA dist — served as the devframe's UI. A local directory, or
+   * a {@link StaticAssetsSource} remote declaration (`{ package, version }`)
+   * served through devframe's caching CDN back-proxy so the assets need not
+   * ship inside the node package.
+   */
+  distDir?: StaticAssetsSource;
   /**
    * 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.
+   * port on the `__ws` route. See {@link DevframeWsOptions} for the
+   * different-port and remote-origin variants. Pass `false` to serve no
+   * WebSocket at all — clients connect over SSE instead (`backend: 'sse'`).
    */
-  ws?: DevframeWsOptions;
+  ws?: DevframeWsOptions | false;
+  /**
+   * How the browser reaches the SSE RPC endpoint — enabled by default
+   * alongside the WebSocket as the more portable transport. Pass `false`
+   * to disable, or a {@link DevframeSseOptions} to change its route.
+   */
+  sse?: boolean | DevframeSseOptions;
   /**
    * Capability-side CAC hook. Called with the CAC instance after the
-   * adapter registers its built-in commands (`build` / `spa` / `mcp`)
+   * adapter registers its built-in commands (`build` / `mcp`)
    * but before `createCac`'s own `configureCli` caller. Use this to
    * contribute tool-specific flags and subcommands from the definition
    * itself.
@@ -1669,12 +1734,12 @@ interface DevframeCliOptions {
 /**
  * Default dock attributes for the iframe entry a hub synthesizes when it
  * mounts this devframe. Framework-neutral metadata only — the hub layer
- * (`mountDevframe`) merges these beneath its per-mount `dock` overrides,
+ * (`ctx.install`) merges these beneath its per-mount `dock` overrides,
  * which in turn sit beneath the locked, derived `id` / `type` / `url`.
  *
  * Every field is optional. `title` / `icon` default to the definition's
  * `name` / `icon` when omitted here; the rest are unset by default.
- * Standalone adapters (`cli` / `spa` / `build`) ignore this entirely.
+ * Standalone adapters (`cli` / `build`) ignore this entirely.
  */
 interface DevframeDockDefaults {
   /** Dock entry title. Defaults to the definition's `name`. */
@@ -1711,22 +1776,6 @@ interface DevframeDockDefaults {
   /** Id of the dock group this entry collapses under, if any. */
   groupId?: string;
 }
-interface DevframeSpaOptions {
-  base?: string;
-  /**
-   * How the deployed SPA loads its data.
-   * - `'query'` — read from URL search params.
-   * - `'upload'` — accept a file drag-drop.
-   * - `'none'`  — use the baked RPC dump only.
-   */
-  loader?: 'query' | 'upload' | 'none';
-}
-interface DevframeBrowserContext {
-  /**
-   * The connected RPC client (may be write-disabled in static/spa modes).
-   */
-  rpc: unknown;
-}
 /**
  * Runtime information threaded into `setup(ctx, info)`. Adapters
  * populate the fields that make sense for their deployment. In
@@ -1753,50 +1802,48 @@ interface DevframeDefinition {
   };
   /**
    * Default dock attributes applied when a hub mounts this devframe as an
-   * iframe dock entry. Consulted only by hub adapters (`mountDevframe`),
+   * iframe dock entry. Consulted only by the hub install path (`ctx.install`),
    * which merge these beneath the per-mount `dock` overrides; standalone
-   * adapters (`cli` / `spa` / `build`) ignore it.
+   * adapters (`cli` / `build`) ignore it.
    *
    * @see {@link DevframeDockDefaults}
    */
   dock?: DevframeDockDefaults;
   /**
    * Mount path override. Defaults depend on the adapter:
-   * `/` for standalone (`cli` / `spa` / `build`), `/__<id>/` for hosted
+   * `/` for standalone (`cli` / `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`)
+   * (`ctx.install`); standalone adapters (`cli` / `build`)
    * ignore it.
    *
    * @default 'warn'
    */
   duplicationStrategy?: DevframeDuplicationStrategy;
   /**
-   * Declares which runtimes meaningfully support this devframe. Consulted
-   * by adapters that can act on a plain `false` before doing any work:
-   * `createCac` skips registering the `build` subcommand entirely when
-   * `capabilities.build` is `false` — useful for a devframe whose value is
-   * inherently live (e.g. it manages real files on disk), so a static
-   * export would only ever produce a broken, write-less shell of the tool.
-   * The `Record<string, boolean>` shape is reserved for finer-grained
-   * sub-capabilities and currently unconsumed by any adapter.
+   * Declares which runtimes meaningfully support this devframe. Adapters
+   * act on a `false` before doing any work:
+   *
+   * - `build: false` — `createCac` skips registering the `build` subcommand,
+   *   and `createBuild` refuses (throws `DF0042`) unless `{ force: true }`.
+   *   Useful for a devframe whose value is inherently live (e.g. it manages
+   *   real files on disk), so a static export would only ever produce a
+   *   broken, write-less shell of the tool.
+   * - `dev: false` — `createDevServer` refuses (throws `DF0058`) unless
+   *   `{ force: true }`. Useful for a devframe that only makes sense as a
+   *   static export (e.g. a report generator with nothing to serve live).
    */
   capabilities?: {
-    dev?: boolean | Record<string, boolean>;
-    build?: boolean | Record<string, boolean>;
-    spa?: boolean | Record<string, boolean>;
+    dev?: boolean;
+    build?: boolean;
   };
   /** Server-side setup — the primary entrypoint. Runs in every runtime. */
   setup: (ctx: DevframeNodeContext, info?: DevframeSetupInfo) => void | Promise<void>;
-  /** Browser-only setup for the SPA adapter (bundled into the client). */
-  setupBrowser?: (ctx: DevframeBrowserContext) => void | Promise<void>;
   cli?: DevframeCliOptions;
-  spa?: DevframeSpaOptions;
 }
-declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
 //#endregion
-export { DevframeRpcServerFunctions as $, DevframeSettingsStore as A, DevframeAgentHostEvents as At, DevframeDefineDiagnosticsOptions as B, DevframeServicesHost as C, AgentResourceContent as Ct, DevframeScopedStreamingHost as D, AgentToolProvider as Dt, DevframeScopedNodeRpc as E, AgentToolInput as Et, ScopedSharedStates as F, InferCliFlags as Ft, RpcBroadcastOptions as G, DevframeDiagnosticsHost as H, SettingsForNamespace as I, defineCliFlags as It, RpcSharedStateHost as J, RpcFunctionsHost as K, DevframeViewHost as L, parseCliFlags as Lt, ScopedClientFunctions as M, EventUnsubscribe as Mt, ScopedRpcFn as N, EventsMap as Nt, DevframeSettings as O, AgentToolProviderHandle as Ot, ScopedServerFunctions as P, CliFlagsSchema as Pt, DevframeRpcClientFunctions as Q, DevframeHost as R, DevframeServiceOf as S, AgentResource as St, DevframeScopedNodeContext as T, AgentTool as Tt, DevframeDiagnosticsLogger as U, DevframeDiagnosticsDefinition as V, DevframeNodeRpcSession as W, RpcStreamingChannelOptions as X, RpcStreamingChannel as Y, RpcStreamingHost as Z, ConnectionMeta as _, SharedStateOptions as _t, DevframeDockDefaults as a, StreamReader as at, DevframeNodeContext as b, AgentHandle as bt, DevframeSetupInfo as c, createStreamReader as ct, McpRouteOptions as d, ImmutableArray as dt, DevframeRpcSharedStates as et, defineDevframe as f, ImmutableMap as ft, Thenable as g, SharedStateEvents as gt, PartialWithoutId as h, SharedState as ht, DevframeDeploymentKind as i, StreamErrorPayload as it, ScopedBroadcastOptions as j, EventEmitter as jt, DevframeSettingsRegistry as k, DevframeAgentHost as kt, DevframeSpaOptions as l, createStreamSink as lt, EntriesToObject as m, ImmutableSet as mt, DevframeCliOptions as n, CreateStreamReaderOptions as nt, DevframeDuplicationStrategy as o, StreamSink as ot, DevframeAuthHandler as p, ImmutableObject as pt, RpcSharedStateGetOptions as q, DevframeDefinition as r, CreateStreamSinkOptions as rt, DevframeRuntime as s, StreamSinkEvents as st, DevframeBrowserContext as t, BufferedChunk as tt, DevframeWsOptions as u, Immutable as ut, ConnectionMetaWebsocket as v, SharedStatePatch as vt, DevframeServicesRegistry as w, AgentResourceInput as wt, DevframeServiceId as x, AgentManifest as xt, DevframeCapabilities as y, createSharedState as yt, DevframeStorageScope as z };
+export { StreamReader as $, ScopedServerFunctions as A, defineCliFlags as At, RpcFunctionsHost as B, DevframeScopedStreamingHost as C, DevframeAgentHost as Ct, ScopedBroadcastOptions as D, EventsMap as Dt, DevframeSettingsStore as E, EventUnsubscribe as Et, DevframeStorageScope as F, RpcStreamingHost as G, RpcSharedStateHost as H, DevframeDiagnosticsHost as I, DevframeRpcSharedStates as J, DevframeRpcClientFunctions as K, DevframeDiagnosticsLogger as L, SettingsForNamespace as M, DevframeViewHost as N, ScopedClientFunctions as O, CliFlagsSchema as Ot, DevframeHost as P, StreamErrorPayload as Q, DevframeNodeRpcSession as R, DevframeScopedNodeRpc as S, AgentToolProviderHandle as St, DevframeSettingsRegistry as T, EventEmitter as Tt, RpcStreamingChannel as U, RpcSharedStateGetOptions as V, RpcStreamingChannelOptions as W, CreateStreamReaderOptions as X, BufferedChunk as Y, CreateStreamSinkOptions as Z, DevframeServiceId as _, AgentResourceContent as _t, DevframeDuplicationStrategy as a, ImmutableArray as at, DevframeServicesRegistry as b, AgentToolInput as bt, DevframeWsOptions as c, ImmutableSet as ct, ConnectionMeta as d, SharedStateOptions as dt, StreamSink as et, ConnectionMetaSse as f, SharedStatePatch as ft, DevframeNodeContext as g, AgentResource as gt, DevframeConnectionConfigsRegistry as h, AgentManifest as ht, DevframeDockDefaults as i, Immutable as it, ScopedSharedStates as j, parseCliFlags as jt, ScopedRpcFn as k, InferCliFlags as kt, McpRouteOptions as l, SharedState as lt, DevframeCapabilities as m, AgentHandle as mt, DevframeDefinition as n, createStreamReader as nt, DevframeSetupInfo as o, ImmutableMap as ot, ConnectionMetaWebsocket as p, createSharedState as pt, DevframeRpcServerFunctions as q, DevframeDeploymentKind as r, createStreamSink as rt, DevframeSseOptions as s, ImmutableObject as st, DevframeCliOptions as t, StreamSinkEvents as tt, DevframeAuthHandler as u, SharedStateEvents as ut, DevframeServiceOf as v, AgentResourceInput as vt, DevframeSettings as w, DevframeAgentHostEvents as wt, DevframeScopedNodeContext as x, AgentToolProvider as xt, DevframeServicesHost as y, AgentTool as yt, RpcBroadcastOptions as z };

package/dist/{diagnostics-hwjXp_UV.mjs → diagnostics-CD8nlgll.mjs}

@@ -1,9 +1,7 @@
-import { t as devframeReporter } from "./diagnostics-reporter-CsIG85Q5.mjs";
-import { defineDiagnostics } from "nostics";
+import { i as defineDiagnostics } from "./nostics-CzECRXpE.mjs";
 //#region src/rpc/diagnostics.ts
 const diagnostics = defineDiagnostics({
 	docsBase: "https://devfra.me/errors",
-	reporters: [devframeReporter],
 	codes: {
 		DF0019: {
 			why: (p) => `RPC function "${p.name}" has \`agent\` set but \`jsonSerializable\` is not \`true\` — MCP requires JSON-serializable data.`,