@nuxt/devtools-kit 4.0.0-alpha.1 → 4.0.0-alpha.10

package/dist/shared/{devtools-kit.f1VcjZlm.d.ts → devtools-kit.DepvFgru.d.ts}

@@ -1,15 +1,17 @@
+import { DevToolsMessageLevel, DevToolsMessageFilePosition, ViteDevToolsNodeContext } from '@vitejs/devtools-kit';
 import { VNode, MaybeRefOrGetter } from 'vue';
 import { BirpcGroup } from 'birpc';
-import { Component, NuxtOptions, NuxtPage, NuxtLayout, NuxtApp, NuxtDebugModuleMutationRecord, Nuxt } from 'nuxt/schema';
+import { Component, NuxtOptions, NuxtPage, NuxtLayout, NuxtApp, Nuxt, NuxtDebugModuleMutationRecord } from 'nuxt/schema';
 import { Import, UnimportMeta } from 'unimport';
 import { RouteRecordNormalized } from 'vue-router';
-import { Nitro, StorageMounts } from 'nitropack';
 import { StorageValue } from 'unstorage';
 import { ResolvedConfig } from 'vite';
 import { NuxtAnalyzeMeta } from '@nuxt/schema';
+import { Nitro as Nitro$1, StorageMounts as StorageMounts$1 } from 'nitro/types';
+import { Nitro, StorageMounts } from 'nitropack';
 import { SpawnOptions } from 'node:child_process';
 
-type TabCategory = 'pinned' | 'app' | 'vue-devtools' | 'analyze' | 'server' | 'modules' | 'documentation' | 'advanced';
+type TabCategory = 'pinned' | 'app' | 'analyze' | 'server' | 'modules' | 'documentation' | 'advanced';
 
 interface ModuleCustomTab {
     /**
@@ -129,6 +131,7 @@ interface ModuleBuiltinTab {
     title?: string;
     path?: string;
     category?: TabCategory;
+    defaultOrder?: number;
     show?: () => MaybeRefOrGetter<any>;
     badge?: () => MaybeRefOrGetter<number | string | undefined>;
     onClick?: () => void;
@@ -136,6 +139,51 @@ interface ModuleBuiltinTab {
 type ModuleTabInfo = ModuleCustomTab | ModuleBuiltinTab;
 type CategorizedTabs = [TabCategory, (ModuleCustomTab | ModuleBuiltinTab)[]][];
 
+/**
+ * Severity level of a notification, mirroring devframe's message levels.
+ *
+ * Determines the color/icon of the entry in the Vite DevTools **Messages** dock
+ * and its toast.
+ */
+type NuxtDevtoolsNotifyLevel = DevToolsMessageLevel;
+/**
+ * A Nuxt-friendly subset of devframe's `DevframeMessageEntryInput`.
+ *
+ * This is the input accepted by the `devtools:notify` Nuxt hook, the `notify`
+ * RPC function and the injected client's `notify()` — all of which forward to
+ * the connected `ctx.messages` host so notifications flow through the single
+ * devframe Messages system (persistent dock list + toast overlay).
+ *
+ * Tiers are expressed through the flags below:
+ * - **Ephemeral** (toast-only feedback like "Copied!"): `notify: true` with an
+ *   `autoDismiss` (toast lifetime) and `autoDelete` (entry lifetime) so it never
+ *   builds up history in the Messages dock.
+ * - **Persistent** (server-originated, leveled): omit `autoDelete` so the entry
+ *   is kept in the Messages dock list.
+ */
+interface NuxtDevtoolsNotifyInput {
+    /** Short title / summary of the message. */
+    message: string;
+    /** Severity level. Defaults to `'info'`. */
+    level?: NuxtDevtoolsNotifyLevel;
+    /** Optional detailed description or explanation. */
+    description?: string;
+    /** Optional tags/labels for filtering in the Messages dock. */
+    labels?: string[];
+    /** Optional grouping category (e.g. `'build'`, `'lint'`, `'runtime'`). */
+    category?: string;
+    /** Optional source file position (e.g. for a build/lint error). */
+    filePosition?: DevToolsMessageFilePosition;
+    /** Optional stack trace string. */
+    stacktrace?: string;
+    /** Whether this message should also appear as a transient toast. */
+    notify?: boolean;
+    /** Time in ms to auto-dismiss the toast (client-side). */
+    autoDismiss?: number;
+    /** Time in ms to auto-delete the entry from the persistent list (server-side). */
+    autoDelete?: number;
+}
+
 interface HookInfo {
     name: string;
     start: number;
@@ -337,13 +385,8 @@ interface ComponentWithRelationships {
     dependencies?: string[];
     dependents?: string[];
 }
-interface CodeServerOptions {
-    codeBinary: string;
-    launchArg: string;
-    licenseTermsArg: string;
-    connectionTokenArg: string;
-}
 
+/** @deprecated Part of the removed `vscode` integration. */
 type CodeServerType = 'ms-code-cli' | 'ms-code-server' | 'coder-code-server';
 interface ModuleOptions {
     /**
@@ -358,8 +401,12 @@ interface ModuleOptions {
      * This is in static format, for dynamic injection, call `nuxt.hook('devtools:customTabs')` instead
      */
     customTabs?: ModuleCustomTab[];
+    /** Code Server integration options. */
+    codeServer?: CodeServerIntegrationOptions;
     /**
-     * VS Code Server integration options.
+     * Legacy VS Code Server integration options.
+     *
+     * @deprecated Use `codeServer`. Legacy modes are no longer supported.
      */
     vscode?: VSCodeIntegrationOptions;
     /**
@@ -369,22 +416,25 @@ interface ModuleOptions {
      */
     componentInspector?: boolean;
     /**
-     * Enable Vue DevTools integration
-     */
-    vueDevTools?: boolean;
-    /**
-     * Enable vite-plugin-inspect
+     * Enable the Vite Inspect integration.
+     *
+     * `vite-plugin-inspect` is an optional peer dependency. When it isn't
+     * installed, DevTools shows an install launcher in its place (like Vite Plus
+     * DevTools); once installed, the real Inspect view is mounted. Set this to
+     * `false` to disable the integration (and its launcher) entirely.
      *
      * @default true
      */
     viteInspect?: boolean;
     /**
-     * Disable dev time authorization check.
+     * Disable the DevTools client authorization prompt, allowing any browser to
+     * connect without approving it first.
      *
-     * **NOT RECOMMENDED**, only use this if you know what you are doing.
+     * Defaults to `true` in sandboxed environments (StackBlitz, CodeSandbox).
      *
-     * @see https://github.com/nuxt/devtools/pull/257
-     * @default false
+     * Note: disabling authorization lets any browser (including other devices, if
+     * you expose the dev server to your LAN/WAN) connect to DevTools and access
+     * your server and filesystem. Only disable it in trusted environments.
      */
     disableAuthorization?: boolean;
     /**
@@ -446,6 +496,31 @@ interface ModuleOptions {
      */
     telemetry?: boolean;
 }
+interface CodeServerIntegrationOptions {
+    /**
+     * Enable the Code Server integration.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /** Path or command name for Coder's `code-server` binary. */
+    bin?: string;
+    /** Workspace opened by Code Server. Defaults to the Nuxt root directory. */
+    cwd?: string;
+    /** Port for the Code Server process. Defaults to the plugin's free-port behavior. */
+    serverPort?: number;
+    /** Host for the Code Server process. Defaults to the plugin's loopback host. */
+    host?: string;
+    /** Additional safe arguments passed to `code-server`. */
+    args?: string[];
+    /** Additional safe environment variables passed to `code-server`. */
+    env?: Record<string, string>;
+    /** Suffix used to isolate the authenticated Code Server session cookie. */
+    cookieSuffix?: string;
+    /** Milliseconds to wait for Code Server to become ready. */
+    startTimeout?: number;
+}
+/** @deprecated Use {@link CodeServerIntegrationOptions}. */
 interface VSCodeIntegrationOptions {
     /**
      * Enable VS Code Server integration
@@ -491,6 +566,7 @@ interface VSCodeIntegrationOptions {
      */
     host?: string;
 }
+/** @deprecated Tunnels are not supported by the Code Server integration. */
 interface VSCodeTunnelOptions {
     /**
      * the machine name for port forwarding service
@@ -513,13 +589,10 @@ interface NuxtDevToolsOptions {
         componentsView: 'list' | 'graph';
         hiddenTabCategories: string[];
         hiddenTabs: string[];
-        interactionCloseOnOutsideClick: boolean;
         pinnedTabs: string[];
         scale: number;
         showExperimentalFeatures: boolean;
         showHelpButtons: boolean;
-        sidebarExpanded: boolean;
-        sidebarScrollable: boolean;
     };
     serverRoutes: {
         selectedRoute: ServerRouteInfo | null;
@@ -551,56 +624,38 @@ interface AnalyzeBuildMeta extends NuxtAnalyzeMeta {
 }
 interface AnalyzeBuildsInfo {
     isBuilding: boolean;
-    builds: AnalyzeBuildMeta[];
-}
-
-interface TerminalBase {
-    id: string;
-    name: string;
-    description?: string;
-    icon?: string;
-}
-type TerminalAction = 'restart' | 'terminate' | 'clear' | 'remove';
-interface SubprocessOptions {
-    command: string;
-    args?: string[];
-    cwd?: string;
-    env?: Record<string, string | undefined>;
-    nodeOptions?: SpawnOptions;
-}
-interface TerminalInfo extends TerminalBase {
-    /**
-     * Whether the terminal can be restarted
-     */
-    restartable?: boolean;
-    /**
-     * Whether the terminal can be terminated
-     */
-    terminatable?: boolean;
-    /**
-     * Whether the terminal is terminated
-     */
-    isTerminated?: boolean;
-    /**
-     * Content buffer
-     */
-    buffer?: string;
-}
-interface TerminalState extends TerminalInfo {
     /**
-     * User action to restart the terminal, when not provided, this action will be disabled
+     * Unique id of the terminal session for the build currently in flight, or
+     * `undefined` when idle. The client reveals this session and derives its
+     * "Building…" state from it instead of an `onTerminalExit` broadcast.
      */
-    onActionRestart?: () => Promise<void> | void;
-    /**
-     * User action to terminate the terminal, when not provided, this action will be disabled
-     */
-    onActionTerminate?: () => Promise<void> | void;
+    activeSessionId?: string;
+    builds: AnalyzeBuildMeta[];
 }
 
+/**
+ * `nitropack` (Nitro v2) and `nitro` (Nitro v3) are both declared as *optional*
+ * peer dependencies, so a consumer only ever has one installed (Nuxt 4 →
+ * `nitropack`, Nuxt 5 → `nitro`). A missing peer resolves its `import type` to
+ * `any`, which would collapse a naive `V2 | V3` union to `any`. Detect which
+ * package actually resolved — `keyof any` matches every key, so probing an
+ * impossible `'___INVALID'` key tells a real Nitro type from the `any`
+ * fallback — and resolve to just that one. Mirrors `@nuxt/kit`'s own detection.
+ */
+type HasNitroV2 = 'options' extends keyof Nitro ? ('___INVALID' extends keyof Nitro ? false : true) : false;
+type HasNitroV3 = 'options' extends keyof Nitro$1 ? ('___INVALID' extends keyof Nitro$1 ? false : true) : false;
+type AnyNitro = HasNitroV2 extends true ? (HasNitroV3 extends true ? Nitro | Nitro$1 : Nitro) : Nitro$1;
+type AnyStorageMounts = HasNitroV2 extends true ? (HasNitroV3 extends true ? StorageMounts | StorageMounts$1 : StorageMounts) : StorageMounts$1;
+
 interface ServerFunctions {
     getServerConfig: () => NuxtOptions;
     getServerDebugContext: () => Promise<ServerDebugContext | undefined>;
-    getServerData: (token: string) => Promise<NuxtServerData>;
+    /**
+     * @deprecated Replaced by the Data Inspector panel's live `Nuxt Application`
+     * source. Kept as a compatibility shim (emits `NDT_DEP_0009`) for one
+     * migration window and will be removed in a future major.
+     */
+    getServerData: () => Promise<NuxtServerData>;
     getServerRuntimeConfig: () => Record<string, any>;
     getModuleOptions: () => ModuleOptions;
     getComponents: () => Component[];
@@ -619,53 +674,60 @@ interface ServerFunctions {
     clearOptions: () => Promise<void>;
     checkForUpdateFor: (name: string) => Promise<PackageUpdateInfo | undefined>;
     getNpmCommand: (command: NpmCommandType, packageName: string, options?: NpmCommandOptions) => Promise<string[] | undefined>;
-    runNpmCommand: (token: string, command: NpmCommandType, packageName: string, options?: NpmCommandOptions) => Promise<{
+    runNpmCommand: (command: NpmCommandType, packageName: string, options?: NpmCommandOptions) => Promise<{
         processId: string;
     } | undefined>;
-    getTerminals: () => TerminalInfo[];
-    getTerminalDetail: (token: string, id: string) => Promise<TerminalInfo | undefined>;
-    runTerminalAction: (token: string, id: string, action: TerminalAction) => Promise<boolean>;
-    getStorageMounts: () => Promise<StorageMounts>;
+    revealTerminal: (id: string) => Promise<boolean>;
+    getStorageMounts: () => Promise<AnyStorageMounts>;
     getStorageKeys: (base?: string) => Promise<string[]>;
-    getStorageItem: (token: string, key: string) => Promise<StorageValue>;
-    setStorageItem: (token: string, key: string, value: StorageValue) => Promise<void>;
-    removeStorageItem: (token: string, key: string) => Promise<void>;
+    getStorageItem: (key: string) => Promise<StorageValue>;
+    setStorageItem: (key: string, value: StorageValue) => Promise<void>;
+    removeStorageItem: (key: string) => Promise<void>;
     getAnalyzeBuildInfo: () => Promise<AnalyzeBuildsInfo>;
     generateAnalyzeBuildName: () => Promise<string>;
-    startAnalyzeBuild: (token: string, name: string) => Promise<string>;
-    clearAnalyzeBuilds: (token: string, names?: string[]) => Promise<void>;
-    getImageMeta: (token: string, filepath: string) => Promise<ImageMeta | undefined>;
-    getTextAssetContent: (token: string, filepath: string, limit?: number) => Promise<string | undefined>;
-    writeStaticAssets: (token: string, file: AssetEntry[], folder: string) => Promise<string[]>;
-    deleteStaticAsset: (token: string, filepath: string) => Promise<void>;
-    renameStaticAsset: (token: string, oldPath: string, newPath: string) => Promise<void>;
+    startAnalyzeBuild: (name: string) => Promise<string>;
+    clearAnalyzeBuilds: (names?: string[]) => Promise<void>;
+    getImageMeta: (filepath: string) => Promise<ImageMeta | undefined>;
+    getTextAssetContent: (filepath: string, limit?: number) => Promise<string | undefined>;
+    writeStaticAssets: (file: AssetEntry[], folder: string) => Promise<string[]>;
+    deleteStaticAsset: (filepath: string) => Promise<void>;
+    renameStaticAsset: (oldPath: string, newPath: string) => Promise<void>;
+    notify: (input: NuxtDevtoolsNotifyInput) => Promise<void>;
     telemetryEvent: (payload: object, immediate?: boolean) => void;
     customTabAction: (name: string, action: number) => Promise<boolean>;
-    enablePages: (token: string) => Promise<void>;
+    enablePages: () => Promise<void>;
     openInEditor: (filepath: string) => Promise<boolean>;
-    restartNuxt: (token: string, hard?: boolean) => Promise<void>;
-    installNuxtModule: (token: string, name: string, dry?: boolean) => Promise<InstallModuleReturn>;
-    uninstallNuxtModule: (token: string, name: string, dry?: boolean) => Promise<InstallModuleReturn>;
+    restartNuxt: (hard?: boolean) => Promise<void>;
+    installNuxtModule: (name: string, dry?: boolean, sessionId?: string) => Promise<InstallModuleReturn>;
+    uninstallNuxtModule: (name: string, dry?: boolean, sessionId?: string) => Promise<InstallModuleReturn>;
     enableTimeline: (dry: boolean) => Promise<[string, string]>;
     requestForAuth: (info?: string, origin?: string) => Promise<void>;
-    verifyAuthToken: (token: string) => Promise<boolean>;
+    verifyAuthToken: () => Promise<boolean>;
 }
 interface ClientFunctions {
     refresh: (event: ClientUpdateEvent) => void;
     callHook: (hook: string, ...args: any[]) => Promise<void>;
     navigateTo: (path: string) => void;
-    onTerminalData: (_: {
-        id: string;
-        data: string;
-    }) => void;
+    /**
+     * Minimal server→client completion signal for generic package updates only
+     * (`runNpmCommand`): the run RPC returns before the process exits, so this
+     * lets `usePackageUpdate` and the restart prompt settle once it finishes. It
+     * carries only `{ id, code }` and is not a terminal-data transport. Module
+     * install/uninstall and analyze-build no longer rely on it — they clear their
+     * UI from the awaited RPC / refreshed info instead.
+     */
     onTerminalExit: (_: {
         id: string;
         code?: number;
     }) => void;
 }
+/**
+ * @deprecated The payload of the deprecated {@link ServerFunctions.getServerData}
+ * shim. Use the Data Inspector panel's live `Nuxt Application` source instead.
+ */
 interface NuxtServerData {
     nuxt: NuxtOptions;
-    nitro?: Nitro['options'];
+    nitro?: AnyNitro['options'];
     vite: {
         server?: ResolvedConfig;
         client?: ResolvedConfig;
@@ -673,13 +735,44 @@ interface NuxtServerData {
 }
 type ClientUpdateEvent = keyof ServerFunctions;
 
+/**
+ * Legacy Nuxt DevTools RPC compatibility surface exposed on `nuxt.devtools.rpc`.
+ *
+ * For new integrations prefer {@link onDevtoolsReady}, where the connected
+ * `ViteDevToolsNodeContext` gives you the full devframe `ctx.rpc`
+ * (`register`/`invokeLocal`/`broadcast`/`sharedState`/…).
+ */
+interface NuxtDevtoolsRpc {
+    /**
+     * Broadcast proxy for calling client functions.
+     * Supports `rpc.broadcast.refresh.asEvent(event)` for backward compatibility.
+     */
+    broadcast: {
+        [K in keyof ClientFunctions]: ClientFunctions[K] & {
+            asEvent: ClientFunctions[K];
+        };
+    };
+    /**
+     * Proxy for reading/writing server functions locally.
+     */
+    functions: ServerFunctions;
+}
 /**
  * @internal
  */
 interface NuxtDevtoolsServerContext {
     nuxt: Nuxt;
     options: ModuleOptions;
-    rpc: BirpcGroup<ClientFunctions, ServerFunctions>;
+    rpc: NuxtDevtoolsRpc;
+    /**
+     * The connected Vite DevTools kit context (`docks`/`terminals`/`messages`/
+     * `commands`/`rpc`/`diagnostics`/…).
+     *
+     * This is the raw escape hatch and is `undefined` until the Vite DevTools
+     * plugin connects. Prefer {@link onDevtoolsReady}, which hands you the
+     * connected context.
+     */
+    devtoolsKit: ViteDevToolsNodeContext | undefined;
     /**
      * Hook to open file in editor
      */
@@ -689,9 +782,18 @@ interface NuxtDevtoolsServerContext {
      */
     refresh: (event: keyof ServerFunctions) => void;
     /**
-     * Ensure dev auth token is valid, throw if not
+     * Push a notification through the devframe Messages system (`ctx.messages`).
+     *
+     * The connected messages host surfaces it in the Vite DevTools **Messages**
+     * dock and/or as a toast. Calls made before the kit connects are buffered and
+     * replayed on connect. Used by the `devtools:notify` hook, the `notify` RPC
+     * function and the curated built-in notification sources.
+     */
+    notify: (input: NuxtDevtoolsNotifyInput) => void;
+    /**
+     * @deprecated Use the Vite DevTools RPC registration instead:
+     * `nuxt.devtools.rpc.register(defineRpcFunction(...))`. Kept working as a shim.
      */
-    ensureDevAuthToken: (token: string) => Promise<void>;
     extendServerRpc: <ClientFunctions extends object = Record<string, unknown>, ServerFunctions extends object = Record<string, unknown>>(name: string, functions: ServerFunctions) => BirpcGroup<ClientFunctions, ServerFunctions>;
 }
 interface NuxtDevtoolsInfo {
@@ -711,6 +813,64 @@ interface ServerDebugContext {
     moduleMutationRecords: ServerDebugModuleMutationRecord[];
 }
 
+interface TerminalBase {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+}
+type TerminalAction = 'restart' | 'terminate' | 'clear' | 'remove';
+interface SubprocessOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    nodeOptions?: SpawnOptions;
+}
+interface TerminalInfo extends TerminalBase {
+    /**
+     * Whether the terminal can be restarted.
+     *
+     * @deprecated Ignored since v4: legacy terminals are bridged onto the built-in
+     * Terminals dock as read-only, output-only sessions, so Devframe shows no
+     * restart control. Restart a `startSubprocess()`-owned process through its
+     * returned handle instead. Will be removed in v5.
+     */
+    restartable?: boolean;
+    /**
+     * Whether the terminal can be terminated.
+     *
+     * @deprecated Ignored since v4 (see {@link TerminalInfo.restartable}). Will be
+     * removed in v5.
+     */
+    terminatable?: boolean;
+    /**
+     * Whether the terminal is terminated
+     */
+    isTerminated?: boolean;
+    /**
+     * Content buffer
+     */
+    buffer?: string;
+}
+interface TerminalState extends TerminalInfo {
+    /**
+     * User action to restart the terminal, when not provided, this action will be disabled.
+     *
+     * @deprecated Ignored since v4: the bridge to the built-in Terminals dock
+     * cannot attach action callbacks to an externally registered session. Will be
+     * removed in v5.
+     */
+    onActionRestart?: () => Promise<void> | void;
+    /**
+     * User action to terminate the terminal, when not provided, this action will be disabled.
+     *
+     * @deprecated Ignored since v4 (see {@link TerminalState.onActionRestart}).
+     * Will be removed in v5.
+     */
+    onActionTerminate?: () => Promise<void> | void;
+}
+
 declare module '@nuxt/schema' {
     interface NuxtHooks {
         /**
@@ -721,6 +881,30 @@ declare module '@nuxt/schema' {
          * Called after devtools is initialized.
          */
         'devtools:initialized': (info: NuxtDevtoolsInfo) => void;
+        /**
+         * Called once the Vite DevTools kit has connected, with the connected
+         * `ViteDevToolsNodeContext`.
+         *
+         * This is the recommended place to do all DevTools integration
+         * (registering docks, terminals, messages, commands, RPC functions,
+         * diagnostics, …): the kit is guaranteed to be available here, so you don't
+         * need the connect-safe accessors on `nuxt.devtools`.
+         */
+        'devtools:ready': (ctx: ViteDevToolsNodeContext) => void | Promise<void>;
+        /**
+         * Push a notification through the devframe Messages system.
+         *
+         * Forwarded to the connected `ctx.messages` host, so it surfaces in the
+         * Vite DevTools **Messages** dock (persistent, when leveled) and/or as a
+         * transient toast (when `notify` is set). Calls made before the kit connects
+         * are buffered and replayed once it does.
+         *
+         * @example
+         * ```ts
+         * nuxt.callHook('devtools:notify', { message: 'Build failed', level: 'error' })
+         * ```
+         */
+        'devtools:notify': (input: NuxtDevtoolsNotifyInput) => void;
         /**
          * Hooks to extend devtools tabs.
          */
@@ -730,7 +914,11 @@ declare module '@nuxt/schema' {
          */
         'devtools:customTabs:refresh': () => void;
         /**
-         * Register a terminal.
+         * Register a terminal whose process is owned by the caller (module).
+         *
+         * The registered session is surfaced **read-only** in the built-in Vite
+         * DevTools **Terminals** dock; stream output into it via
+         * `devtools:terminal:write`.
          */
         'devtools:terminal:register': (terminal: TerminalState) => void;
         /**
@@ -759,19 +947,5 @@ declare module '@nuxt/schema' {
         }) => void;
     }
 }
-declare module '@nuxt/schema' {
-    /**
-     * Runtime Hooks
-     */
-    interface RuntimeNuxtHooks {
-        /**
-         * On terminal data.
-         */
-        'devtools:terminal:data': (payload: {
-            id: string;
-            data: string;
-        }) => void;
-    }
-}
 
-export type { ServerDebugContext as $, AnalyzeBuildMeta as A, BasicModuleInfo as B, ClientFunctions as C, ModuleTabInfo as D, ModuleType as E, ModuleVNodeView as F, GitHubContributor as G, HookInfo as H, ImageMeta as I, ModuleView as J, NpmCommandOptions as K, LoadingTimeMetric as L, ModuleCustomTab as M, NuxtDevtoolsInfo as N, NpmCommandType as O, PluginMetric as P, NuxtDevToolsOptions as Q, NuxtDevtoolsServerContext as R, SubprocessOptions as S, TerminalState as T, NuxtServerData as U, PackageManagerName as V, PackageUpdateInfo as W, Payload as X, PluginInfoWithMetic as Y, RouteInfo as Z, ScannedNitroTasks as _, ServerFunctions as a, ServerDebugModuleMutationRecord as a0, ServerRouteInfo as a1, ServerRouteInput as a2, ServerRouteInputType as a3, ServerTaskInfo as a4, TabCategory as a5, TerminalAction as a6, TerminalBase as a7, TerminalInfo as a8, VSCodeIntegrationOptions as a9, VSCodeTunnelOptions as aa, VueInspectorClient as ab, VueInspectorData as ac, AnalyzeBuildsInfo as b, AssetEntry as c, AssetInfo as d, AssetType as e, AutoImportsWithMetadata as f, CategorizedTabs as g, ClientUpdateEvent as h, CodeServerOptions as i, CodeServerType as j, CodeSnippet as k, CompatibilityStatus as l, ComponentRelationship as m, ComponentWithRelationships as n, InstallModuleReturn as o, InstalledModuleInfo as p, MaintainerInfo as q, ModuleBuiltinTab as r, ModuleCompatibility as s, ModuleIframeTabLazyOptions as t, ModuleIframeView as u, ModuleLaunchAction as v, ModuleLaunchView as w, ModuleOptions as x, ModuleStaticInfo as y, ModuleStats as z };
+export type { PluginInfoWithMetic as $, AnalyzeBuildMeta as A, BasicModuleInfo as B, CategorizedTabs as C, ModuleStaticInfo as D, ModuleStats as E, ModuleTabInfo as F, GitHubContributor as G, HookInfo as H, ImageMeta as I, ModuleType as J, ModuleVNodeView as K, LoadingTimeMetric as L, ModuleCustomTab as M, NuxtDevtoolsServerContext as N, ModuleView as O, PluginMetric as P, NpmCommandOptions as Q, NpmCommandType as R, SubprocessOptions as S, TerminalState as T, NuxtDevToolsOptions as U, NuxtDevtoolsNotifyLevel as V, NuxtDevtoolsRpc as W, NuxtServerData as X, PackageManagerName as Y, PackageUpdateInfo as Z, Payload as _, NuxtDevtoolsInfo as a, RouteInfo as a0, ScannedNitroTasks as a1, ServerDebugContext as a2, ServerDebugModuleMutationRecord as a3, ServerRouteInfo as a4, ServerRouteInput as a5, ServerRouteInputType as a6, ServerTaskInfo as a7, TabCategory as a8, TerminalAction as a9, TerminalBase as aa, TerminalInfo as ab, VSCodeIntegrationOptions as ac, VSCodeTunnelOptions as ad, VueInspectorClient as ae, VueInspectorData as af, ServerFunctions as b, NuxtDevtoolsNotifyInput as c, AnalyzeBuildsInfo as d, AssetEntry as e, AssetInfo as f, AssetType as g, AutoImportsWithMetadata as h, ClientFunctions as i, ClientUpdateEvent as j, CodeServerIntegrationOptions as k, CodeServerType as l, CodeSnippet as m, CompatibilityStatus as n, ComponentRelationship as o, ComponentWithRelationships as p, InstallModuleReturn as q, InstalledModuleInfo as r, MaintainerInfo as s, ModuleBuiltinTab as t, ModuleCompatibility as u, ModuleIframeTabLazyOptions as v, ModuleIframeView as w, ModuleLaunchAction as x, ModuleLaunchView as y, ModuleOptions as z };

package/dist/types.d.cts

@@ -1,6 +1,6 @@
-import { a as ServerFunctions, C as ClientFunctions, H as HookInfo, P as PluginMetric, L as LoadingTimeMetric } from './shared/devtools-kit.f1VcjZlm.cjs';
-export { A as AnalyzeBuildMeta, b as AnalyzeBuildsInfo, c as AssetEntry, d as AssetInfo, e as AssetType, f as AutoImportsWithMetadata, B as BasicModuleInfo, g as CategorizedTabs, h as ClientUpdateEvent, i as CodeServerOptions, j as CodeServerType, k as CodeSnippet, l as CompatibilityStatus, m as ComponentRelationship, n as ComponentWithRelationships, G as GitHubContributor, I as ImageMeta, o as InstallModuleReturn, p as InstalledModuleInfo, q as MaintainerInfo, r as ModuleBuiltinTab, s as ModuleCompatibility, M as ModuleCustomTab, t as ModuleIframeTabLazyOptions, u as ModuleIframeView, v as ModuleLaunchAction, w as ModuleLaunchView, x as ModuleOptions, y as ModuleStaticInfo, z as ModuleStats, D as ModuleTabInfo, E as ModuleType, F as ModuleVNodeView, J as ModuleView, K as NpmCommandOptions, O as NpmCommandType, Q as NuxtDevToolsOptions, N as NuxtDevtoolsInfo, R as NuxtDevtoolsServerContext, U as NuxtServerData, V as PackageManagerName, W as PackageUpdateInfo, X as Payload, Y as PluginInfoWithMetic, Z as RouteInfo, _ as ScannedNitroTasks, $ as ServerDebugContext, a0 as ServerDebugModuleMutationRecord, a1 as ServerRouteInfo, a2 as ServerRouteInput, a3 as ServerRouteInputType, a4 as ServerTaskInfo, S as SubprocessOptions, a5 as TabCategory, a6 as TerminalAction, a7 as TerminalBase, a8 as TerminalInfo, T as TerminalState, a9 as VSCodeIntegrationOptions, aa as VSCodeTunnelOptions, ab as VueInspectorClient, ac as VueInspectorData } from './shared/devtools-kit.f1VcjZlm.cjs';
-import { BirpcReturn } from 'birpc';
+import { b as ServerFunctions, c as NuxtDevtoolsNotifyInput, H as HookInfo, P as PluginMetric, L as LoadingTimeMetric } from './shared/devtools-kit.DepvFgru.cjs';
+export { A as AnalyzeBuildMeta, d as AnalyzeBuildsInfo, e as AssetEntry, f as AssetInfo, g as AssetType, h as AutoImportsWithMetadata, B as BasicModuleInfo, C as CategorizedTabs, i as ClientFunctions, j as ClientUpdateEvent, k as CodeServerIntegrationOptions, l as CodeServerType, m as CodeSnippet, n as CompatibilityStatus, o as ComponentRelationship, p as ComponentWithRelationships, G as GitHubContributor, I as ImageMeta, q as InstallModuleReturn, r as InstalledModuleInfo, s as MaintainerInfo, t as ModuleBuiltinTab, u as ModuleCompatibility, M as ModuleCustomTab, v as ModuleIframeTabLazyOptions, w as ModuleIframeView, x as ModuleLaunchAction, y as ModuleLaunchView, z as ModuleOptions, D as ModuleStaticInfo, E as ModuleStats, F as ModuleTabInfo, J as ModuleType, K as ModuleVNodeView, O as ModuleView, Q as NpmCommandOptions, R as NpmCommandType, U as NuxtDevToolsOptions, a as NuxtDevtoolsInfo, V as NuxtDevtoolsNotifyLevel, W as NuxtDevtoolsRpc, N as NuxtDevtoolsServerContext, X as NuxtServerData, Y as PackageManagerName, Z as PackageUpdateInfo, _ as Payload, $ as PluginInfoWithMetic, a0 as RouteInfo, a1 as ScannedNitroTasks, a2 as ServerDebugContext, a3 as ServerDebugModuleMutationRecord, a4 as ServerRouteInfo, a5 as ServerRouteInput, a6 as ServerRouteInputType, a7 as ServerTaskInfo, S as SubprocessOptions, a8 as TabCategory, a9 as TerminalAction, aa as TerminalBase, ab as TerminalInfo, T as TerminalState, ac as VSCodeIntegrationOptions, ad as VSCodeTunnelOptions, ae as VueInspectorClient, af as VueInspectorData } from './shared/devtools-kit.DepvFgru.cjs';
+import { DevToolsRpcClient } from '@vitejs/devtools-kit/client';
 import { Hookable } from 'hookable';
 import { NuxtApp } from 'nuxt/app';
 import { AppConfig } from 'nuxt/schema';
@@ -8,12 +8,15 @@ import { $Fetch } from 'ofetch';
 import { BuiltinLanguage } from 'shiki';
 import { Ref } from 'vue';
 import { StackFrame } from 'error-stack-parser-es';
+import '@vitejs/devtools-kit';
+import 'birpc';
 import 'unimport';
 import 'vue-router';
-import 'nitropack';
 import 'unstorage';
 import 'vite';
 import '@nuxt/schema';
+import 'nitro/types';
+import 'nitropack';
 import 'node:child_process';
 
 interface TimelineEventFunction {
@@ -149,15 +152,41 @@ interface NuxtDevtoolsHostClient {
 interface CodeHighlightOptions {
     grammarContextCode?: string;
 }
+type AsyncServerFunctions = {
+    [K in keyof ServerFunctions]: (...args: Parameters<ServerFunctions[K]>) => Promise<Awaited<ReturnType<ServerFunctions[K]>>>;
+};
 interface NuxtDevtoolsClient {
-    rpc: BirpcReturn<ServerFunctions, ClientFunctions>;
+    rpc: AsyncServerFunctions;
     renderCodeHighlight: (code: string, lang?: BuiltinLanguage, options?: CodeHighlightOptions) => {
         code: string;
         supported: boolean;
     };
     renderMarkdown: (markdown: string) => string;
     colorMode: string;
-    extendClientRpc: <ServerFunctions extends object = Record<string, unknown>, ClientFunctions extends object = Record<string, unknown>>(name: string, functions: ClientFunctions) => BirpcReturn<ServerFunctions, ClientFunctions>;
+    /**
+     * Push a notification through the devframe Messages system.
+     *
+     * Routes to the shared Messages host, so it surfaces in the Vite DevTools
+     * **Messages** dock and/or as a transient toast (when `notify` is set — the
+     * default). Use this from custom tabs / in-client code to give feedback
+     * through the same notification system as the rest of DevTools.
+     */
+    notify: (input: NuxtDevtoolsNotifyInput) => Promise<void>;
+    /**
+     * The connected Vite DevTools RPC client, mirroring `nuxt.devtools.devtoolsKit`
+     * on the server. Use it for full devframe-native access — register client RPC
+     * functions (`devtoolsKit.client.register(...)`), call server functions
+     * (`devtoolsKit.call(...)`), shared state, streaming, scoping, etc.
+     *
+     * `undefined` until the DevTools client has connected.
+     */
+    devtoolsKit: DevToolsRpcClient | undefined;
+    /**
+     * @deprecated Use `onDevtoolsReady((kit) => kit.client.register(...))` from
+     * `@nuxt/devtools-kit/iframe-client`, or the exposed `devtoolsKit` client
+     * directly (`client.devtools.devtoolsKit?.client.register(...)`).
+     */
+    extendClientRpc: <ServerFunctions extends object = Record<string, unknown>, ClientFunctions extends object = Record<string, unknown>>(name: string, functions: ClientFunctions) => ServerFunctions;
 }
 interface NuxtDevtoolsIframeClient {
     host: NuxtDevtoolsHostClient;
@@ -167,5 +196,5 @@ interface NuxtDevtoolsGlobal {
     setClient: (client: NuxtDevtoolsHostClient) => void;
 }
 
-export { ClientFunctions, HookInfo, LoadingTimeMetric, PluginMetric, ServerFunctions };
-export type { CodeHighlightOptions, DevToolsFrameState, NuxtDevtoolsClient, NuxtDevtoolsClientHooks, NuxtDevtoolsGlobal, NuxtDevtoolsHostClient, NuxtDevtoolsIframeClient, TimelineEvent, TimelineEventFunction, TimelineEventNormalized, TimelineEventRoute, TimelineEventsSegment, TimelineMetrics, TimelineOptions, TimelineServerState };
+export { HookInfo, LoadingTimeMetric, NuxtDevtoolsNotifyInput, PluginMetric, ServerFunctions };
+export type { AsyncServerFunctions, CodeHighlightOptions, DevToolsFrameState, NuxtDevtoolsClient, NuxtDevtoolsClientHooks, NuxtDevtoolsGlobal, NuxtDevtoolsHostClient, NuxtDevtoolsIframeClient, TimelineEvent, TimelineEventFunction, TimelineEventNormalized, TimelineEventRoute, TimelineEventsSegment, TimelineMetrics, TimelineOptions, TimelineServerState };