@nuxt/devtools 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/chunks/module-main.mjs

@@ -1,24 +1,22 @@
-import fs$1, { existsSync, promises, statSync, realpathSync, readFileSync, accessSync, constants } from 'node:fs';
+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, deprecate, registerHostDiagnostics, NUXT_DEVTOOLS_GROUP_ID } 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.COlX0Gls.mjs';
-import path, { dirname, join as join$1, relative, parse } from 'node:path';
-import { hash } from 'ohash';
+import { d as defaultAllowedExtensions, c as createDefaultTabOptions, s as setServerTasksEnabledByDefault } from '../shared/devtools.BNZC-DT8.mjs';
 import { runtimeDir, clientDir, packageDir } from '../dirs.mjs';
-import { createBirpcGroup } from 'birpc';
-import { parse as parse$1, stringify } from 'structured-clone-es';
-import { startSubprocess } from '@nuxt/devtools-kit';
 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';
@@ -29,124 +27,81 @@ import { format, inspect } from 'node:util';
 import { resolveModule, getPackageInfo } from 'local-pkg';
 import { parseModule } from 'magicast';
 import { getDefaultExportOptions, addNuxtModule } from 'magicast/helpers';
-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 = "4.0.0-alpha.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.11";
 
-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(filePath), { recursive: true });
-  await fs.writeFile(
-    filePath,
-    JSON.stringify(
-      {
-        root: options.root,
-        hash: hashedKey,
-        settings
-      },
-      null,
-      2
-    ),
-    "utf-8"
-  );
-}
+const RPC_NAMESPACE = "nuxt:devtools";
 
-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 fs.readFile(filepath, "utf-8")).trim();
-  if (!token)
-    token = randomStr(16);
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(filepath, token, "utf-8");
-  return token;
+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 = Promise.resolve(result.getResult()).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([
@@ -161,7 +116,7 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
       });
       for (const file of files2) {
         const slug = JSON.parse(await fs.readFile(file, "utf-8")).slug;
-        const dir2 = dirname$1(file);
+        const dir2 = dirname(file);
         await fs.mkdir(devtoolsAnalyzeDir, { recursive: true });
         await fs.rename(dir2, join(devtoolsAnalyzeDir, slug));
       }
@@ -172,7 +127,7 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
       absolute: true
     });
     builds = await Promise.all(files.map(async (file) => {
-      const dir = dirname$1(file);
+      const dir = dirname(file);
       const json = JSON.parse(await fs.readFile(file, "utf-8"));
       return {
         ...json,
@@ -209,11 +164,11 @@ 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 fs.rm(devtoolsAnalyzeDir, { recursive: true, force: true });
       } else {
@@ -224,14 +179,13 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
       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;
@@ -287,8 +241,7 @@ 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 {
@@ -301,8 +254,7 @@ 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 fs.readFile(filepath, "utf-8");
         return content.slice(0, limit);
@@ -311,8 +263,7 @@ function setupAssetsRPC({ nuxt, ensureDevAuthToken, refresh, options }) {
         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 }) => {
@@ -343,12 +294,10 @@ You can configure it in Nuxt config at \`devtools.assets.uploadExtensions\`.`);
         })
       );
     },
-    async deleteStaticAsset(token, path) {
-      await ensureDevAuthToken(token);
+    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`);
@@ -818,6 +767,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
@@ -859,6 +811,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
@@ -1012,13 +969,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:
@@ -1044,7 +1005,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;
@@ -1082,9 +1043,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 };
@@ -1223,6 +1186,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) {
@@ -1418,7 +1392,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
 };
 
@@ -1511,6 +1496,10 @@ pp$8.parseStatement = function(context, topLevel, exports$1) {
       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");
@@ -1644,11 +1633,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); }
@@ -3155,15 +3145,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
@@ -3228,7 +3222,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();
@@ -3328,7 +3322,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
@@ -3780,6 +3774,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")
@@ -6696,7 +6692,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,
@@ -9068,7 +9064,11 @@ function _extractExtraNames(extraNamesStr) {
       angleDepth++;
       continue;
     }
-    if (inTypeAnnotation && char === ">" && angleDepth > 0) {
+    if (!inTypeAnnotation && char === "<" && depth === 0 && i > 0 && _isIdentifierBeforeAngleBracket(extraNamesStr, i)) {
+      angleDepth++;
+      continue;
+    }
+    if (char === ">" && angleDepth > 0 && extraNamesStr[i - 1] !== "=") {
       angleDepth--;
       continue;
     }
@@ -9233,6 +9233,14 @@ function _getLocations(code, label) {
   }
   return locations;
 }
+function _isIdentifierBeforeAngleBracket(str, i) {
+  let j = i - 1;
+  while (j >= 0 && /[A-Za-z0-9_$]/.test(str[j])) {
+    j--;
+  }
+  const wordStart = j + 1;
+  return wordStart < i && /[A-Za-z_$]/.test(str[wordStart]);
+}
 
 function defineUnimportPreset(preset) {
   return preset;
@@ -9275,7 +9283,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;
@@ -10256,23 +10264,82 @@ 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 }) {
+  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");
@@ -10306,13 +10373,11 @@ function setupOptionsRPC({ nuxt }) {
 
 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 = [];
@@ -10496,8 +10561,7 @@ function setupGeneralRPC({
         return false;
       }
     },
-    async enablePages(token) {
-      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");
@@ -10517,7 +10581,7 @@ const route = useRoute()
   </div>
 </template>
 `;
-      await fs.mkdir(dirname$1(pathPageIndex), { recursive: true });
+      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")) {
@@ -10526,40 +10590,63 @@ const route = useRoute()
       }
       logger.success("Routing creation completed");
     },
-    async restartNuxt(token, hard = true) {
-      await ensureDevAuthToken(token);
+    async restartNuxt(hard = true) {
       logger.info("Restarting Nuxt...");
       return nuxt.callHook("restart", { hard });
     },
-    async requestForAuth(info, origin) {
-      if (options.disableAuthorization)
-        return;
-      const token = await getDevAuthToken();
-      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);
     }
   };
 }
@@ -10570,13 +10657,19 @@ const AGENTS = [
   "yarn@berry",
   "pnpm",
   "pnpm@6",
+  "pnpm-rush",
   "bun",
-  "deno"
+  "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",
@@ -10584,6 +10677,7 @@ const LOCKS = {
   "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",
@@ -10636,6 +10730,9 @@ async function detect(options = {}) {
     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];
@@ -11103,7 +11200,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,
@@ -11127,7 +11224,179 @@ async function magicastGuard(fn, message = "") {
   return generated;
 }
 
-function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
+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: []
+    };
+  }
+  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() {
@@ -11162,15 +11431,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
@@ -11185,12 +11457,10 @@ 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;
@@ -11200,27 +11470,39 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
         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 result = await process.getResult();
+        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 fs.writeFile(filepath, generated, "utf-8");
@@ -11233,41 +11515,43 @@ 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 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 result = await process.getResult();
+        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}`);
         }
+        ctx.notify({
+          message: `Uninstalled ${name}`,
+          level: "success",
+          category: "module",
+          notify: true
+        });
         await fs.writeFile(filepath, generated, "utf-8");
       }
       return {
@@ -11280,112 +11564,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)
@@ -11419,29 +11615,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)
@@ -11454,7 +11643,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;
@@ -11470,24 +11667,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)) {
@@ -11502,7 +11728,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 () => {
@@ -11524,20 +11750,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);
@@ -11546,6 +11769,10 @@ function setupStorageRPC({
 }
 
 const SEND_DELAY = 5e3;
+function isDoNotTrackEnabled() {
+  const value = process.env.DO_NOT_TRACK;
+  return value === "1" || value?.toLowerCase() === "true";
+}
 function throttle(fn, delay) {
   let timer;
   return () => {
@@ -11562,7 +11789,7 @@ const throttledSend = throttle(() => {
   telemetry?.sendEvents();
 }, SEND_DELAY);
 function setupTelemetryRPC({ nuxt, options }) {
-  if (options.telemetry !== false) {
+  if (options.telemetry !== false && !isDoNotTrackEnabled()) {
     nuxt.hook("telemetry:setup", (t) => {
       telemetry = t;
       t.eventFactories.devtools = (_, payload) => {
@@ -11586,6 +11813,8 @@ function telemetryEvent(payload, immediate = false) {
     return;
   if (getOptions()?.behavior.telemetry === false)
     return;
+  if (isDoNotTrackEnabled())
+    return;
   telemetry.createEvent("devtools", payload);
   if (immediate)
     telemetry.sendEvents();
@@ -11593,91 +11822,6 @@ 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
-    };
-  }
-  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 }) {
   return {
     async enableTimeline(dry) {
@@ -11703,115 +11847,155 @@ function setupTimelineRPC({ nuxt }) {
 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 || "")
-        );
-      },
-      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),
-    ...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 () => import('./data-inspector.mjs').then(({ getServerData }) => getServerData(nuxt))
   });
-  const wsClients = /* @__PURE__ */ new Set();
-  const vitePlugin = {
-    name: "nuxt:devtools:rpc",
-    configureServer(server) {
-      server.ws.on("connection", (ws) => {
-        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
   };
 }
 
@@ -11830,6 +12014,13 @@ async function enableModule(options, nuxt) {
     return;
   }
   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;
@@ -11843,19 +12034,59 @@ async function enableModule(options, nuxt) {
     src: join(runtimeDir, "plugins/devtools.server"),
     mode: "server"
   });
+  if (nuxt.options.dev) {
+    nuxt.options.vite.optimizeDeps ||= {};
+    nuxt.options.vite.optimizeDeps.include ||= [];
+    nuxt.options.vite.optimizeDeps.include.push(
+      // Vite DevTools 0.5's embedded client is served by the hub as an external
+      // `embedded.js` script (see `runtime/plugins/vite-devtools.client`), so it
+      // is no longer a bundler-resolved `@vitejs/devtools/client/inject` import to
+      // pre-bundle here.
+      "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: {
-      setup(ctx2) {
-        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/"
-        });
+      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",
+            title: "Nuxt DevTools",
+            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);
       }
     }
   }));
@@ -11867,9 +12098,7 @@ async function enableModule(options, nuxt) {
     filename: "devtools/settings.mjs",
     async getContents() {
       const uiOptions = await readLocalOptions(
-        {
-          ...defaultTabOptions.ui
-        },
+        createDefaultTabOptions().ui,
         { root: nuxt.options.rootDir }
       );
       return `export default ${JSON.stringify({
@@ -11879,10 +12108,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__) {
@@ -11898,10 +12135,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 ||= {};
@@ -11923,8 +12160,6 @@ 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");
@@ -11943,42 +12178,28 @@ 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));
+  if (options.dataInspector !== false)
+    await import('./data-inspector.mjs').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));
+  if (options.codeServer?.enabled === false && options.vscode !== void 0) {
+    deprecate(nuxt, "NDT_DEP_0008", {
+      api: "devtools.vscode",
+      replacement: "devtools.codeServer"
+    });
+  }
   const integrations = [
-    options.vscode?.enabled ? import('./vscode.mjs').then(({ setup }) => setup(ctx)) : null,
+    options.codeServer?.enabled !== false ? import('./code-server.mjs').then(({ setup }) => setup(ctx)) : null,
     options.experimental?.timeline || options.timeline?.enabled ? import('./timeline.mjs').then(({ setup }) => setup(ctx)) : null
   ];
   await Promise.all(integrations);
@@ -12003,4 +12224,9 @@ function defineViteDevToolsPlugin(plugin) {
   return plugin;
 }
 
-export { enableModule };
+const moduleMain = {
+  __proto__: null,
+  enableModule: enableModule
+};
+
+export { RPC_NAMESPACE as R, moduleMain as m };