@nuxt/devtools 4.0.0-alpha.7 → 4.0.0-alpha.9

package/dist/chunks/module-main.mjs

@@ -1,14 +1,16 @@
 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, resolve, isAbsolute } from 'pathe';
 import sirv from 'sirv';
 import { searchForWorkspaceRoot } from 'vite';
-import { d as defaultAllowedExtensions, a as defaultTabOptions } from '../shared/devtools.nEotcg1R.mjs';
+import { d as defaultAllowedExtensions, c as createDefaultTabOptions, s as setServerTasksEnabledByDefault } from '../shared/devtools.CCWq4fFE.mjs';
 import { runtimeDir, clientDir, packageDir } from '../dirs.mjs';
-import { startSubprocess } from '@nuxt/devtools-kit';
+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';
@@ -27,41 +29,169 @@ 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 { isLess } from 'verkit';
+import { DEVTOOLS_TERMINALS_DOCK_ID } from '@vitejs/devtools-kit/constants';
 import { normalizeBaseKey, normalizeKey } from 'unstorage';
 
-const version$1 = "4.0.0-alpha.7";
+const version$1 = "4.0.0-alpha.9";
+
+const captured = {};
+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
+  };
+}
+function setup(ctx) {
+  const { nuxt } = ctx;
+  nuxt.hook("nitro:build:before", (nitro) => {
+    captured.nitro = nitro;
+  });
+  nuxt.hook("vite:configResolved", (config, env) => {
+    if (env.isClient)
+      captured.viteClient = config;
+    if (env.isServer)
+      captured.viteSsr = config;
+  });
+  const unregister = 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: {
+        client: captured.viteClient,
+        ssr: captured.viteSsr
+      }
+    }),
+    queries: [
+      { title: "Overview", query: "", excludeFunctions: true },
+      { title: "Nuxt options", query: "nuxt", excludeFunctions: true },
+      { title: "Nitro options", query: "nitro", excludeFunctions: true },
+      { title: "Vite configs", query: "vite", excludeFunctions: true }
+    ]
+  });
+  nuxt.hook("close", () => {
+    unregister();
+    captured.nitro = void 0;
+    captured.viteClient = void 0;
+    captured.viteSsr = void 0;
+  });
+  const definition = createDataInspectorDevframe({ exampleSource: false });
+  onDevtoolsReady((kit) => {
+    return mountDevframe(kit, definition, {
+      dock: {
+        groupId: NUXT_DEVTOOLS_GROUP_ID,
+        category: "advanced"
+      }
+    });
+  }, nuxt);
+}
+function getServerData(nuxt) {
+  deprecate(nuxt, "NDT_DEP_0009", {
+    api: "getServerData()",
+    replacement: "the Nuxt Application source in the Data Inspector panel"
+  });
+  return {
+    nuxt: nuxt.options,
+    nitro: captured.nitro?.options,
+    vite: {
+      server: captured.viteSsr ? normalizeViteConfig(captured.viteSsr) : void 0,
+      client: captured.viteClient ? normalizeViteConfig(captured.viteClient) : void 0
+    }
+    // `nuxt.options` is `@nuxt/schema`'s `NuxtOptions` while `NuxtServerData`
+    // pins the structurally-identical `nuxt/schema` one; bridge the two.
+  };
+}
+
+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 }) {
+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([
@@ -124,6 +254,7 @@ function setupAnalyzeBuildRPC({ nuxt, refresh }) {
       await initalized;
       return {
         isBuilding: !!promise,
+        activeSessionId,
         builds
       };
     },
@@ -726,6 +857,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
@@ -952,7 +1086,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;
@@ -990,9 +1124,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 };
@@ -1131,6 +1267,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) {
@@ -1234,10 +1381,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)
@@ -1326,7 +1473,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
 };
 
@@ -1345,7 +1503,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)) {
@@ -1400,7 +1558,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
@@ -1419,6 +1577,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");
@@ -1552,11 +1714,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); }
@@ -2161,11 +2324,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;
     }
@@ -2179,14 +2342,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")
   }
@@ -2194,16 +2357,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();
@@ -2253,47 +2416,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);
   }
 };
 
@@ -2308,13 +2471,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
   );
@@ -2322,7 +2485,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);
@@ -2332,7 +2495,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
 };
@@ -3063,15 +3226,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
@@ -3136,7 +3303,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();
@@ -3688,6 +3855,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")
@@ -6604,7 +6773,7 @@ pp.readWord = function() {
 // [ghbt]: https://github.com/acornjs/acorn/issues
 
 
-var version = "8.16.0";
+var version = "8.17.0";
 
 Parser.acorn = {
   Parser: Parser,
@@ -10238,18 +10407,20 @@ 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");
@@ -10516,19 +10687,70 @@ const route = useRoute()
   };
 }
 
+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"
+  "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",
@@ -10536,6 +10758,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",
@@ -10588,6 +10811,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];
@@ -11055,7 +11281,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,
@@ -11079,7 +11305,179 @@ async function magicastGuard(fn, message = "") {
   return generated;
 }
 
-function setupNpmRPC({ nuxt }) {
+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() {
@@ -11114,15 +11512,18 @@ function setupNpmRPC({ nuxt }) {
     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
@@ -11140,7 +11541,7 @@ function setupNpmRPC({ nuxt }) {
     async runNpmCommand(...args) {
       return runNpmCommand(...args);
     },
-    async installNuxtModule(name, dry = true) {
+    async installNuxtModule(name, dry = true, sessionId) {
       const commands = await getNpmCommand("install", name, { dev: true });
       const filepath = nuxt.options._nuxtConfigFile;
       let source = latestGenerated;
@@ -11150,27 +11551,39 @@ function setupNpmRPC({ nuxt }) {
         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");
@@ -11183,40 +11596,43 @@ function setupNpmRPC({ nuxt }) {
         processId
       };
     },
-    async uninstallNuxtModule(name, dry = true) {
+    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 {
@@ -11229,71 +11645,6 @@ function setupNpmRPC({ nuxt }) {
   };
 }
 
-function setupServerDataRPC({
-  nuxt
-}) {
-  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() {
-      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);
@@ -11417,14 +11768,16 @@ function setupServerTasksRPC({ nuxt, refresh }) {
   };
 }
 
+function skipInSSR(ctx) {
+  return Boolean(ctx?.viteConfig?.build?.ssr);
+}
+
 const IGNORE_STORAGE_MOUNTS = ["root", "build", "src", "cache"];
 function shouldIgnoreStorageKey(key) {
   return IGNORE_STORAGE_MOUNTS.includes(key.split(":")[0]);
 }
-function setupStorageRPC({
-  nuxt,
-  rpc
-}) {
+function setupStorageRPC(ctx) {
+  const { nuxt } = ctx;
   const storageMounts = {};
   let storage;
   let unwatchStorageMounts = [];
@@ -11448,7 +11801,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 () => {
@@ -11536,89 +11889,6 @@ function telemetryEvent(payload, immediate = false) {
     throttledSend();
 }
 
-function setupTerminalRPC({ nuxt, rpc, refresh }) {
-  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(id) {
-      return serializeTerminal(terminals.get(id), true);
-    },
-    async runTerminalAction(id, action) {
-      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) {
@@ -11682,14 +11952,29 @@ function setupRPC(nuxt, options) {
       return true;
     }
   });
-  const rpc = {
+  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) {
     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);
     if (devtoolsKitCtx) {
       for (const [fnName, handler] of Object.entries(functions)) {
@@ -11713,70 +11998,71 @@ function setupRPC(nuxt, options) {
       return devtoolsKitCtx;
     },
     refresh,
+    notify,
     extendServerRpc,
     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 () => getServerData(nuxt)
   });
-  function connectDevToolsKit(ctx2) {
-    if (devtoolsKitCtx)
+  async function connectDevToolsKit(kitCtx) {
+    if (devtoolsKitCtx || skipInSSR(kitCtx))
       return;
-    devtoolsKitCtx = ctx2;
-    const host = ctx2.rpc;
+    devtoolsKitCtx = kitCtx;
+    const host = kitCtx.rpc;
     for (const { method, args } of pendingBroadcasts) {
       broadcast(method, ...args);
     }
     pendingBroadcasts.length = 0;
-    for (const [name, handler] of Object.entries(serverFunctions)) {
-      if (typeof handler === "function") {
-        try {
-          host.register({
-            name,
-            handler
-          });
-        } catch (e) {
-          logger.warn(
-            colors.yellow(`[nuxt-devtools] Failed to register RPC function "${name}":
+    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") {
-          try {
-            host.register({
-              name: `${namespace}:${fnName}`,
-              handler
-            });
-          } catch (e) {
-            logger.warn(
-              colors.yellow(`[nuxt-devtools] Failed to register RPC function "${namespace}:${fnName}":
-`) + colors.red(e?.message || "")
-            );
-          }
-        }
+        if (typeof handler === "function")
+          registerFn(`${namespace}:${fnName}`, handler);
       }
     }
+    await nuxt.callHook("devtools:ready", kitCtx);
   }
   return {
     connectDevToolsKit,
-    ...ctx
+    ctx
   };
 }
 
@@ -11795,8 +12081,12 @@ async function enableModule(options, nuxt) {
     return;
   }
   await nuxt.callHook("devtools:before");
-  if (nuxt.options.devtools && typeof nuxt.options.devtools !== "boolean" && "disableAuthorization" in nuxt.options.devtools) {
-    logger.warn("[nuxt-devtools] `disableAuthorization` option is deprecated. Auth is now handled by Vite DevTools.");
+  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 ||= {};
@@ -11829,15 +12119,49 @@ async function enableModule(options, nuxt) {
   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/"
-        });
-        connectDevToolsKit?.(ctx2);
+      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",
+            // Order the in-group sub-categories (each member's `category`) the
+            // way Nuxt DevTools orders its own tab categories, rather than the
+            // dock's shared default table. Requires `@vitejs/devtools` >= 0.4.6
+            // / `@devframes/hub` >= 0.7.12 (vitejs/devtools#468).
+            categoryOrder: {
+              "pinned": 0,
+              "app": 1,
+              "vue-devtools": 2,
+              "analyze": 3,
+              "server": 4,
+              "modules": 5,
+              "documentation": 6,
+              "advanced": 7
+            }
+          });
+          ctx2.docks.register({
+            id: "nuxt:devtools",
+            type: "iframe",
+            title: "Nuxt DevTools",
+            icon: "/__nuxt_devtools__/client/nuxt.svg",
+            // The client renders chromelessly as this shared-frame anchor (no
+            // SideNav/split pane) and runs the frame-nav shim, which announces
+            // one member dock per tab and soft-navigates within this one iframe.
+            url: "/__nuxt_devtools__/client/",
+            groupId: NUXT_DEVTOOLS_GROUP_ID,
+            frameId: "nuxt:devtools",
+            subTabs: { protocol: "postmessage" },
+            // TODO: this seems still not working correctly with defaultChildId, enable it back later.
+            // visibility: 'false',
+            defaultOrder: -300
+          });
+        }
+        await connectDevToolsKit?.(ctx2);
       }
     }
   }));
@@ -11849,9 +12173,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({
@@ -11861,7 +12183,7 @@ async function enableModule(options, nuxt) {
   });
   nuxt.hook("nitro:config", (config) => {
     if (config.experimental?.tasks)
-      defaultTabOptions.serverTasks.enabled = true;
+      setServerTasksEnabledByDefault(true);
     config.externals = config.externals || {};
     config.externals.inline = config.externals.inline || [];
     config.externals.inline.push(join(runtimeDir, "nitro"));
@@ -11881,7 +12203,7 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
   });
   const {
     connectDevToolsKit: _connectDevToolsKit,
-    ...ctx
+    ctx
   } = setupRPC(nuxt, options);
   connectDevToolsKit = _connectDevToolsKit;
   const clientDirExists = existsSync(clientDir);
@@ -11923,13 +12245,15 @@ 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));
       });
     }
   });
   await import('./plugin-metrics.mjs').then(({ setup }) => setup(ctx));
+  await Promise.resolve().then(function () { return dataInspector; }).then(({ setup }) => setup(ctx));
   if (options.vueDevTools !== false)
     await import('./vue-devtools.mjs').then(({ setup }) => setup(ctx));
   if (options.viteInspect !== false)
@@ -11937,7 +12261,7 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
   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);
@@ -11962,4 +12286,9 @@ function defineViteDevToolsPlugin(plugin) {
   return plugin;
 }
 
-export { enableModule };
+const moduleMain = {
+  __proto__: null,
+  enableModule: enableModule
+};
+
+export { RPC_NAMESPACE as R, moduleMain as m };