devframe 0.1.19 → 0.1.20

package/dist/{devtool-CIqONpYU.d.mts → devtool-Bm6zZAw5.d.mts}

@@ -1,7 +1,8 @@
-import { g as RpcFunctionsCollectorBase } from "./index-BwrLhNmz.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-DHMeNOY_.mjs";
+import { g as RpcFunctionsCollectorBase } from "./index-BCo03GEF.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-VQqESKAs.mjs";
 import { Logger, createLogger, defineDiagnostics } from "logs-sdk";
 import { BirpcReturn } from "birpc";
+import { Objectish, Patch, Patch as SharedStatePatch } from "immer";
 import { CAC } from "cac";
 import { GenericSchema, InferOutput } from "valibot";
 import { ChildProcess } from "node:child_process";
@@ -666,6 +667,23 @@ interface DevToolsHost {
    * reasonable value.
    */
   resolveOrigin: () => string;
+  /**
+   * Resolve a directory the host owns for persisted devtools state.
+   * Each host picks its own app-name namespace so storage doesn't
+   * collide between, say, the Vite host (`.vite/devtools`) and a
+   * standalone CLI host (`.<appName>/devtools`).
+   *
+   *   - `workspace` — per-project state (settings, caches). Typically
+   *     under `${workspaceRoot}/node_modules/.<appName>/devtools/`.
+   *   - `global`    — per-user state (auth tokens, machine-wide
+   *     preferences). Typically under
+   *     `${homedir()}/.<appName>/devtools/`.
+   *
+   * Implementations should ensure the directory exists or be safe to
+   * pass to a downstream `createStorage(...)` call that creates it
+   * lazily.
+   */
+  getStorageDir: (scope: 'workspace' | 'global') => string;
 }
 //#endregion
 //#region src/types/messages.d.ts
@@ -833,11 +851,105 @@ type DevToolsLogsHost = DevToolsMessagesHost;
 /**
  * To be extended
  */
-interface DevToolsRpcClientFunctions {}
+interface DevToolsRpcClientFunctions {
+  /**
+   * Streaming chunk pushed from server to subscribed clients. Wired by
+   * `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:streaming:chunk': (channel: string, id: string, seq: number, chunk: any) => Promise<void>;
+  /**
+   * Streaming terminator pushed from server to subscribed clients. Wired by
+   * `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:streaming:end': (channel: string, id: string, error?: {
+    name: string;
+    message: string;
+  }) => Promise<void>;
+  /**
+   * Server→client cancel for an in-flight upload. Wired by
+   * `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:streaming:upload-cancel': (channel: string, id: string) => Promise<void>;
+}
 /**
  * To be extended
  */
-interface DevToolsRpcServerFunctions {}
+interface DevToolsRpcServerFunctions {
+  /**
+   * Subscribe a client to a shared-state key. Wired by
+   * `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:rpc:server-state:subscribe': (key: string) => Promise<void>;
+  /**
+   * Read the current value for a shared-state key. Wired by
+   * `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:rpc:server-state:get': (key: string) => Promise<any>;
+  /**
+   * Replace a shared-state value (from the client). Wired by
+   * `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:rpc:server-state:set': (key: string, value: any, syncId: string) => Promise<void>;
+  /**
+   * Apply a patch to a shared-state value (from the client). Wired by
+   * `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:rpc:server-state:patch': (key: string, patches: any[], syncId: string) => Promise<void>;
+  /**
+   * Client→server streaming subscription with optional replay cursor.
+   * Wired by `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:streaming:subscribe': (channel: string, id: string, opts?: {
+    afterSeq?: number;
+  }) => Promise<void>;
+  /**
+   * Client→server streaming unsubscribe. Wired by `RpcStreamingHost`;
+   * do not register manually.
+   *
+   * @internal
+   */
+  'devframe:streaming:unsubscribe': (channel: string, id: string) => Promise<void>;
+  /**
+   * Client→server streaming cancellation request. Wired by
+   * `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
+   */
+  'devframe:streaming:cancel': (channel: string, id: string) => Promise<void>;
+  /**
+   * Client→server upload chunk. Wired by `RpcStreamingHost`; do not
+   * register manually.
+   *
+   * @internal
+   */
+  'devframe:streaming:upload-chunk': (channel: string, id: string, seq: number, chunk: any) => Promise<void>;
+  /**
+   * Client→server upload terminator. Wired by `RpcStreamingHost`; do not
+   * register manually.
+   *
+   * @internal
+   */
+  'devframe:streaming:upload-end': (channel: string, id: string, error?: {
+    name: string;
+    message: string;
+  }) => Promise<void>;
+}
 /**
  * To be extended
  */
@@ -855,16 +967,10 @@ interface DevToolsDocksUserSettings {
 }
 //#endregion
 //#region src/types/terminals.d.ts
-interface DevToolsTerminalSessionStreamChunkEvent {
-  id: string;
-  chunks: string[];
-  ts: number;
-}
 interface DevToolsTerminalHost {
   readonly sessions: Map<string, DevToolsTerminalSession>;
   readonly events: EventEmitter<{
     'terminal:session:updated': (session: DevToolsTerminalSession) => void;
-    'terminal:session:stream-chunk': (data: DevToolsTerminalSessionStreamChunkEvent) => void;
   }>;
   register: (session: DevToolsTerminalSession) => DevToolsTerminalSession;
   update: (session: DevToolsTerminalSession) => void;
@@ -922,21 +1028,6 @@ interface DevToolsViewHost {
   hostStatic: (baseUrl: string, distDir: string) => void;
 }
 //#endregion
-//#region ../../../node_modules/.pnpm/immer@11.1.4/node_modules/immer/dist/immer.d.ts
-interface Patch {
-  op: "replace" | "remove" | "add";
-  path: (string | number)[];
-  value?: any;
-}
-type Objectish = AnyObject | AnyArray | AnyMap | AnySet;
-type AnyObject = {
-  [key: string]: any;
-};
-type AnyArray = Array<any>;
-type AnySet = Set<any>;
-type AnyMap = Map<any, any>;
-/** Returns true if the given value is an Immer draft */
-//#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>;
@@ -986,6 +1077,128 @@ interface SharedStateOptions<T> {
 }
 declare function createSharedState<T extends Objectish>(options: SharedStateOptions<T>): SharedState<T>;
 //#endregion
+//#region src/utils/streaming-channel.d.ts
+/**
+ * Serialized error shape sent over the wire when a stream ends with a failure.
+ * Stays JSON-safe so the strict-JSON encoder can carry it without coercion.
+ */
+interface StreamErrorPayload {
+  name: string;
+  message: string;
+}
+/**
+ * Single buffered chunk in the server-side ring buffer.
+ *
+ * Sequence numbers start at 1 and increment per write. Subscribers track
+ * `lastSeenSeq` and ask for `afterSeq` on resubscribe so the server can
+ * replay any chunks the client missed during a brief disconnect.
+ */
+interface BufferedChunk<T> {
+  seq: number;
+  chunk: T;
+}
+interface StreamSinkEvents<T> {
+  /** Fired for each `write()`. The RPC layer subscribes and broadcasts. */
+  chunk: (seq: number, chunk: T) => void;
+  /** Terminal — fired exactly once per sink lifetime. */
+  end: (error?: StreamErrorPayload) => void;
+}
+interface CreateStreamSinkOptions {
+  id?: string;
+  /**
+   * Size of the per-stream ring buffer kept for replay-on-resubscribe.
+   * `0` (default) disables replay.
+   */
+  replayWindow?: number;
+}
+/**
+ * Server-side producer handle. Two equivalent surfaces share one piece of
+ * state: the imperative `write/error/close` triple, and a `WritableStream<T>`
+ * for `pipeTo`-style consumption.
+ */
+interface StreamSink<T> {
+  /** Stable id used by clients to subscribe. */
+  readonly id: string;
+  /**
+   * Aborts when the consumer cancels (server-side) or when the transport
+   * loses every subscriber. Producers should poll `signal.aborted` and exit
+   * cleanly.
+   */
+  readonly signal: AbortSignal;
+  /** `true` after `close()` / `error()`. Further writes throw. */
+  readonly closed: boolean;
+  /** Last allocated sequence number. `0` until the first write. */
+  readonly lastSeq: number;
+  write: (chunk: T) => void;
+  error: (reason: unknown) => void;
+  close: () => void;
+  /** External-cancel path. Aborts the signal so handlers can short-circuit. */
+  abort: (reason?: unknown) => void;
+  /** `WritableStream<T>` adapter — same in-memory state as the imperative API. */
+  readonly writable: WritableStream<T>;
+  /**
+   * Internal — RPC layer subscribes to receive chunk/end notifications.
+   * Not part of the public contract; do not call directly.
+   *
+   * @internal
+   */
+  readonly events: EventEmitter<StreamSinkEvents<T>>;
+  /**
+   * Internal — replay buffer. RPC layer reads on (re)subscribe to feed
+   * missed chunks before going live.
+   *
+   * @internal
+   */
+  readonly buffer: ReadonlyArray<BufferedChunk<T>>;
+}
+interface CreateStreamReaderOptions {
+  id?: string;
+  /**
+   * Maximum number of buffered chunks held client-side while the consumer
+   * isn't draining. On overflow, the oldest chunk is dropped.
+   */
+  highWaterMark?: number;
+  /**
+   * Called when the chunk queue overflows the high-water mark. The RPC
+   * layer wires this to a coded warning; the primitive itself is
+   * RPC-agnostic.
+   */
+  onOverflow?: (dropped: number) => void;
+  /** Called when the consumer cancels — the RPC layer sends `:cancel` upstream. */
+  onCancel?: () => void;
+}
+/**
+ * Client-side consumer handle. Both an `AsyncIterable<T>` (for `for await`)
+ * and exposes `readable: ReadableStream<T>` (for `pipeTo`). Pick one — they
+ * share a single internal queue, so concurrent draining will race.
+ */
+interface StreamReader<T> extends AsyncIterable<T> {
+  readonly id: string;
+  readonly cancelled: boolean;
+  readonly done: boolean;
+  /** Highest `seq` observed. Used for replay on reconnect. */
+  readonly lastSeenSeq: number;
+  /** `ReadableStream<T>` adapter for `pipeTo`-style consumption. */
+  readonly readable: ReadableStream<T>;
+  cancel: () => void;
+  /** @internal */
+  _push: (seq: number, chunk: T) => void;
+  /** @internal */
+  _end: (error?: StreamErrorPayload) => void;
+}
+/**
+ * Build a server-side stream sink. RPC-agnostic — the RPC host wires
+ * `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
+ * for late or reconnecting subscribers.
+ */
+declare function createStreamSink<T>(options?: CreateStreamSinkOptions): StreamSink<T>;
+/**
+ * Build a client-side stream reader. RPC-agnostic — the RPC host calls
+ * `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
+ * terminal frame. Consumers iterate with `for await` or pipe `readable`.
+ */
+declare function createStreamReader<T>(options?: CreateStreamReaderOptions): StreamReader<T>;
+//#endregion
 //#region src/types/rpc.d.ts
 interface DevToolsNodeRpcSession {
   meta: DevToolsNodeRpcSessionMeta;
@@ -1019,6 +1232,13 @@ type RpcFunctionsHost = RpcFunctionsCollectorBase<DevToolsRpcServerFunctions, De
    * The shared state host
    */
   sharedState: RpcSharedStateHost;
+  /**
+   * The streaming channel host. Provides per-channel `start()` /
+   * `pipeFrom()` producers; clients consume via `rpc.streaming.subscribe()`.
+   *
+   * @see RpcStreamingHost
+   */
+  streaming: RpcStreamingHost;
 };
 interface RpcSharedStateGetOptions<T> {
   sharedState?: SharedState<T>;
@@ -1035,6 +1255,109 @@ interface RpcSharedStateHost {
    */
   onKeyAdded: (fn: (key: string) => void) => () => void;
 }
+/**
+ * Options for `RpcStreamingHost.create()`.
+ */
+interface RpcStreamingChannelOptions {
+  /**
+   * Size of the per-stream ring buffer kept on the server for
+   * replay-on-resubscribe. `0` (default) disables replay; on reconnect
+   * the consumer only sees chunks that arrive after subscribing.
+   *
+   * The buffer is per stream id, not per channel — each `channel.start()`
+   * gets its own.
+   */
+  replayWindow?: number;
+  /**
+   * Milliseconds a closed stream is retained on the server after its
+   * last subscriber leaves (or if no subscriber ever arrived). During
+   * this window, late subscribers can still join and replay the buffer
+   * + receive the `end` frame.
+   *
+   * Defaults to `30_000` (30 s) when `replayWindow > 0`, else `0`
+   * (immediate free). Set to `0` to opt out, or higher for longer
+   * post-mortem replay.
+   */
+  closedStreamRetention?: number;
+}
+/**
+ * Channel handle returned by `ctx.rpc.streaming.create(name, opts)`. A
+ * channel owns a wire namespace; calling `start()` produces individual
+ * streams keyed by id.
+ *
+ * @see {@link https://devfra.me/guide/streaming Streaming guide}
+ */
+interface RpcStreamingChannel<T = unknown> {
+  /** Channel name as registered with `ctx.rpc.streaming.create()`. */
+  readonly name: string;
+  /**
+   * Start a new stream. Returns a server-side sink with both an imperative
+   * (`write` / `close` / `error`) surface and a `WritableStream<T>` for
+   * `pipeTo` consumption. The sink's `signal` aborts when every subscriber
+   * disconnects or cancels.
+   */
+  start: (opts?: {
+    id?: string;
+  }) => StreamSink<T>;
+  /**
+   * Convenience: start a stream and pipe a `ReadableStream<T>` into it.
+   * The pipe uses `sink.signal` so cancellation propagates upstream.
+   *
+   * Node-stream interop: convert a `Readable` with `Readable.toWeb(node)`
+   * before passing it here.
+   */
+  pipeFrom: (readable: ReadableStream<T>, opts?: {
+    id?: string;
+  }) => Promise<StreamSink<T>>;
+  /** Look up an active stream by id. Returns `undefined` if none. */
+  get: (id: string) => StreamSink<T> | undefined;
+  /** All active outbound stream ids on this channel. */
+  ids: () => string[];
+  /**
+   * Open an inbound stream — the server side of a client-to-server
+   * upload. Allocates an id, returns a `StreamReader<T>` that fills as
+   * the client writes chunks. Typical pattern is to call this from an
+   * action handler, kick off background processing, and return the id
+   * so the caller can start uploading:
+   *
+   * ```ts
+   * handler: async () => {
+   *   const reader = channel.openInbound()
+   *   ;(async () => {
+   *     for await (const chunk of reader) processChunk(chunk)
+   *   })()
+   *   return { uploadId: reader.id }
+   * }
+   * ```
+   *
+   * Calling `reader.cancel()` on the server sends an `upload-cancel` to
+   * the uploading client, which aborts its sink.
+   */
+  openInbound: (opts?: {
+    id?: string;
+  }) => StreamReader<T>;
+}
+/**
+ * Server-side streaming host. Lives on `ctx.rpc.streaming` alongside
+ * `ctx.rpc.sharedState`. Each named channel owns its own stream registry
+ * and wire namespace.
+ */
+interface RpcStreamingHost {
+  /**
+   * Register a streaming channel. Names follow the `<plugin-id>:<channel>`
+   * convention (e.g. `'my-devtool:chat-stream'`). Throws `DF0032` if the
+   * name is already taken.
+   */
+  create: <T = unknown>(name: string, opts?: RpcStreamingChannelOptions) => RpcStreamingChannel<T>;
+  /**
+   * 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.
+   *
+   * @internal
+   */
+  _onSessionDisconnected: (meta: DevToolsNodeRpcSessionMeta) => void;
+}
 //#endregion
 //#region src/types/context.d.ts
 interface DevToolsCapabilities {
@@ -1044,9 +1367,24 @@ interface DevToolsCapabilities {
 interface DevToolsNodeContext {
   readonly workspaceRoot: string;
   readonly cwd: string;
+  /**
+   * Lifecycle distinction surfaced to plugin authors:
+   *
+   *   - `'dev'`   — long-running, interactive session. Connections come and
+   *                 go; broadcasts and shared-state mutations are debounced
+   *                 to keep the UI responsive.
+   *   - `'build'` — one-shot batch run. The context is set up, the devtool
+   *                 collects what it needs, and a snapshot is written. No
+   *                 live UI, no WS server.
+   *
+   * Names are inherited from Vite's serve/build dichotomy but the meaning
+   * is general: the same distinction applies to any tool that runs in
+   * either an interactive or a static-output mode.
+   */
   readonly mode: 'dev' | 'build';
   /**
-   * Host runtime abstraction — exposes `mountStatic` / `resolveOrigin`.
+   * Host runtime abstraction — exposes `mountStatic` / `resolveOrigin` /
+   * `getStorageDir`.
    */
   host: DevToolsHost;
   rpc: RpcFunctionsHost;
@@ -1235,4 +1573,4 @@ interface DevtoolDefinition {
 }
 declare function defineDevtool(d: DevtoolDefinition): DevtoolDefinition;
 //#endregion
-export { DevToolsLogsHost as $, EventsMap as $t, DevToolsViewHost as A, DevToolsDiagnosticsHost as At, DevToolsTerminalStatus as B, DevToolsServerCommandEntry as Bt, ImmutableSet as C, DevToolsViewLauncher as Ct, createSharedState as D, JsonRenderer as Dt, SharedStateOptions as E, JsonRenderSpec as Et, DevToolsChildProcessTerminalSession as F, DevToolsCommandHandle as Ft, DevToolsLogElementPosition as G, AgentResourceContent as Gt, DevToolsRpcClientFunctions as H, AgentHandle as Ht, DevToolsTerminalHost as I, DevToolsCommandKeybinding as It, DevToolsLogEntryInput as J, AgentToolInput as Jt, DevToolsLogEntry as K, AgentResourceInput as Kt, DevToolsTerminalSession as L, DevToolsCommandShortcutOverrides as Lt, PartialWithoutId as M, DevToolsClientCommand as Mt, Thenable as N, DevToolsCommandBase as Nt, Objectish as O, RemoteDockOptions as Ot, DevToolsChildProcessExecuteOptions as P, DevToolsCommandEntry as Pt, DevToolsLogsClient as Q, EventUnsubscribe as Qt, DevToolsTerminalSessionBase as R, DevToolsCommandsHost as Rt, ImmutableObject as S, DevToolsViewJsonRender as St, SharedStateEvents as T, JsonRenderElement as Tt, DevToolsRpcServerFunctions as U, AgentManifest as Ut, DevToolsDocksUserSettings as V, DevToolsServerCommandInput as Vt, DevToolsRpcSharedStates as W, AgentResource as Wt, DevToolsLogHandle as X, DevToolsAgentHostEvents as Xt, DevToolsLogFilePosition as Y, DevToolsAgentHost as Yt, DevToolsLogLevel as Z, EventEmitter as Zt, RpcSharedStateGetOptions as _, DevToolsDockUserEntry as _t, DevtoolRuntime as a, DevToolsMessageHandle as at, ImmutableArray as b, DevToolsViewCustomRender as bt, defineDevtool as c, DevToolsMessagesHost as ct, DevToolsNodeContext as d, DevToolsDockEntriesGrouped as dt, CliFlagsSchema as en, DevToolsMessageElementPosition as et, DevToolsNodeUtils as f, DevToolsDockEntry as ft, RpcFunctionsHost as g, DevToolsDockHost as gt, RpcBroadcastOptions as h, DevToolsDockEntryIcon as ht, DevtoolDeploymentKind as i, DevToolsMessageFilePosition as it, EntriesToObject as j, DevToolsDiagnosticsLogger as jt, Patch as k, DevToolsDiagnosticsDefinition as kt, ConnectionMeta as l, DevToolsHost as lt, DevToolsNodeRpcSession as m, DevToolsDockEntryCategory as mt, DevtoolCliOptions as n, defineCliFlags as nn, DevToolsMessageEntryFrom as nt, DevtoolSetupInfo as o, DevToolsMessageLevel as ot, RemoteConnectionInfo as p, DevToolsDockEntryBase as pt, DevToolsLogEntryFrom as q, AgentTool as qt, DevtoolDefinition as r, parseCliFlags as rn, DevToolsMessageEntryInput as rt, DevtoolSpaOptions as s, DevToolsMessagesClient as st, DevtoolBrowserContext as t, InferCliFlags as tn, DevToolsMessageEntry as tt, DevToolsCapabilities as u, ClientScriptEntry as ut, RpcSharedStateHost as v, DevToolsViewAction as vt, SharedState as w, DevToolsViewLauncherStatus as wt, ImmutableMap as x, DevToolsViewIframe as xt, Immutable as y, DevToolsViewBuiltin as yt, DevToolsTerminalSessionStreamChunkEvent as z, DevToolsCommandsHostEvents as zt };
+export { DevToolsRpcServerFunctions as $, AgentManifest as $t, createStreamSink as A, DevToolsViewCustomRender as At, createSharedState as B, DevToolsDiagnosticsHost as Bt, CreateStreamReaderOptions as C, DevToolsDockEntryBase as Ct, StreamSink as D, DevToolsDockUserEntry as Dt, StreamReader as E, DevToolsDockHost as Et, ImmutableSet as F, JsonRenderElement as Ft, DevToolsChildProcessExecuteOptions as G, DevToolsCommandHandle as Gt, EntriesToObject as H, DevToolsClientCommand as Ht, SharedState as I, JsonRenderSpec as It, DevToolsTerminalSession as J, DevToolsCommandsHost as Jt, DevToolsChildProcessTerminalSession as K, DevToolsCommandKeybinding as Kt, SharedStateEvents as L, JsonRenderer as Lt, ImmutableArray as M, DevToolsViewJsonRender as Mt, ImmutableMap as N, DevToolsViewLauncher as Nt, StreamSinkEvents as O, DevToolsViewAction as Ot, ImmutableObject as P, DevToolsViewLauncherStatus as Pt, DevToolsRpcClientFunctions as Q, AgentHandle as Qt, SharedStateOptions as R, RemoteDockOptions as Rt, BufferedChunk as S, DevToolsDockEntry as St, StreamErrorPayload as T, DevToolsDockEntryIcon as Tt, PartialWithoutId as U, DevToolsCommandBase as Ut, DevToolsViewHost as V, DevToolsDiagnosticsLogger as Vt, Thenable as W, DevToolsCommandEntry as Wt, DevToolsTerminalStatus as X, DevToolsServerCommandEntry as Xt, DevToolsTerminalSessionBase as Y, DevToolsCommandsHostEvents as Yt, DevToolsDocksUserSettings as Z, DevToolsServerCommandInput as Zt, RpcSharedStateGetOptions as _, DevToolsMessagesClient as _t, DevtoolRuntime as a, DevToolsAgentHost as an, DevToolsLogFilePosition as at, RpcStreamingChannelOptions as b, ClientScriptEntry as bt, defineDevtool as c, EventUnsubscribe as cn, DevToolsLogsClient as ct, DevToolsNodeContext as d, InferCliFlags as dn, DevToolsMessageEntry as dt, AgentResource as en, DevToolsRpcSharedStates as et, DevToolsNodeUtils as f, defineCliFlags as fn, DevToolsMessageEntryFrom as ft, RpcFunctionsHost as g, DevToolsMessageLevel as gt, RpcBroadcastOptions as h, DevToolsMessageHandle as ht, DevtoolDeploymentKind as i, AgentToolInput as in, DevToolsLogEntryInput as it, Immutable as j, DevToolsViewIframe as jt, createStreamReader as k, DevToolsViewBuiltin as kt, ConnectionMeta as l, EventsMap as ln, DevToolsLogsHost as lt, DevToolsNodeRpcSession as m, DevToolsMessageFilePosition as mt, DevtoolCliOptions as n, AgentResourceInput as nn, DevToolsLogEntry as nt, DevtoolSetupInfo as o, DevToolsAgentHostEvents as on, DevToolsLogHandle as ot, RemoteConnectionInfo as p, parseCliFlags as pn, DevToolsMessageEntryInput as pt, DevToolsTerminalHost as q, DevToolsCommandShortcutOverrides as qt, DevtoolDefinition as r, AgentTool as rn, DevToolsLogEntryFrom as rt, DevtoolSpaOptions as s, EventEmitter as sn, DevToolsLogLevel as st, DevtoolBrowserContext as t, AgentResourceContent as tn, DevToolsLogElementPosition as tt, DevToolsCapabilities as u, CliFlagsSchema as un, DevToolsMessageElementPosition as ut, RpcSharedStateHost as v, DevToolsMessagesHost as vt, CreateStreamSinkOptions as w, DevToolsDockEntryCategory as wt, RpcStreamingHost as x, DevToolsDockEntriesGrouped as xt, RpcStreamingChannel as y, DevToolsHost as yt, SharedStatePatch as z, DevToolsDiagnosticsDefinition as zt };

package/dist/host-h3-BMvrFzIJ.mjs

@@ -0,0 +1,24 @@
+import { join } from "pathe";
+import process from "node:process";
+import { homedir } from "node:os";
+//#region src/node/host-h3.ts
+/**
+* h3-backed {@link DevToolsHost} — used by the standalone CLI adapter.
+*/
+function createH3DevToolsHost(options) {
+	const workspaceRoot = options.workspaceRoot ?? process.cwd();
+	return {
+		mountStatic(base, distDir) {
+			return options.mount?.(base, distDir);
+		},
+		resolveOrigin() {
+			return options.origin;
+		},
+		getStorageDir(scope) {
+			const namespace = `.${options.appName}/devtools`;
+			return scope === "workspace" ? join(workspaceRoot, "node_modules", namespace) : join(homedir(), namespace);
+		}
+	};
+}
+//#endregion
+export { createH3DevToolsHost as t };

package/dist/{index-BwrLhNmz.d.mts → index-BCo03GEF.d.mts}

@@ -1,4 +1,4 @@
-import { C as RpcReturnSchema, S as RpcFunctionsCollector, b as RpcFunctionSetupResult, c as RpcDumpClientOptions, g as RpcFunctionDefinitionAny, h as RpcFunctionDefinition, i as RpcArgsSchema, l as RpcDumpCollectionOptions, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpStore, x as RpcFunctionType } from "./types-gWbe-b2R.mjs";
+import { C as RpcReturnSchema, S as RpcFunctionsCollector, b as RpcFunctionSetupResult, c as RpcDumpClientOptions, g as RpcFunctionDefinitionAny, h as RpcFunctionDefinition, i as RpcArgsSchema, l as RpcDumpCollectionOptions, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpStore, x as RpcFunctionType } from "./types-ag029cAe.mjs";
 import { deserialize as structuredCloneDeserialize, parse as structuredCloneParse, serialize as structuredCloneSerialize, stringify as structuredCloneStringify } from "structured-clone-es";
 
 //#region src/rpc/cache.d.ts

package/dist/index.d.mts

@@ -1,10 +1,10 @@
-import { $ as DevToolsLogsHost, $t as EventsMap, A as DevToolsViewHost, At as DevToolsDiagnosticsHost, B as DevToolsTerminalStatus, Bt as DevToolsServerCommandEntry, Ct as DevToolsViewLauncher, Dt as JsonRenderer, Et as JsonRenderSpec, F as DevToolsChildProcessTerminalSession, Ft as DevToolsCommandHandle, G as DevToolsLogElementPosition, Gt as AgentResourceContent, H as DevToolsRpcClientFunctions, Ht as AgentHandle, I as DevToolsTerminalHost, It as DevToolsCommandKeybinding, J as DevToolsLogEntryInput, Jt as AgentToolInput, K as DevToolsLogEntry, Kt as AgentResourceInput, L as DevToolsTerminalSession, Lt as DevToolsCommandShortcutOverrides, M as PartialWithoutId, Mt as DevToolsClientCommand, N as Thenable, Nt as DevToolsCommandBase, Ot as RemoteDockOptions, P as DevToolsChildProcessExecuteOptions, Pt as DevToolsCommandEntry, Q as DevToolsLogsClient, Qt as EventUnsubscribe, R as DevToolsTerminalSessionBase, Rt as DevToolsCommandsHost, St as DevToolsViewJsonRender, Tt as JsonRenderElement, U as DevToolsRpcServerFunctions, Ut as AgentManifest, V as DevToolsDocksUserSettings, Vt as DevToolsServerCommandInput, W as DevToolsRpcSharedStates, Wt as AgentResource, X as DevToolsLogHandle, Xt as DevToolsAgentHostEvents, Y as DevToolsLogFilePosition, Yt as DevToolsAgentHost, Z as DevToolsLogLevel, Zt as EventEmitter, _ as RpcSharedStateGetOptions, _t as DevToolsDockUserEntry, a as DevtoolRuntime, at as DevToolsMessageHandle, bt as DevToolsViewCustomRender, c as defineDevtool, ct as DevToolsMessagesHost, d as DevToolsNodeContext, dt as DevToolsDockEntriesGrouped, et as DevToolsMessageElementPosition, f as DevToolsNodeUtils, ft as DevToolsDockEntry, g as RpcFunctionsHost, gt as DevToolsDockHost, h as RpcBroadcastOptions, ht as DevToolsDockEntryIcon, i as DevtoolDeploymentKind, it as DevToolsMessageFilePosition, j as EntriesToObject, jt as DevToolsDiagnosticsLogger, kt as DevToolsDiagnosticsDefinition, l as ConnectionMeta, lt as DevToolsHost, m as DevToolsNodeRpcSession, mt as DevToolsDockEntryCategory, n as DevtoolCliOptions, nt as DevToolsMessageEntryFrom, o as DevtoolSetupInfo, ot as DevToolsMessageLevel, p as RemoteConnectionInfo, pt as DevToolsDockEntryBase, q as DevToolsLogEntryFrom, qt as AgentTool, r as DevtoolDefinition, rt as DevToolsMessageEntryInput, s as DevtoolSpaOptions, st as DevToolsMessagesClient, t as DevtoolBrowserContext, tt as DevToolsMessageEntry, u as DevToolsCapabilities, ut as ClientScriptEntry, v as RpcSharedStateHost, vt as DevToolsViewAction, wt as DevToolsViewLauncherStatus, xt as DevToolsViewIframe, yt as DevToolsViewBuiltin, z as DevToolsTerminalSessionStreamChunkEvent, zt as DevToolsCommandsHostEvents } from "./devtool-CIqONpYU.mjs";
-import { C as RpcReturnSchema, h as RpcFunctionDefinition, i as RpcArgsSchema, m as RpcFunctionAgentOptions, x as RpcFunctionType } from "./types-gWbe-b2R.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-DHMeNOY_.mjs";
+import { $ as DevToolsRpcServerFunctions, $t as AgentManifest, At as DevToolsViewCustomRender, Bt as DevToolsDiagnosticsHost, Ct as DevToolsDockEntryBase, Dt as DevToolsDockUserEntry, Et as DevToolsDockHost, Ft as JsonRenderElement, G as DevToolsChildProcessExecuteOptions, Gt as DevToolsCommandHandle, H as EntriesToObject, Ht as DevToolsClientCommand, It as JsonRenderSpec, J as DevToolsTerminalSession, Jt as DevToolsCommandsHost, K as DevToolsChildProcessTerminalSession, Kt as DevToolsCommandKeybinding, Lt as JsonRenderer, Mt as DevToolsViewJsonRender, Nt as DevToolsViewLauncher, Ot as DevToolsViewAction, Pt as DevToolsViewLauncherStatus, Q as DevToolsRpcClientFunctions, Qt as AgentHandle, Rt as RemoteDockOptions, St as DevToolsDockEntry, Tt as DevToolsDockEntryIcon, U as PartialWithoutId, Ut as DevToolsCommandBase, V as DevToolsViewHost, Vt as DevToolsDiagnosticsLogger, W as Thenable, Wt as DevToolsCommandEntry, X as DevToolsTerminalStatus, Xt as DevToolsServerCommandEntry, Y as DevToolsTerminalSessionBase, Yt as DevToolsCommandsHostEvents, Z as DevToolsDocksUserSettings, Zt as DevToolsServerCommandInput, _ as RpcSharedStateGetOptions, _t as DevToolsMessagesClient, a as DevtoolRuntime, an as DevToolsAgentHost, at as DevToolsLogFilePosition, b as RpcStreamingChannelOptions, bt as ClientScriptEntry, c as defineDevtool, cn as EventUnsubscribe, ct as DevToolsLogsClient, d as DevToolsNodeContext, dt as DevToolsMessageEntry, en as AgentResource, et as DevToolsRpcSharedStates, f as DevToolsNodeUtils, ft as DevToolsMessageEntryFrom, g as RpcFunctionsHost, gt as DevToolsMessageLevel, h as RpcBroadcastOptions, ht as DevToolsMessageHandle, i as DevtoolDeploymentKind, in as AgentToolInput, it as DevToolsLogEntryInput, jt as DevToolsViewIframe, kt as DevToolsViewBuiltin, l as ConnectionMeta, ln as EventsMap, lt as DevToolsLogsHost, m as DevToolsNodeRpcSession, mt as DevToolsMessageFilePosition, n as DevtoolCliOptions, nn as AgentResourceInput, nt as DevToolsLogEntry, o as DevtoolSetupInfo, on as DevToolsAgentHostEvents, ot as DevToolsLogHandle, p as RemoteConnectionInfo, pt as DevToolsMessageEntryInput, q as DevToolsTerminalHost, qt as DevToolsCommandShortcutOverrides, r as DevtoolDefinition, rn as AgentTool, rt as DevToolsLogEntryFrom, s as DevtoolSpaOptions, sn as EventEmitter, st as DevToolsLogLevel, t as DevtoolBrowserContext, tn as AgentResourceContent, tt as DevToolsLogElementPosition, u as DevToolsCapabilities, ut as DevToolsMessageElementPosition, v as RpcSharedStateHost, vt as DevToolsMessagesHost, wt as DevToolsDockEntryCategory, x as RpcStreamingHost, xt as DevToolsDockEntriesGrouped, y as RpcStreamingChannel, yt as DevToolsHost, zt as DevToolsDiagnosticsDefinition } from "./devtool-Bm6zZAw5.mjs";
+import { C as RpcReturnSchema, h as RpcFunctionDefinition, i as RpcArgsSchema, m as RpcFunctionAgentOptions, x as RpcFunctionType } from "./types-ag029cAe.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-VQqESKAs.mjs";
 
 //#region src/define.d.ts
 declare const defineRpcFunction: <NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevToolsNodeContext>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevToolsNodeContext>;
 declare function defineCommand(command: DevToolsServerCommandInput): DevToolsServerCommandInput;
 declare function defineJsonRenderSpec(spec: JsonRenderSpec): JsonRenderSpec;
 //#endregion
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ClientScriptEntry, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsChildProcessExecuteOptions, DevToolsChildProcessTerminalSession, DevToolsClientCommand, DevToolsCommandBase, DevToolsCommandEntry, DevToolsCommandHandle, DevToolsCommandKeybinding, DevToolsCommandShortcutOverrides, DevToolsCommandsHost, DevToolsCommandsHostEvents, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsDockEntriesGrouped, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockEntryCategory, DevToolsDockEntryIcon, DevToolsDockHost, DevToolsDockUserEntry, DevToolsDocksUserSettings, DevToolsHost, DevToolsLogElementPosition, DevToolsLogEntry, DevToolsLogEntryFrom, DevToolsLogEntryInput, DevToolsLogFilePosition, DevToolsLogHandle, DevToolsLogLevel, DevToolsLogsClient, DevToolsLogsHost, DevToolsMessageElementPosition, DevToolsMessageEntry, DevToolsMessageEntryFrom, DevToolsMessageEntryInput, DevToolsMessageFilePosition, DevToolsMessageHandle, DevToolsMessageLevel, DevToolsMessagesClient, DevToolsMessagesHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsNodeUtils, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsServerCommandEntry, DevToolsServerCommandInput, DevToolsTerminalHost, DevToolsTerminalSession, DevToolsTerminalSessionBase, DevToolsTerminalSessionStreamChunkEvent, DevToolsTerminalStatus, DevToolsViewAction, DevToolsViewBuiltin, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewJsonRender, DevToolsViewLauncher, DevToolsViewLauncherStatus, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RemoteConnectionInfo, RemoteDockOptions, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, Thenable, defineCommand, defineDevtool, defineJsonRenderSpec, defineRpcFunction };
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ClientScriptEntry, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsChildProcessExecuteOptions, DevToolsChildProcessTerminalSession, DevToolsClientCommand, DevToolsCommandBase, DevToolsCommandEntry, DevToolsCommandHandle, DevToolsCommandKeybinding, DevToolsCommandShortcutOverrides, DevToolsCommandsHost, DevToolsCommandsHostEvents, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsDockEntriesGrouped, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockEntryCategory, DevToolsDockEntryIcon, DevToolsDockHost, DevToolsDockUserEntry, DevToolsDocksUserSettings, DevToolsHost, DevToolsLogElementPosition, DevToolsLogEntry, DevToolsLogEntryFrom, DevToolsLogEntryInput, DevToolsLogFilePosition, DevToolsLogHandle, DevToolsLogLevel, DevToolsLogsClient, DevToolsLogsHost, DevToolsMessageElementPosition, DevToolsMessageEntry, DevToolsMessageEntryFrom, DevToolsMessageEntryInput, DevToolsMessageFilePosition, DevToolsMessageHandle, DevToolsMessageLevel, DevToolsMessagesClient, DevToolsMessagesHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsNodeUtils, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsServerCommandEntry, DevToolsServerCommandInput, DevToolsTerminalHost, DevToolsTerminalSession, DevToolsTerminalSessionBase, DevToolsTerminalStatus, DevToolsViewAction, DevToolsViewBuiltin, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewJsonRender, DevToolsViewLauncher, DevToolsViewLauncherStatus, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RemoteConnectionInfo, RemoteDockOptions, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineCommand, defineDevtool, defineJsonRenderSpec, defineRpcFunction };

package/dist/node/index.d.mts

@@ -1,7 +1,8 @@
-import { A as DevToolsViewHost$1, At as DevToolsDiagnosticsHost$1, Bt as DevToolsServerCommandEntry, F as DevToolsChildProcessTerminalSession, Ft as DevToolsCommandHandle, Gt as AgentResourceContent, H as DevToolsRpcClientFunctions, Ht as AgentHandle, I as DevToolsTerminalHost$1, Jt as AgentToolInput, Kt as AgentResourceInput, L as DevToolsTerminalSession, M as PartialWithoutId, P as DevToolsChildProcessExecuteOptions, R as DevToolsTerminalSessionBase, Rt as DevToolsCommandsHost$1, U as DevToolsRpcServerFunctions, Ut as AgentManifest, V as DevToolsDocksUserSettings, Vt as DevToolsServerCommandInput, Wt as AgentResource, Xt as DevToolsAgentHostEvents, Yt as DevToolsAgentHost$1, Zt as EventEmitter, _t as DevToolsDockUserEntry, at as DevToolsMessageHandle, ct as DevToolsMessagesHost$1, d as DevToolsNodeContext, ft as DevToolsDockEntry, g as RpcFunctionsHost$1, gt as DevToolsDockHost$1, h as RpcBroadcastOptions, jt as DevToolsDiagnosticsLogger, lt as DevToolsHost, m as DevToolsNodeRpcSession, qt as AgentTool, rt as DevToolsMessageEntryInput, tt as DevToolsMessageEntry, ut as ClientScriptEntry, v as RpcSharedStateHost, w as SharedState } from "../devtool-CIqONpYU.mjs";
-import { g as RpcFunctionsCollectorBase } from "../index-BwrLhNmz.mjs";
-import { g as RpcFunctionDefinitionAny } from "../types-gWbe-b2R.mjs";
-import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-CaUeMcAh.mjs";
+import { $ as DevToolsRpcServerFunctions, $t as AgentManifest, Bt as DevToolsDiagnosticsHost$1, Dt as DevToolsDockUserEntry, Et as DevToolsDockHost$1, G as DevToolsChildProcessExecuteOptions, Gt as DevToolsCommandHandle, I as SharedState, J as DevToolsTerminalSession, Jt as DevToolsCommandsHost$1, K as DevToolsChildProcessTerminalSession, Q as DevToolsRpcClientFunctions, Qt as AgentHandle, St as DevToolsDockEntry, U as PartialWithoutId, V as DevToolsViewHost$1, Vt as DevToolsDiagnosticsLogger, Xt as DevToolsServerCommandEntry, Y as DevToolsTerminalSessionBase, Z as DevToolsDocksUserSettings, Zt as DevToolsServerCommandInput, an as DevToolsAgentHost$1, bt as ClientScriptEntry, d as DevToolsNodeContext, dt as DevToolsMessageEntry, en as AgentResource, g as RpcFunctionsHost$1, h as RpcBroadcastOptions, ht as DevToolsMessageHandle, in as AgentToolInput, m as DevToolsNodeRpcSession, nn as AgentResourceInput, on as DevToolsAgentHostEvents, pt as DevToolsMessageEntryInput, q as DevToolsTerminalHost$1, rn as AgentTool, sn as EventEmitter, tn as AgentResourceContent, v as RpcSharedStateHost, vt as DevToolsMessagesHost$1, x as RpcStreamingHost, yt as DevToolsHost } from "../devtool-Bm6zZAw5.mjs";
+import { g as RpcFunctionsCollectorBase } from "../index-BCo03GEF.mjs";
+import { g as RpcFunctionDefinitionAny } from "../types-ag029cAe.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-VQqESKAs.mjs";
+import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-DksyT-um.mjs";
 import { createLogger, defineDiagnostics } from "logs-sdk";
 import { BirpcGroup } from "birpc";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -215,6 +216,15 @@ declare class RpcFunctionsHost extends RpcFunctionsCollectorBase<DevToolsRpcServ
   _asyncStorage: AsyncLocalStorage<DevToolsNodeRpcSession>;
   constructor(context: DevToolsNodeContext);
   sharedState: RpcSharedStateHost;
+  streaming: RpcStreamingHost;
+  /**
+   * Adapters call this from their WS `onDisconnected` hook so downstream
+   * hosts (streaming, …) can free per-session state. Public-ish because
+   * tests / custom adapters may want to mirror it.
+   *
+   * @internal
+   */
+  _emitSessionDisconnected(meta: DevToolsNodeRpcSessionMeta): void;
   invokeLocal<T extends keyof DevToolsRpcServerFunctions, Args extends Parameters<DevToolsRpcServerFunctions[T]>>(method: T, ...args: Args): Promise<Awaited<ReturnType<DevToolsRpcServerFunctions[T]>>>;
   broadcast<T extends keyof DevToolsRpcClientFunctions, Args extends Parameters<DevToolsRpcClientFunctions[T]>>(options: RpcBroadcastOptions<T, Args>): Promise<void>;
   getCurrentRpcSession(): DevToolsNodeRpcSession | undefined;
@@ -235,11 +245,22 @@ interface CreateH3DevToolsHostOptions {
    * the CLI isn't running, so the default is a no-op.
    */
   mount?: (base: string, distDir: string) => void | Promise<void>;
+  /**
+   * Namespace for storage paths returned by `getStorageDir`. Workspace
+   * state lives under `${workspaceRoot}/node_modules/.<appName>/devtools/`
+   * and global state under `${homedir()}/.<appName>/devtools/`. Pick the
+   * devtool's id (or another stable, filesystem-safe identifier) so the
+   * standalone host doesn't collide with other tools' storage.
+   */
+  appName: string;
+  /**
+   * Workspace root used as the parent of the per-project storage
+   * directory. Defaults to `process.cwd()`.
+   */
+  workspaceRoot?: string;
 }
 /**
  * h3-backed {@link DevToolsHost} — used by the standalone CLI adapter.
- * This commit adds the shell; the CLI adapter in commit 5 wires it up
- * with a real h3 app and sirv handler.
  */
 declare function createH3DevToolsHost(options: CreateH3DevToolsHostOptions): DevToolsHost;
 //#endregion
@@ -272,7 +293,14 @@ declare class DevToolsTerminalHost implements DevToolsTerminalHost$1 {
   readonly sessions: DevToolsTerminalHost$1['sessions'];
   readonly events: DevToolsTerminalHost$1['events'];
   private _boundStreams;
+  private _channel?;
   constructor(context: DevToolsNodeContext);
+  /**
+   * Lazily acquire the streaming channel — `context.rpc` isn't assigned
+   * until after every host is constructed, so we can't grab it in the
+   * constructor.
+   */
+  private getStreamingChannel;
   register(session: DevToolsTerminalSession): DevToolsTerminalSession;
   update(patch: PartialWithoutId<DevToolsTerminalSession>): void;
   remove(session: DevToolsTerminalSession): void;
@@ -297,6 +325,15 @@ declare class DevToolsViewHost implements DevToolsViewHost$1 {
 //#region src/node/rpc-shared-state.d.ts
 declare function createRpcSharedStateServerHost(rpc: RpcFunctionsHost$1): RpcSharedStateHost;
 //#endregion
+//#region src/node/rpc-streaming.d.ts
+/**
+ * Build the server-side streaming host. Mirrors the layout of
+ * `createRpcSharedStateServerHost` — registers a fixed set of internal
+ * RPC methods (`subscribe` / `unsubscribe` / `cancel`) once, then per-channel
+ * state lives in a `Map<channelName, ChannelState>`.
+ */
+declare function createRpcStreamingServerHost(rpc: RpcFunctionsHost$1): RpcStreamingHost;
+//#endregion
 //#region src/node/static-dump.d.ts
 type StaticRpcDumpSerialization = 'json' | 'structured-clone';
 interface StaticRpcDumpManifestStaticEntry {
@@ -341,4 +378,4 @@ declare function createStorage<T extends object>(options: CreateStorageOptions<T
 declare function isObject(value: unknown): value is Record<string, any>;
 declare function normalizeHttpServerUrl(host: string, port: number | string): string;
 //#endregion
-export { ContextUtils, CreateH3DevToolsHostOptions, CreateHostContextOptions, CreateStorageOptions, DevToolsAgentHost, DevToolsCommandsHost, DevToolsDiagnosticsHost, DevToolsDockHost, DevToolsInternalContext, DevToolsMessagesHost, DevToolsTerminalHost, DevToolsViewHost, InternalAnonymousAuthStorage, PendingAuthRequest, RemoteTokenRecord, RpcFunctionsHost, StartHttpAndWsOptions, StartedServer, StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, abortPendingAuth, collectStaticRpcDump, consumeTempAuthToken, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createStorage, getInternalContext, getPendingAuth, getTempAuthToken, internalContextMap, isObject, normalizeHttpServerUrl, refreshTempAuthToken, revokeActiveConnectionsForToken, revokeAuthToken, setPendingAuth, startHttpAndWs };
+export { ContextUtils, CreateH3DevToolsHostOptions, CreateHostContextOptions, CreateStorageOptions, DevToolsAgentHost, DevToolsCommandsHost, DevToolsDiagnosticsHost, DevToolsDockHost, DevToolsInternalContext, DevToolsMessagesHost, DevToolsTerminalHost, DevToolsViewHost, InternalAnonymousAuthStorage, PendingAuthRequest, RemoteTokenRecord, RpcFunctionsHost, StartHttpAndWsOptions, StartedServer, StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, abortPendingAuth, collectStaticRpcDump, consumeTempAuthToken, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createRpcStreamingServerHost, createStorage, getInternalContext, getPendingAuth, getTempAuthToken, internalContextMap, isObject, normalizeHttpServerUrl, refreshTempAuthToken, revokeActiveConnectionsForToken, revokeAuthToken, setPendingAuth, startHttpAndWs };