devframe 0.8.2 → 0.9.0-beta.10

package/dist/adapters/initiate.d.mts

@@ -0,0 +1,224 @@
+import { F as DevframeStorageScope, R as DevframeNodeRpcSession, c as DevframeWsOptions, d as ConnectionMeta, g as DevframeNodeContext, l as McpRouteOptions, n as DevframeDefinition, s as DevframeSseOptions, u as DevframeAuthHandler } from "../devframe-DJMg0WLe.mjs";
+import { d as DevframeRpcConnection, n as WsOriginRegistry, u as DevframeNodeRpcSessionMeta } from "../ws-server-D1d3QM9f.mjs";
+import { o as StaticAssetsSource } from "../remote-assets-Bg4gCUZ_.mjs";
+import { c as StartedServer, f as DevframeInstanceRecord } from "../instance-shell-CljiKq1c.mjs";
+import { Buffer } from "node:buffer";
+import { IncomingMessage, Server, ServerResponse } from "node:http";
+import { Duplex } from "node:stream";
+import { H3 } from "h3";
+//#region src/adapters/initiate.d.ts
+interface InitDevframeOptions {
+  /**
+   * Mount base the handler answers under (e.g. `/__my-tool/`) — required so
+   * the mount path is explicit at the call site. A handler is by definition
+   * mounted *inside* a host app's origin; the resolved value is echoed back
+   * as {@link DevframeInstance.base} so route/middleware code references it
+   * instead of repeating the string. `resolveBasePath(def, 'hosted')` gives
+   * the conventional `def.basePath ?? /__<id>/`.
+   */
+  base: string;
+  /**
+   * Override `def.cli?.distDir`. When neither is set — or `false` is passed
+   * to suppress the definition's own `distDir` — the handler runs in
+   * **bridge mode**: only `__connection.json`, the WS endpoint, and the MCP
+   * route (when enabled) are served; the SPA is hosted elsewhere.
+   */
+  distDir?: StaticAssetsSource | false;
+  /**
+   * Share the host's `node:http` server for the WebSocket RPC endpoint: the
+   * upgrade listener binds to `<base>__ws` on this server, so no extra port
+   * is needed and the socket follows the app through proxies/HTTPS. Hosts
+   * whose handlers never see upgrades (Next.js route handlers, Nitro,
+   * Rsbuild) ask for a side-car instead with `ws: { sidecar: true }`; hosts
+   * that own their upgrade routing wire {@link DevframeInstance.attach} /
+   * {@link DevframeInstance.handleUpgrade} themselves.
+   */
+  server?: Server;
+  /**
+   * Explicit control over how the browser reaches the RPC WebSocket —
+   * advertised in `__connection.json`. The **local binding** resolves in
+   * precedence order `ws.port` (pinned side-car) > `server` (shared upgrade)
+   * > `ws.sidecar` (auto-port side-car) > none (the host drives the socket
+   * through {@link DevframeInstance.attach}). `ws.url` controls the
+   * advertisement* only: the browser dials it verbatim (a tunnel/relay),
+   * while the local binding keeps following the options above — and on its
+   * own it means an external server owns both the transport and its auth.
+   * Pass `false` to serve no WebSocket at all — clients connect over the
+   * SSE endpoint instead (`backend: 'sse'`).
+   */
+  ws?: DevframeWsOptions | false;
+  /**
+   * SSE RPC endpoint control — enabled by default at `<base>__sse` as the
+   * more portable transport alongside the WebSocket. Pass `false` to
+   * disable, or a {@link DevframeSseOptions} to rename the route.
+   */
+  sse?: boolean | DevframeSseOptions;
+  /**
+   * Bind host for a side-car WebSocket server (default: `def.cli?.host ??
+   * 'localhost'`). Irrelevant for the `server` / `ws.url` tiers.
+   */
+  host?: string;
+  /**
+   * Authentication for the RPC endpoint. A handler mounted inside an app
+   * server is reachable by anything that can open its socket, so it **gates
+   * by default**: when unset (or `true`), devframe's interactive OTP handler
+   * is wired and its code/link banner prints once the public origin is known
+   * (derived from the first request, or `origin`). Pass a
+   * {@link DevframeAuthHandler} for a custom scheme, or `false` to opt out
+   * for a single-user localhost setup that owns the trust boundary another
+   * way. Ignored for the `ws.url` tier — the server behind that URL owns auth.
+   */
+  auth?: boolean | DevframeAuthHandler;
+  /**
+   * Expose a route-based MCP server (Streamable-HTTP) at `<base>__mcp` and
+   * advertise it in `__connection.json`. Overrides `def.cli?.mcp`;
+   * `undefined` falls through to it. See {@link McpRouteOptions}.
+   */
+  mcp?: boolean | McpRouteOptions;
+  /**
+   * Public origin the host app is reachable at (e.g. `http://localhost:3000`),
+   * or a getter for hosts that resolve it late. When omitted (or the getter
+   * returns a falsy value), it is derived lazily from the first request the
+   * handler serves — used for the auth banner's magic link and absolute dock
+   * URLs.
+   */
+  origin?: string | (() => string);
+  /**
+   * Publish this instance in the global registry (`~/.devframe/instances/`)
+   * so discovery tooling (`devframe connect`, the inspect plugin's Instances
+   * tab) finds it without port guessing. Registration is a dynamic import
+   * that fires once the public origin resolves and is torn down on
+   * {@link DevframeInstance.close}. Defaults to off; pass `true` to enable, or
+   * an object to override individual record fields (`id`, `name`, `mcp`, …).
+   */
+  register?: boolean | Partial<DevframeInstanceRecord>;
+  /** Parsed flag bag forwarded to `def.setup(ctx, { flags })`. */
+  flags?: Record<string, unknown>;
+  /**
+   * Extra origins to accept on the WS upgrade beyond the loopback default.
+   * Add your LAN/tunnel origin here when reaching the tool from another
+   * host. Pass `false` to disable origin checking entirely (not
+   * recommended). Default: loopback-only.
+   */
+  allowedOrigins?: readonly string[] | WsOriginRegistry | false;
+  /**
+   * h3 app to mount the handler's routes on. When omitted a fresh internal
+   * app is created — the common middleware case. An adapter that owns the
+   * whole server (e.g. `createDevServer`) passes its own app so callers can
+   * compose custom routes ahead of devframe's.
+   */
+  app?: H3;
+  /**
+   * Override where persisted devframe state lives, per
+   * `DevframeHost.getStorageDir`. Defaults to the standalone host layout
+   * (`.devframe/`, `node_modules/.<id>/devframe/`, `~/.<id>/devframe/`).
+   */
+  getStorageDir?: (scope: DevframeStorageScope) => string;
+  /**
+   * Destroy upgrade requests on a shared `server` that don't match the WS
+   * route, instead of leaving them for the host's own upgrade handlers.
+   * Enable when devframe's adapter owns the server outright (nothing else
+   * handles its upgrades) so off-route clients are rejected promptly.
+   * Default: `false` (coexist-friendly).
+   */
+  destroyUnmatchedUpgrades?: boolean;
+  /**
+   * Called once per new RPC connection, right after its session is created.
+   * Forwarded verbatim to the underlying transport.
+   */
+  onPeerConnect?: (connection: DevframeRpcConnection, session: DevframeNodeRpcSession) => void;
+  /**
+   * Called once per closed RPC connection, right after the transport's own
+   * disconnect bookkeeping runs.
+   */
+  onPeerDisconnect?: (connection: DevframeRpcConnection, meta: DevframeNodeRpcSessionMeta) => void;
+}
+interface DevframeInstance {
+  /**
+   * The normalized mount base this instance answers under (leading and
+   * trailing slash, e.g. `/__my-tool/`). Reference it when wiring the mount
+   * — route guards, middleware path checks — instead of repeating the
+   * string.
+   */
+  base: string;
+  /**
+   * Web-standard request handler — mount it on a catch-all route under
+   * {@link DevframeInstance.base} (Next.js route handler, SvelteKit
+   * `+server.ts`, Hono `c.req.raw`, Nitro `toWebRequest(event)`, …).
+   * Requests outside the base 404.
+   */
+  handler: (request: Request) => Promise<Response>;
+  /**
+   * Connect/Express-style middleware over the same surface — for
+   * `viteServer.middlewares.use(handler.nodeMiddleware)` or any other
+   * node middleware stack. Mount it un-prefixed: paths outside the base
+   * call `next()` so the rest of the stack keeps working.
+   */
+  nodeMiddleware: (req: IncomingMessage, res: ServerResponse, next?: (err?: unknown) => void) => void;
+  /**
+   * Route a host server's `upgrade` events to the RPC socket, returning a
+   * detach function — the manual counterpart to the `server` option, for
+   * hosts that get their `node:http` server only after the instance exists.
+   * Available on the default tier; a configured transport (`server`,
+   * `ws.port`, `ws.sidecar`, `ws.url`) already owns the socket and reports
+   * `DF0055` / `DF0056` instead.
+   */
+  attach: (server: Server) => () => void;
+  /**
+   * Complete a single `upgrade` event on the RPC socket, for hosts that
+   * already own an `upgrade` listener: `server.on('upgrade',
+   * instance.handleUpgrade)`. Same availability as
+   * {@link DevframeInstance.attach}.
+   */
+  handleUpgrade: (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
+  /**
+   * Resolves once `def.setup` has run and the WebSocket binding is live.
+   * `handler`/`nodeMiddleware` await it internally, so hosts never race
+   * initialization — await it yourself only when you need the timing.
+   */
+  ready: Promise<void>;
+  /** The node context, once initialized — for advanced wiring (own WS transport, extra RPC registration). */
+  context: Promise<DevframeNodeContext>;
+  /**
+   * The `ConnectionMeta` this handler serves at `<base>__connection.json`.
+   * Only readable after initialization (`DF0054` otherwise).
+   */
+  connectionMeta: () => ConnectionMeta;
+  /** Tear down: WS transport/side-car, MCP sessions. */
+  close: () => Promise<void>;
+}
+/**
+ * Live internals of a handler, for the first-party adapters built on it
+ * (`createDevServer` exposes the transport's `ws`/`rpcGroup` through its
+ * `StartedServer` contract).
+ *
+ * @internal
+ */
+interface DevframeInstanceInternals {
+  /** The bound HTTP+WS server handle backing the side-car / shared-server WS tiers. */
+  readonly started?: StartedServer;
+  /** The resolved auth handler when the gate is active. */
+  readonly authHandler?: DevframeAuthHandler;
+}
+/** @internal */
+declare function getInstanceInternals(handler: object): DevframeInstanceInternals;
+/**
+ * Serve a devframe through one framework-agnostic, web-standard handler —
+ * the SPA, `__connection.json` discovery, the WebSocket RPC endpoint, the
+ * auth gate, and the optional MCP route, all under a single mount base.
+ * Mount `handler` on any framework's catch-all route (or `nodeMiddleware` on
+ * a connect stack) and the devframe is live inside that app.
+ *
+ * The factory is synchronous and kicks off initialization eagerly;
+ * `handler`/`nodeMiddleware` await readiness internally. Nothing binds a port
+ * on its own: the WebSocket resolves in precedence order — `ws.port` (pinned
+ * side-car) > `server` (shared upgrade at `<base>__ws`) > `ws.sidecar`
+ * (auto-port side-car) > the host driving upgrades itself through
+ * {@link DevframeInstance.attach} — while `ws.url`, when set, overrides the
+ * advertised* endpoint (the tunnel pattern) and on its own hands the whole
+ * transport to an external server. `__connection.json` reflects whichever
+ * combination is active.
+ */
+declare function initDevframe(def: DevframeDefinition, options: InitDevframeOptions): DevframeInstance;
+//#endregion
+export { DevframeInstance, DevframeInstanceInternals, InitDevframeOptions, getInstanceInternals, initDevframe };

package/dist/adapters/initiate.mjs

@@ -0,0 +1,2 @@
+import { n as getInstanceInternals, r as initDevframe } from "../dev--rAPzbvO.mjs";
+export { getInstanceInternals, initDevframe };

package/dist/adapters/mcp.d.mts

@@ -1,4 +1,5 @@
-import { b as DevframeNodeContext, r as DevframeDefinition } from "../devframe-mQ4qZAuo.mjs";
+import { g as DevframeNodeContext, n as DevframeDefinition } from "../devframe-DJMg0WLe.mjs";
+import { H3 } from "h3";
 import "@modelcontextprotocol/server";
 //#region src/adapters/mcp/build-server.d.ts
 interface CreateMcpServerOptions {
@@ -31,9 +32,6 @@ interface McpServerHandle {
 /**
  * Build an MCP server over the agent surface of a devframe definition.
  * Currently supports `stdio` transport only.
- *
- * @experimental The agent-native surface is experimental and may change
- * without a major version bump until it stabilizes.
  */
 declare function createMcpServer(definition: DevframeDefinition, options?: CreateMcpServerOptions): Promise<McpServerHandle>;
 //#endregion
@@ -80,9 +78,28 @@ interface McpFetchHandler {
  * loopback-default DNS-rebinding protection that — unlike the WS upgrade's
  * `isAllowedOrigin` — also rejects `Origin`-less requests, so a route-based
  * endpoint isn't reachable by an arbitrary local process.
- *
- * @experimental
  */
 declare function createMcpFetchHandler(ctx: DevframeNodeContext, options: CreateMcpFetchHandlerOptions): McpFetchHandler;
 //#endregion
-export { type CreateMcpFetchHandlerOptions, type CreateMcpServerOptions, type McpFetchHandler, type McpServerHandle, createMcpFetchHandler, createMcpServer };
+//#region src/adapters/mcp/http.d.ts
+interface MountMcpHttpOptions extends CreateMcpFetchHandlerOptions {}
+interface MountedMcpHttp {
+  /** Tear down every live MCP session (closes servers, drops subscriptions). */
+  dispose: () => Promise<void>;
+}
+/**
+ * Mount an MCP Streamable-HTTP endpoint on an h3 app at `path` — the h3
+ * binding over {@link createMcpFetchHandler}, which owns the sessions, the
+ * origin gate, and the transport plumbing.
+ *
+ * The handler is web-standard — it takes the h3 event's web `Request` and
+ * returns a web `Response` (an SSE `ReadableStream` body for the
+ * server→client stream). We copy that response onto `event.res` and return
+ * its body rather than returning the `Response` object directly, so a
+ * legitimate MCP 404 (unknown session) isn't swallowed by h3's
+ * "Response-with-404 falls through to the next handler" rule (which would
+ * otherwise hand the request to the SPA static catch-all).
+ */
+declare function mountMcpHttp(app: H3, ctx: DevframeNodeContext, path: string, options: MountMcpHttpOptions): MountedMcpHttp;
+//#endregion
+export { type CreateMcpFetchHandlerOptions, type CreateMcpServerOptions, type McpFetchHandler, type McpServerHandle, type MountMcpHttpOptions, type MountedMcpHttp, createMcpFetchHandler, createMcpServer, mountMcpHttp };

package/dist/adapters/mcp.mjs

@@ -1,2 +1,2 @@
-import { n as createMcpServer, t as createMcpFetchHandler } from "../fetch-BKaD0Vb3.mjs";
-export { createMcpFetchHandler, createMcpServer };
+import { i as createMcpServer, n as mountMcpHttp, r as createMcpFetchHandler } from "../http-DYpK0cUi.mjs";
+export { createMcpFetchHandler, createMcpServer, mountMcpHttp };

package/dist/{agent-tool-name-C3b5vEwJ.mjs → agent-tool-name-EgfoFO8C.mjs}

@@ -23,9 +23,6 @@ const MAX_TOOL_NAME_LENGTH = 128;
 * A plain string transform with no node dependency, so browser-side UIs
 * that display a tool's id (e.g. the inspect plugin's agent view) can
 * import it too and show the name a client actually calls.
-*
-* @experimental The agent-native surface is experimental and may change
-* without a major version bump until it stabilizes.
 */
 function toAgentToolName(id) {
 	return id.replace(/[^\w-]+/g, "_").slice(0, MAX_TOOL_NAME_LENGTH);

package/dist/cli/main.d.mts

@@ -3,8 +3,6 @@
  * The `devframe` bin — the framework's own CLI, distinct from the per-app
  * CLI shells authors build with `createCac(definition)`. It hosts the
  * app-independent commands; today that is `connect`, the MCP connector.
- *
- * @experimental
  */
 declare function runDevframeCli(argv?: string[]): Promise<void>;
 //#endregion

package/dist/cli/main.mjs

@@ -1,7 +1,7 @@
-import { t as diagnostics } from "../diagnostics-D7wM2cwM.mjs";
-import { n as probeDevframeOrigin, t as listLiveDevframeInstances } from "../instance-registry-BnnA2Eoh.mjs";
-import { t as toAgentToolName } from "../agent-tool-name-C3b5vEwJ.mjs";
-import { Diagnostic } from "nostics";
+import { t as Diagnostic } from "../nostics-CzECRXpE.mjs";
+import { t as diagnostics } from "../diagnostics-DOQPnQmX.mjs";
+import { n as listLiveDevframeInstances, r as probeDevframeOrigin } from "../instance-registry-WvQkt42E.mjs";
+import { t as toAgentToolName } from "../agent-tool-name-EgfoFO8C.mjs";
 import process from "node:process";
 import { joinURL } from "ufo";
 import { cac } from "cac";
@@ -54,8 +54,6 @@ const GATEWAY_TOOLS = [{
 * the instance registry and list each one's MCP tools) and
 * `devframe_connect_call-tool` (invoke one tool on one instance over its
 * Streamable-HTTP endpoint) — and holds no domain knowledge of its own.
-*
-* @experimental
 */
 async function startConnectServer(options = {}) {
 	const sdk = await importSdk();
@@ -259,8 +257,6 @@ function keepAlive() {
 * The `devframe` bin — the framework's own CLI, distinct from the per-app
 * CLI shells authors build with `createCac(definition)`. It hosts the
 * app-independent commands; today that is `connect`, the MCP connector.
-*
-* @experimental
 */
 async function runDevframeCli(argv = process.argv) {
 	const cli = cac("devframe");

package/dist/client/index.d.mts

@@ -1,7 +1,8 @@
-import { $ as DevframeRpcServerFunctions, F as ScopedSharedStates, I as SettingsForNamespace, J as RpcSharedStateHost, N as ScopedRpcFn, O as DevframeSettings, P as ScopedServerFunctions, Q as DevframeRpcClientFunctions, _ as ConnectionMeta, at as StreamReader, ht as SharedState, jt as EventEmitter, ot as StreamSink, q as RpcSharedStateGetOptions } from "../devframe-mQ4qZAuo.mjs";
-import { _ as RpcFunctionDefinition, w as RpcFunctionsCollector } from "../types-CnJSgRVa.mjs";
-import { E as RpcCacheOptions, T as RpcCacheManager } from "../index-Dbw1p5ch.mjs";
-import { t as WsRpcChannelOptions } from "../ws-client-B6Tnr0ic.mjs";
+import { $ as StreamReader, A as ScopedServerFunctions, H as RpcSharedStateHost, K as DevframeRpcClientFunctions, M as SettingsForNamespace, Tt as EventEmitter, V as RpcSharedStateGetOptions, d as ConnectionMeta, et as StreamSink, j as ScopedSharedStates, k as ScopedRpcFn, lt as SharedState, q as DevframeRpcServerFunctions, w as DevframeSettings } from "../devframe-DJMg0WLe.mjs";
+import { f as RpcCacheManager, p as RpcCacheOptions } from "../index-tdrk1bzV.mjs";
+import { _ as RpcFunctionDefinition, w as RpcFunctionsCollector } from "../types-Djq7CBXh.mjs";
+import { t as SseRpcChannelOptions } from "../sse-client-CFBOIaUi.mjs";
+import { t as WsRpcChannelOptions } from "../ws-client-DhjNyQo3.mjs";
 import { BirpcOptions, BirpcReturn } from "birpc";
 //#region src/client/connection.d.ts
 interface DevframeConnection {
@@ -251,7 +252,24 @@ interface DevframeRpcClientOptions extends SetupDevframeConnectionOptions {
    * @default true
    */
   simpleAuth?: boolean;
+  /**
+   * Which live transport to connect over:
+   *
+   *  - `'auto'` (default) — trust the server's advertisement: its declared
+   *    primary (`backend`), preferring the WebSocket when both endpoints are
+   *    present. A server that couldn't bind a socket advertises SSE as its
+   *    primary, so no client-side fallback probing is needed.
+   *  - `'websocket'` / `'sse'` — pin one transport; connecting fails with a
+   *    clear error when the server doesn't advertise it. Reach for
+   *    `transport: 'sse'` when an intermediary silently strips WS upgrades —
+   *    something the server cannot detect.
+   *
+   * A `static` backend ignores this option (there is no live transport).
+   */
+  transport?: 'auto' | 'websocket' | 'sse';
   wsOptions?: Partial<WsRpcChannelOptions>;
+  /** Channel overrides for the SSE transport — the `wsOptions` counterpart. */
+  sseOptions?: Partial<SseRpcChannelOptions>;
   rpcOptions?: Partial<BirpcOptions<DevframeRpcServerFunctions, DevframeRpcClientFunctions, boolean>>;
   cacheOptions?: boolean | Partial<RpcCacheOptions>;
   /**
@@ -282,10 +300,16 @@ interface DevframeRpcClient {
    */
   readonly status: DevframeConnectionStatus;
   /**
-   * The most recent connection-level error (WebSocket error, refused trust, or
-   * failed connection-meta load), or `null` when the connection is healthy.
+   * The most recent connection-level error (transport error, refused trust,
+   * or failed connection-meta load), or `null` when the connection is healthy.
    */
   readonly connectionError: Error | null;
+  /**
+   * The transport this client is actually connected over — `'websocket'`,
+   * `'sse'`, or `'static'`. Reflects the resolution of the `transport`
+   * option against the server's advertisement.
+   */
+  readonly transport: 'websocket' | 'sse' | 'static';
   /**
    * The complete connection used by this client, including the metadata source
    * URL external viewers use to resolve relative resources.
@@ -362,8 +386,27 @@ interface DevframeRpcClient {
     <NS extends string>(namespace: NS): DevframeScopedClientContext<NS, SettingsForNamespace<NS>>;
     (namespace?: null | ''): DevframeRpcClient;
   };
+  /**
+   * Close the connection. A `static` backend is a no-op (there is no live socket to close);
+   * a `websocket` backend closes the underlying `WebSocket`, which the server observes as a
+   * normal disconnect. Mirrors {@link WsRpcTransport.close} on the server side.
+   *
+   * There is no corresponding "reconnect" — a closed client is done. Discard it and call
+   * {@link getDevframeRpcClient} again to reconnect.
+   *
+   * Optional so a `DevframeRpcClientMode` implemented before this method existed — a custom
+   * transport, a hand-typed mock — still satisfies the interface; an absent `close` is treated
+   * as nothing to close.
+   */
+  close?: () => void;
 }
 interface DevframeRpcClientMode {
+  /**
+   * The transport this mode speaks. Optional so a mode implemented before
+   * this field existed — a custom transport, a hand-typed mock — still
+   * satisfies the interface; an absent value reads as `'websocket'`.
+   */
+  readonly transport?: 'websocket' | 'sse' | 'static';
   readonly isTrusted: boolean;
   readonly status: DevframeConnectionStatus;
   readonly connectionError: Error | null;
@@ -378,7 +421,17 @@ interface DevframeRpcClientMode {
   call: DevframeRpcClient['call'];
   callEvent: DevframeRpcClient['callEvent'];
   callOptional: DevframeRpcClient['callOptional'];
+  /** See {@link DevframeRpcClient.close}. */
+  close?: () => void;
 }
+/**
+ * Resolve the requested `transport` option against what the server
+ * advertises. `'auto'` trusts the advertisement — the server's declared
+ * primary (`backend`), preferring the WebSocket when both endpoints are
+ * present; an explicit `'websocket'` / `'sse'` pins that transport and
+ * throws when the server doesn't advertise it.
+ */
+declare function resolveClientTransport(requested: 'auto' | 'websocket' | 'sse', meta: ConnectionMeta): 'websocket' | 'sse' | 'static';
 declare function getDevframeRpcClient(options?: DevframeRpcClientOptions): Promise<DevframeRpcClient>;
 //#endregion
 //#region src/client/otp.d.ts
@@ -431,6 +484,17 @@ interface WsUrlLocation {
  */
 declare function resolveWsUrl(websocket: ConnectionMeta['websocket'], metaBaseUrl: string, loc: WsUrlLocation): string;
 //#endregion
+//#region src/client/rpc-sse.d.ts
+/**
+ * Resolve a {@link ConnectionMeta.sse} descriptor into a concrete
+ * `http(s)://` URL, with the same proxy-safe rules as `resolveWsUrl`: the
+ * object / relative-path forms resolve against where `__connection.json`
+ * was loaded (the client trusts its own location, never a server-baked
+ * hostname), while an explicit `port`/`host` (or a full `http(s)://` URL
+ * string) opts into a cross-origin endpoint.
+ */
+declare function resolveSseUrl(sse: ConnectionMeta['sse'], metaBaseUrl: string, loc: WsUrlLocation): string;
+//#endregion
 //#region src/client/settings.d.ts
 /**
  * Build the client-side `settings` surface for a scope namespace. Mirrors
@@ -441,4 +505,4 @@ declare function createClientSettings<T extends Record<string, any> = Record<str
 //#region src/client/index.d.ts
 declare const connectDevframe: typeof getDevframeRpcClient;
 //#endregion
-export { DevframeClientRpcHost, DevframeConnection, DevframeConnectionError, DevframeConnectionErrorKind, DevframeConnectionStatus, DevframeRpcClient, DevframeRpcClientCall, DevframeRpcClientCallEvent, DevframeRpcClientCallOptional, DevframeRpcClientMode, DevframeRpcClientOptions, DevframeRpcContext, DevframeScopedClientContext, DevframeScopedClientRpc, DevframeScopedClientStreamingHost, RpcClientEvents, RpcStreamingClientHost, SetupDevframeConnectionOptions, StreamingSubscribeOptions, type WsUrlLocation, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeConnection, getDevframeRpcClient, isCallableStatus, readOtpFromUrl, registerDevframeViewerOrigin, resolveWsUrl, setupDevframeConnection };
+export { DevframeClientRpcHost, DevframeConnection, DevframeConnectionError, DevframeConnectionErrorKind, DevframeConnectionStatus, DevframeRpcClient, DevframeRpcClientCall, DevframeRpcClientCallEvent, DevframeRpcClientCallOptional, DevframeRpcClientMode, DevframeRpcClientOptions, DevframeRpcContext, DevframeScopedClientContext, DevframeScopedClientRpc, DevframeScopedClientStreamingHost, RpcClientEvents, RpcStreamingClientHost, SetupDevframeConnectionOptions, StreamingSubscribeOptions, type WsUrlLocation, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeConnection, getDevframeRpcClient, isCallableStatus, readOtpFromUrl, registerDevframeViewerOrigin, resolveClientTransport, resolveSseUrl, resolveWsUrl, setupDevframeConnection };