@nuxt/devtools-kit-nightly 3.2.4-29563355.8807be5 → 4.0.0-29884714.dcb247f

package/README.md

@@ -24,15 +24,15 @@ Unleash Nuxt Developer Experience.
 </p>
 
 > [!NOTE]
-> You are current at the `main` branch for v4 development. The latest stable branch is [`v3`](https://github.com/nuxt/devtools/tree/v3).
+> You are at the `main` branch for v4. The v3 branch is [`v3`](https://github.com/nuxt/devtools/tree/v3).
 
 <br>
 
 ## Installation
 
-> Nuxt DevTools v2 requires **Nuxt v3.15.0 or higher**.
+> Nuxt DevTools v4 requires **Nuxt v4.5.0 or higher** (Vite 8). It is built on [Vite DevTools](https://github.com/vitejs/devtools) and shows up as the `Nuxt` group inside the Vite DevTools panel.
 
-Nuxt DevTools is **enabled by default** in Nuxt v3.8.0. You can press <kbd>Shift</kbd> + <kbd>Alt</kbd> / <kbd>⇧ Shift</kbd> + <kbd>⌥ Option</kbd> + <kbd>D</kbd> in your app to open it up.
+Nuxt DevTools is **enabled by default**. You can press <kbd>Shift</kbd> + <kbd>Alt</kbd> / <kbd>⇧ Shift</kbd> + <kbd>⌥ Option</kbd> + <kbd>D</kbd> in your app to open it up.
 
 If you want to explicitly enable or disable Nuxt DevTools, you can update your `nuxt.config` with:
 
@@ -44,21 +44,57 @@ export default defineNuxtConfig({
 })
 ```
 
+### Nuxt 4
+
+Nuxt 5 ships with Nuxt DevTools v4. Nuxt 4.5+ still bundles v3; override `@nuxt/devtools` to `^4.0.0` with your package manager (`overrides` for npm and pnpm, `resolutions` for yarn), remove your lockfile and reinstall. See the [upgrade guide](https://devtools.nuxt.com/guide/upgrading-to-v4) for details and for what changed.
+
 ### Nightly Release Channel
 
 Similar to [Nuxt's Nightly Channel](https://nuxt.com/docs/guide/going-further/nightly-release-channel), DevTools also offers a nightly release channel, that automatically releases for every commit to `main` branch.
 
-You can opt-in to the nightly release channel by running:
+You can opt-in to the nightly release channel by using package manager resolutions:
+
+<details>
+<summary>npm</summary>
+
+```json
+{
+  "overrides": {
+    "@nuxt/devtools": "npm:@nuxt/devtools-nightly@latest"
+  }
+}
+```
+
+</details>
+
+<details>
+<summary>yarn</summary>
 
-```diff
+```json
 {
-  "devDependencies": {
---    "@nuxt/devtools": "^0.1.0"
-++    "@nuxt/devtools": "npm:@nuxt/devtools-nightly@latest"
+  "resolutions": {
+    "@nuxt/devtools": "npm:@nuxt/devtools-nightly@latest"
   }
 }
 ```
 
+</details>
+
+<details>
+<summary>pnpm</summary>
+
+```json
+{
+  "pnpm": {
+    "overrides": {
+      "@nuxt/devtools": "npm:@nuxt/devtools-nightly@latest"
+    }
+  }
+}
+```
+
+</details>
+
 Remove lockfile (`package-lock.json`, `yarn.lock`, or `pnpm-lock.yaml`) and reinstall dependencies.
 
 ### Module Options
@@ -71,8 +107,8 @@ export default defineNuxtConfig({
   devtools: {
     // Enable devtools (default: true)
     enabled: true,
-    // VS Code Server options
-    vscode: {},
+    // Coder code-server options (enabled by default)
+    codeServer: {},
     // ...other options
   }
 })
@@ -98,6 +134,8 @@ Nuxt DevTools collects anonymous telemetry data about general usage. This helps
 
 Nuxt DevTools' telemetry data is piped through [Nuxt Telemetry](https://github.com/nuxt/telemetry), meaning that Nuxt DevTools will respect your local and global Nuxt Telemetry settings. You can also opt-out Nuxt DevTools' telemetry in the Nuxt DevTools settings.
 
+Nuxt DevTools also respects the [`DO_NOT_TRACK`](https://donottrack.sh/) environment variable convention — set `DO_NOT_TRACK=1` in your environment to disable Nuxt DevTools telemetry regardless of any other setting.
+
 The data we collect is completely anonymous, not traceable to the source (using hash+seed), and only meaningful in aggregate form. No data we collect is personally identifiable or trackable.
 
 ### Events

package/dist/index.d.mts

@@ -1,38 +1,277 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { ViteDevToolsNodeContext } from '@vitejs/devtools-kit';
 import { BirpcGroup } from 'birpc';
 import { ChildProcess } from 'node:child_process';
 import { Result } from 'tinyexec';
-import { M as ModuleCustomTab, N as NuxtDevtoolsInfo, S as SubprocessOptions, T as TerminalState } from './shared/devtools-kit-nightly.f1VcjZlm.mjs';
+import { NuxtDevtoolsServerContext, ModuleCustomTab, NuxtDevtoolsInfo, SubprocessOptions, TerminalState } from './types.mjs';
+import * as nostics from 'nostics';
+import { defineDiagnostics } from 'nostics';
+export { createConsoleReporter, defineDiagnostics } from 'nostics';
+import { Nuxt } from 'nuxt/schema';
 import 'vue';
-import 'nuxt/schema';
 import 'unimport';
 import 'vue-router';
-import 'nitropack';
 import 'unstorage';
 import 'vite';
+import 'nitro/types';
+import 'nitropack';
+
+/**
+ * Canonical docs URL for a Nuxt DevTools diagnostic code.
+ *
+ * Each code links to a per-code anchor in the v4 migration guide, e.g.
+ * `NDT_DEP_0001` → `.../module/migration-v4#ndt_dep_0001`.
+ */
+declare function diagnosticsDocsBase(code: string | number): string;
+/**
+ * Parameters shared by every deprecation code: the API being used and its
+ * recommended replacement. Interpolated into the `why`/`fix` messages.
+ */
+interface DeprecationParams {
+    /** The deprecated API / option being used. */
+    api: string;
+    /** The recommended replacement to migrate to. */
+    replacement: string;
+}
+/**
+ * The Nuxt DevTools diagnostics catalog.
+ *
+ * Codes are grouped by prefix:
+ * - `NDT_DEP_xxxx` — soft/hard deprecations (this is the only range used today).
+ *
+ * Severity is **not** encoded here; it is chosen per emission via the reporter
+ * `method` (`warn` by default, `error` for hard breaks).
+ */
+declare const diagnosticCodes: {
+    /** `startSubprocess().getProcess()` → `getResult()`. */
+    NDT_DEP_0001: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `extendServerRpc` → `onDevtoolsReady((ctx) => ctx.rpc.register(...))`. */
+    NDT_DEP_0003: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `startSubprocess` → `onDevtoolsReady((ctx) => ctx.terminals.startChildProcess(...))`. */
+    NDT_DEP_0004: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `addCustomTab` → `onDevtoolsReady((ctx) => ctx.docks.register(...))`. */
+    NDT_DEP_0005: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `refreshCustomTabs` → `onDevtoolsReady((ctx) => ctx.docks.register(...))`. */
+    NDT_DEP_0006: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** Direct `nuxt.devtools.rpc` access (`broadcast` / `functions`). */
+    NDT_DEP_0007: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** Removed `vscode` module option → `codeServer`. */
+    NDT_DEP_0008: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `getServerData()` RPC → the Data Inspector panel's `Nuxt Application` source. */
+    NDT_DEP_0009: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+};
+type NuxtDiagnosticCode = keyof typeof diagnosticCodes;
+/**
+ * Standalone catalog that prints to the terminal via nostics'
+ * {@link createConsoleReporter} (default method `warn`). Works before the Vite
+ * DevTools kit connects, so it is the fallback sink for pre-connect emissions.
+ */
+declare const consoleDiagnostics: nostics.Diagnostics<{
+    /** `startSubprocess().getProcess()` → `getResult()`. */
+    NDT_DEP_0001: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `extendServerRpc` → `onDevtoolsReady((ctx) => ctx.rpc.register(...))`. */
+    NDT_DEP_0003: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `startSubprocess` → `onDevtoolsReady((ctx) => ctx.terminals.startChildProcess(...))`. */
+    NDT_DEP_0004: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `addCustomTab` → `onDevtoolsReady((ctx) => ctx.docks.register(...))`. */
+    NDT_DEP_0005: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `refreshCustomTabs` → `onDevtoolsReady((ctx) => ctx.docks.register(...))`. */
+    NDT_DEP_0006: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** Direct `nuxt.devtools.rpc` access (`broadcast` / `functions`). */
+    NDT_DEP_0007: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** Removed `vscode` module option → `codeServer`. */
+    NDT_DEP_0008: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+    /** `getServerData()` RPC → the Data Inspector panel's `Nuxt Application` source. */
+    NDT_DEP_0009: {
+        why: (p: DeprecationParams) => string;
+        fix: (p: DeprecationParams) => string;
+    };
+}, readonly [nostics.DiagnosticReporter<{
+    method?: nostics.ConsoleMethod;
+}, any>], never>;
+/**
+ * Register the Nuxt deprecation codes into the connected Vite DevTools kit's
+ * diagnostics host so they are known to DevTools and post-connect emissions
+ * surface in the DevTools diagnostics UI. Safe to call when no host is present.
+ *
+ * Called from `connectDevToolsKit`.
+ */
+declare function registerHostDiagnostics(ctx: NuxtDevtoolsServerContext): void;
+/**
+ * Options for {@link deprecate}.
+ */
+interface DeprecateOptions {
+    /**
+     * Dedupe key appended to the code. Defaults to the code itself, i.e. the
+     * deprecation warns once per process. Pass a finer key (e.g. a subprocess id)
+     * to warn once per distinct call site instead.
+     */
+    key?: string;
+    /**
+     * Reporter method / severity. `warn` (default) for soft deprecations, `error`
+     * for hard breaks. The returned {@link Diagnostic} can be thrown to abort.
+     */
+    method?: 'warn' | 'error';
+}
+/**
+ * Emit a Nuxt DevTools deprecation diagnostic.
+ *
+ * Routing: when the Vite DevTools kit is connected the emission goes through the
+ * DevTools host catalog (terminal **and** the DevTools diagnostics UI); before
+ * connect it falls back to the terminal-only console catalog. A single emission
+ * per call — no double printing.
+ *
+ * Deduped per `${code}:${key ?? code}` on the resolved server context, so a hot
+ * path warns only once.
+ *
+ * @returns the built `Diagnostic` (which extends `Error`, so it can be thrown
+ * for hard breaks), or `undefined` if the emission was deduped.
+ */
+declare function deprecate(nuxt: Nuxt, code: NuxtDiagnosticCode, params: DeprecationParams, options?: DeprecateOptions): Error | undefined;
+/**
+ * Build a standalone nostics catalog that prints to the terminal.
+ *
+ * Used by the connect-safe `nuxt.devtools.diagnostics` accessor so module
+ * authors can define + emit diagnostics before the Vite DevTools kit connects.
+ * A `createConsoleReporter()` is added automatically unless the caller supplies
+ * its own `reporters`.
+ */
+declare function defineStandaloneDiagnostics(options: Parameters<typeof defineDiagnostics>[0]): ReturnType<typeof defineDiagnostics>;
+/**
+ * Convenience wrapper for call sites that don't already hold the Nuxt instance.
+ */
+declare function deprecateWithNuxt(code: NuxtDiagnosticCode, params: DeprecationParams, options?: DeprecateOptions): Error | undefined;
 
+/**
+ * The public `Nuxt` dock group id registered on the Vite DevTools framework
+ * category. Module authors join the group natively by pointing their own
+ * dock entries at it — no special Nuxt API required:
+ *
+ * @example
+ * ```ts
+ * import { NUXT_DEVTOOLS_GROUP_ID, onDevtoolsReady } from '@nuxt/devtools-kit'
+ *
+ * onDevtoolsReady((ctx) => {
+ *   ctx.docks.register({
+ *     id: 'my-module',
+ *     type: 'iframe',
+ *     title: 'My Module',
+ *     icon: 'i-ph-puzzle-piece',
+ *     url: '/my-module/',
+ *     groupId: NUXT_DEVTOOLS_GROUP_ID,
+ *   })
+ * })
+ * ```
+ */
+declare const NUXT_DEVTOOLS_GROUP_ID = "nuxt";
 /**
  * Hooks to extend a custom tab in devtools.
  *
  * Provide a function to pass a factory that can be updated dynamically.
+ *
+ * @deprecated Register a dock entry from the `devtools:ready` hook instead:
+ * `onDevtoolsReady((ctx) => ctx.docks.register(...))`. Still works as a shim, but
+ * emits the `NDT_DEP_0005` deprecation diagnostic. Note the docks host does not
+ * yet cover `vnode` views or tab categories.
  */
 declare function addCustomTab(tab: ModuleCustomTab | (() => ModuleCustomTab | Promise<ModuleCustomTab>), nuxt?: _nuxt_schema.Nuxt): void;
 /**
  * Retrigger update for custom tabs, `devtools:customTabs` will be called again.
+ *
+ * @deprecated Update dock entries directly via the handle returned by
+ * `ctx.docks.register(...)` inside the `devtools:ready` hook. Still works as a
+ * shim, but emits the `NDT_DEP_0006` deprecation diagnostic.
  */
 declare function refreshCustomTabs(nuxt?: _nuxt_schema.Nuxt): void | Promise<any>;
-/**
- * Create a subprocess that handled by the DevTools.
- */
-declare function startSubprocess(execaOptions: SubprocessOptions, tabOptions: TerminalState, nuxt?: _nuxt_schema.Nuxt): {
+interface StartSubprocessReturn {
     /** @deprecated Use `getResult()` instead */
     getProcess: () => ChildProcess | undefined;
     getResult: () => Result;
     terminate: () => void;
     restart: () => void;
     clear: () => void;
-};
+}
+/**
+ * Create a subprocess that handled by the DevTools.
+ *
+ * @deprecated Use the Vite DevTools terminals host from the `devtools:ready`
+ * hook instead: `onDevtoolsReady((ctx) => ctx.terminals.startChildProcess(...))`.
+ * Still works as a shim, but emits the `NDT_DEP_0004` deprecation diagnostic.
+ */
+declare function startSubprocess(execaOptions: SubprocessOptions, tabOptions: TerminalState, nuxt?: _nuxt_schema.Nuxt): StartSubprocessReturn;
+/**
+ * Extend server RPC with namespaced functions.
+ *
+ * Returns an object with a `broadcast` proxy for calling client functions.
+ *
+ * @deprecated Register RPC functions from the `devtools:ready` hook instead:
+ * `onDevtoolsReady((ctx) => ctx.rpc.register(defineRpcFunction(...)))`. Still
+ * works as a shim, but emits the `NDT_DEP_0003` deprecation diagnostic.
+ */
 declare function extendServerRpc<ClientFunctions extends object = Record<string, unknown>, ServerFunctions extends object = Record<string, unknown>>(namespace: string, functions: ServerFunctions, nuxt?: _nuxt_schema.Nuxt): BirpcGroup<ClientFunctions, ServerFunctions>;
 declare function onDevToolsInitialized(fn: (info: NuxtDevtoolsInfo) => void, nuxt?: _nuxt_schema.Nuxt): void;
+/**
+ * Run a callback once the Vite DevTools kit has connected, receiving the
+ * connected `ViteDevToolsNodeContext`.
+ *
+ * This is the recommended entry point for DevTools integration: the kit is
+ * guaranteed available, so you can use `ctx.docks` / `ctx.terminals` /
+ * `ctx.messages` / `ctx.commands` / `ctx.rpc` / `ctx.diagnostics` directly
+ * without the connect-safe accessors on `nuxt.devtools`.
+ *
+ * @example
+ * ```ts
+ * onDevtoolsReady((ctx) => {
+ *   ctx.docks.register({ id: 'my-module', title: 'My Module', type: 'iframe', url: '/…' })
+ * })
+ * ```
+ */
+declare function onDevtoolsReady(fn: (ctx: ViteDevToolsNodeContext) => void | Promise<void>, nuxt?: _nuxt_schema.Nuxt): void;
 
-export { addCustomTab, extendServerRpc, onDevToolsInitialized, refreshCustomTabs, startSubprocess };
+export { NUXT_DEVTOOLS_GROUP_ID, addCustomTab, consoleDiagnostics, defineStandaloneDiagnostics, deprecate, deprecateWithNuxt, diagnosticCodes, diagnosticsDocsBase, extendServerRpc, onDevToolsInitialized, onDevtoolsReady, refreshCustomTabs, registerHostDiagnostics, startSubprocess };
+export type { DeprecateOptions, DeprecationParams, NuxtDiagnosticCode, StartSubprocessReturn };

package/dist/index.mjs

@@ -1,7 +1,126 @@
 import { useNuxt } from '@nuxt/kit';
 import { x } from 'tinyexec';
+import { defineDiagnostics, createConsoleReporter } from 'nostics';
+export { createConsoleReporter, defineDiagnostics } from 'nostics';
 
+function diagnosticsDocsBase(code) {
+  return `https://devtools.nuxt.com/module/migration-v4#${String(code).toLowerCase()}`;
+}
+const diagnosticCodes = {
+  /** `startSubprocess().getProcess()` → `getResult()`. */
+  NDT_DEP_0001: {
+    why: (p) => `\`${p.api}\` is deprecated.`,
+    fix: (p) => `Use \`${p.replacement}\` instead.`
+  },
+  // NDT_DEP_0002 is retired (was `disableAuthorization`, now a supported
+  // first-class option). The code is left unused so numbers stay stable.
+  /** `extendServerRpc` → `onDevtoolsReady((ctx) => ctx.rpc.register(...))`. */
+  NDT_DEP_0003: {
+    why: (p) => `\`${p.api}\` is deprecated.`,
+    fix: (p) => `Use \`${p.replacement}\` instead.`
+  },
+  /** `startSubprocess` → `onDevtoolsReady((ctx) => ctx.terminals.startChildProcess(...))`. */
+  NDT_DEP_0004: {
+    why: (p) => `\`${p.api}\` is deprecated.`,
+    fix: (p) => `Use \`${p.replacement}\` instead.`
+  },
+  /** `addCustomTab` → `onDevtoolsReady((ctx) => ctx.docks.register(...))`. */
+  NDT_DEP_0005: {
+    why: (p) => `\`${p.api}\` is deprecated.`,
+    fix: (p) => `Use \`${p.replacement}\` instead.`
+  },
+  /** `refreshCustomTabs` → `onDevtoolsReady((ctx) => ctx.docks.register(...))`. */
+  NDT_DEP_0006: {
+    why: (p) => `\`${p.api}\` is deprecated.`,
+    fix: (p) => `Use \`${p.replacement}\` instead.`
+  },
+  /** Direct `nuxt.devtools.rpc` access (`broadcast` / `functions`). */
+  NDT_DEP_0007: {
+    why: (p) => `\`${p.api}\` is deprecated.`,
+    fix: (p) => `Use \`${p.replacement}\` instead.`
+  },
+  /** Removed `vscode` module option → `codeServer`. */
+  NDT_DEP_0008: {
+    why: (p) => `\`${p.api}\` is deprecated and its legacy modes are no longer supported.`,
+    fix: (p) => `Use \`${p.replacement}\` instead. The legacy value is ignored rather than partially translated.`
+  },
+  /** `getServerData()` RPC → the Data Inspector panel's `Nuxt Application` source. */
+  NDT_DEP_0009: {
+    why: (p) => `\`${p.api}\` is deprecated.`,
+    fix: (p) => `Use \`${p.replacement}\` instead.`
+  }
+};
+const consoleDiagnostics = defineDiagnostics({
+  docsBase: diagnosticsDocsBase,
+  reporters: [
+    createConsoleReporter()
+  ],
+  codes: diagnosticCodes
+});
+const stateByCtx = /* @__PURE__ */ new WeakMap();
+const fallbackState = {
+  emitted: /* @__PURE__ */ new Set()
+};
+function getState(ctx) {
+  if (!ctx)
+    return fallbackState;
+  let state = stateByCtx.get(ctx);
+  if (!state) {
+    state = {
+      emitted: /* @__PURE__ */ new Set()
+    };
+    stateByCtx.set(ctx, state);
+  }
+  return state;
+}
+function getServerContext(nuxt) {
+  return nuxt?.devtools;
+}
+function registerHostDiagnostics(ctx) {
+  const host = ctx.devtoolsKit?.diagnostics;
+  if (!host)
+    return;
+  const catalog = host.defineDiagnostics({
+    docsBase: diagnosticsDocsBase,
+    codes: diagnosticCodes
+  });
+  host.register(catalog);
+  getState(ctx).hostCatalog = catalog;
+}
+function deprecate(nuxt, code, params, options = {}) {
+  const ctx = getServerContext(nuxt);
+  const state = getState(ctx);
+  const dedupeKey = `${code}:${options.key ?? code}`;
+  if (state.emitted.has(dedupeKey))
+    return;
+  state.emitted.add(dedupeKey);
+  const method = options.method ?? "warn";
+  const hostHandle = state.hostCatalog?.[code];
+  if (hostHandle)
+    return hostHandle(params, { method });
+  const handle = consoleDiagnostics[code];
+  return handle(params, { method });
+}
+function defineStandaloneDiagnostics(options) {
+  return defineDiagnostics({
+    ...options,
+    reporters: options.reporters ?? [
+      createConsoleReporter()
+    ]
+  });
+}
+function deprecateWithNuxt(code, params, options) {
+  return deprecate(useNuxt(), code, params, options);
+}
+
+const NUXT_DEVTOOLS_GROUP_ID = "nuxt";
 function addCustomTab(tab, nuxt = useNuxt()) {
+  deprecate(nuxt, "NDT_DEP_0005", {
+    api: "addCustomTab",
+    replacement: "onDevtoolsReady((ctx) => ctx.docks.register(...))"
+  }, {
+    key: typeof tab === "function" ? void 0 : tab.name
+  });
   nuxt.hook("devtools:customTabs", async (tabs) => {
     if (typeof tab === "function")
       tab = await tab();
@@ -9,9 +128,17 @@ function addCustomTab(tab, nuxt = useNuxt()) {
   });
 }
 function refreshCustomTabs(nuxt = useNuxt()) {
+  deprecate(nuxt, "NDT_DEP_0006", {
+    api: "refreshCustomTabs",
+    replacement: "onDevtoolsReady((ctx) => ctx.docks.register(...).update(...))"
+  });
   return nuxt.callHook("devtools:customTabs:refresh");
 }
 function startSubprocess(execaOptions, tabOptions, nuxt = useNuxt()) {
+  deprecate(nuxt, "NDT_DEP_0004", {
+    api: "startSubprocess",
+    replacement: "onDevtoolsReady((ctx) => ctx.terminals.startChildProcess(...))"
+  }, { key: tabOptions.id });
   const id = tabOptions.id;
   let restarting = false;
   function start() {
@@ -21,6 +148,7 @@ function startSubprocess(execaOptions, tabOptions, nuxt = useNuxt()) {
       {
         nodeOptions: {
           ...execaOptions.nodeOptions,
+          cwd: execaOptions.cwd ?? execaOptions.nodeOptions?.cwd,
           env: {
             ...process.env,
             COLORS: "true",
@@ -32,14 +160,23 @@ function startSubprocess(execaOptions, tabOptions, nuxt = useNuxt()) {
         }
       }
     );
-    nuxt.callHook("devtools:terminal:write", { id, data: `> ${[execaOptions.command, ...execaOptions.args || []].join(" ")}
+    nuxt.callHook("devtools:terminal:write", { id, data: `> ${[
+      execaOptions.command,
+      ...execaOptions.args || []
+    ].join(" ")}
 
 ` });
     proc.process?.stdout?.on("data", (data) => {
-      nuxt.callHook("devtools:terminal:write", { id, data: data.toString() });
+      nuxt.callHook("devtools:terminal:write", {
+        id,
+        data: data.toString()
+      });
     });
     proc.process?.stderr?.on("data", (data) => {
-      nuxt.callHook("devtools:terminal:write", { id, data: data.toString() });
+      nuxt.callHook("devtools:terminal:write", {
+        id,
+        data: data.toString()
+      });
     });
     proc.process?.on("exit", (code) => {
       if (!restarting) {
@@ -86,7 +223,10 @@ function startSubprocess(execaOptions, tabOptions, nuxt = useNuxt()) {
   return {
     /** @deprecated Use `getResult()` instead */
     getProcess: () => {
-      console.warn("[nuxt-devtools] `getProcess()` is deprecated, use `getResult()` instead.");
+      deprecate(nuxt, "NDT_DEP_0001", {
+        api: "startSubprocess().getProcess()",
+        replacement: "getResult()"
+      }, { key: id });
       return result.process;
     },
     getResult: () => result,
@@ -104,8 +244,11 @@ function extendServerRpc(namespace, functions, nuxt = useNuxt()) {
 function onDevToolsInitialized(fn, nuxt = useNuxt()) {
   nuxt.hook("devtools:initialized", fn);
 }
+function onDevtoolsReady(fn, nuxt = useNuxt()) {
+  nuxt.hook("devtools:ready", fn);
+}
 function _getContext(nuxt = useNuxt()) {
   return nuxt?.devtools;
 }
 
-export { addCustomTab, extendServerRpc, onDevToolsInitialized, refreshCustomTabs, startSubprocess };
+export { NUXT_DEVTOOLS_GROUP_ID, addCustomTab, consoleDiagnostics, defineStandaloneDiagnostics, deprecate, deprecateWithNuxt, diagnosticCodes, diagnosticsDocsBase, extendServerRpc, onDevToolsInitialized, onDevtoolsReady, refreshCustomTabs, registerHostDiagnostics, startSubprocess };

package/dist/runtime/host-client.d.mts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+import '../shared/devtools-kit-nightly.CtfaEBN3.mjs';
+import { NuxtDevtoolsHostClient } from '../types.mjs';
+import '@vitejs/devtools-kit';
+import 'birpc';
+import 'nuxt/schema';
+import 'unimport';
+import 'vue-router';
+import 'unstorage';
+import 'vite';
+import '@nuxt/schema';
+import 'nitro/types';
+import 'nitropack';
+import 'node:child_process';
+import '@vitejs/devtools-kit/client';
+import 'hookable';
+import 'nuxt/app';
+import 'ofetch';
+import 'shiki';
+import 'error-stack-parser-es';
+
+declare function onDevtoolsHostClientConnected(fn: (client: NuxtDevtoolsHostClient) => void): (() => void) | undefined;
+declare function useDevtoolsHostClient(): Ref<NuxtDevtoolsHostClient | undefined>;
+
+export { onDevtoolsHostClientConnected, useDevtoolsHostClient };

package/dist/runtime/host-client.mjs

@@ -1,7 +1,8 @@
-import { shallowRef } from "vue";
+import { shallowRef } from 'vue';
+
 let clientRef;
 const fns = [];
-export function onDevtoolsHostClientConnected(fn) {
+function onDevtoolsHostClientConnected(fn) {
   fns.push(fn);
   if (typeof window === "undefined")
     return;
@@ -22,7 +23,7 @@ export function onDevtoolsHostClientConnected(fn) {
     fns.splice(fns.indexOf(fn), 1);
   };
 }
-export function useDevtoolsHostClient() {
+function useDevtoolsHostClient() {
   if (!clientRef) {
     clientRef = shallowRef();
     onDevtoolsHostClientConnected(setup);
@@ -32,3 +33,5 @@ export function useDevtoolsHostClient() {
   }
   return clientRef;
 }
+
+export { onDevtoolsHostClientConnected, useDevtoolsHostClient };

package/dist/runtime/iframe-client.d.mts

@@ -0,0 +1,42 @@
+import { DevToolsRpcClient } from '@vitejs/devtools-kit/client';
+import { Ref } from 'vue';
+import '../shared/devtools-kit-nightly.CtfaEBN3.mjs';
+import { NuxtDevtoolsIframeClient } from '../types.mjs';
+import '@vitejs/devtools-kit';
+import 'birpc';
+import 'nuxt/schema';
+import 'unimport';
+import 'vue-router';
+import 'unstorage';
+import 'vite';
+import '@nuxt/schema';
+import 'nitro/types';
+import 'nitropack';
+import 'node:child_process';
+import 'hookable';
+import 'nuxt/app';
+import 'ofetch';
+import 'shiki';
+import 'error-stack-parser-es';
+
+declare function onDevtoolsClientConnected(fn: (client: NuxtDevtoolsIframeClient) => void): (() => void) | undefined;
+/**
+ * Run a callback once the Vite DevTools client is ready, receiving the connected
+ * `DevToolsRpcClient` — the client-side mirror of the server's
+ * `onDevtoolsReady((ctx) => …)`.
+ *
+ * This is the recommended way to do client-side DevTools integration (register
+ * client RPC functions, call server functions, shared state, streaming, …):
+ *
+ * ```ts
+ * import { onDevtoolsReady } from '@nuxt/devtools-kit/iframe-client'
+ *
+ * onDevtoolsReady((kit) => {
+ *   kit.client.register({ name: 'my-module:on-update', type: 'event', handler })
+ * })
+ * ```
+ */
+declare function onDevtoolsReady(fn: (kit: DevToolsRpcClient) => void): (() => void) | undefined;
+declare function useDevtoolsClient(): Ref<NuxtDevtoolsIframeClient | undefined, NuxtDevtoolsIframeClient | undefined>;
+
+export { onDevtoolsClientConnected, onDevtoolsReady, useDevtoolsClient };