@nuxt/cli-nightly 3.26.0-20250607-210256-59f83b1 → 3.26.0-20250607-223602-1089c0e

package/dist/chunks/cleanup.mjs

@@ -1,17 +1,18 @@
 import { defineCommand } from 'citty';
 import { resolve } from 'pathe';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { c as cleanupNuxtDirs } from '../shared/cli-nightly.DDBHWicM.mjs';
-import { b as legacyRootDirArgs, c as cwdArgs } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import 'jiti';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { c as cleanupNuxtDirs } from '../shared/cli-nightly.Bu_9IHj2.mjs';
+import { l as legacyRootDirArgs, c as cwdArgs } from '../shared/cli-nightly.DSXVWJCf.mjs';
+import 'node:url';
+import 'exsolve';
 import 'node:fs';
 import 'ohash';
-import '../shared/cli-nightly.BnfAj4iy.mjs';
+import '../shared/cli-nightly.B9AmABr3.mjs';
+import 'consola';
+import '../shared/cli-nightly.DPmMxQ6h.mjs';
 import 'node:path';
 import 'node:process';
 import 'std-env';
-import 'consola';
-import 'node:url';
 
 const cleanup = defineCommand({
   meta: {

package/dist/chunks/dev-child.mjs

@@ -1,26 +1,11 @@
 import process from 'node:process';
 import { defineCommand } from 'citty';
-import defu from 'defu';
 import { resolve } from 'pathe';
 import { isTest } from 'std-env';
-import { _ as _getDevServerOverrides, a as _getDevServerDefaults, c as createNuxtDevServer } from './dev2.mjs';
-import { o as overrideEnv } from '../shared/cli-nightly.DdmGgrsK.mjs';
-import { b as legacyRootDirArgs, d as dotEnvArgs, e as envNameArgs, l as logLevelArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import 'node:events';
-import 'chokidar';
-import 'h3';
-import 'jiti';
-import 'listhen';
-import 'perfect-debounce';
-import 'ufo';
-import '../shared/cli-nightly.BnfAj4iy.mjs';
-import 'node:fs';
-import '../shared/cli-nightly.DlcAx0De.mjs';
-import '../shared/cli-nightly.DDBHWicM.mjs';
-import 'ohash';
-import 'youch';
+import { l as legacyRootDirArgs, d as dotEnvArgs, e as envNameArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.DSXVWJCf.mjs';
 import 'node:path';
 import 'consola';
+import '../shared/cli-nightly.B9AmABr3.mjs';
 import 'node:url';
 
 const devChild = defineCommand({
@@ -33,65 +18,20 @@ const devChild = defineCommand({
     ...logLevelArgs,
     ...envNameArgs,
     ...dotEnvArgs,
-    ...legacyRootDirArgs
+    ...legacyRootDirArgs,
+    clear: {
+      type: "boolean",
+      description: "Clear console on restart",
+      negativeDescription: "Disable clear console on restart"
+    }
   },
   async run(ctx) {
     if (!process.send && !isTest) {
-      logger.warn("`nuxi _dev` is an internal command and should not be used directly. Please use `nuxi dev` instead.");
+      console.warn("`nuxi _dev` is an internal command and should not be used directly. Please use `nuxi dev` instead.");
     }
-    overrideEnv("development");
     const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-    const devContext = JSON.parse(process.env.__NUXT_DEV__ || "null") || {};
-    function sendIPCMessage(message) {
-      if (process.send) {
-        process.send(message);
-      } else {
-        logger.info(
-          "Dev server event:",
-          Object.entries(message).map((e) => `${e[0]}=${JSON.stringify(e[1])}`).join(" ")
-        );
-      }
-    }
-    process.once("unhandledRejection", (reason) => {
-      sendIPCMessage({ type: "nuxt:internal:dev:rejection", message: reason instanceof Error ? reason.toString() : "Unhandled Rejection" });
-      process.exit();
-    });
-    const devServerOverrides = _getDevServerOverrides({
-      public: devContext.public
-    });
-    const devServerDefaults = _getDevServerDefaults({
-      hostname: devContext.hostname,
-      https: devContext.proxy?.https
-    }, devContext.publicURLs);
-    const nuxtDev = await createNuxtDevServer({
-      cwd,
-      overrides: defu(ctx.data?.overrides, devServerOverrides),
-      defaults: devServerDefaults,
-      logLevel: ctx.args.logLevel,
-      clear: !!ctx.args.clear,
-      dotenv: { cwd, fileName: ctx.args.dotenv },
-      envName: ctx.args.envName,
-      port: process.env._PORT ?? void 0,
-      devContext
-    });
-    nuxtDev.on("loading:error", (_error) => {
-      sendIPCMessage({ type: "nuxt:internal:dev:loading:error", error: {
-        message: _error.message,
-        stack: _error.stack,
-        name: _error.name,
-        code: _error.code
-      } });
-    });
-    nuxtDev.on("loading", (message) => {
-      sendIPCMessage({ type: "nuxt:internal:dev:loading", message });
-    });
-    nuxtDev.on("restart", () => {
-      sendIPCMessage({ type: "nuxt:internal:dev:restart" });
-    });
-    nuxtDev.on("ready", (payload) => {
-      sendIPCMessage({ type: "nuxt:internal:dev:ready", port: payload.port });
-    });
-    await nuxtDev.init();
+    const { initialize } = await import('./index.mjs').then(function (n) { return n.a; });
+    await initialize({ cwd, args: ctx.args }, ctx);
   }
 });
 

package/dist/chunks/dev.mjs

@@ -1,35 +1,36 @@
 import { fork } from 'node:child_process';
 import process from 'node:process';
 import { defineCommand } from 'citty';
-import defu from 'defu';
-import { createJiti } from 'jiti';
+import { createProxyServer } from 'httpxy';
+import { listen } from 'listhen';
 import { getArgs, parseArgs } from 'listhen/cli';
 import { resolve } from 'pathe';
 import { satisfies } from 'semver';
 import { isTest, isBun } from 'std-env';
-import { s as showVersions } from '../shared/cli-nightly.COGWopdX.mjs';
-import { _ as _getDevServerOverrides, a as _getDevServerDefaults, r as renderError } from './dev2.mjs';
-import { o as overrideEnv } from '../shared/cli-nightly.DdmGgrsK.mjs';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { e as envNameArgs, b as legacyRootDirArgs, d as dotEnvArgs, l as logLevelArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import 'consola/utils';
-import 'pkg-types';
+import { i as initialize, r as renderError } from './index.mjs';
+import { s as showVersions } from '../shared/cli-nightly.Dc8ncNQ_.mjs';
+import { o as overrideEnv } from '../shared/cli-nightly.DkO5RR_e.mjs';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { e as envNameArgs, l as legacyRootDirArgs, d as dotEnvArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.DSXVWJCf.mjs';
+import 'defu';
 import 'node:events';
 import 'chokidar';
 import 'h3';
-import 'listhen';
 import 'perfect-debounce';
 import 'ufo';
-import '../shared/cli-nightly.BnfAj4iy.mjs';
+import '../shared/cli-nightly.DPmMxQ6h.mjs';
 import 'node:fs';
-import '../shared/cli-nightly.DDBHWicM.mjs';
+import '../shared/cli-nightly.Bu_9IHj2.mjs';
 import 'ohash';
 import 'youch';
-import 'node:path';
-import 'consola';
+import 'consola/utils';
+import 'exsolve';
 import 'node:url';
+import 'consola';
+import 'node:path';
 
-let startTime = Date.now();
+const startTime = Date.now();
 const forkSupported = !isTest && (!isBun || isBunForkSupported());
 const listhenArgs = getArgs();
 const command = defineCommand({
@@ -90,7 +91,7 @@ const command = defineCommand({
   async run(ctx) {
     overrideEnv("development");
     const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-    await showVersions(cwd);
+    showVersions(cwd);
     const { loadNuxtConfig } = await loadKit(cwd);
     const nuxtOptions = await loadNuxtConfig({
       cwd,
@@ -103,69 +104,65 @@ const command = defineCommand({
         ...ctx.data?.overrides
       }
     });
-    const listenOptions = _resolveListenOptions(nuxtOptions, ctx.args);
-    if (ctx.args.fork) {
-      const devProxy = await _createDevProxy(nuxtOptions, listenOptions);
-      const subprocess = await _startSubprocess(devProxy, ctx.rawArgs, listenOptions);
-      return {
-        listener: devProxy?.listener,
-        async close() {
-          await devProxy?.listener.close();
-          subprocess?.kill(0);
-        }
-      };
-    } else {
-      const { createNuxtDevServer } = await import('./dev2.mjs').then(function (n) { return n.d; });
-      const devServerOverrides = _getDevServerOverrides({
-        public: listenOptions.public
-      });
-      const devServerDefaults = _getDevServerDefaults({
+    const listenOptions = resolveListenOptions(nuxtOptions, ctx.args);
+    if (!ctx.args.fork) {
+      const { listener, close: close2 } = await initialize({
+        cwd,
+        args: ctx.args,
         hostname: listenOptions.hostname,
-        https: listenOptions.https
-      });
-      const devServer = await createNuxtDevServer(
-        {
-          cwd,
-          overrides: defu(ctx.data?.overrides, devServerOverrides),
-          defaults: devServerDefaults,
-          logLevel: ctx.args.logLevel,
-          clear: ctx.args.clear,
-          dotenv: {
-            cwd,
-            fileName: ctx.args.dotenv
-          },
-          envName: ctx.args.envName,
-          loadingTemplate: nuxtOptions.devServer.loadingTemplate,
-          devContext: {}
-        },
-        listenOptions
-      );
-      await devServer.init();
+        public: listenOptions.public,
+        publicURLs: void 0,
+        proxy: {
+          https: listenOptions.https
+        }
+      }, { data: ctx.data }, listenOptions);
       return {
-        listener: devServer?.listener,
+        listener,
         async close() {
-          await devServer.listener.close();
-          await devServer.close();
+          await close2();
+          await listener.close();
         }
       };
     }
+    const devProxy = await createDevProxy(nuxtOptions, listenOptions);
+    const urls = await devProxy.listener.getURLs();
+    const { onRestart, onReady, close } = await initialize({
+      cwd,
+      args: ctx.args,
+      hostname: listenOptions.hostname,
+      public: listenOptions.public,
+      publicURLs: urls.map((r) => r.url),
+      proxy: {
+        url: devProxy.listener.url,
+        urls,
+        https: devProxy.listener.https
+      }
+    });
+    onReady((port) => devProxy.setAddress(`http://127.0.0.1:${port}`));
+    const fork2 = startSubprocess(cwd, ctx.args, ctx.rawArgs, listenOptions);
+    onRestart(async (devServer) => {
+      await devServer.close();
+      const subprocess = await fork2;
+      await subprocess.initialize(devProxy);
+    });
+    return {
+      listener: devProxy.listener,
+      async close() {
+        await close();
+        const subprocess = await fork2;
+        subprocess.kill(0);
+        await devProxy.listener.close();
+      }
+    };
   }
 });
-async function _createDevProxy(nuxtOptions, listenOptions) {
-  const jiti = createJiti(nuxtOptions.rootDir);
+async function createDevProxy(nuxtOptions, listenOptions) {
   let loadingMessage = "Nuxt dev server is starting...";
   let error;
+  let address;
   let loadingTemplate = nuxtOptions.devServer.loadingTemplate;
-  for (const url of nuxtOptions.modulesDir) {
-    if (loadingTemplate) {
-      break;
-    }
-    loadingTemplate = await jiti.import("@nuxt/ui-templates", { parentURL: url }).then((r) => r.loading);
-  }
-  const { createProxyServer } = await import('httpxy');
   const proxy = createProxyServer({});
-  let address;
-  const handler = (req, res) => {
+  const listener = await listen((req, res) => {
     if (error) {
       renderError(req, res, error);
       return;
@@ -173,25 +170,38 @@ async function _createDevProxy(nuxtOptions, listenOptions) {
     if (!address) {
       res.statusCode = 503;
       res.setHeader("Content-Type", "text/html");
-      res.end(loadingTemplate({ loading: loadingMessage }));
-      return;
+      if (loadingTemplate) {
+        res.end(loadingTemplate({ loading: loadingMessage }));
+        return;
+      }
+      async function resolveLoadingMessage() {
+        const { createJiti } = await import('jiti');
+        const jiti = createJiti(nuxtOptions.rootDir);
+        for (const url of nuxtOptions.modulesDir) {
+          const r = await jiti.import("@nuxt/ui-templates", {
+            parentURL: url,
+            try: true
+          });
+          if (r) {
+            loadingTemplate = r.loading;
+            res.end(r.loading({ loading: loadingMessage }));
+            break;
+          }
+        }
+      }
+      return resolveLoadingMessage();
     }
-    return proxy.web(req, res, { target: address });
-  };
-  const wsHandler = (req, socket, head) => {
+    proxy.web(req, res, { target: address });
+  }, listenOptions);
+  listener.server.on("upgrade", (req, socket, head) => {
     if (!address) {
       socket.destroy();
       return;
     }
     return proxy.ws(req, socket, { target: address }, head);
-  };
-  const { listen } = await import('listhen');
-  const listener = await listen(handler, listenOptions);
-  listener.server.on("upgrade", wsHandler);
+  });
   return {
     listener,
-    handler,
-    wsHandler,
     setAddress: (_addr) => {
       address = _addr;
     },
@@ -206,38 +216,48 @@ async function _createDevProxy(nuxtOptions, listenOptions) {
     }
   };
 }
-async function _startSubprocess(devProxy, rawArgs, listenArgs) {
+async function startSubprocess(cwd, args, rawArgs, listenOptions) {
   let childProc;
+  let devProxy;
+  let ready;
   const kill = (signal) => {
     if (childProc) {
       childProc.kill(signal);
       childProc = void 0;
     }
   };
-  const restart = async () => {
-    devProxy.clearError();
+  async function initialize2(proxy) {
+    devProxy = proxy;
+    const urls = await devProxy.listener.getURLs();
+    await ready;
+    childProc.send({
+      type: "nuxt:internal:dev:context",
+      context: {
+        cwd,
+        args,
+        hostname: listenOptions.hostname,
+        public: listenOptions.public,
+        publicURLs: urls.map((r) => r.url),
+        proxy: {
+          url: devProxy.listener.url,
+          urls,
+          https: devProxy.listener.https
+        }
+      }
+    });
+  }
+  async function restart() {
+    devProxy?.clearError();
     if (process.platform === "win32") {
       kill("SIGTERM");
     } else {
       kill("SIGHUP");
     }
-    childProc = fork(globalThis.__nuxt_cli__.entry, ["_dev", ...rawArgs], {
-      execArgv: [
-        "--enable-source-maps",
-        process.argv.find((a) => a.includes("--inspect"))
-      ].filter(Boolean),
+    childProc = fork(globalThis.__nuxt_cli__.devEntry, rawArgs, {
+      execArgv: ["--enable-source-maps", process.argv.find((a) => a.includes("--inspect"))].filter(Boolean),
       env: {
         ...process.env,
-        __NUXT_DEV__: JSON.stringify({
-          hostname: listenArgs.hostname,
-          public: listenArgs.public,
-          publicURLs: await devProxy.listener.getURLs().then((r) => r.map((r2) => r2.url)),
-          proxy: {
-            url: devProxy.listener.url,
-            urls: await devProxy.listener.getURLs(),
-            https: devProxy.listener.https
-          }
-        })
+        __NUXT__FORK: "true"
       }
     });
     childProc.on("close", (errorCode) => {
@@ -245,28 +265,32 @@ async function _startSubprocess(devProxy, rawArgs, listenArgs) {
         process.exit(errorCode);
       }
     });
-    childProc.on("message", (message) => {
-      if (message.type === "nuxt:internal:dev:ready") {
-        devProxy.setAddress(`http://127.0.0.1:${message.port}`);
-        if (startTime) {
-          logger.debug(`Dev server ready for connections in ${Date.now() - startTime}ms`);
-          startTime = void 0;
+    ready = new Promise((resolve2, reject) => {
+      childProc.on("error", reject);
+      childProc.on("message", (message) => {
+        if (message.type === "nuxt:internal:dev:fork-ready") {
+          resolve2();
+        } else if (message.type === "nuxt:internal:dev:ready") {
+          devProxy.setAddress(`http://127.0.0.1:${message.port}`);
+          if (startTime) {
+            logger.debug(`Dev server ready for connections in ${Date.now() - startTime}ms`);
+          }
+        } else if (message.type === "nuxt:internal:dev:loading") {
+          devProxy.setAddress(void 0);
+          devProxy.setLoadingMessage(message.message);
+          devProxy.clearError();
+        } else if (message.type === "nuxt:internal:dev:loading:error") {
+          devProxy.setAddress(void 0);
+          devProxy.setError(message.error);
+        } else if (message.type === "nuxt:internal:dev:restart") {
+          restart();
+        } else if (message.type === "nuxt:internal:dev:rejection") {
+          logger.info(`Restarting Nuxt due to error: \`${message.message}\``);
+          restart();
         }
-      } else if (message.type === "nuxt:internal:dev:loading") {
-        devProxy.setAddress(void 0);
-        devProxy.setLoadingMessage(message.message);
-        devProxy.clearError();
-      } else if (message.type === "nuxt:internal:dev:loading:error") {
-        devProxy.setAddress(void 0);
-        devProxy.setError(message.error);
-      } else if (message.type === "nuxt:internal:dev:restart") {
-        restart();
-      } else if (message.type === "nuxt:internal:dev:rejection") {
-        logger.info(`Restarting Nuxt due to error: \`${message.message}\``);
-        restart();
-      }
+      });
     });
-  };
+  }
   for (const signal of [
     "exit",
     "SIGTERM",
@@ -279,11 +303,12 @@ async function _startSubprocess(devProxy, rawArgs, listenArgs) {
   }
   await restart();
   return {
+    initialize: initialize2,
     restart,
     kill
   };
 }
-function _resolveListenOptions(nuxtOptions, args) {
+function resolveListenOptions(nuxtOptions, args) {
   const _port = args.port ?? args.p ?? process.env.NUXT_PORT ?? process.env.NITRO_PORT ?? process.env.PORT ?? nuxtOptions.devServer.port;
   const _hostname = typeof args.host === "string" ? args.host : (args.host === true ? "" : void 0) ?? process.env.NUXT_HOST ?? process.env.NITRO_HOST ?? process.env.HOST ?? (nuxtOptions.devServer?.host || void 0) ?? void 0;
   const _public = args.public ?? (_hostname && !["localhost", "127.0.0.1", "::1"].includes(_hostname)) ? true : void 0;

package/dist/chunks/devtools.mjs

@@ -2,10 +2,11 @@ import process from 'node:process';
 import { defineCommand } from 'citty';
 import { resolve } from 'pathe';
 import { x } from 'tinyexec';
-import { b as legacyRootDirArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { l as legacyRootDirArgs, c as cwdArgs } from '../shared/cli-nightly.DSXVWJCf.mjs';
+import 'consola';
 import 'node:path';
 import 'std-env';
-import 'consola';
 import 'node:url';
 
 const devtools = defineCommand({

package/dist/chunks/generate.mjs

@@ -1,20 +1,20 @@
 import { defineCommand } from 'citty';
-import { b as legacyRootDirArgs, e as envNameArgs, d as dotEnvArgs, l as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.CjK7ZDKA.mjs';
+import { l as legacyRootDirArgs, e as envNameArgs, d as dotEnvArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.DSXVWJCf.mjs';
 import buildCommand from './build.mjs';
 import 'node:path';
 import 'node:process';
 import 'std-env';
 import 'consola';
+import '../shared/cli-nightly.B9AmABr3.mjs';
 import 'node:url';
 import 'pathe';
-import '../shared/cli-nightly.COGWopdX.mjs';
-import 'consola/utils';
-import 'pkg-types';
-import '../shared/cli-nightly.DlcAx0De.mjs';
-import 'jiti';
-import '../shared/cli-nightly.DdmGgrsK.mjs';
-import '../shared/cli-nightly.BnfAj4iy.mjs';
+import '../shared/cli-nightly.Dc8ncNQ_.mjs';
 import 'node:fs';
+import 'consola/utils';
+import 'exsolve';
+import '../shared/cli-nightly.BrKZotr9.mjs';
+import '../shared/cli-nightly.DkO5RR_e.mjs';
+import '../shared/cli-nightly.DPmMxQ6h.mjs';
 
 const generate = defineCommand({
   meta: {