devframe 0.1.19 → 0.1.21

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

@@ -1,10 +1,10 @@
-import { g as RpcFunctionsCollectorBase } from "./index-BwrLhNmz.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-DHMeNOY_.mjs";
+import { g as RpcFunctionsCollectorBase } from "./index-CuLRIMto.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-C7LnhOHi.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";
 
 //#region src/adapters/flags.d.ts
 /**
@@ -285,127 +285,6 @@ interface DevToolsAgentHost {
   getResource: (id: string) => AgentResource | undefined;
 }
 //#endregion
-//#region src/types/commands.d.ts
-interface DevToolsCommandKeybinding {
-  /**
-   * Keyboard shortcut string.
-   * Use "Mod" for platform-aware modifier (Cmd on macOS, Ctrl elsewhere).
-   * Examples: "Mod+K", "Mod+Shift+P", "Alt+N"
-   */
-  key: string;
-}
-interface DevToolsCommandBase {
-  /**
-   * Unique namespaced ID, e.g. "vite:open-in-editor"
-   */
-  id: string;
-  title: string;
-  description?: string;
-  /**
-   * Iconify icon string, e.g. "ph:pencil-duotone"
-   */
-  icon?: string;
-  category?: string;
-  /**
-   * Whether to show in command palette. Default: true
-   *
-   * - `true` — show the command and flatten its children into search results
-   * - `false` — hide the command entirely from the palette
-   * - `'without-children'` — show the command but don't flatten children into top-level search (children are still accessible via drill-down)
-   */
-  showInPalette?: boolean | 'without-children';
-  /**
-   * Optional context expression for conditional visibility.
-   * When set, the command is only shown in the palette and only executable
-   * when the expression evaluates to true.
-   *
-   * Uses the same syntax as keybinding `when` clauses.
-   * @example 'clientType == embedded'
-   * @example 'dockOpen && !paletteOpen'
-   */
-  when?: string;
-  /**
-   * Default keyboard shortcut(s) for this command
-   */
-  keybindings?: DevToolsCommandKeybinding[];
-}
-/**
- * Server command input — what plugins pass to `ctx.commands.register()`.
- */
-interface DevToolsServerCommandInput extends DevToolsCommandBase {
-  /**
-   * Handler for this command. Optional if the command only serves as a group for children.
-   */
-  handler?: (...args: any[]) => any | Promise<any>;
-  /**
-   * Static sub-commands. Two levels max (parent → children).
-   * Each child must have a globally unique `id`.
-   */
-  children?: DevToolsServerCommandInput[];
-}
-/**
- * Serializable server command entry — sent over RPC (no handler).
- */
-interface DevToolsServerCommandEntry extends DevToolsCommandBase {
-  source: 'server';
-  children?: DevToolsServerCommandEntry[];
-}
-/**
- * Client command — registered in the webcomponent context.
- */
-interface DevToolsClientCommand extends DevToolsCommandBase {
-  source: 'client';
-  /**
-   * Action for this command. Optional if the command only serves as a group for children.
-   * Return sub-commands for dynamic nested palette menus (runtime submenus).
-   */
-  action?: (...args: any[]) => void | DevToolsClientCommand[] | Promise<void | DevToolsClientCommand[]>;
-  /**
-   * Static sub-commands. Two levels max (parent → children).
-   */
-  children?: DevToolsClientCommand[];
-}
-/**
- * Union of command entries visible in the palette.
- */
-type DevToolsCommandEntry = DevToolsServerCommandEntry | DevToolsClientCommand;
-interface DevToolsCommandHandle {
-  readonly id: string;
-  update: (patch: Partial<Omit<DevToolsServerCommandInput, 'id'>>) => void;
-  unregister: () => void;
-}
-interface DevToolsCommandsHostEvents {
-  'command:registered': (command: DevToolsServerCommandEntry) => void;
-  'command:unregistered': (id: string) => void;
-}
-interface DevToolsCommandsHost {
-  readonly commands: Map<string, DevToolsServerCommandInput>;
-  readonly events: EventEmitter<DevToolsCommandsHostEvents>;
-  /**
-   * Register a command (with optional children).
-   */
-  register: (command: DevToolsServerCommandInput) => DevToolsCommandHandle;
-  /**
-   * Unregister a command by ID (removes parent and all children).
-   */
-  unregister: (id: string) => boolean;
-  /**
-   * Execute a command by ID. Searches top-level and children.
-   * Throws if not found or if command has no handler.
-   */
-  execute: (id: string, ...args: any[]) => Promise<unknown>;
-  /**
-   * Returns serializable list (no handlers), preserving tree structure.
-   */
-  list: () => DevToolsServerCommandEntry[];
-}
-interface DevToolsCommandShortcutOverrides {
-  /**
-   * Command ID → keybinding overrides. Empty array = shortcut disabled.
-   */
-  [commandId: string]: DevToolsCommandKeybinding[];
-}
-//#endregion
 //#region src/types/diagnostics.d.ts
 /**
  * A diagnostics definition object built with `defineDiagnostics`. Typed as
@@ -472,147 +351,43 @@ interface DevToolsDiagnosticsHost {
   createLogger: typeof createLogger;
 }
 //#endregion
-//#region src/types/docks.d.ts
-interface DevToolsDockHost {
-  readonly views: Map<string, DevToolsDockUserEntry>;
-  readonly events: EventEmitter<{
-    'dock:entry:updated': (entry: DevToolsDockUserEntry) => void;
-  }>;
-  register: <T extends DevToolsDockUserEntry>(entry: T, force?: boolean) => {
-    update: (patch: Partial<T>) => void;
-  };
-  update: (entry: DevToolsDockUserEntry) => void;
-  values: (options?: {
-    includeBuiltin?: boolean;
-  }) => DevToolsDockEntry[];
-}
-type DevToolsDockEntryCategory = 'app' | 'framework' | 'web' | 'advanced' | 'default' | '~viteplus' | '~builtin';
-type DevToolsDockEntryIcon = string | {
-  light: string;
-  dark: string;
-};
-interface DevToolsDockEntryBase {
-  id: string;
-  title: string;
-  icon: DevToolsDockEntryIcon;
-  /**
-   * The default order of the entry in the dock.
-   * The higher the number the earlier it appears.
-   * @default 0
-   */
-  defaultOrder?: number;
-  /**
-   * The category of the entry
-   * @default 'default'
-   */
-  category?: DevToolsDockEntryCategory;
-  /**
-   * Conditional visibility expression.
-   * When set, the dock entry is only visible when the expression evaluates to true.
-   * Uses the same syntax as command `when` clauses.
-   *
-   * Set to `'false'` to unconditionally hide the entry.
-   *
-   * @example 'clientType == embedded'
-   * @see {@link import('../utils/when').evaluateWhen}
-   */
-  when?: string;
-  /**
-   * Badge text to display on the dock icon (e.g., unread count)
-   */
-  badge?: string;
-}
-interface ClientScriptEntry {
-  /**
-   * The filepath or module name to import from
-   */
-  importFrom: string;
-  /**
-   * The name to import the module as
-   *
-   * @default 'default'
-   */
-  importName?: string;
-}
-interface DevToolsViewIframe extends DevToolsDockEntryBase {
-  type: 'iframe';
-  url: string;
-  /**
-   * The id of the iframe, if multiple tabs is assigned with the same id, the iframe will be shared.
-   *
-   * When not provided, it would be treated as a unique frame.
-   */
-  frameId?: string;
+//#region src/types/host.d.ts
+interface DevToolsHost {
   /**
-   * Optional client script to import into the iframe
+   * Serve a static directory at the given URL base. Called by
+   * `DevToolsViewHost.hostStatic`. Implementations map this to whatever
+   * the underlying runtime expects (Vite middleware, h3 handler, no-op
+   * for build snapshots).
    */
-  clientScript?: ClientScriptEntry;
+  mountStatic: (base: string, distDir: string) => void | Promise<void>;
   /**
-   * Enable remote-UI mode: the core injects a connection descriptor
-   * (WS URL + pre-approved auth token) into the iframe URL so a hosted
-   * page can connect back via `connectRemoteDevTools()` from
-   * `@vitejs/devtools-kit/client` — without needing to ship a dist with
-   * the plugin.
-   *
-   * Requires dev mode (no effect in build mode — no WS server exists).
-   * When enabled, the dock is automatically hidden in build mode unless
-   * the author provides an explicit `when` clause.
-   *
-   * @example
-   *   remote: true
-   *   remote: { transport: 'query', originLock: false }
+   * Return the public origin the host is reachable at, e.g.
+   * `http://localhost:5173`. Used by the dock host to enrich remote
+   * iframe URLs with a full `origin`. Called only when a dock needs an
+   * absolute URL; hosts that never serve remote docks can return any
+   * reasonable value.
    */
-  remote?: boolean | RemoteDockOptions;
-}
-interface RemoteDockOptions {
+  resolveOrigin: () => string;
   /**
-   * How to pass the connection descriptor to the hosted page.
+   * 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`).
    *
-   * - `'fragment'` (default): appended as `#vite-devtools-kit-connection=...`.
-   *   Not sent in HTTP requests or Referer headers — safest for auth tokens.
-   * - `'query'`: appended as `?vite-devtools-kit-connection=...`. Use when
-   *   your hosting platform rewrites fragments or your SPA router repurposes
-   *   the fragment for navigation. The token will appear in server access
-   *   logs and outbound Referer headers.
+   *   - `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/`.
    *
-   * @default 'fragment'
+   * Implementations should ensure the directory exists or be safe to
+   * pass to a downstream `createStorage(...)` call that creates it
+   * lazily.
    */
-  transport?: 'fragment' | 'query';
-  /**
-   * Reject WS handshakes whose `Origin` header doesn't match the dock URL
-   * origin. Turn off when the same hosted app is served from multiple
-   * origins (e.g. preview deploys).
-   *
-   * @default true
-   */
-  originLock?: boolean;
-}
-type DevToolsViewLauncherStatus = 'idle' | 'loading' | 'success' | 'error';
-interface DevToolsViewLauncher extends DevToolsDockEntryBase {
-  type: 'launcher';
-  launcher: {
-    icon?: DevToolsDockEntryIcon;
-    title: string;
-    status?: DevToolsViewLauncherStatus;
-    error?: string;
-    description?: string;
-    buttonStart?: string;
-    buttonLoading?: string;
-    onLaunch: () => Promise<void>;
-  };
-}
-interface DevToolsViewAction extends DevToolsDockEntryBase {
-  type: 'action';
-  action: ClientScriptEntry;
-}
-interface DevToolsViewCustomRender extends DevToolsDockEntryBase {
-  type: 'custom-render';
-  renderer: ClientScriptEntry;
-}
-interface DevToolsViewBuiltin extends DevToolsDockEntryBase {
-  type: '~builtin';
-  id: '~terminals' | '~messages' | '~client-auth-notice' | '~settings' | '~popup';
+  getStorageDir: (scope: 'workspace' | 'global') => string;
 }
+//#endregion
+//#region src/types/json-render.d.ts
 interface JsonRenderElement {
   type: string;
   props?: Record<string, unknown>;
@@ -640,262 +415,115 @@ interface JsonRenderer {
   /** Internal: shared state key used by the client to subscribe */
   readonly _stateKey: string;
 }
-interface DevToolsViewJsonRender extends DevToolsDockEntryBase {
-  type: 'json-render';
-  /** JsonRenderer handle created by ctx.createJsonRenderer() */
-  ui: JsonRenderer;
-}
-type DevToolsDockUserEntry = DevToolsViewIframe | DevToolsViewAction | DevToolsViewCustomRender | DevToolsViewLauncher | DevToolsViewJsonRender;
-type DevToolsDockEntry = DevToolsDockUserEntry | DevToolsViewBuiltin;
-type DevToolsDockEntriesGrouped = [category: string, entries: DevToolsDockEntry[]][];
-//#endregion
-//#region src/types/host.d.ts
-interface DevToolsHost {
-  /**
-   * Serve a static directory at the given URL base. Called by
-   * `DevToolsViewHost.hostStatic`. Implementations map this to whatever
-   * the underlying runtime expects (Vite middleware, h3 handler, no-op
-   * for build snapshots).
-   */
-  mountStatic: (base: string, distDir: string) => void | Promise<void>;
-  /**
-   * Return the public origin the host is reachable at, e.g.
-   * `http://localhost:5173`. Used by the dock host to enrich remote
-   * iframe URLs with a full `origin`. Called only when a dock needs an
-   * absolute URL; hosts that never serve remote docks can return any
-   * reasonable value.
-   */
-  resolveOrigin: () => string;
-}
 //#endregion
-//#region src/types/messages.d.ts
-type DevToolsMessageLevel = 'info' | 'warn' | 'error' | 'success' | 'debug';
-type DevToolsMessageEntryFrom = 'server' | 'browser';
-interface DevToolsMessageElementPosition {
-  /** CSS selector for the element */
-  selector?: string;
-  /** Bounding box of the element */
-  boundingBox?: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  };
-  /** Human-readable description of the element */
-  description?: string;
-}
-interface DevToolsMessageFilePosition {
-  /** Absolute or relative file path */
-  file: string;
-  /** Line number (1-based) */
-  line?: number;
-  /** Column number (1-based) */
-  column?: number;
-}
-interface DevToolsMessageEntry {
-  /**
-   * Unique identifier for this message entry (auto-generated if not provided)
-   */
-  id: string;
-  /**
-   * Short title or summary of the message
-   */
-  message: string;
-  /**
-   * Optional detailed description or explanation
-   */
-  description?: string;
-  /**
-   * Severity level, determines color and icon
-   */
-  level: DevToolsMessageLevel;
-  /**
-   * Optional stack trace string
-   */
-  stacktrace?: string;
-  /**
-   * Optional DOM element position info (e.g., for a11y issues)
-   */
-  elementPosition?: DevToolsMessageElementPosition;
-  /**
-   * Optional source file position info (e.g., for lint errors)
-   */
-  filePosition?: DevToolsMessageFilePosition;
-  /**
-   * Whether this message should also appear as a toast notification
-   */
-  notify?: boolean;
+//#region src/types/rpc-augments.d.ts
+/**
+ * To be extended
+ */
+interface DevToolsRpcClientFunctions {
   /**
-   * Origin of the message entry, automatically set by the context
+   * Streaming chunk pushed from server to subscribed clients. Wired by
+   * `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
    */
-  from: DevToolsMessageEntryFrom;
+  'devframe:streaming:chunk': (channel: string, id: string, seq: number, chunk: any) => Promise<void>;
   /**
-   * Grouping category (e.g., 'a11y', 'lint', 'runtime', 'test')
+   * Streaming terminator pushed from server to subscribed clients. Wired by
+   * `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
    */
-  category?: string;
+  'devframe:streaming:end': (channel: string, id: string, error?: {
+    name: string;
+    message: string;
+  }) => Promise<void>;
   /**
-   * Optional tags/labels for filtering
+   * Server→client cancel for an in-flight upload. Wired by
+   * `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
    */
-  labels?: string[];
+  'devframe:streaming:upload-cancel': (channel: string, id: string) => Promise<void>;
+}
+/**
+ * To be extended
+ */
+interface DevToolsRpcServerFunctions {
   /**
-   * Time in ms to auto-dismiss the toast notification (client-side)
+   * Subscribe a client to a shared-state key. Wired by
+   * `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
    */
-  autoDismiss?: number;
+  'devframe:rpc:server-state:subscribe': (key: string) => Promise<void>;
   /**
-   * Time in ms to auto-delete this message entry (server-side)
+   * Read the current value for a shared-state key. Wired by
+   * `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
    */
-  autoDelete?: number;
+  'devframe:rpc:server-state:get': (key: string) => Promise<any>;
   /**
-   * Timestamp when the message was created (auto-generated if not provided)
+   * Replace a shared-state value (from the client). Wired by
+   * `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
    */
-  timestamp: number;
+  'devframe:rpc:server-state:set': (key: string, value: any, syncId: string) => Promise<void>;
   /**
-   * Status of the message entry (e.g., 'loading' while an operation is in progress).
-   * Defaults to 'idle' when not specified.
+   * Apply a patch to a shared-state value (from the client). Wired by
+   * `RpcSharedStateHost`; do not register manually.
+   *
+   * @internal
    */
-  status?: 'loading' | 'idle';
-}
-/**
- * Input type for creating a message entry.
- * `id`, `timestamp`, and `from` are auto-filled by the host.
- */
-type DevToolsMessageEntryInput = Omit<DevToolsMessageEntry, 'id' | 'timestamp' | 'from'> & {
-  id?: string;
-  timestamp?: number;
-};
-interface DevToolsMessageHandle {
-  /** The underlying message entry data */
-  readonly entry: DevToolsMessageEntry;
-  /** Shortcut to entry.id */
-  readonly id: string;
-  /** Partial update of this message entry */
-  update: (patch: Partial<DevToolsMessageEntryInput>) => Promise<DevToolsMessageEntry | undefined>;
-  /** Remove this message entry */
-  dismiss: () => Promise<void>;
-}
-interface DevToolsMessagesClient {
+  'devframe:rpc:server-state:patch': (key: string, patches: any[], syncId: string) => Promise<void>;
   /**
-   * Add a message entry. Returns a Promise resolving to a handle for subsequent updates/dismissal.
-   * Can be used without `await` for fire-and-forget usage.
+   * Client→server streaming subscription with optional replay cursor.
+   * Wired by `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
    */
-  add: (input: DevToolsMessageEntryInput) => Promise<DevToolsMessageHandle>;
-  /** Remove a message entry by id */
-  remove: (id: string) => Promise<void>;
-  /** Clear all message entries */
-  clear: () => Promise<void>;
-}
-interface DevToolsMessagesHost {
-  readonly entries: Map<string, DevToolsMessageEntry>;
-  readonly events: EventEmitter<{
-    'message:added': (entry: DevToolsMessageEntry) => void;
-    'message:updated': (entry: DevToolsMessageEntry) => void;
-    'message:removed': (id: string) => void;
-    'message:cleared': () => void;
-  }>;
+  'devframe:streaming:subscribe': (channel: string, id: string, opts?: {
+    afterSeq?: number;
+  }) => Promise<void>;
   /**
-   * Add a new message entry. If an entry with the same `id` already exists, it will be updated instead.
-   * Returns a handle for subsequent updates/dismissal. Can be used without `await` for fire-and-forget.
+   * Client→server streaming unsubscribe. Wired by `RpcStreamingHost`;
+   * do not register manually.
+   *
+   * @internal
    */
-  add: (entry: DevToolsMessageEntryInput) => Promise<DevToolsMessageHandle>;
+  'devframe:streaming:unsubscribe': (channel: string, id: string) => Promise<void>;
   /**
-   * Update an existing message entry by id (partial update)
+   * Client→server streaming cancellation request. Wired by
+   * `RpcStreamingHost`; do not register manually.
+   *
+   * @internal
    */
-  update: (id: string, patch: Partial<DevToolsMessageEntryInput>) => Promise<DevToolsMessageEntry | undefined>;
+  'devframe:streaming:cancel': (channel: string, id: string) => Promise<void>;
   /**
-   * Remove a message entry by id
+   * Client→server upload chunk. Wired by `RpcStreamingHost`; do not
+   * register manually.
+   *
+   * @internal
    */
-  remove: (id: string) => Promise<void>;
+  'devframe:streaming:upload-chunk': (channel: string, id: string, seq: number, chunk: any) => Promise<void>;
   /**
-   * Clear all message entries
+   * Client→server upload terminator. Wired by `RpcStreamingHost`; do not
+   * register manually.
+   *
+   * @internal
    */
-  clear: () => Promise<void>;
+  'devframe:streaming:upload-end': (channel: string, id: string, error?: {
+    name: string;
+    message: string;
+  }) => Promise<void>;
 }
-/** @deprecated alias of {@link DevToolsMessageLevel}. Will be removed in a future release. */
-type DevToolsLogLevel = DevToolsMessageLevel;
-/** @deprecated alias of {@link DevToolsMessageEntryFrom}. Will be removed in a future release. */
-type DevToolsLogEntryFrom = DevToolsMessageEntryFrom;
-/** @deprecated alias of {@link DevToolsMessageElementPosition}. Will be removed in a future release. */
-type DevToolsLogElementPosition = DevToolsMessageElementPosition;
-/** @deprecated alias of {@link DevToolsMessageFilePosition}. Will be removed in a future release. */
-type DevToolsLogFilePosition = DevToolsMessageFilePosition;
-/** @deprecated alias of {@link DevToolsMessageEntry}. Will be removed in a future release. */
-type DevToolsLogEntry = DevToolsMessageEntry;
-/** @deprecated alias of {@link DevToolsMessageEntryInput}. Will be removed in a future release. */
-type DevToolsLogEntryInput = DevToolsMessageEntryInput;
-/** @deprecated alias of {@link DevToolsMessageHandle}. Will be removed in a future release. */
-type DevToolsLogHandle = DevToolsMessageHandle;
-/** @deprecated alias of {@link DevToolsMessagesClient}. Will be removed in a future release. */
-type DevToolsLogsClient = DevToolsMessagesClient;
-/** @deprecated alias of {@link DevToolsMessagesHost}. Will be removed in a future release. */
-type DevToolsLogsHost = DevToolsMessagesHost;
-//#endregion
-//#region src/types/rpc-augments.d.ts
-/**
- * To be extended
- */
-interface DevToolsRpcClientFunctions {}
-/**
- * To be extended
- */
-interface DevToolsRpcServerFunctions {}
 /**
  * To be extended
  */
 interface DevToolsRpcSharedStates {}
 //#endregion
-//#region src/types/settings.d.ts
-interface DevToolsDocksUserSettings {
-  docksHidden: string[];
-  docksCategoriesHidden: string[];
-  docksPinned: string[];
-  docksCustomOrder: Record<string, number>;
-  showIframeAddressBar: boolean;
-  closeOnOutsideClick: boolean;
-  commandShortcuts: DevToolsCommandShortcutOverrides;
-}
-//#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;
-  startChildProcess: (executeOptions: DevToolsChildProcessExecuteOptions, terminal: Omit<DevToolsTerminalSessionBase, 'status'>) => Promise<DevToolsChildProcessTerminalSession>;
-}
-type DevToolsTerminalStatus = 'running' | 'stopped' | 'error';
-interface DevToolsTerminalSessionBase {
-  id: string;
-  title: string;
-  description?: string;
-  status: DevToolsTerminalStatus;
-  icon?: DevToolsDockEntryIcon;
-}
-interface DevToolsTerminalSession extends DevToolsTerminalSessionBase {
-  buffer?: string[];
-  stream?: ReadableStream<string>;
-}
-interface DevToolsChildProcessExecuteOptions {
-  command: string;
-  args: string[];
-  cwd?: string;
-  env?: Record<string, string>;
-}
-interface DevToolsChildProcessTerminalSession extends DevToolsTerminalSession {
-  type: 'child-process';
-  executeOptions: DevToolsChildProcessExecuteOptions;
-  getChildProcess: () => ChildProcess | undefined;
-  terminate: () => Promise<void>;
-  restart: () => Promise<void>;
-}
-//#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] };
@@ -922,21 +550,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 +599,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 +754,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,41 +777,152 @@ 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 {
   rpc?: boolean;
   views?: boolean;
 }
+/**
+ * Framework-neutral node context — RPC + diagnostics + agent + the
+ * view-host (HTTP file-serving). Hub-level subsystems (docks,
+ * terminals, messages, commands) are not part of this surface; they are
+ * added by `@vitejs/devtools-kit`'s `createKitContext` when the devtool
+ * is mounted into a multi-integration hub.
+ */
 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;
-  docks: DevToolsDockHost;
   views: DevToolsViewHost;
-  utils: DevToolsNodeUtils;
-  terminals: DevToolsTerminalHost;
-  /**
-   * User-facing message subsystem — toast notifications and the
-   * "Messages & Notifications" dock panel. Plugins call
-   * `ctx.messages.add({ ... })` to surface activity to users.
-   */
-  messages: DevToolsMessagesHost;
-  /**
-   * @deprecated Use `ctx.messages` instead. Will be removed in a future release.
-   */
-  readonly logs: DevToolsMessagesHost;
   /**
    * Structured diagnostics host — wraps `logs-sdk` and lets integrations
    * register their own coded errors/warnings into the shared logger.
    */
   diagnostics: DevToolsDiagnosticsHost;
-  commands: DevToolsCommandsHost;
   /**
    * Agent host — aggregates the agent-exposed surface of this devtool.
    *
@@ -1081,15 +934,6 @@ interface DevToolsNodeContext {
    */
   createJsonRenderer: (spec: JsonRenderSpec) => JsonRenderer;
 }
-interface DevToolsNodeUtils {
-  /**
-   * Create a simple client script from a function or stringified code.
-   *
-   * @deprecated testing helper; prefer a proper importable module.
-   * @experimental
-   */
-  createSimpleClientScript: (fn: string | ((ctx: any) => void)) => ClientScriptEntry;
-}
 interface ConnectionMeta {
   backend: 'websocket' | 'static';
   websocket?: number | string;
@@ -1103,20 +947,13 @@ interface ConnectionMeta {
    */
   jsonSerializableMethods?: string[];
 }
-interface RemoteConnectionInfo extends ConnectionMeta {
-  backend: 'websocket';
-  websocket: string;
-  v: 1;
-  authToken: string;
-  origin: string;
-}
 //#endregion
 //#region src/types/devtool.d.ts
 type DevtoolRuntime = 'cli' | 'build' | 'spa' | 'vite' | 'kit' | 'embedded';
 /**
  * Classification of how a devtool is being deployed. Hosted adapters
  * (`vite`, `kit`, `embedded`) share their origin with a host app and
- * must namespace their mount path under `/.<id>/`. Standalone adapters
+ * must namespace their mount path under `/__<id>/`. Standalone adapters
  * (`cli`, `spa`, `build`) own the origin and default to `/`.
  */
 type DevtoolDeploymentKind = 'standalone' | 'hosted';
@@ -1217,7 +1054,7 @@ interface DevtoolDefinition {
   version?: string;
   /**
    * Mount path override. Defaults depend on the adapter:
-   * `/` for standalone (`cli` / `spa` / `build`), `/.<id>/` for hosted
+   * `/` for standalone (`cli` / `spa` / `build`), `/__<id>/` for hosted
    * (`vite` / `kit` / `embedded`).
    */
   basePath?: string;
@@ -1235,4 +1072,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 { AgentHandle as $, ImmutableArray as A, EntriesToObject as B, StreamErrorPayload as C, createStreamReader as D, StreamSinkEvents as E, SharedStateEvents as F, DevToolsRpcSharedStates as G, Thenable as H, SharedStateOptions as I, JsonRenderer as J, JsonRenderElement as K, SharedStatePatch as L, ImmutableObject as M, ImmutableSet as N, createStreamSink as O, SharedState as P, DevToolsDiagnosticsLogger as Q, createSharedState as R, CreateStreamSinkOptions as S, StreamSink as T, DevToolsRpcClientFunctions as U, PartialWithoutId as V, DevToolsRpcServerFunctions as W, DevToolsDiagnosticsDefinition as X, DevToolsHost as Y, DevToolsDiagnosticsHost as Z, RpcStreamingChannel as _, DevtoolRuntime as a, AgentToolInput as at, BufferedChunk as b, defineDevtool as c, EventEmitter as ct, DevToolsNodeContext as d, CliFlagsSchema as dt, AgentManifest as et, DevToolsNodeRpcSession as f, InferCliFlags as ft, RpcSharedStateHost as g, RpcSharedStateGetOptions as h, DevtoolDeploymentKind as i, AgentTool as it, ImmutableMap as j, Immutable as k, ConnectionMeta as l, EventUnsubscribe as lt, RpcFunctionsHost as m, parseCliFlags as mt, DevtoolCliOptions as n, AgentResourceContent as nt, DevtoolSetupInfo as o, DevToolsAgentHost as ot, RpcBroadcastOptions as p, defineCliFlags as pt, JsonRenderSpec as q, DevtoolDefinition as r, AgentResourceInput as rt, DevtoolSpaOptions as s, DevToolsAgentHostEvents as st, DevtoolBrowserContext as t, AgentResource as tt, DevToolsCapabilities as u, EventsMap as ut, RpcStreamingChannelOptions as v, StreamReader as w, CreateStreamReaderOptions as x, RpcStreamingHost as y, DevToolsViewHost as z };