@nuxt/devtools 3.4.1 → 4.0.0-alpha.10

package/dist/chunks/module-main.mjs

@@ -1,24 +1,24 @@
-import fs, { existsSync, promises, statSync, realpathSync, readFileSync, accessSync, constants } from 'node:fs';
-import fsp from 'node:fs/promises';
+import fs$1, { promises, statSync, realpathSync, readFileSync, existsSync, accessSync, constants } from 'node:fs';
+import fs from 'node:fs/promises';
 import os, { homedir } from 'node:os';
-import { logger, useNuxt, addVitePlugin, addPlugin, addTemplate, extendViteConfig, addImports } from '@nuxt/kit';
+import { onDevtoolsReady, NUXT_DEVTOOLS_GROUP_ID, deprecate, registerHostDiagnostics } from '@nuxt/devtools-kit';
+import { logger, useNuxt, extendViteConfig, addPlugin, addVitePlugin, addTemplate, addImports } from '@nuxt/kit';
 import { colors } from 'consola/utils';
-import { join, dirname as dirname$1, resolve, isAbsolute } from 'pathe';
+import { join, dirname, resolve, isAbsolute } from 'pathe';
 import sirv from 'sirv';
 import { searchForWorkspaceRoot } from 'vite';
-import { d as defaultAllowedExtensions, a as defaultTabOptions, W as WS_EVENT_NAME } from '../shared/devtools.DFpGUHRZ.mjs';
-import path, { dirname, join as join$1, relative, parse } from 'node:path';
-import { hash } from 'ohash';
-import { runtimeDir, clientDir, packageDir, isGlobalInstall } from '../dirs.mjs';
-import { createBirpcGroup } from 'birpc';
-import { parse as parse$1, stringify } from 'structured-clone-es';
-import { startSubprocess } from '@nuxt/devtools-kit';
-import Git from 'simple-git';
+import { d as defaultAllowedExtensions, c as createDefaultTabOptions, s as setServerTasksEnabledByDefault } from '../shared/devtools.CCWq4fFE.mjs';
+import { runtimeDir, clientDir, packageDir } from '../dirs.mjs';
+import { registerDataSource, createDataInspectorDevframe } from '@devframes/plugin-data-inspector';
+import { mountDevframe } from '@vitejs/devtools-kit/node';
+import { x } from 'tinyexec';
 import { glob } from 'tinyglobby';
+import path, { relative, parse, dirname as dirname$1 } from 'node:path';
 import { imageMeta } from 'image-meta';
 import { debounce } from 'perfect-debounce';
 import destr from 'destr';
 import { setupHooksDebug } from '../../dist/runtime/shared/hooks.js';
+import { hash } from 'ohash';
 import process$1 from 'node:process';
 import { builtinModules, createRequire } from 'node:module';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
@@ -27,140 +27,167 @@ import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
 import { resolveModule, getPackageInfo } from 'local-pkg';
-import isInstalledGlobally from 'is-installed-globally';
 import { parseModule } from 'magicast';
 import { getDefaultExportOptions, addNuxtModule } from 'magicast/helpers';
-import { detectPackageManager } from 'nypm';
-import semver from 'semver';
-import { normalizeBaseKey, normalizeKey } from 'unstorage';
+import { isLess } from 'verkit';
+import { DEVTOOLS_TERMINALS_DOCK_ID } from '@vitejs/devtools-kit/constants';
+import { normalizeBaseKey, normalizeKey, createStorage, builtinDrivers } from 'unstorage';
 
-const version$1 = "3.4.1";
-
-const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-function randomStr(size = 16, dict = urlAlphabet) {
-  let id = "";
-  let i = size;
-  const len = dict.length;
-  while (i--)
-    id += dict[Math.random() * len | 0];
-  return id;
-}
+const version$1 = "4.0.0-alpha.10";
 
-function getHomeDir() {
-  return process.env.XDG_CONFIG_HOME || homedir();
-}
-async function readLocalOptions(defaults, options) {
-  const { filePath } = getOptionsFilepath(options);
-  if (existsSync(filePath)) {
-    try {
-      const options2 = {
-        ...defaults,
-        ...JSON.parse(await fsp.readFile(filePath, "utf-8")).settings || {}
-      };
-      return options2;
-    } catch (e) {
-      console.error(`[DevTools] failed to parse local options file: ${filePath}, fallback to defaults`);
-      console.error(e);
-      return { ...defaults };
-    }
-  } else {
-    return { ...defaults };
-  }
-}
-function getOptionsFilepath(options) {
-  let hashedKey;
-  if (options.key)
-    hashedKey = hash(`${options.root}:${options.key}`);
-  else
-    hashedKey = hash(options.root);
-  const home = getHomeDir();
-  const filePath = join(home, ".nuxt/devtools", `${hashedKey}.json`);
+const captured = {};
+function normalizeViteConfig(config) {
   return {
-    filePath,
-    hashedKey
+    ...config,
+    environments: Object.fromEntries(
+      Object.entries(config.env ?? {}).map(([key, _]) => {
+        return [key, null];
+      })
+    ),
+    plugins: (config.plugins ?? []).map((i) => {
+      const clone = { ...i };
+      delete clone.api;
+      return clone;
+    }),
+    inlineConfig: null
   };
 }
-async function clearLocalOptions(options) {
-  const { filePath } = getOptionsFilepath(options);
-  if (existsSync(filePath))
-    await fsp.unlink(filePath);
+function setup(ctx) {
+  const { nuxt } = ctx;
+  nuxt.hook("nitro:build:before", (nitro) => {
+    captured.nitro = nitro;
+  });
+  nuxt.hook("vite:serverCreated", (server) => {
+    captured.vite = server;
+  });
+  const dataSource = registerDataSource({
+    id: "nuxt:application",
+    title: "Nuxt Application",
+    description: "Live Nuxt, Nitro, and Vite configuration",
+    icon: "i-ph:database-duotone",
+    static: false,
+    data: () => ({
+      nuxt: nuxt.options,
+      nitro: captured.nitro?.options,
+      vite: captured.vite
+    }),
+    queries: [
+      { title: "Overview", query: "", excludeFunctions: true },
+      { title: "Nuxt modules", query: "nuxt.modules", excludeFunctions: true },
+      { title: "Vite plugins", query: "vite.config.plugins", excludeFunctions: true },
+      { title: "Vite config", query: "vite.config", excludeFunctions: true },
+      { title: "Vite environments", query: "vite.environments", excludeFunctions: true },
+      { title: "Nitro routes", query: "nitro.handlers", excludeFunctions: true }
+    ]
+  });
+  nuxt.hook("close", () => {
+    dataSource.unregister();
+    captured.nitro = void 0;
+    captured.vite = void 0;
+  });
+  const definition = createDataInspectorDevframe({ exampleSource: false });
+  onDevtoolsReady((kit) => {
+    return mountDevframe(kit, definition, {
+      dock: {
+        groupId: NUXT_DEVTOOLS_GROUP_ID,
+        category: "advanced"
+      }
+    });
+  }, nuxt);
 }
-async function writeLocalOptions(settings, options) {
-  const { filePath, hashedKey } = getOptionsFilepath(options);
-  await fsp.mkdir(dirname(filePath), { recursive: true });
-  await fsp.writeFile(
-    filePath,
-    JSON.stringify(
-      {
-        root: options.root,
-        hash: hashedKey,
-        settings
-      },
-      null,
-      2
-    ),
-    "utf-8"
-  );
+function getServerData(nuxt) {
+  deprecate(nuxt, "NDT_DEP_0009", {
+    api: "getServerData()",
+    replacement: "the Nuxt Application source in the Data Inspector panel"
+  });
+  const config = captured.vite?.config;
+  return {
+    nuxt: nuxt.options,
+    nitro: captured.nitro?.options,
+    vite: {
+      server: config ? normalizeViteConfig(config) : void 0,
+      client: config ? normalizeViteConfig(config) : void 0
+    }
+    // `nuxt.options` is `@nuxt/schema`'s `NuxtOptions` while `NuxtServerData`
+    // pins the structurally-identical `nuxt/schema` one; bridge the two.
+  };
 }
 
-let token;
-async function getDevAuthToken() {
-  if (token)
-    return token;
-  const home = getHomeDir();
-  const dir = join$1(home, ".nuxt/devtools");
-  const filepath = join$1(dir, "dev-auth-token.txt");
-  if (existsSync(filepath))
-    token = (await fsp.readFile(filepath, "utf-8")).trim();
-  if (!token)
-    token = randomStr(16);
-  await fsp.mkdir(dir, { recursive: true });
-  await fsp.writeFile(filepath, token, "utf-8");
-  return token;
-}
-
-function isAllowedRpcOrigin(origin, host) {
-  if (!origin)
-    return true;
-  let originHost;
-  try {
-    originHost = new URL(origin).host;
-  } catch {
-    return false;
-  }
-  return !!host && originHost === host;
+const dataInspector = {
+  __proto__: null,
+  getServerData: getServerData,
+  setup: setup
+};
+
+const RPC_NAMESPACE = "nuxt:devtools";
+
+let counter = 0;
+function createUniqueSessionId(baseId) {
+  counter += 1;
+  return `${baseId}#${counter}`;
 }
 
 const COLON_RE = /:/g;
-function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
+function setupAnalyzeBuildRPC(ctx) {
+  const { nuxt, refresh } = ctx;
   let builds = [];
   let promise;
   let initalized;
-  const processId = "devtools:analyze-build";
+  let activeSessionId;
   const devtoolsAnalyzeDir = join(nuxt.options.rootDir, "node_modules/.cache/nuxt-devtools/analyze");
   async function startAnalyzeBuild(name) {
     if (promise)
       throw new Error("[Nuxt DevTools] A building process is already running");
-    const result = startSubprocess({
+    const kit = ctx.devtoolsKit;
+    if (!kit)
+      throw new Error("[Nuxt DevTools] Vite DevTools kit is not connected yet.");
+    const sessionId = createUniqueSessionId("devtools:analyze-build");
+    activeSessionId = sessionId;
+    const session = await kit.terminals.startChildProcess({
       command: "npx",
       args: ["nuxi", "analyze", "--no-serve", "--name", name],
       cwd: nuxt.options.rootDir
     }, {
-      id: processId,
-      name: "Analyze Build",
+      id: sessionId,
+      title: "Analyze Build",
       icon: "logos-nuxt-icon"
-    }, nuxt);
+    });
     refresh("getAnalyzeBuildInfo");
     initalized = void 0;
-    promise = result.getProcess().then(() => {
+    promise = Promise.resolve(session.getResult()).then((result) => {
+      if (result.exitCode && result.exitCode !== 0) {
+        ctx.notify({
+          message: `Build analysis "${name}" failed`,
+          level: "error",
+          description: `Process exited with code ${result.exitCode}. Check the Analyze Build terminal for details.`,
+          category: "build",
+          notify: true
+        });
+      } else {
+        ctx.notify({
+          message: `Build analysis "${name}" complete`,
+          level: "success",
+          category: "build",
+          notify: true
+        });
+      }
       refresh("getAnalyzeBuildInfo");
       return readBuildInfo();
+    }).catch((error) => {
+      ctx.notify({
+        message: `Build analysis "${name}" failed`,
+        level: "error",
+        description: error instanceof Error ? error.message : String(error),
+        category: "build",
+        notify: true
+      });
     }).finally(() => {
       promise = void 0;
       initalized = void 0;
+      activeSessionId = void 0;
       refresh("getAnalyzeBuildInfo");
     });
-    return processId;
+    return sessionId;
   }
   async function readBuildInfo() {
     for (const dir of /* @__PURE__ */ new Set([
@@ -174,10 +201,10 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
         absolute: true
       });
       for (const file of files2) {
-        const slug = JSON.parse(await fsp.readFile(file, "utf-8")).slug;
-        const dir2 = dirname$1(file);
-        await fsp.mkdir(devtoolsAnalyzeDir, { recursive: true });
-        await fsp.rename(dir2, join(devtoolsAnalyzeDir, slug));
+        const slug = JSON.parse(await fs.readFile(file, "utf-8")).slug;
+        const dir2 = dirname(file);
+        await fs.mkdir(devtoolsAnalyzeDir, { recursive: true });
+        await fs.rename(dir2, join(devtoolsAnalyzeDir, slug));
       }
     }
     const files = await glob(["**/meta.json"], {
@@ -186,27 +213,30 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
       absolute: true
     });
     builds = await Promise.all(files.map(async (file) => {
-      const dir = dirname$1(file);
-      const json = JSON.parse(await fsp.readFile(file, "utf-8"));
+      const dir = dirname(file);
+      const json = JSON.parse(await fs.readFile(file, "utf-8"));
       return {
         ...json,
         features: {
-          bundleClient: fs.existsSync(join(dir, "client.html")),
-          bundleNitro: fs.existsSync(join(dir, "nitro.html")),
-          viteInspect: fs.existsSync(join(dir, ".vite-inspect"))
+          bundleClient: fs$1.existsSync(join(dir, "client.html")),
+          bundleNitro: fs$1.existsSync(join(dir, "nitro.html")),
+          viteInspect: fs$1.existsSync(join(dir, ".vite-inspect"))
         }
       };
     }));
     return builds.sort((a, b) => b.endTime - a.endTime);
   }
+  async function git(...args) {
+    const result = await x("git", args, { nodeOptions: { cwd: nuxt.options.rootDir }, throwOnError: true });
+    return result.stdout.trim();
+  }
   async function generateAnalyzeBuildName() {
     try {
-      const git = Git(nuxt.options.rootDir);
-      const branch = await git.branch();
-      const branchName = branch.current || "head";
-      const sha = await git.revparse(["--short", "HEAD"]);
-      const isWorkingTreeClean = (await git.status()).isClean();
-      if (isWorkingTreeClean)
+      const branchName = await git("rev-parse", "--abbrev-ref", "HEAD") || "head";
+      const sha = await git("rev-parse", "--short", "HEAD");
+      const status = await git("status", "--porcelain");
+      const isClean = status === "";
+      if (isClean)
         return `${branchName}#${sha}`;
       return `${branchName}#${sha}-dirty`;
     } catch {
@@ -220,29 +250,28 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
       await initalized;
       return {
         isBuilding: !!promise,
+        activeSessionId,
         builds
       };
     },
-    async clearAnalyzeBuilds(token, names) {
-      await ensureDevAuthToken(token);
+    async clearAnalyzeBuilds(names) {
       if (!names) {
-        await fsp.rm(devtoolsAnalyzeDir, { recursive: true, force: true });
+        await fs.rm(devtoolsAnalyzeDir, { recursive: true, force: true });
       } else {
         const targets = builds.filter((build) => names.includes(build.name));
-        await Promise.all(targets.map((target) => fsp.rm(join(devtoolsAnalyzeDir, target.slug), { recursive: true, force: true })));
+        await Promise.all(targets.map((target) => fs.rm(join(devtoolsAnalyzeDir, target.slug), { recursive: true, force: true })));
       }
       initalized = readBuildInfo();
       refresh("getAnalyzeBuildInfo");
     },
     generateAnalyzeBuildName,
-    async startAnalyzeBuild(token, ...args) {
-      await ensureDevAuthToken(token);
+    async startAnalyzeBuild(...args) {
       return startAnalyzeBuild(...args);
     }
   };
 }
 
-function setupAssetsRPC({ nuxt, ensureDevAuthToken, refresh, options }) {
+function setupAssetsRPC({ nuxt, refresh, options }) {
   const _imageMetaCache = /* @__PURE__ */ new Map();
   let cache = null;
   const extensions = options.assets?.uploadExtensions || defaultAllowedExtensions;
@@ -276,7 +305,7 @@ function setupAssetsRPC({ nuxt, ensureDevAuthToken, refresh, options }) {
         const filePath = resolve(layerDir, path);
         if (!filePath.startsWith(layerDir))
           continue;
-        const stat = await fsp.lstat(filePath);
+        const stat = await fs.lstat(filePath);
         const fullPath = join(baseURL, path);
         if (!uniquePaths.has(fullPath)) {
           cache.push({
@@ -298,12 +327,11 @@ function setupAssetsRPC({ nuxt, ensureDevAuthToken, refresh, options }) {
     async getStaticAssets() {
       return await scan();
     },
-    async getImageMeta(token, filepath) {
-      await ensureDevAuthToken(token);
+    async getImageMeta(filepath) {
       if (_imageMetaCache.has(filepath))
         return _imageMetaCache.get(filepath);
       try {
-        const meta = imageMeta(await fsp.readFile(filepath));
+        const meta = imageMeta(await fs.readFile(filepath));
         _imageMetaCache.set(filepath, meta);
         return meta;
       } catch (e) {
@@ -312,18 +340,16 @@ function setupAssetsRPC({ nuxt, ensureDevAuthToken, refresh, options }) {
         return void 0;
       }
     },
-    async getTextAssetContent(token, filepath, limit = 300) {
-      await ensureDevAuthToken(token);
+    async getTextAssetContent(filepath, limit = 300) {
       try {
-        const content = await fsp.readFile(filepath, "utf-8");
+        const content = await fs.readFile(filepath, "utf-8");
         return content.slice(0, limit);
       } catch (e) {
         console.error(e);
         return void 0;
       }
     },
-    async writeStaticAssets(token, files, folder) {
-      await ensureDevAuthToken(token);
+    async writeStaticAssets(files, folder) {
       const baseDir = resolve(nuxt.options.srcDir, nuxt.options.dir.public + folder);
       return await Promise.all(
         files.map(async ({ path, content, encoding, override }) => {
@@ -338,32 +364,30 @@ You can configure it in Nuxt config at \`devtools.assets.uploadExtensions\`.`);
           }
           if (!override) {
             try {
-              await fsp.stat(finalPath);
+              await fs.stat(finalPath);
               const base = finalPath.slice(0, finalPath.length - ext.length - 1);
               let i = 1;
-              while (await fsp.access(`${base}-${i}.${ext}`).then(() => true).catch(() => false))
+              while (await fs.access(`${base}-${i}.${ext}`).then(() => true).catch(() => false))
                 i++;
               finalPath = `${base}-${i}.${ext}`;
             } catch {
             }
           }
-          await fsp.writeFile(finalPath, content, {
+          await fs.writeFile(finalPath, content, {
             encoding: encoding ?? "utf-8"
           });
           return finalPath;
         })
       );
     },
-    async deleteStaticAsset(token, path) {
-      await ensureDevAuthToken(token);
-      return await fsp.unlink(path);
+    async deleteStaticAsset(path) {
+      return await fs.unlink(path);
     },
-    async renameStaticAsset(token, oldPath, newPath) {
-      await ensureDevAuthToken(token);
+    async renameStaticAsset(oldPath, newPath) {
       const exist = cache?.find((asset) => asset.filePath === newPath);
       if (exist)
         throw new Error(`[Nuxt DevTools] File ${newPath} already exists, failed to rename`);
-      return await fsp.rename(oldPath, newPath);
+      return await fs.rename(oldPath, newPath);
     }
   };
 }
@@ -386,7 +410,7 @@ function guessType(path) {
   return "other";
 }
 
-function setupCustomTabRPC({ nuxt, options, refresh, ensureDevAuthToken }) {
+function setupCustomTabRPC({ nuxt, options, refresh }) {
   const iframeTabs = [];
   const customTabs = [];
   if (options.customTabs?.length)
@@ -415,8 +439,7 @@ function setupCustomTabRPC({ nuxt, options, refresh, ensureDevAuthToken }) {
         return i;
       });
     },
-    async customTabAction(token, name, actionIndex) {
-      await ensureDevAuthToken(token);
+    async customTabAction(name, actionIndex) {
       const tab = customTabs.find((i) => i.name === name);
       if (!tab)
         return false;
@@ -830,6 +853,9 @@ var defaultOptions = {
   // Can be either `"script"`, `"module"` or `"commonjs"`. This influences global
   // strict mode and parsing of `import` and `export` declarations.
   sourceType: "script",
+  // When set to true, enable strict parsing mode even if `sourceType`
+  // is `"script"`.
+  strict: false,
   // `onInsertedSemicolon` can be a callback that will be called when
   // a semicolon is automatically inserted. It will be passed the
   // position of the inserted semicolon as an offset, and if
@@ -871,6 +897,11 @@ var defaultOptions = {
   // line being 1-based and column 0-based) will be attached to the
   // nodes.
   locations: false,
+  // Pass an optional `{line, column}` object to use for the start of
+  // the parse. This is mostly useful when using `parseExpressionAt`
+  // with `locations: true`, to prevent the parser from having to
+  // determine the line position at the start position.
+  startLocation: null,
   // A function can be passed as `onToken` option, which will
   // cause Acorn to call that function with object in the same
   // format as tokens returned from `tokenizer().getToken()`. Note
@@ -1024,13 +1055,17 @@ var Parser = function Parser(options, input, startPos) {
   // Set up token state
 
   // The current position of the tokenizer in the input.
-  if (startPos) {
-    this.pos = startPos;
+  this.pos = startPos || 0;
+  this.curLine = 1;
+  if (options.startLocation) {
+    this.lineStart = this.pos - options.startLocation.column;
+    this.curLine = options.startLocation.line;
+  } else if (startPos) {
     this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;
-    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
+    if (this.options.locations)
+      { this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length; }
   } else {
-    this.pos = this.lineStart = 0;
-    this.curLine = 1;
+    this.lineStart = 0;
   }
 
   // Properties of the current token:
@@ -1056,7 +1091,7 @@ var Parser = function Parser(options, input, startPos) {
 
   // Figure out if it's a module code.
   this.inModule = options.sourceType === "module";
-  this.strict = this.inModule || this.strictDirective(this.pos);
+  this.strict = this.inModule || options.strict === true || this.strictDirective(this.pos);
 
   // Used to signify the start of a potential arrow function
   this.potentialArrowAt = -1;
@@ -1094,9 +1129,11 @@ var Parser = function Parser(options, input, startPos) {
 var prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },canAwait: { configurable: true },allowReturn: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true },allowNewDotTarget: { configurable: true },allowUsing: { configurable: true },inClassStaticBlock: { configurable: true } };
 
 Parser.prototype.parse = function parse () {
+    var this$1$1 = this;
+
   var node = this.options.program || this.startNode();
   this.nextToken();
-  return this.parseTopLevel(node)
+  return this.catchStackOverflow(function () { return this$1$1.parseTopLevel(node); })
 };
 
 prototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };
@@ -1235,6 +1272,17 @@ pp$9.eatContextual = function(name) {
   return true
 };
 
+pp$9.catchStackOverflow = function(f) {
+  try {
+    return f()
+  } catch (e) {
+    if (e instanceof Error && (/\bstack\b.*\b(exceeded|overflow)\b/i.test(e.message) || /\btoo much recursion\b/i.test(e.message)))
+      { this.raise(this.start, "Not enough stack space to parse input"); }
+    else
+      { throw e }
+  }
+};
+
 // Asserts that following token is given contextual keyword.
 
 pp$9.expectContextual = function(name) {
@@ -1338,10 +1386,10 @@ var pp$8 = Parser.prototype;
 // to its body instead of creating a new node.
 
 pp$8.parseTopLevel = function(node) {
-  var exports = Object.create(null);
+  var exports$1 = Object.create(null);
   if (!node.body) { node.body = []; }
   while (this.type !== types$1.eof) {
-    var stmt = this.parseStatement(null, true, exports);
+    var stmt = this.parseStatement(null, true, exports$1);
     node.body.push(stmt);
   }
   if (this.inModule)
@@ -1430,7 +1478,18 @@ pp$8.isUsingKeyword = function(isAwaitUsing, isFor) {
   while (isIdentifierChar(ch = this.fullCharCodeAt(next)))
   if (ch === 92) { return true }
   var id = this.input.slice(idStart, next);
-  if (keywordRelationalOperator.test(id) || isFor && id === "of") { return false }
+  if (keywordRelationalOperator.test(id)) { return false }
+  if (isFor && !isAwaitUsing && id === "of") {
+    // Look ahead for using declaration with initializer, i.e., `for (using of = ...)`
+    skipWhiteSpace.lastIndex = next;
+    var skipAfterOf = skipWhiteSpace.exec(this.input);
+    next = next + skipAfterOf[0].length;
+    if (this.input.charCodeAt(next) !== 61 /* '=' */ ||
+      // Check for ==, === and => operators
+      (ch = this.input.charCodeAt(next + 1)) === 61 /* '=' */ || ch === 62 /* '>' */) {
+      return false
+    }
+  }
   return true
 };
 
@@ -1449,7 +1508,7 @@ pp$8.isUsing = function(isFor) {
 // `if (foo) /blah/.exec(foo)`, where looking at the previous token
 // does not help.
 
-pp$8.parseStatement = function(context, topLevel, exports) {
+pp$8.parseStatement = function(context, topLevel, exports$1) {
   var starttype = this.type, node = this.startNode(), kind;
 
   if (this.isLet(context)) {
@@ -1504,7 +1563,7 @@ pp$8.parseStatement = function(context, topLevel, exports) {
       if (!this.inModule)
         { this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); }
     }
-    return starttype === types$1._import ? this.parseImport(node) : this.parseExport(node, exports)
+    return starttype === types$1._import ? this.parseImport(node) : this.parseExport(node, exports$1)
 
     // If the statement does not start with a statement keyword or a
     // brace, it's an ExpressionStatement or LabeledStatement. We
@@ -1523,6 +1582,10 @@ pp$8.parseStatement = function(context, topLevel, exports) {
       if (!this.allowUsing) {
         this.raise(this.start, "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement");
       }
+      if (context) {
+        // Cases like `for (;;) using x = ...;`, `if (true) await using x = ...;`, etc. are not allowed.
+        this.raise(this.start, "Using declaration is not allowed in single-statement positions");
+      }
       if (usingKind === "await using") {
         if (!this.canAwait) {
           this.raise(this.start, "Await using cannot appear outside of async function");
@@ -1656,11 +1719,12 @@ pp$8.parseForStatement = function(node) {
 // Helper method to parse for loop after variable initialization
 pp$8.parseForAfterInit = function(node, init, awaitAt) {
   if ((this.type === types$1._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1) {
-    if (this.options.ecmaVersion >= 9) {
-      if (this.type === types$1._in) {
-        if (awaitAt > -1) { this.unexpected(awaitAt); }
-      } else { node.await = awaitAt > -1; }
-    }
+    if (this.type === types$1._in) {
+      if ((init.kind === "using" || init.kind === "await using") && !init.declarations[0].init) {
+        this.raise(this.start, "Using declaration is not allowed in for-in loops");
+      }
+      if (this.options.ecmaVersion >= 9 && awaitAt > -1) { this.unexpected(awaitAt); }
+    } else if (this.options.ecmaVersion >= 9) { node.await = awaitAt > -1; }
     return this.parseForIn(node, init)
   }
   if (awaitAt > -1) { this.unexpected(awaitAt); }
@@ -2265,11 +2329,11 @@ function checkKeyName(node, name) {
 
 // Parses module export declaration.
 
-pp$8.parseExportAllDeclaration = function(node, exports) {
+pp$8.parseExportAllDeclaration = function(node, exports$1) {
   if (this.options.ecmaVersion >= 11) {
     if (this.eatContextual("as")) {
       node.exported = this.parseModuleExportName();
-      this.checkExport(exports, node.exported, this.lastTokStart);
+      this.checkExport(exports$1, node.exported, this.lastTokStart);
     } else {
       node.exported = null;
     }
@@ -2283,14 +2347,14 @@ pp$8.parseExportAllDeclaration = function(node, exports) {
   return this.finishNode(node, "ExportAllDeclaration")
 };
 
-pp$8.parseExport = function(node, exports) {
+pp$8.parseExport = function(node, exports$1) {
   this.next();
   // export * from '...'
   if (this.eat(types$1.star)) {
-    return this.parseExportAllDeclaration(node, exports)
+    return this.parseExportAllDeclaration(node, exports$1)
   }
   if (this.eat(types$1._default)) { // export default ...
-    this.checkExport(exports, "default", this.lastTokStart);
+    this.checkExport(exports$1, "default", this.lastTokStart);
     node.declaration = this.parseExportDefaultDeclaration();
     return this.finishNode(node, "ExportDefaultDeclaration")
   }
@@ -2298,16 +2362,16 @@ pp$8.parseExport = function(node, exports) {
   if (this.shouldParseExportStatement()) {
     node.declaration = this.parseExportDeclaration(node);
     if (node.declaration.type === "VariableDeclaration")
-      { this.checkVariableExport(exports, node.declaration.declarations); }
+      { this.checkVariableExport(exports$1, node.declaration.declarations); }
     else
-      { this.checkExport(exports, node.declaration.id, node.declaration.id.start); }
+      { this.checkExport(exports$1, node.declaration.id, node.declaration.id.start); }
     node.specifiers = [];
     node.source = null;
     if (this.options.ecmaVersion >= 16)
       { node.attributes = []; }
   } else { // export { x, y as z } [from '...']
     node.declaration = null;
-    node.specifiers = this.parseExportSpecifiers(exports);
+    node.specifiers = this.parseExportSpecifiers(exports$1);
     if (this.eatContextual("from")) {
       if (this.type !== types$1.string) { this.unexpected(); }
       node.source = this.parseExprAtom();
@@ -2357,47 +2421,47 @@ pp$8.parseExportDefaultDeclaration = function() {
   }
 };
 
-pp$8.checkExport = function(exports, name, pos) {
-  if (!exports) { return }
+pp$8.checkExport = function(exports$1, name, pos) {
+  if (!exports$1) { return }
   if (typeof name !== "string")
     { name = name.type === "Identifier" ? name.name : name.value; }
-  if (hasOwn(exports, name))
+  if (hasOwn(exports$1, name))
     { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
-  exports[name] = true;
+  exports$1[name] = true;
 };
 
-pp$8.checkPatternExport = function(exports, pat) {
+pp$8.checkPatternExport = function(exports$1, pat) {
   var type = pat.type;
   if (type === "Identifier")
-    { this.checkExport(exports, pat, pat.start); }
+    { this.checkExport(exports$1, pat, pat.start); }
   else if (type === "ObjectPattern")
     { for (var i = 0, list = pat.properties; i < list.length; i += 1)
       {
         var prop = list[i];
 
-        this.checkPatternExport(exports, prop);
+        this.checkPatternExport(exports$1, prop);
       } }
   else if (type === "ArrayPattern")
     { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
       var elt = list$1[i$1];
 
-        if (elt) { this.checkPatternExport(exports, elt); }
+        if (elt) { this.checkPatternExport(exports$1, elt); }
     } }
   else if (type === "Property")
-    { this.checkPatternExport(exports, pat.value); }
+    { this.checkPatternExport(exports$1, pat.value); }
   else if (type === "AssignmentPattern")
-    { this.checkPatternExport(exports, pat.left); }
+    { this.checkPatternExport(exports$1, pat.left); }
   else if (type === "RestElement")
-    { this.checkPatternExport(exports, pat.argument); }
+    { this.checkPatternExport(exports$1, pat.argument); }
 };
 
-pp$8.checkVariableExport = function(exports, decls) {
-  if (!exports) { return }
+pp$8.checkVariableExport = function(exports$1, decls) {
+  if (!exports$1) { return }
   for (var i = 0, list = decls; i < list.length; i += 1)
     {
     var decl = list[i];
 
-    this.checkPatternExport(exports, decl.id);
+    this.checkPatternExport(exports$1, decl.id);
   }
 };
 
@@ -2412,13 +2476,13 @@ pp$8.shouldParseExportStatement = function() {
 
 // Parses a comma-separated list of module exports.
 
-pp$8.parseExportSpecifier = function(exports) {
+pp$8.parseExportSpecifier = function(exports$1) {
   var node = this.startNode();
   node.local = this.parseModuleExportName();
 
   node.exported = this.eatContextual("as") ? this.parseModuleExportName() : node.local;
   this.checkExport(
-    exports,
+    exports$1,
     node.exported,
     node.exported.start
   );
@@ -2426,7 +2490,7 @@ pp$8.parseExportSpecifier = function(exports) {
   return this.finishNode(node, "ExportSpecifier")
 };
 
-pp$8.parseExportSpecifiers = function(exports) {
+pp$8.parseExportSpecifiers = function(exports$1) {
   var nodes = [], first = true;
   // export { x, y as z } [from '...']
   this.expect(types$1.braceL);
@@ -2436,7 +2500,7 @@ pp$8.parseExportSpecifiers = function(exports) {
       if (this.afterTrailingComma(types$1.braceR)) { break }
     } else { first = false; }
 
-    nodes.push(this.parseExportSpecifier(exports));
+    nodes.push(this.parseExportSpecifier(exports$1));
   }
   return nodes
 };
@@ -3167,15 +3231,19 @@ pp$5.checkPropClash = function(prop, propHash, refDestructuringErrors) {
 // delayed syntax error at correct position).
 
 pp$5.parseExpression = function(forInit, refDestructuringErrors) {
-  var startPos = this.start, startLoc = this.startLoc;
-  var expr = this.parseMaybeAssign(forInit, refDestructuringErrors);
-  if (this.type === types$1.comma) {
-    var node = this.startNodeAt(startPos, startLoc);
-    node.expressions = [expr];
-    while (this.eat(types$1.comma)) { node.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors)); }
-    return this.finishNode(node, "SequenceExpression")
-  }
-  return expr
+  var this$1$1 = this;
+
+  return this.catchStackOverflow(function () {
+    var startPos = this$1$1.start, startLoc = this$1$1.startLoc;
+    var expr = this$1$1.parseMaybeAssign(forInit, refDestructuringErrors);
+    if (this$1$1.type === types$1.comma) {
+      var node = this$1$1.startNodeAt(startPos, startLoc);
+      node.expressions = [expr];
+      while (this$1$1.eat(types$1.comma)) { node.expressions.push(this$1$1.parseMaybeAssign(forInit, refDestructuringErrors)); }
+      return this$1$1.finishNode(node, "SequenceExpression")
+    }
+    return expr
+  })
 };
 
 // Parse an assignment expression. This includes applications of
@@ -3240,7 +3308,7 @@ pp$5.parseMaybeConditional = function(forInit, refDestructuringErrors) {
   var startPos = this.start, startLoc = this.startLoc;
   var expr = this.parseExprOps(forInit, refDestructuringErrors);
   if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
-  if (this.eat(types$1.question)) {
+  if (!(expr.type === "ArrowFunctionExpression" && expr.start === startPos) && this.eat(types$1.question)) {
     var node = this.startNodeAt(startPos, startLoc);
     node.test = expr;
     node.consequent = this.parseMaybeAssign();
@@ -3340,7 +3408,7 @@ pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forIni
     }
   }
 
-  if (!incDec && this.eat(types$1.starstar)) {
+  if (!incDec && !(expr.type === "ArrowFunctionExpression" && expr.start === startPos) && this.eat(types$1.starstar)) {
     if (sawUnary)
       { this.unexpected(this.lastTokStart); }
     else
@@ -3792,6 +3860,8 @@ pp$5.parseNew = function() {
   }
   var startPos = this.start, startLoc = this.startLoc;
   node.callee = this.parseSubscripts(this.parseExprAtom(null, false, true), startPos, startLoc, true, false);
+  if (node.callee.type === "Super")
+    { this.raiseRecoverable(startPos, "Invalid use of 'super'"); }
   if (this.eat(types$1.parenL)) { node.arguments = this.parseExprList(types$1.parenR, this.options.ecmaVersion >= 8, false); }
   else { node.arguments = empty; }
   return this.finishNode(node, "NewExpression")
@@ -6708,7 +6778,7 @@ pp.readWord = function() {
 // [ghbt]: https://github.com/acornjs/acorn/issues
 
 
-var version = "8.16.0";
+var version = "8.18.0";
 
 Parser.acorn = {
   Parser: Parser,
@@ -7477,7 +7547,7 @@ function read(jsonPath, {base, specifier}) {
   let string;
 
   try {
-    string = fs.readFileSync(path.toNamespacedPath(jsonPath), 'utf8');
+    string = fs$1.readFileSync(path.toNamespacedPath(jsonPath), 'utf8');
   } catch (error) {
     const exception = /** @type {ErrnoException} */ (error);
 
@@ -9299,7 +9369,7 @@ async function extractExports(name, url, cache = true) {
     return JSON.parse(await promises.readFile(cachePath, "utf-8"));
   const scanned = await resolveModuleExportNames(name, { url });
   if (useCache) {
-    await promises.mkdir(dirname$1(cachePath), { recursive: true });
+    await promises.mkdir(dirname(cachePath), { recursive: true });
     await promises.writeFile(cachePath, JSON.stringify(scanned), "utf-8");
   }
   return scanned;
@@ -10280,36 +10350,93 @@ function safeKey(key) {
   return JSON.stringify(key);
 }
 
+function getHomeDir() {
+  return process.env.XDG_CONFIG_HOME || homedir();
+}
+async function readLocalOptions(defaults, options) {
+  const { filePath } = getOptionsFilepath(options);
+  if (existsSync(filePath)) {
+    try {
+      const options2 = {
+        ...defaults,
+        ...JSON.parse(await fs.readFile(filePath, "utf-8")).settings || {}
+      };
+      return options2;
+    } catch (e) {
+      console.error(`[DevTools] failed to parse local options file: ${filePath}, fallback to defaults`);
+      console.error(e);
+      return { ...defaults };
+    }
+  } else {
+    return { ...defaults };
+  }
+}
+function getOptionsFilepath(options) {
+  let hashedKey;
+  if (options.key)
+    hashedKey = hash(`${options.root}:${options.key}`);
+  else
+    hashedKey = hash(options.root);
+  const home = getHomeDir();
+  const filePath = join(home, ".nuxt/devtools", `${hashedKey}.json`);
+  return {
+    filePath,
+    hashedKey
+  };
+}
+async function clearLocalOptions(options) {
+  const { filePath } = getOptionsFilepath(options);
+  if (existsSync(filePath))
+    await fs.unlink(filePath);
+}
+async function writeLocalOptions(settings, options) {
+  const { filePath, hashedKey } = getOptionsFilepath(options);
+  await fs.mkdir(dirname$1(filePath), { recursive: true });
+  await fs.writeFile(
+    filePath,
+    JSON.stringify(
+      {
+        root: options.root,
+        hash: hashedKey,
+        settings
+      },
+      null,
+      2
+    ),
+    "utf-8"
+  );
+}
+
 let options;
 function getOptions() {
   return options;
 }
-function setupOptionsRPC({ nuxt, ensureDevAuthToken }) {
+function setupOptionsRPC({ nuxt }) {
+  const hasReadOnce = /* @__PURE__ */ new Set();
   async function getOptions2(tab) {
-    if (!options || options[tab]) {
-      options = defaultTabOptions;
+    if (!options)
+      options = createDefaultTabOptions();
+    if (!hasReadOnce.has(tab))
       await read(tab);
-    }
     return options[tab];
   }
   async function read(tab) {
-    options[tab] = await readLocalOptions(defaultTabOptions[tab], {
+    options[tab] = await readLocalOptions(createDefaultTabOptions()[tab], {
       root: nuxt.options.rootDir,
       key: tab !== "ui" && tab
     });
+    hasReadOnce.add(tab);
     return options;
   }
   getOptions2("ui");
-  async function clearOptions(token) {
-    await ensureDevAuthToken(token);
+  async function clearOptions() {
     options = void 0;
     await clearLocalOptions({
       root: nuxt.options.rootDir
     });
   }
   return {
-    async updateOptions(token, tab, _settings) {
-      await ensureDevAuthToken(token);
+    async updateOptions(tab, _settings) {
       const settings = await getOptions2(tab);
       Object.assign(settings, _settings);
       await writeLocalOptions(
@@ -10332,12 +10459,11 @@ function setupOptionsRPC({ nuxt, ensureDevAuthToken }) {
 
 const ABSOLUTE_PATH_RE = /^[a-z]:|^\//i;
 const FILE_LINE_COL_RE = /^(.*?)(:[:\d]*)$/;
-const MULTIPLE_SLASHES_RE$1 = /\/+/g;
+const NUXT_WELCOME_RE = /<NuxtWelcome\s*\/>/;
 function setupGeneralRPC({
   nuxt,
   options,
   refresh,
-  ensureDevAuthToken,
   openInEditorHooks
 }) {
   const components = [];
@@ -10393,14 +10519,7 @@ function setupGeneralRPC({
   });
   return {
     getServerConfig() {
-      const { runtimeConfig, ...rest } = nuxt.options;
-      return {
-        ...rest,
-        runtimeConfig: {
-          app: runtimeConfig?.app,
-          public: runtimeConfig?.public
-        }
-      };
+      return nuxt.options;
     },
     async getServerDebugContext() {
       if (!nuxt._debug)
@@ -10434,8 +10553,7 @@ function setupGeneralRPC({
         )
       };
     },
-    async getServerRuntimeConfig(token) {
-      await ensureDevAuthToken(token);
+    getServerRuntimeConfig() {
       const ENV_PREFIX = "NITRO_";
       const ENV_PREFIX_ALT = "NUXT_";
       function _getEnv(key) {
@@ -10494,8 +10612,7 @@ function setupGeneralRPC({
     getServerHooks() {
       return Object.values(serverHooks);
     },
-    async openInEditor(token, input) {
-      await ensureDevAuthToken(token);
+    async openInEditor(input) {
       if (input.startsWith("./") || !ABSOLUTE_PATH_RE.test(input))
         input = resolve(process.cwd(), input);
       const match = input.match(FILE_LINE_COL_RE);
@@ -10530,44 +10647,261 @@ function setupGeneralRPC({
         return false;
       }
     },
-    async restartNuxt(token, hard = true) {
-      await ensureDevAuthToken(token);
+    async enablePages() {
+      const baseDir = nuxt.options.future.compatibilityVersion === 4 ? nuxt.options.dir.app : nuxt.options.srcDir;
+      const pathApp = join(baseDir, "app.vue");
+      const pathPageIndex = join(baseDir, "pages/index.vue");
+      if (existsSync(pathPageIndex)) {
+        logger.warn("pages/index.vue already exists, skipping");
+        return;
+      }
+      const pagesIndexTemplate = `<script setup lang="ts">
+const route = useRoute()
+<\/script>
+
+<template>
+  <div>
+    <h1>Nuxt Routing set up successfully!</h1>
+    <p>Current route: {{ route.path }}</p>
+    <a href="https://nuxt.com/docs/getting-started/routing" target="_blank">Learn more about Nuxt Routing</a>
+  </div>
+</template>
+`;
+      await fs.mkdir(dirname(pathPageIndex), { recursive: true });
+      await fs.writeFile(pathPageIndex, pagesIndexTemplate, "utf-8");
+      let appContent = existsSync(pathApp) ? await fs.readFile(pathApp, "utf-8") : void 0;
+      if (appContent && !appContent.includes("<NuxtPage")) {
+        appContent = appContent.replace("</template>", "  <NuxtPage />\n</template>").replace(NUXT_WELCOME_RE, "");
+        await fs.writeFile(pathApp, appContent, "utf-8");
+      }
+      logger.success("Routing creation completed");
+    },
+    async restartNuxt(hard = true) {
       logger.info("Restarting Nuxt...");
       return nuxt.callHook("restart", { hard });
     },
-    async requestForAuth(info) {
-      if (options.disableAuthorization)
-        return;
-      const token = await getDevAuthToken();
-      const origin = `${nuxt.options.devServer.https ? "https" : "http"}://${nuxt.options.devServer.host === "::" ? "localhost" : nuxt.options.devServer.host || "localhost"}:${nuxt.options.devServer.port}`;
-      const ROUTE_AUTH = `${nuxt.options.app.baseURL || "/"}/__nuxt_devtools__/auth`.replace(MULTIPLE_SLASHES_RE$1, "/");
-      const message = [
-        `A browser is requesting permissions of ${colors.bold(colors.yellow("writing files and running commands"))} from the DevTools UI.`,
-        colors.bold(info || "Unknown"),
-        "",
-        "Please open the following URL in the browser:",
-        colors.bold(colors.green(`${origin}${ROUTE_AUTH}?token=${token}`)),
-        "",
-        "Or manually copy and paste the following token:",
-        colors.bold(colors.cyan(token))
-      ];
-      logger.box({
-        message: message.join("\n"),
-        title: colors.bold(colors.yellow(" Permission Request ")),
-        style: {
-          borderColor: "yellow",
-          borderStyle: "rounded"
-        }
-      });
+    /** @deprecated Auth is now handled by Vite DevTools */
+    async requestForAuth() {
+      logger.warn("[nuxt-devtools] `requestForAuth` is deprecated. Auth is now handled by Vite DevTools.");
     },
-    async verifyAuthToken(token) {
-      if (options.disableAuthorization)
-        return true;
-      return token === await getDevAuthToken();
+    /** @deprecated Auth is now handled by Vite DevTools */
+    async verifyAuthToken() {
+      logger.warn("[nuxt-devtools] `verifyAuthToken` is deprecated. Auth is now handled by Vite DevTools.");
+      return true;
+    }
+  };
+}
+
+function toEntryInput(input) {
+  return {
+    message: input.message,
+    level: input.level ?? "info",
+    description: input.description,
+    labels: input.labels,
+    category: input.category,
+    filePosition: input.filePosition,
+    stacktrace: input.stacktrace,
+    notify: input.notify,
+    autoDismiss: input.autoDismiss,
+    autoDelete: input.autoDelete
+  };
+}
+function createNotifier(nuxt) {
+  let messages;
+  const pending = [];
+  function add(input) {
+    void messages.add(toEntryInput(input)).catch(() => {
+    });
+  }
+  function notify(input) {
+    if (!messages) {
+      pending.push(input);
+      return;
+    }
+    add(input);
+  }
+  onDevtoolsReady((kit) => {
+    messages = kit.messages;
+    for (const input of pending)
+      add(input);
+    pending.length = 0;
+  }, nuxt);
+  nuxt.hook("devtools:notify", notify);
+  return notify;
+}
+function setupMessagesRPC(ctx) {
+  return {
+    async notify(input) {
+      ctx.notify(input);
     }
   };
 }
 
+const AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "pnpm-rush",
+  "bun",
+  "deno",
+  "nub",
+  "aube"
+];
+const LOCKS = {
+  "aube-lock.yaml": "aube",
+  "aube-workspace.yaml": "aube",
+  "bun.lock": "bun",
+  "bun.lockb": "bun",
+  "deno.lock": "deno",
+  "nub.lock": "nub",
+  "pnpm-lock.yaml": "pnpm",
+  "pnpm-workspace.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+const INSTALL_METADATA = {
+  "node_modules/.aube/": "aube",
+  "node_modules/.deno/": "deno",
+  "node_modules/.pnpm/": "pnpm",
+  "node_modules/.yarn-state.yml": "yarn",
+  // yarn v2+ (node-modules)
+  "node_modules/.yarn_integrity": "yarn",
+  // yarn v1
+  "node_modules/.package-lock.json": "npm",
+  ".pnp.cjs": "yarn",
+  // yarn v3+ (pnp)
+  ".pnp.js": "yarn",
+  // yarn v2 (pnp)
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+};
+
+async function pathExists(path2, type) {
+  try {
+    const stat = await fs.stat(path2);
+    return type === "file" ? stat.isFile() : stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function* lookup(cwd = process$1.cwd()) {
+  let directory = path.resolve(cwd);
+  const { root } = path.parse(directory);
+  while (directory && directory !== root) {
+    yield directory;
+    directory = path.dirname(directory);
+  }
+}
+async function parsePackageJson(filepath, options) {
+  if (!filepath || !await pathExists(filepath, "file"))
+    return null;
+  return await handlePackageManager(filepath, options);
+}
+async function detect(options = {}) {
+  const {
+    cwd,
+    strategies = ["lockfile", "packageManager-field", "devEngines-field"]
+  } = options;
+  let stopDir;
+  if (typeof options.stopDir === "string") {
+    const resolved = path.resolve(options.stopDir);
+    stopDir = (dir) => dir === resolved;
+  } else {
+    stopDir = options.stopDir;
+  }
+  for (const directory of lookup(cwd)) {
+    for (const strategy of strategies) {
+      switch (strategy) {
+        case "lockfile": {
+          if (await pathExists(path.join(directory, "rush.json"), "file")) {
+            return { name: "pnpm", agent: "pnpm-rush" };
+          }
+          for (const lock of Object.keys(LOCKS)) {
+            if (await pathExists(path.join(directory, lock), "file")) {
+              const name = LOCKS[lock];
+              const result = await parsePackageJson(path.join(directory, "package.json"), options);
+              if (result)
+                return result;
+              else
+                return { name, agent: name };
+            }
+          }
+          break;
+        }
+        case "packageManager-field":
+        case "devEngines-field": {
+          const result = await parsePackageJson(path.join(directory, "package.json"), options);
+          if (result)
+            return result;
+          break;
+        }
+        case "install-metadata": {
+          for (const metadata of Object.keys(INSTALL_METADATA)) {
+            const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
+            if (await pathExists(path.join(directory, metadata), fileOrDir)) {
+              const name = INSTALL_METADATA[metadata];
+              const agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
+              return { name, agent };
+            }
+          }
+          break;
+        }
+      }
+    }
+    if (stopDir?.(directory))
+      break;
+  }
+  return null;
+}
+function getNameAndVer(pkg) {
+  const handelVer = (version) => version?.match(/\d+(\.\d+){0,2}/)?.[0] ?? version;
+  if (typeof pkg.packageManager === "string") {
+    const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+    return { name, ver: handelVer(ver) };
+  }
+  if (typeof pkg.devEngines?.packageManager?.name === "string") {
+    return {
+      name: pkg.devEngines.packageManager.name,
+      ver: handelVer(pkg.devEngines.packageManager.version)
+    };
+  }
+  return void 0;
+}
+async function handlePackageManager(filepath, options) {
+  try {
+    const content = await fs.readFile(filepath, "utf8");
+    const pkg = options.packageJsonParser ? await options.packageJsonParser(content, filepath) : JSON.parse(content);
+    let agent;
+    const nameAndVer = getNameAndVer(pkg);
+    if (nameAndVer) {
+      const name = nameAndVer.name;
+      const ver = nameAndVer.ver;
+      let version = ver;
+      if (name === "yarn" && ver && Number.parseInt(ver) > 1) {
+        agent = "yarn@berry";
+        version = "berry";
+        return { name, agent, version };
+      } else if (name === "pnpm" && ver && Number.parseInt(ver) < 7) {
+        agent = "pnpm@6";
+        return { name, agent, version };
+      } else if (AGENTS.includes(name)) {
+        agent = name;
+        return { name, agent, version };
+      } else {
+        return options.onUnknown?.(pkg.packageManager) ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function isMetadataYarnClassic(metadataPath) {
+  return metadataPath.endsWith(".yarn_integrity");
+}
+
 class FetchError extends Error {
   constructor(message, opts) {
     super(message, opts);
@@ -10952,7 +11286,7 @@ async function checkForUpdateOf(name, current, nuxt = useNuxt()) {
     const { version: latest } = await getLatestVersion(name, {
       fetch
     });
-    const needsUpdate = !!latest && latest !== current && semver.lt(current, latest);
+    const needsUpdate = !!latest && latest !== current && isLess(current, latest);
     return {
       name,
       current,
@@ -10976,19 +11310,190 @@ async function magicastGuard(fn, message = "") {
   return generated;
 }
 
-function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
-  let detectPromise;
-  const updatesPromise = /* @__PURE__ */ new Map();
-  function getPackageManager() {
-    detectPromise ||= detectPackageManager(nuxt.options.rootDir);
-    return detectPromise;
+function removeNuxtModuleFromCode(source, name, filepath) {
+  const mod = parseModule(source, filepath ? { sourceFileName: filepath } : void 0);
+  const config = getDefaultExportOptions(mod);
+  if (!Array.isArray(config.modules))
+    return mod.generate().code;
+  for (let i = config.modules.length - 1; i >= 0; i--) {
+    const entry = config.modules[i];
+    const matches = typeof entry === "string" ? entry === name : Array.isArray(entry) && entry[0] === name;
+    if (matches)
+      config.modules.splice(i, 1);
+  }
+  return mod.generate().code;
+}
+
+function broadcastTerminalExit(ctx, id, code) {
+  ctx.devtoolsKit?.rpc.broadcast({ method: "onTerminalExit", args: [{ id, code }], event: true });
+}
+function statusForExit(code) {
+  return code == null || code === 0 ? "stopped" : "error";
+}
+function setupTerminalsBridge(ctx) {
+  const { nuxt } = ctx;
+  const runs = /* @__PURE__ */ new Map();
+  const generations = /* @__PURE__ */ new Map();
+  let host;
+  function createRun(terminal) {
+    const legacyId = terminal.id;
+    const generation = (generations.get(legacyId) ?? 0) + 1;
+    generations.set(legacyId, generation);
+    let controller;
+    const stream = new ReadableStream({
+      start(c) {
+        controller = c;
+      }
+    });
+    const session = {
+      id: createUniqueSessionId(legacyId),
+      title: terminal.name,
+      description: terminal.description,
+      icon: terminal.icon,
+      status: "running",
+      interactive: false,
+      stream
+    };
+    return {
+      legacyId,
+      sessionId: session.id,
+      generation,
+      session,
+      controller,
+      registered: false,
+      streamClosed: false,
+      pendingChunks: []
+    };
   }
-  async function getNpmCommand(command, packageName, options = {}) {
-    const {
-      dev = true,
-      global = packageName === "@nuxt/devtools" && isInstalledGlobally
-    } = options;
-    const agent = await getPackageManager();
+  function isCurrent(run) {
+    return runs.get(run.legacyId) === run;
+  }
+  function closeStream(run) {
+    if (run.streamClosed)
+      return;
+    run.streamClosed = true;
+    try {
+      run.controller?.close();
+    } catch {
+    }
+  }
+  function applyExit(run, code) {
+    if (!isCurrent(run) || run.streamClosed)
+      return;
+    closeStream(run);
+    run.session.status = statusForExit(code);
+    host?.update(run.session);
+  }
+  function registerWithHost(run) {
+    if (!host || run.registered || !isCurrent(run))
+      return;
+    host.register(run.session);
+    run.registered = true;
+    for (const chunk of run.pendingChunks) {
+      try {
+        run.controller?.enqueue(chunk);
+      } catch {
+      }
+    }
+    run.pendingChunks.length = 0;
+    if (run.pendingExit) {
+      const { code } = run.pendingExit;
+      run.pendingExit = void 0;
+      applyExit(run, code);
+    }
+  }
+  nuxt.hook("devtools:terminal:register", (terminal) => {
+    const existing = runs.get(terminal.id);
+    if (existing) {
+      closeStream(existing);
+      if (host && existing.registered)
+        host.remove(existing.session);
+    }
+    const run = createRun(terminal);
+    runs.set(terminal.id, run);
+    if (host)
+      registerWithHost(run);
+    return terminal.id;
+  });
+  nuxt.hook("devtools:terminal:write", ({ id, data }) => {
+    const run = runs.get(id);
+    if (!run || run.streamClosed)
+      return false;
+    if (run.registered) {
+      try {
+        run.controller?.enqueue(data);
+      } catch {
+      }
+    } else {
+      run.pendingChunks.push(data);
+    }
+    return true;
+  });
+  nuxt.hook("devtools:terminal:exit", ({ id, code }) => {
+    const run = runs.get(id);
+    if (!run)
+      return false;
+    if (run.registered)
+      applyExit(run, code);
+    else
+      run.pendingExit = { code };
+    return true;
+  });
+  nuxt.hook("devtools:terminal:remove", ({ id }) => {
+    const run = runs.get(id);
+    if (!run)
+      return false;
+    closeStream(run);
+    runs.delete(id);
+    if (host && run.registered)
+      host.remove(run.session);
+    return true;
+  });
+  nuxt.hook("devtools:ready", (kit) => {
+    host = kit.terminals;
+    for (const run of runs.values())
+      registerWithHost(run);
+  });
+  return {
+    /**
+     * Focus the built-in **Terminals** dock on a session (Devframe 0.7
+     * `docks.activate`, driven by the `hub:docks:activate` RPC). Replaces the
+     * old in-client "go to Terminals tab" navigation now that terminals live in
+     * the hub dock. `id` is a unique Devframe session id (from a bridged run or
+     * a `startChildProcess` call). Returns `false` when the kit isn't connected
+     * or the session is unknown.
+     */
+    async revealTerminal(id) {
+      const kit = ctx.devtoolsKit;
+      if (!kit)
+        return false;
+      if (!kit.terminals.sessions.has(id))
+        return false;
+      kit.docks.activate(DEVTOOLS_TERMINALS_DOCK_ID, { sessionId: id });
+      return true;
+    }
+  };
+}
+
+function setupNpmRPC(ctx) {
+  const { nuxt } = ctx;
+  function getTerminals() {
+    const kit = ctx.devtoolsKit;
+    if (!kit)
+      throw new Error("[Nuxt DevTools] Vite DevTools kit is not connected yet.");
+    return kit.terminals;
+  }
+  let detectPromise;
+  const updatesPromise = /* @__PURE__ */ new Map();
+  function getPackageManager() {
+    detectPromise ||= detect({ cwd: nuxt.options.rootDir });
+    return detectPromise;
+  }
+  async function getNpmCommand(command, packageName, options = {}) {
+    const {
+      dev = true
+    } = options;
+    const agent = await getPackageManager();
     const name = agent?.name || "npm";
     if (command === "install" || command === "update") {
       return [
@@ -10996,7 +11501,6 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
         name === "npm" ? "install" : "add",
         `${packageName}@latest`,
         dev ? "-D" : "",
-        global ? "-g" : "",
         // In yarn berry, `--ignore-scripts` is removed
         name === "yarn" && !agent?.version?.startsWith("1.") ? "" : "--ignore-scripts"
       ].filter(Boolean);
@@ -11005,8 +11509,7 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
       return [
         name,
         name === "npm" ? "uninstall" : "remove",
-        packageName,
-        global ? "-g" : ""
+        packageName
       ].filter(Boolean);
     }
   }
@@ -11014,15 +11517,18 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
     const args = await getNpmCommand(command, packageName, options);
     if (!args)
       return;
-    const processId = `npm:${command}:${packageName}`;
-    startSubprocess({
+    const processId = createUniqueSessionId(`npm:${command}:${packageName}`);
+    const session = await getTerminals().startChildProcess({
       command: args[0],
       args: args.slice(1)
     }, {
       id: processId,
-      name: `${command} ${packageName}`,
-      icon: "i-logos-npm-icon",
-      restartable: false
+      title: `${command} ${packageName}`,
+      icon: "i-logos-npm-icon"
+    });
+    void Promise.resolve(session.getResult()).then((result) => {
+      broadcastTerminalExit(ctx, processId, result.exitCode);
+    }).catch(() => {
     });
     return {
       processId
@@ -11037,46 +11543,55 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
       return updatesPromise.get(name);
     },
     getNpmCommand,
-    async runNpmCommand(token, ...args) {
-      await ensureDevAuthToken(token);
+    async runNpmCommand(...args) {
       return runNpmCommand(...args);
     },
-    async installNuxtModule(token, name, dry = true) {
-      await ensureDevAuthToken(token);
+    async installNuxtModule(name, dry = true, sessionId) {
       const commands = await getNpmCommand("install", name, { dev: true });
       const filepath = nuxt.options._nuxtConfigFile;
       let source = latestGenerated;
-      source ??= await fsp.readFile(filepath, "utf-8");
+      source ??= await fs.readFile(filepath, "utf-8");
       const generated = await magicastGuard(async () => {
         const mod = parseModule(source, { sourceFileName: filepath });
         addNuxtModule(mod, name);
         return mod.generate().code;
       });
-      const processId = `nuxt:add-module:${name}`;
+      const processId = sessionId ?? createUniqueSessionId(`nuxt:add-module:${name}`);
       if (!dry) {
         latestGenerated = generated;
         installSet.add(name);
-        const process = startSubprocess({
+        const session = await getTerminals().startChildProcess({
           command: commands[0],
           args: commands.slice(1)
         }, {
           id: processId,
-          name: `Install ${name}`,
-          icon: "carbon:intent-request-create",
-          restartable: false
+          title: `Install ${name}`,
+          icon: "carbon:intent-request-create"
         });
-        const execa = process.getProcess();
-        const result = await execa;
+        const result = await session.getResult();
         await Promise.resolve();
         installSet.delete(name);
         const code = result.exitCode;
         if (code !== 0) {
           console.error(result.stderr);
+          ctx.notify({
+            message: `Failed to install ${name}`,
+            level: "error",
+            description: `Process exited with code ${code}. Check the Install ${name} terminal for details.`,
+            category: "module",
+            notify: true
+          });
           throw new Error(`[Nuxt DevTools] Failed to install module, process exited with ${code}`);
         }
+        ctx.notify({
+          message: `Installed ${name}`,
+          level: "success",
+          category: "module",
+          notify: true
+        });
         if (installSet.size === 0) {
           latestGenerated = null;
-          await fsp.writeFile(filepath, generated, "utf-8");
+          await fs.writeFile(filepath, generated, "utf-8");
         }
       }
       return {
@@ -11086,43 +11601,44 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
         processId
       };
     },
-    async uninstallNuxtModule(token, name, dry = true) {
-      await ensureDevAuthToken(token);
+    async uninstallNuxtModule(name, dry = true, sessionId) {
       const commands = await getNpmCommand("uninstall", name);
       const filepath = nuxt.options._nuxtConfigFile;
-      const source = await fsp.readFile(filepath, "utf-8");
+      const source = await fs.readFile(filepath, "utf-8");
       const generated = await magicastGuard(async () => {
-        const mod = parseModule(source, { sourceFileName: filepath });
-        const config = getDefaultExportOptions(mod);
-        config.modules ||= [];
-        if (config.modules.includes(name)) {
-          Object.values(config.modules).forEach((value, index) => {
-            if (value === name)
-              config.modules.splice(index - 1, 1);
-          });
-        }
-        return mod.generate().code;
+        return removeNuxtModuleFromCode(source, name, filepath);
       });
-      const processId = `nuxt:remove-module:${name}`;
+      const processId = sessionId ?? createUniqueSessionId(`nuxt:remove-module:${name}`);
       if (!dry) {
-        const process = startSubprocess({
+        const session = await getTerminals().startChildProcess({
           command: commands[0],
           args: commands.slice(1)
         }, {
           id: processId,
-          name: `Uninstall ${name}`,
-          icon: "carbon:intent-request-uninstall",
-          restartable: false
+          title: `Uninstall ${name}`,
+          icon: "carbon:intent-request-uninstall"
         });
-        const execa = process.getProcess();
-        const result = await execa;
+        const result = await session.getResult();
         await Promise.resolve();
         const code = result.exitCode;
         if (code !== 0) {
           console.error(result.stderr);
+          ctx.notify({
+            message: `Failed to uninstall ${name}`,
+            level: "error",
+            description: `Process exited with code ${code}. Check the Uninstall ${name} terminal for details.`,
+            category: "module",
+            notify: true
+          });
           throw new Error(`[Nuxt DevTools] Failed to uninstall module, process exited with ${code}`);
         }
-        await fsp.writeFile(filepath, generated, "utf-8");
+        ctx.notify({
+          message: `Uninstalled ${name}`,
+          level: "success",
+          category: "module",
+          notify: true
+        });
+        await fs.writeFile(filepath, generated, "utf-8");
       }
       return {
         configOriginal: source,
@@ -11134,112 +11650,24 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
   };
 }
 
-function setupServerDataRPC({
-  nuxt,
-  ensureDevAuthToken
-}) {
-  let nitro;
-  let viteServer;
-  let viteClient;
-  function normalizeViteConfig(config) {
-    return {
-      ...config,
-      environments: Object.fromEntries(
-        Object.entries(config.env).map(([key, _]) => {
-          return [key, null];
-        })
-      ),
-      plugins: config.plugins.map((i) => {
-        const clone = { ...i };
-        delete clone.api;
-        return clone;
-      }),
-      inlineConfig: null
-    };
-  }
-  nuxt.hook("nitro:build:before", (_nitro) => {
-    nitro = _nitro;
-  });
-  addVitePlugin({
-    name: "nuxt:devtools:config",
-    applyToEnvironment(environment) {
-      if (environment.name === "ssr") {
-        return {
-          name: "nuxt:devtools:config-retriever",
-          enforce: "post",
-          configResolved(config) {
-            viteServer = normalizeViteConfig(config);
-          }
-        };
-      }
-      if (environment.name === "client") {
-        return {
-          name: "nuxt:devtools:config-retriever",
-          enforce: "post",
-          configResolved(config) {
-            viteClient = normalizeViteConfig(config);
-          }
-        };
-      }
-    }
-  });
-  return {
-    getServerConfig() {
-      return nuxt.options;
-    },
-    async getServerData(token) {
-      await ensureDevAuthToken(token);
-      return {
-        nuxt: nuxt.options,
-        nitro: nitro?.options,
-        vite: {
-          server: viteServer,
-          client: viteClient
-        }
-      };
-    }
-  };
-}
-
-async function watchStorageMount(storage, mountName, onChange) {
-  const mountKey = normalizeBaseKey(mountName);
-  const mount = storage.getMount(mountKey);
-  if (!mount || normalizeBaseKey(mount.base) !== mountKey || !mount.driver?.watch)
-    return () => {
-    };
-  const unwatch = await mount.driver.watch((event, key) => {
-    const fullKey = key.startsWith(mountKey) ? key : `${mountKey}${key}`;
-    onChange(event, normalizeKey(fullKey));
-  });
-  return unwatch ?? (() => {
-  });
-}
-
 function setupServerRoutesRPC({ nuxt, refresh }) {
   let nitro;
-  let unwatchStorage;
+  let unhookDevReload;
   let cache = null;
   const refreshDebounced = debounce(() => {
     cache = null;
     refresh("getServerRoutes");
   }, 500);
-  nuxt.hook("nitro:init", (_) => {
-    nitro = _;
+  nuxt.hook("nitro:init", (_nitro) => {
+    nitro = _nitro;
     cache = null;
     refresh("getServerRoutes");
+    unhookDevReload?.();
+    unhookDevReload = _nitro.hooks.hook("dev:reload", () => refreshDebounced());
   });
-  nuxt.hook("ready", async () => {
-    if (!nitro)
-      return;
-    await unwatchStorage?.();
-    unwatchStorage = await watchStorageMount(nitro.storage, "src", (_event, key) => {
-      if (key.startsWith("src:api:") || key.startsWith("src:routes:"))
-        refreshDebounced();
-    });
-  });
-  nuxt.hook("close", async () => {
-    await unwatchStorage?.();
-    unwatchStorage = void 0;
+  nuxt.hook("close", () => {
+    unhookDevReload?.();
+    unhookDevReload = void 0;
   });
   function scan() {
     if (cache)
@@ -11273,29 +11701,22 @@ function setupServerRoutesRPC({ nuxt, refresh }) {
 
 function setupServerTasksRPC({ nuxt, refresh }) {
   let nitro;
-  let unwatchStorage;
+  let unhookDevReload;
   let cache = null;
   const refreshDebounced = debounce(() => {
     cache = null;
     refresh("getServerTasks");
   }, 500);
-  nuxt.hook("nitro:init", (_) => {
-    nitro = _;
+  nuxt.hook("nitro:init", (_nitro) => {
+    nitro = _nitro;
     cache = null;
     refresh("getServerTasks");
+    unhookDevReload?.();
+    unhookDevReload = _nitro.hooks.hook("dev:reload", () => refreshDebounced());
   });
-  nuxt.hook("ready", async () => {
-    if (!nitro)
-      return;
-    await unwatchStorage?.();
-    unwatchStorage = await watchStorageMount(nitro.storage, "src", (_event, key) => {
-      if (key.startsWith("src:tasks:"))
-        refreshDebounced();
-    });
-  });
-  nuxt.hook("close", async () => {
-    await unwatchStorage?.();
-    unwatchStorage = void 0;
+  nuxt.hook("close", () => {
+    unhookDevReload?.();
+    unhookDevReload = void 0;
   });
   function scan() {
     if (cache)
@@ -11308,7 +11729,15 @@ function setupServerTasksRPC({ nuxt, refresh }) {
         };
       }
       return {
-        tasks: nitro.options.tasks,
+        // Nitro v3's task config types `handler`/`description` as optional
+        // (they're always populated in practice by Nitro's own task scanner),
+        // so normalize with fallbacks to satisfy `ScannedNitroTasks`.
+        tasks: Object.fromEntries(
+          Object.entries(nitro.options.tasks ?? {}).map(([name, task]) => [
+            name,
+            { handler: task.handler ?? "", description: task.description ?? "" }
+          ])
+        ),
         scheduledTasks: Object.entries(nitro.options.scheduledTasks ?? {}).reduce((acc, [cron, tasks]) => {
           acc[cron] = Array.isArray(tasks) ? tasks : [tasks];
           return acc;
@@ -11324,24 +11753,53 @@ function setupServerTasksRPC({ nuxt, refresh }) {
   };
 }
 
+function skipInSSR(ctx) {
+  return Boolean(ctx?.viteConfig?.build?.ssr);
+}
+
+async function watchStorageMount(storage, mountName, onChange) {
+  const mountKey = normalizeBaseKey(mountName);
+  const mount = storage.getMount(mountKey);
+  if (!mount || normalizeBaseKey(mount.base) !== mountKey || !mount.driver?.watch)
+    return () => {
+    };
+  const unwatch = await mount.driver.watch((event, key) => {
+    const fullKey = key.startsWith(mountKey) ? key : `${mountKey}${key}`;
+    onChange(event, normalizeKey(fullKey));
+  });
+  return unwatch ?? (() => {
+  });
+}
+
 const IGNORE_STORAGE_MOUNTS = ["root", "build", "src", "cache"];
 function shouldIgnoreStorageKey(key) {
   return IGNORE_STORAGE_MOUNTS.includes(key.split(":")[0]);
 }
-function setupStorageRPC({
-  nuxt,
-  rpc,
-  ensureDevAuthToken
-}) {
+function setupStorageRPC(ctx) {
+  const { nuxt } = ctx;
   const storageMounts = {};
   let storage;
   let unwatchStorageMounts = [];
-  nuxt.hook("nitro:init", (nitro) => {
-    storage = nitro.storage;
+  nuxt.hook("nitro:init", async (nitro) => {
     const mounts = {
       ...nitro.options.storage,
       ...nitro.options.devStorage
     };
+    const nextStorage = createStorage();
+    for (const [path, opts] of Object.entries(mounts)) {
+      if (!opts?.driver) {
+        nitro.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
+        continue;
+      }
+      try {
+        const driverImport = builtinDrivers[opts.driver] || opts.driver;
+        const driverFactory = await import(driverImport).then((r) => r.default || r);
+        nextStorage.mount(path, driverFactory(opts));
+      } catch (err) {
+        nitro.logger.warn(`Failed to mount storage driver "${opts.driver}" for the DevTools storage browser:`, err);
+      }
+    }
+    storage = nextStorage;
     for (const key of Object.keys(storageMounts))
       delete storageMounts[key];
     for (const name of Object.keys(mounts)) {
@@ -11356,7 +11814,7 @@ function setupStorageRPC({
       return;
     await Promise.all(unwatchStorageMounts.map((unwatch) => unwatch()));
     unwatchStorageMounts = await Promise.all(Object.keys(storageMounts).map((mountName) => watchStorageMount(activeStorage, mountName, (event, key) => {
-      rpc.broadcast.callHook.asEvent("storage:key:update", key, event);
+      ctx.devtoolsKit?.rpc.broadcast({ method: "callHook", args: ["storage:key:update", key, event], event: true });
     })));
   });
   nuxt.hook("close", async () => {
@@ -11378,20 +11836,17 @@ function setupStorageRPC({
         return [];
       }
     },
-    async getStorageItem(token, key) {
-      await ensureDevAuthToken(token);
+    async getStorageItem(key) {
       if (!storage)
         return null;
       return await storage.getItem(key);
     },
-    async setStorageItem(token, key, value) {
-      await ensureDevAuthToken(token);
+    async setStorageItem(key, value) {
       if (!storage)
         return;
       return await storage.setItem(key, value);
     },
-    async removeStorageItem(token, key) {
-      await ensureDevAuthToken(token);
+    async removeStorageItem(key) {
       if (!storage)
         return;
       return await storage.removeItem(key);
@@ -11447,97 +11902,11 @@ function telemetryEvent(payload, immediate = false) {
     throttledSend();
 }
 
-function setupTerminalRPC({ nuxt, rpc, refresh, ensureDevAuthToken }) {
-  const terminals = /* @__PURE__ */ new Map();
-  nuxt.hook("devtools:terminal:register", (terminal) => {
-    terminals.set(terminal.id, terminal);
-    refresh("getTerminals");
-    return terminal.id;
-  });
-  nuxt.hook("devtools:terminal:remove", ({ id }) => {
-    if (!terminals.has(id))
-      return false;
-    terminals.delete(id);
-    refresh("getTerminals");
-    return true;
-  });
-  nuxt.hook("devtools:terminal:write", ({ id, data }) => {
-    const terminal = terminals.get(id);
-    if (!terminal)
-      return false;
-    terminal.buffer ||= "";
-    terminal.buffer += data;
-    rpc.broadcast.onTerminalData.asEvent({ id, data });
-    return true;
-  });
-  nuxt.hook("devtools:terminal:exit", ({ id, code }) => {
-    const terminal = terminals.get(id);
-    if (!terminal)
-      return false;
-    terminal.isTerminated = true;
-    rpc.broadcast.onTerminalExit.asEvent({ id, code });
-    refresh("getTerminals");
-    return true;
-  });
-  function serializeTerminal(terminal, buffer = false) {
-    if (!terminal)
-      return;
-    return {
-      id: terminal.id,
-      name: terminal.name,
-      description: terminal.description,
-      icon: terminal.icon,
-      terminatable: terminal.terminatable ?? !!terminal.onActionTerminate,
-      restartable: terminal.restartable ?? !!terminal.onActionRestart,
-      isTerminated: terminal.isTerminated,
-      buffer: buffer ? terminal.buffer : void 0
-    };
-  }
+function setupTimelineRPC({ nuxt }) {
   return {
-    getTerminals() {
-      return Array.from(terminals.values(), (i) => serializeTerminal(i));
-    },
-    async getTerminalDetail(token, id) {
-      await ensureDevAuthToken(token);
-      return serializeTerminal(terminals.get(id), true);
-    },
-    async runTerminalAction(token, id, action) {
-      await ensureDevAuthToken(token);
-      const terminal = terminals.get(id);
-      if (!terminal)
-        return false;
-      switch (action) {
-        case "restart":
-          if (!terminal.onActionRestart)
-            return false;
-          await terminal.onActionRestart();
-          return true;
-        case "terminate":
-          if (!terminal.onActionTerminate)
-            return false;
-          await terminal.onActionTerminate();
-          return true;
-        case "remove":
-          if (!terminal.isTerminated)
-            terminal.onActionTerminate?.();
-          terminals.delete(id);
-          refresh("getTerminals");
-          return true;
-        case "clear":
-          terminal.buffer = "";
-          refresh("getTerminals");
-          return true;
-      }
-    }
-  };
-}
-
-function setupTimelineRPC({ nuxt, ensureDevAuthToken }) {
-  return {
-    async enableTimeline(token, dry) {
-      await ensureDevAuthToken(token);
+    async enableTimeline(dry) {
       const filepath = nuxt.options._nuxtConfigFile;
-      const source = await fsp.readFile(filepath, "utf-8");
+      const source = await fs.readFile(filepath, "utf-8");
       const generated = await magicastGuard(async () => {
         const mod = parseModule(source, { sourceFileName: filepath });
         const options = getDefaultExportOptions(mod);
@@ -11547,7 +11916,7 @@ function setupTimelineRPC({ nuxt, ensureDevAuthToken }) {
         return mod.generate().code;
       }, "\nYou can enable timeline manually by adding `devtools: { timeline: { enabled: true } }`");
       if (!dry) {
-        await fsp.writeFile(filepath, generated, "utf-8");
+        await fs.writeFile(filepath, generated, "utf-8");
         await nuxt.callHook("restart", { hard: true });
       }
       return [source, generated];
@@ -11555,181 +11924,158 @@ function setupTimelineRPC({ nuxt, ensureDevAuthToken }) {
   };
 }
 
-const LOG_PREFIX = colors.cyan("Nuxt DevTools:");
-
-const NUXT_WELCOME_RE = /<NuxtWelcome\s*\/>/;
-const pagesIndexTemplate = `<script setup lang="ts">
-const route = useRoute()
-<\/script>
-
-<template>
-  <div>
-    <h1>Nuxt Routing set up successfully!</h1>
-    <p>Current route: {{ route.path }}</p>
-    <a href="https://nuxt.com/docs/getting-started/routing" target="_blank">Learn more about Nuxt Routing</a>
-  </div>
-</template>
-`;
-async function enablePages(nuxt) {
-  const baseDir = nuxt.options.future.compatibilityVersion === 4 ? nuxt.options.dir.app : nuxt.options.srcDir;
-  const pathApp = join(baseDir, "app.vue");
-  const pathPageIndex = join(baseDir, "pages/index.vue");
-  if (fs.existsSync(pathPageIndex)) {
-    logger.warn("pages/index.vue already exists, skipping");
-    return;
-  }
-  let appContent = fs.existsSync(pathApp) ? await fsp.readFile(pathApp, "utf-8") : void 0;
-  await fsp.mkdir(dirname$1(pathPageIndex), { recursive: true });
-  await fsp.writeFile(pathPageIndex, pagesIndexTemplate, "utf-8");
-  if (appContent && !appContent.includes("<NuxtPage")) {
-    appContent = appContent.replace("</template>", "  <NuxtPage />\n</template>").replace(NUXT_WELCOME_RE, "");
-    await fsp.writeFile(pathApp, appContent, "utf-8");
-  }
-  logger.success("Routing creation wizard completed");
-}
-
-const wizard = {
-  enablePages
-};
-
-function setupWizardRPC({ nuxt, ensureDevAuthToken }) {
-  return {
-    async runWizard(token, name, ...args) {
-      await ensureDevAuthToken(token);
-      logger.info(LOG_PREFIX, `Running wizard ${colors.green(name)}...`);
-      return wizard[name](nuxt, ...args);
-    }
-  };
-}
-
 function setupRPC(nuxt, options) {
   const serverFunctions = {};
   const extendedRpcMap = /* @__PURE__ */ new Map();
-  const rpc = createBirpcGroup(
-    serverFunctions,
-    [],
-    {
-      resolver: (name, fn) => {
-        if (fn)
-          return fn;
-        if (!name.includes(":"))
+  let devtoolsKitCtx;
+  const pendingBroadcasts = [];
+  function broadcast(method, ...args) {
+    if (!devtoolsKitCtx) {
+      pendingBroadcasts.push({ method, args });
+      return;
+    }
+    devtoolsKitCtx.rpc.broadcast({
+      method,
+      args,
+      event: true
+    });
+  }
+  function createBroadcastProxy(prefix = "") {
+    return new Proxy({}, {
+      get: (_, method) => {
+        if (typeof method !== "string")
           return;
-        const [namespace, fnName] = name.split(":");
-        return extendedRpcMap.get(namespace)?.[fnName];
-      },
-      onFunctionError(error, name) {
-        logger.error(
-          colors.yellow(`[nuxt-devtools] RPC error on executing "${colors.bold(name)}":
-`) + colors.red(error?.message || "")
-        );
-      },
-      // A malformed or hostile frame over the (unauthenticated) HMR socket can
-      // make deserialization throw. Swallow it here so a bad frame is dropped
-      // rather than surfacing as an unhandled rejection that crashes dev.
-      onGeneralError(error) {
-        logger.error(
-          colors.yellow("[nuxt-devtools] RPC channel error:\n") + colors.red(error?.message || String(error))
-        );
-        return true;
-      },
-      timeout: 12e4
+        const fullMethod = prefix ? `${prefix}:${method}` : method;
+        const fn = (...args) => broadcast(fullMethod, ...args);
+        fn.asEvent = (...args) => broadcast(fullMethod, ...args);
+        return fn;
+      }
+    });
+  }
+  const functionsProxy = new Proxy(serverFunctions, {
+    set(target, prop, value) {
+      target[prop] = value;
+      if (devtoolsKitCtx && typeof prop === "string") {
+        if (devtoolsKitCtx.rpc.has(prop)) {
+          devtoolsKitCtx.rpc.update({ name: prop, handler: value });
+        } else {
+          devtoolsKitCtx.rpc.register({ name: prop, handler: value });
+        }
+      }
+      return true;
     }
-  );
+  });
+  const rpc = new Proxy({
+    broadcast: createBroadcastProxy(),
+    functions: functionsProxy
+  }, {
+    get(target, prop, receiver) {
+      if (prop === "broadcast" || prop === "functions") {
+        deprecate(nuxt, "NDT_DEP_0007", {
+          api: `nuxt.devtools.rpc.${prop}`,
+          replacement: "the connected ctx.rpc from onDevtoolsReady((ctx) => ...)"
+        }, { key: prop });
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
   function refresh(event) {
-    rpc.broadcast.refresh.asEvent(event);
+    broadcast("refresh", event);
   }
+  const notify = createNotifier(nuxt);
   function extendServerRpc(namespace, functions) {
+    deprecate(nuxt, "NDT_DEP_0003", {
+      api: "extendServerRpc",
+      replacement: "onDevtoolsReady((ctx) => ctx.rpc.register(defineRpcFunction(...)))"
+    }, { key: namespace });
     extendedRpcMap.set(namespace, functions);
-    return {
-      broadcast: new Proxy({}, {
-        get: (_, key) => {
-          if (typeof key !== "string")
-            return;
-          return rpc.broadcast[`${namespace}:${key}`];
+    if (devtoolsKitCtx) {
+      for (const [fnName, handler] of Object.entries(functions)) {
+        if (typeof handler === "function") {
+          devtoolsKitCtx.rpc.register({ name: `${namespace}:${fnName}`, handler });
         }
-      })
+      }
+    }
+    return {
+      broadcast: createBroadcastProxy(namespace),
+      functions,
+      clients: [],
+      updateChannels: () => []
     };
   }
   const ctx = {
     nuxt,
     options,
     rpc,
+    get devtoolsKit() {
+      return devtoolsKitCtx;
+    },
     refresh,
+    notify,
     extendServerRpc,
-    openInEditorHooks: [],
-    async ensureDevAuthToken(token) {
-      if (options.disableAuthorization)
-        return;
-      if (token !== await getDevAuthToken())
-        throw new Error("[Nuxt DevTools] Invalid dev auth token.");
-    }
+    openInEditorHooks: []
   };
   nuxt.devtools = ctx;
   Object.assign(serverFunctions, {
     ...setupGeneralRPC(ctx),
+    ...setupMessagesRPC(ctx),
     ...setupCustomTabRPC(ctx),
     ...setupStorageRPC(ctx),
     ...setupAssetsRPC(ctx),
     ...setupNpmRPC(ctx),
-    ...setupWizardRPC(ctx),
-    ...setupTerminalRPC(ctx),
+    // Bridge the `devtools:terminal:*` hooks onto the Vite DevTools terminals
+    // host so module terminals surface in the built-in Terminals dock. Also
+    // registers its own hook listeners (including `devtools:ready`) as a side
+    // effect, and contributes the `revealTerminal` RPC.
+    ...setupTerminalsBridge(ctx),
     ...setupServerRoutesRPC(ctx),
     ...setupServerTasksRPC(ctx),
     ...setupAnalyzeBuildRPC(ctx),
     ...setupOptionsRPC(ctx),
     ...setupTimelineRPC(ctx),
     ...setupTelemetryRPC(ctx),
-    ...setupServerDataRPC(ctx)
+    // Deprecated compat shim (NDT_DEP_0009). The capture + live source now live
+    // in the Data Inspector integration; `getServerConfig` is served by the
+    // canonical `setupGeneralRPC` above.
+    getServerData: async () => getServerData(nuxt)
   });
-  const wsClients = /* @__PURE__ */ new Set();
-  const vitePlugin = {
-    name: "nuxt:devtools:rpc",
-    configureServer(server) {
-      server.ws.on("connection", (ws, request) => {
-        if (!isAllowedRpcOrigin(request?.headers?.origin, request?.headers?.host)) {
-          logger.warn(
-            colors.yellow(`[nuxt-devtools] Ignored a cross-origin RPC connection from origin "${request?.headers?.origin}".`)
-          );
-          return;
-        }
-        wsClients.add(ws);
-        const channel = {
-          post: (d) => ws.send(JSON.stringify({
-            type: "custom",
-            event: WS_EVENT_NAME,
-            data: d
-          })),
-          on: (fn) => {
-            ws.on("message", (e) => {
-              try {
-                const data = JSON.parse(String(e)) || {};
-                if (data.type === "custom" && data.event === WS_EVENT_NAME) {
-                  fn(data.data);
-                }
-              } catch {
-              }
-            });
-          },
-          serialize: stringify,
-          deserialize: parse$1
-        };
-        rpc.updateChannels((c) => {
-          c.push(channel);
-        });
-        ws.on("close", () => {
-          wsClients.delete(ws);
-          rpc.updateChannels((c) => {
-            const index = c.indexOf(channel);
-            if (index >= 0)
-              c.splice(index, 1);
-          });
-        });
-      });
+  async function connectDevToolsKit(kitCtx) {
+    if (devtoolsKitCtx || skipInSSR(kitCtx))
+      return;
+    devtoolsKitCtx = kitCtx;
+    const host = kitCtx.rpc;
+    for (const { method, args } of pendingBroadcasts) {
+      broadcast(method, ...args);
+    }
+    pendingBroadcasts.length = 0;
+    registerHostDiagnostics(ctx);
+    function registerFn(name, handler) {
+      try {
+        host.register({ name, handler });
+      } catch (e) {
+        logger.warn(
+          colors.yellow(`[nuxt-devtools] Failed to register RPC function "${name}":
+`) + colors.red(e?.message || "")
+        );
+      }
     }
-  };
+    for (const [name, handler] of Object.entries(serverFunctions)) {
+      if (typeof handler !== "function")
+        continue;
+      registerFn(`${RPC_NAMESPACE}:${name}`, handler);
+      registerFn(name, handler);
+    }
+    for (const [namespace, fns] of extendedRpcMap) {
+      for (const [fnName, handler] of Object.entries(fns)) {
+        if (typeof handler === "function")
+          registerFn(`${namespace}:${fnName}`, handler);
+      }
+    }
+    await nuxt.callHook("devtools:ready", kitCtx);
+  }
   return {
-    vitePlugin,
-    ...ctx
+    connectDevToolsKit,
+    ctx
   };
 }
 
@@ -11747,8 +12093,14 @@ async function enableModule(options, nuxt) {
       await import('./analyze-build.mjs').then(({ setup }) => setup(nuxt, options));
     return;
   }
-  const enabledExplicitly = nuxt.options.devtools === true || nuxt.options.devtools && nuxt.options.devtools.enabled || nuxt.options.modules.some((m) => m === "@nuxt/devtools" || m === "@nuxt/devtools-edge" || m === "@nuxt/devtools-nightly");
   await nuxt.callHook("devtools:before");
+  if (options.disableAuthorization) {
+    extendViteConfig((config) => {
+      const devtoolsConfig = config.devtools ||= {};
+      if (devtoolsConfig.clientAuth === void 0)
+        devtoolsConfig.clientAuth = false;
+    });
+  }
   if (options.iframeProps) {
     nuxt.options.runtimeConfig.app.devtools ||= {};
     nuxt.options.runtimeConfig.app.devtools.iframeProps = options.iframeProps;
@@ -11762,39 +12114,68 @@ async function enableModule(options, nuxt) {
     src: join(runtimeDir, "plugins/devtools.server"),
     mode: "server"
   });
-  if (options.viteDevTools) {
-    logger.info("[nuxt-devtools] Enabling experimental Vite DevTools integration");
-    const DevTools = await import('@vitejs/devtools').then((r) => r.DevTools());
-    addVitePlugin(DevTools);
-    addVitePlugin(defineViteDevToolsPlugin({
-      name: "nuxt:devtools",
-      devtools: {
-        setup(ctx2) {
+  if (nuxt.options.dev) {
+    nuxt.options.vite.optimizeDeps ||= {};
+    nuxt.options.vite.optimizeDeps.include ||= [];
+    nuxt.options.vite.optimizeDeps.include.push(
+      "nuxt > @nuxt/devtools > @vitejs/devtools/client/inject",
+      "nuxt > @nuxt/devtools > @vitejs/devtools-kit/client",
+      "nuxt > @nuxt/devtools > error-stack-parser-es",
+      "nuxt > @nuxt/devtools > vite-plugin-vue-tracer/client/overlay"
+    );
+  }
+  const DevTools = await import('@vitejs/devtools').then((r) => r.DevTools());
+  addVitePlugin(DevTools);
+  let connectDevToolsKit;
+  addVitePlugin(defineViteDevToolsPlugin({
+    name: "nuxt:devtools",
+    devtools: {
+      async setup(ctx2) {
+        if (!skipInSSR(ctx2)) {
+          ctx2.docks.register({
+            id: NUXT_DEVTOOLS_GROUP_ID,
+            type: "group",
+            title: "Nuxt",
+            icon: "/__nuxt_devtools__/client/nuxt.svg",
+            category: "framework",
+            defaultOrder: -2e3,
+            defaultChildId: "nuxt:devtools",
+            categoryOrder: {
+              pinned: 0,
+              app: 1,
+              analyze: 2,
+              server: 3,
+              modules: 4,
+              documentation: 5,
+              advanced: 6
+            }
+          });
           ctx2.docks.register({
             id: "nuxt:devtools",
             type: "iframe",
-            icon: "https://nuxt.com/assets/design-kit/icon-green.svg",
             title: "Nuxt DevTools",
-            url: "/__nuxt_devtools__/client/"
+            icon: "/__nuxt_devtools__/client/nuxt.svg",
+            url: "/__nuxt_devtools__/client/",
+            groupId: NUXT_DEVTOOLS_GROUP_ID,
+            frameId: "nuxt:devtools",
+            subTabs: { protocol: "postmessage" },
+            visibility: "false",
+            defaultOrder: -300
           });
         }
+        await connectDevToolsKit?.(ctx2);
       }
-    }));
-    addPlugin({
-      src: join(runtimeDir, "plugins/vite-devtools.client"),
-      mode: "client"
-    });
-  }
+    }
+  }));
+  addPlugin({
+    src: join(runtimeDir, "plugins/vite-devtools.client"),
+    mode: "client"
+  });
   addTemplate({
     filename: "devtools/settings.mjs",
     async getContents() {
       const uiOptions = await readLocalOptions(
-        {
-          ...defaultTabOptions.ui,
-          // When not enabled explicitly, we hide the panel by default
-          // When Vite DevTools is enabled, we hide the panel by default
-          showPanel: options.viteDevTools ? false : enabledExplicitly ? true : null
-        },
+        createDefaultTabOptions().ui,
         { root: nuxt.options.rootDir }
       );
       return `export default ${JSON.stringify({
@@ -11804,10 +12185,18 @@ async function enableModule(options, nuxt) {
   });
   nuxt.hook("nitro:config", (config) => {
     if (config.experimental?.tasks)
-      defaultTabOptions.serverTasks.enabled = true;
-    config.externals = config.externals || {};
-    config.externals.inline = config.externals.inline || [];
-    config.externals.inline.push(join(runtimeDir, "nitro"));
+      setServerTasksEnabledByDefault(true);
+    const inlinePath = join(runtimeDir, "nitro");
+    if ("externals" in config) {
+      config.externals ||= {};
+      config.externals.inline ||= [];
+      config.externals.inline.push(inlinePath);
+    }
+    if ("noExternals" in config && Array.isArray(config.noExternals)) {
+      config.noExternals.push(inlinePath);
+    } else if (!("noExternals" in config) || config.noExternals === void 0) {
+      config.noExternals = [inlinePath];
+    }
     config.virtual = config.virtual || {};
     config.virtual["#nuxt-devtools-inline"] = `export const script = \`
 if (!window.__NUXT_DEVTOOLS_TIME_METRIC__) {
@@ -11823,10 +12212,10 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
     config.plugins.unshift(join(runtimeDir, "nitro/inline"));
   });
   const {
-    vitePlugin,
-    ...ctx
+    connectDevToolsKit: _connectDevToolsKit,
+    ctx
   } = setupRPC(nuxt, options);
-  addVitePlugin(vitePlugin);
+  connectDevToolsKit = _connectDevToolsKit;
   const clientDirExists = existsSync(clientDir);
   extendViteConfig((config) => {
     config.server ||= {};
@@ -11848,15 +12237,13 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
   });
   const ROUTE_PATH = `${nuxt.options.app.baseURL || "/"}/__nuxt_devtools__`.replace(MULTIPLE_SLASHES_RE, "/");
   const ROUTE_CLIENT = `${ROUTE_PATH}/client`;
-  const ROUTE_AUTH = `${ROUTE_PATH}/auth`;
-  const ROUTE_AUTH_VERIFY = `${ROUTE_PATH}/auth-verify`;
   const ROUTE_ANALYZE = `${ROUTE_PATH}/analyze`;
   nuxt.hook("vite:serverCreated", (server) => {
     const devtoolsAnalyzeDir = join(nuxt.options.rootDir, "node_modules/.cache/nuxt-devtools/analyze");
     server.middlewares.use(ROUTE_ANALYZE, sirv(devtoolsAnalyzeDir, { single: false, dev: true, dotfiles: true, ignores: false }));
     if (clientDirExists) {
       const indexHtmlPath = join(clientDir, "index.html");
-      const indexContent = fsp.readFile(indexHtmlPath, "utf-8");
+      const indexContent = fs.readFile(indexHtmlPath, "utf-8");
       const handleStatic = sirv(clientDir, {
         dev: true,
         single: false
@@ -11868,49 +12255,27 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
         res.end();
       };
       server.middlewares.use(ROUTE_CLIENT, (req, res) => {
-        if (req.url === "/")
+        const pathname = (req.url || "/").split("?")[0];
+        if (pathname === "/" || pathname === "")
           return handleIndex(res);
         return handleStatic(req, res, () => handleIndex(res));
       });
     }
-    server.middlewares.use(ROUTE_AUTH, sirv(join(runtimeDir, "auth"), { single: true, dev: true }));
-    server.middlewares.use(ROUTE_AUTH_VERIFY, async (req, res) => {
-      const search = req.url?.split("?")[1];
-      if (!search) {
-        res.statusCode = 400;
-        res.end("No token provided");
-      }
-      const query = new URLSearchParams(search);
-      const token = query.get("token");
-      if (!token) {
-        res.statusCode = 400;
-        res.end("No token provided");
-      }
-      if (token === await getDevAuthToken()) {
-        res.statusCode = 200;
-        res.end("Valid token");
-      } else {
-        res.statusCode = 403;
-        res.end("Invalid token");
-      }
-    });
   });
   await import('./plugin-metrics.mjs').then(({ setup }) => setup(ctx));
-  if (options.vueDevTools !== false)
-    await import('./vue-devtools.mjs').then(({ setup }) => setup(ctx));
+  await Promise.resolve().then(function () { return dataInspector; }).then(({ setup }) => setup(ctx));
   if (options.viteInspect !== false)
     await import('./vite-inspect.mjs').then(({ setup }) => setup(ctx));
   if (options.componentInspector !== false)
     await import('./vue-tracer.mjs').then(({ setup }) => setup(ctx));
   const integrations = [
-    options.vscode?.enabled ? import('./vscode.mjs').then(({ setup }) => setup(ctx)) : null,
+    import('./code-server.mjs').then(({ setup }) => setup(ctx)),
     options.experimental?.timeline || options.timeline?.enabled ? import('./timeline.mjs').then(({ setup }) => setup(ctx)) : null
   ];
   await Promise.all(integrations);
   nuxt.hook("modules:done", () => nuxt.callHook("devtools:initialized", {
     version: version$1,
-    packagePath: packageDir,
-    isGlobalInstall: isGlobalInstall()
+    packagePath: packageDir
   }));
   const isMac = os.platform() === "darwin";
   logger.log([
@@ -11934,4 +12299,4 @@ const moduleMain = {
   enableModule: enableModule
 };
 
-export { LOG_PREFIX as L, moduleMain as m };
+export { RPC_NAMESPACE as R, moduleMain as m };