@nuxt/cli-nightly 3.26.0-20250607-210256-59f83b1 → 3.26.0-20250607-215204-1943f84

package/dist/chunks/index.mjs

@@ -1,15 +1,382 @@
-import { defineCommand } from 'citty';
+import process from 'node:process';
+import defu from 'defu';
+import EventEmitter from 'node:events';
+import chokidar from 'chokidar';
+import { toNodeListener } from 'h3';
+import { listen } from 'listhen';
+import { resolve, join, relative } from 'pathe';
+import { debounce } from 'perfect-debounce';
+import { provider } from 'std-env';
+import { joinURL } from 'ufo';
+import { a as clearBuildDir } from '../shared/cli-nightly.DPmMxQ6h.mjs';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as loadNuxtManifest, r as resolveNuxtManifest, w as writeNuxtManifest } from '../shared/cli-nightly.Bu_9IHj2.mjs';
+import { Youch } from 'youch';
 
-const index = defineCommand({
-  meta: {
-    name: "module",
-    description: "Manage Nuxt modules"
-  },
-  args: {},
-  subCommands: {
-    add: () => import('./add2.mjs').then((r) => r.default || r),
-    search: () => import('./search.mjs').then((r) => r.default || r)
+async function renderError(req, res, error) {
+  const youch = new Youch();
+  res.statusCode = 500;
+  res.setHeader("Content-Type", "text/html");
+  const html = await youch.toHTML(error, {
+    request: {
+      url: req.url,
+      method: req.method,
+      headers: req.headers
+    }
+  });
+  res.end(html);
+}
+
+async function createNuxtDevServer(options, listenOptions) {
+  const devServer = new NuxtDevServer(options);
+  devServer.listener = await listen(
+    devServer.handler,
+    listenOptions || {
+      port: options.port ?? 0,
+      hostname: "127.0.0.1",
+      showURL: false
+    }
+  );
+  devServer.listener._url = devServer.listener.url;
+  if (options.devContext.proxy?.url) {
+    devServer.listener.url = options.devContext.proxy.url;
+  }
+  if (options.devContext.proxy?.urls) {
+    const _getURLs = devServer.listener.getURLs.bind(devServer.listener);
+    devServer.listener.getURLs = async () => Array.from(/* @__PURE__ */ new Set([...options.devContext.proxy?.urls || [], ...await _getURLs()]));
+  }
+  return devServer;
+}
+const RESTART_RE = /^(?:nuxt\.config\.[a-z0-9]+|\.nuxtignore|\.nuxtrc|\.config\/nuxt(?:\.config)?\.[a-z0-9]+)$/;
+class NuxtDevServer extends EventEmitter {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.loadDebounced = debounce(this.load);
+    let _initResolve;
+    const _initPromise = new Promise((resolve2) => {
+      _initResolve = resolve2;
+    });
+    this.once("ready", () => {
+      _initResolve();
+    });
+    this.cwd = options.cwd;
+    this.handler = async (req, res) => {
+      if (this._loadingError) {
+        this._renderError(req, res);
+        return;
+      }
+      await _initPromise;
+      if (this._handler) {
+        this._handler(req, res);
+      } else {
+        this._renderLoadingScreen(req, res);
+      }
+    };
+    this.listener = void 0;
+  }
+  _handler;
+  _distWatcher;
+  _currentNuxt;
+  _loadingMessage;
+  _loadingError;
+  cwd;
+  loadDebounced;
+  handler;
+  listener;
+  _renderError(req, res) {
+    renderError(req, res, this._loadingError);
+  }
+  async resolveLoadingTemplate() {
+    const { createJiti } = await import('jiti');
+    const jiti = createJiti(this.cwd);
+    const loading = await jiti.import("@nuxt/ui-templates").then((r) => r.loading).catch(() => {
+    });
+    return loading || ((params) => `<h2>${params.loading}</h2>`);
+  }
+  async _renderLoadingScreen(req, res) {
+    res.statusCode = 503;
+    res.setHeader("Content-Type", "text/html");
+    const loadingTemplate = this.options.loadingTemplate || this._currentNuxt?.options.devServer.loadingTemplate || await this.resolveLoadingTemplate();
+    res.end(
+      loadingTemplate({
+        loading: this._loadingMessage || "Loading..."
+      })
+    );
+  }
+  async init() {
+    await this.load();
+    await this._watchConfig();
+  }
+  async load(reload, reason) {
+    try {
+      await this._load(reload, reason);
+      this._loadingError = void 0;
+    } catch (error) {
+      console.error(`Cannot ${reload ? "restart" : "start"} nuxt: `, error);
+      this._handler = void 0;
+      this._loadingError = error;
+      this._loadingMessage = "Error while loading Nuxt. Please check console and fix errors.";
+      this.emit("loading:error", error);
+    }
+  }
+  async close() {
+    if (this._currentNuxt) {
+      await this._currentNuxt.close();
+    }
+    if (this._distWatcher) {
+      await this._distWatcher.close();
+    }
+  }
+  async _load(reload, reason) {
+    const action = reload ? "Restarting" : "Starting";
+    this._loadingMessage = `${reason ? `${reason}. ` : ""}${action} Nuxt...`;
+    this._handler = void 0;
+    this.emit("loading", this._loadingMessage);
+    if (reload) {
+      console.info(this._loadingMessage);
+    }
+    await this.close();
+    const kit = await loadKit(this.options.cwd);
+    const devServerDefaults = resolveDevServerDefaults({}, await this.listener.getURLs().then((r) => r.map((r2) => r2.url)));
+    this._currentNuxt = await kit.loadNuxt({
+      cwd: this.options.cwd,
+      dev: true,
+      ready: false,
+      envName: this.options.envName,
+      dotenv: {
+        cwd: this.options.cwd,
+        fileName: this.options.dotenv.fileName
+      },
+      defaults: defu(this.options.defaults, devServerDefaults),
+      overrides: {
+        logLevel: this.options.logLevel,
+        ...this.options.overrides,
+        vite: {
+          clearScreen: this.options.clear,
+          ...this.options.overrides.vite
+        }
+      }
+    });
+    if (!process.env.NUXI_DISABLE_VITE_HMR) {
+      this._currentNuxt.hooks.hook("vite:extend", ({ config }) => {
+        if (config.server) {
+          config.server.hmr = {
+            protocol: void 0,
+            ...config.server.hmr,
+            port: void 0,
+            host: void 0,
+            server: this.listener.server
+          };
+        }
+      });
+    }
+    this._currentNuxt.hooks.hookOnce("close", () => {
+      this.listener.server.removeAllListeners("upgrade");
+    });
+    if (!reload) {
+      const previousManifest = await loadNuxtManifest(this._currentNuxt.options.buildDir);
+      const newManifest = resolveNuxtManifest(this._currentNuxt);
+      const promise = writeNuxtManifest(this._currentNuxt, newManifest);
+      this._currentNuxt.hooks.hookOnce("ready", async () => {
+        await promise;
+      });
+      if (previousManifest && newManifest && previousManifest._hash !== newManifest._hash) {
+        await clearBuildDir(this._currentNuxt.options.buildDir);
+      }
+    }
+    await this._currentNuxt.ready();
+    const unsub = this._currentNuxt.hooks.hook("restart", async (options) => {
+      unsub();
+      if (options?.hard) {
+        this.emit("restart");
+        return;
+      }
+      await this.load(true);
+    });
+    if (this._currentNuxt.server && "upgrade" in this._currentNuxt.server) {
+      this.listener.server.on("upgrade", (req, socket, head) => {
+        const nuxt = this._currentNuxt;
+        if (!nuxt || !nuxt.server)
+          return;
+        const viteHmrPath = joinURL(
+          nuxt.options.app.baseURL.startsWith("./") ? nuxt.options.app.baseURL.slice(1) : nuxt.options.app.baseURL,
+          nuxt.options.app.buildAssetsDir
+        );
+        if (req.url?.startsWith(viteHmrPath)) {
+          return;
+        }
+        nuxt.server.upgrade(req, socket, head);
+      });
+    }
+    await this._currentNuxt.hooks.callHook("listen", this.listener.server, this.listener);
+    const addr = this.listener.address;
+    this._currentNuxt.options.devServer.host = addr.address;
+    this._currentNuxt.options.devServer.port = addr.port;
+    this._currentNuxt.options.devServer.url = getAddressURL(addr, !!this.listener.https);
+    this._currentNuxt.options.devServer.https = this.options.devContext.proxy?.https;
+    if (this.listener.https && !process.env.NODE_TLS_REJECT_UNAUTHORIZED) {
+      console.warn("You might need `NODE_TLS_REJECT_UNAUTHORIZED=0` environment variable to make https work.");
+    }
+    await Promise.all([
+      kit.writeTypes(this._currentNuxt).catch(console.error),
+      kit.buildNuxt(this._currentNuxt)
+    ]);
+    if (!this._currentNuxt.server) {
+      throw new Error("Nitro server has not been initialized.");
+    }
+    this._distWatcher = chokidar.watch(resolve(this._currentNuxt.options.buildDir, "dist"), {
+      ignoreInitial: true,
+      depth: 0
+    });
+    this._distWatcher.on("unlinkDir", () => {
+      this.loadDebounced(true, ".nuxt/dist directory has been removed");
+    });
+    this._handler = toNodeListener(this._currentNuxt.server.app);
+    this.emit("ready", addr);
+  }
+  async _watchConfig() {
+    const configWatcher = chokidar.watch([this.options.cwd, join(this.options.cwd, ".config")], {
+      ignoreInitial: true,
+      depth: 0
+    });
+    configWatcher.on("all", (event, _file) => {
+      if (event === "all" || event === "ready" || event === "error" || event === "raw") {
+        return;
+      }
+      const file = relative(this.options.cwd, _file);
+      if (file === (this.options.dotenv.fileName || ".env")) {
+        this.emit("restart");
+      }
+      if (RESTART_RE.test(file)) {
+        this.loadDebounced(true, `${file} updated`);
+      }
+    });
   }
-});
+}
+function getAddressURL(addr, https) {
+  const proto = https ? "https" : "http";
+  let host = addr.address.includes(":") ? `[${addr.address}]` : addr.address;
+  if (host === "[::]") {
+    host = "localhost";
+  }
+  const port = addr.port || 3e3;
+  return `${proto}://${host}:${port}/`;
+}
+function resolveDevServerOverrides(listenOptions) {
+  if (listenOptions.public || provider === "codesandbox") {
+    return {
+      devServer: { cors: { origin: "*" } },
+      vite: { server: { allowedHosts: true } }
+    };
+  }
+  return {};
+}
+function resolveDevServerDefaults(listenOptions, urls = []) {
+  const defaultConfig = {};
+  if (urls) {
+    defaultConfig.vite = { server: { allowedHosts: urls.map((u) => new URL(u).hostname) } };
+  }
+  if (listenOptions.hostname) {
+    const protocol = listenOptions.https ? "https" : "http";
+    defaultConfig.devServer = { cors: { origin: [`${protocol}://${listenOptions.hostname}`, ...urls] } };
+    defaultConfig.vite = defu(defaultConfig.vite, { server: { allowedHosts: [listenOptions.hostname] } });
+  }
+  return defaultConfig;
+}
+
+const start = Date.now();
+process.env.NODE_ENV = "development";
+class IPC {
+  enabled = !!process.send && !process.title.includes("vitest") && process.env.__NUXT__FORK;
+  constructor() {
+    process.once("unhandledRejection", (reason) => {
+      this.send({ type: "nuxt:internal:dev:rejection", message: reason instanceof Error ? reason.toString() : "Unhandled Rejection" });
+      process.exit();
+    });
+    process.on("message", (message) => {
+      if (message.type === "nuxt:internal:dev:context") {
+        initialize(message.context);
+      }
+    });
+    this.send({ type: "nuxt:internal:dev:fork-ready" });
+  }
+  send(message) {
+    if (this.enabled) {
+      process.send?.(message);
+    }
+  }
+}
+const ipc = new IPC();
+async function initialize(devContext, ctx = {}, listenOptions) {
+  const devServerOverrides = resolveDevServerOverrides({
+    public: devContext.public
+  });
+  const devServerDefaults = resolveDevServerDefaults({
+    hostname: devContext.hostname,
+    https: devContext.proxy?.https
+  }, devContext.publicURLs);
+  const devServer = await createNuxtDevServer({
+    cwd: devContext.cwd,
+    overrides: defu(ctx.data?.overrides, devServerOverrides),
+    defaults: devServerDefaults,
+    logLevel: devContext.args.logLevel,
+    clear: !!devContext.args.clear,
+    dotenv: { cwd: devContext.cwd, fileName: devContext.args.dotenv },
+    envName: devContext.args.envName,
+    port: process.env._PORT ?? void 0,
+    devContext
+  }, listenOptions);
+  let port;
+  if (ipc.enabled) {
+    devServer.on("loading:error", (_error) => {
+      ipc.send({
+        type: "nuxt:internal:dev:loading:error",
+        error: {
+          message: _error.message,
+          stack: _error.stack,
+          name: _error.name,
+          code: _error.code
+        }
+      });
+    });
+    devServer.on("loading", (message) => {
+      ipc.send({ type: "nuxt:internal:dev:loading", message });
+    });
+    devServer.on("restart", () => {
+      ipc.send({ type: "nuxt:internal:dev:restart" });
+    });
+    devServer.on("ready", (payload) => {
+      ipc.send({ type: "nuxt:internal:dev:ready", port: payload.port });
+    });
+  } else {
+    devServer.on("ready", (payload) => {
+      port = payload.port;
+    });
+  }
+  await devServer.init();
+  if (process.env.DEBUG) {
+    console.debug(`Dev server (internal) initialized in ${Date.now() - start}ms`);
+  }
+  return {
+    listener: devServer.listener,
+    close: () => devServer.close(),
+    onReady: (callback) => {
+      if (port) {
+        callback(port);
+      } else {
+        devServer.once("ready", (payload) => callback(payload.port));
+      }
+    },
+    onRestart: (callback) => {
+      devServer.once("restart", () => callback(devServer));
+    }
+  };
+}
+
+const index = {
+  __proto__: null,
+  initialize: initialize
+};
 
-export { index as default };
+export { index as a, initialize as i, renderError as r };

package/dist/chunks/index2.mjs

@@ -0,0 +1,15 @@
+import { defineCommand } from 'citty';
+
+const index = defineCommand({
+  meta: {
+    name: "module",
+    description: "Manage Nuxt modules"
+  },
+  args: {},
+  subCommands: {
+    add: () => import('./add.mjs').then((r) => r.default || r),
+    search: () => import('./search.mjs').then((r) => r.default || r)
+  }
+});
+
+export { index as default };

package/dist/chunks/info.mjs

@@ -8,14 +8,16 @@ import { resolve } from 'pathe';
 import { readPackageJSON } from 'pkg-types';
 import { splitByCase } from 'scule';
 import { isMinimal } from 'std-env';
-import { v as version } from '../shared/cli-nightly.DPQxxyDx.mjs';
-import { t as tryResolveNuxt } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { b as legacyRootDirArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
+import { v as version } from '../shared/cli-nightly.Cf9T6EbF.mjs';
+import { t as tryResolveNuxt } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
 import { g as getPackageManagerVersion } from '../shared/cli-nightly.BSm0_9Hr.mjs';
-import 'node:path';
-import 'consola';
+import { l as legacyRootDirArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
 import 'node:url';
+import 'exsolve';
+import 'consola';
 import 'node:child_process';
+import 'node:path';
 
 const info = defineCommand({
   meta: {
@@ -30,7 +32,7 @@ const info = defineCommand({
     const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
     const nuxtConfig = await getNuxtConfig(cwd);
     const { dependencies = {}, devDependencies = {} } = await readPackageJSON(cwd).catch(() => ({}));
-    const nuxtPath = await tryResolveNuxt(cwd);
+    const nuxtPath = tryResolveNuxt(cwd);
     async function getDepVersion(name) {
       for (const url of [cwd, nuxtPath]) {
         if (!url) {

package/dist/chunks/init.mjs

@@ -8,12 +8,13 @@ import { $fetch } from 'ofetch';
 import { resolve, relative, join } from 'pathe';
 import { hasTTY } from 'std-env';
 import { x } from 'tinyexec';
-import { r as runCommand } from '../shared/cli-nightly.DTVmTXKJ.mjs';
-import { l as logLevelArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
+import { r as runCommand } from '../shared/cli-nightly.B4U5vhqQ.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
 import 'node:url';
 import 'node:crypto';
 import 'node:path';
-import '../shared/cli-nightly.DPQxxyDx.mjs';
+import '../shared/cli-nightly.Cf9T6EbF.mjs';
 import 'consola';
 
 const themeColor = "\x1B[38;2;0;220;130m";

package/dist/chunks/prepare.mjs

@@ -1,15 +1,16 @@
 import process from 'node:process';
 import { defineCommand } from 'citty';
 import { resolve, relative } from 'pathe';
-import { a as clearBuildDir } from '../shared/cli-nightly.BnfAj4iy.mjs';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { b as legacyRootDirArgs, e as envNameArgs, l as logLevelArgs, c as cwdArgs, d as dotEnvArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
+import { a as clearBuildDir } from '../shared/cli-nightly.DPmMxQ6h.mjs';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { l as legacyRootDirArgs, e as envNameArgs, a as logLevelArgs, c as cwdArgs, d as dotEnvArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
 import 'node:fs';
-import 'jiti';
+import 'node:url';
+import 'exsolve';
+import 'consola';
 import 'node:path';
 import 'std-env';
-import 'consola';
-import 'node:url';
 
 const prepare = defineCommand({
   meta: {

package/dist/chunks/preview.mjs

@@ -7,12 +7,13 @@ import { box, colors } from 'consola/utils';
 import { getArgs } from 'listhen/cli';
 import { resolve } from 'pathe';
 import { x } from 'tinyexec';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { d as dotEnvArgs, b as legacyRootDirArgs, e as envNameArgs, l as logLevelArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import 'jiti';
-import 'std-env';
-import 'consola';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { d as dotEnvArgs, l as legacyRootDirArgs, e as envNameArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
 import 'node:url';
+import 'exsolve';
+import 'consola';
+import 'std-env';
 
 const command = defineCommand({
   meta: {

package/dist/chunks/search.mjs

@@ -2,12 +2,13 @@ import { defineCommand } from 'citty';
 import { colors } from 'consola/utils';
 import Fuse from 'fuse.js';
 import { upperFirst, kebabCase } from 'scule';
-import { c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
 import { g as getNuxtVersion, f as fetchModules, c as checkNuxtCompatibility } from '../shared/cli-nightly.C935N1ss.mjs';
+import 'consola';
 import 'node:path';
 import 'node:process';
 import 'std-env';
-import 'consola';
 import 'node:url';
 import 'ofetch';
 import 'pkg-types';

package/dist/chunks/test.mjs

@@ -1,10 +1,11 @@
 import process from 'node:process';
 import { defineCommand } from 'citty';
 import { resolve } from 'pathe';
-import { b as legacyRootDirArgs, l as logLevelArgs, 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, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
+import 'consola';
 import 'node:path';
 import 'std-env';
-import 'consola';
 import 'node:url';
 
 const test = defineCommand({

package/dist/chunks/typecheck.mjs

@@ -1,14 +1,15 @@
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { defineCommand } from 'citty';
-import { createJiti } from 'jiti';
+import { resolveModulePath } from 'exsolve';
 import { resolve } from 'pathe';
 import { isBun } from 'std-env';
 import { x } from 'tinyexec';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { b as legacyRootDirArgs, d as dotEnvArgs, l as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.CjK7ZDKA.mjs';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as legacyRootDirArgs, d as dotEnvArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
 import 'node:path';
 import 'consola';
+import '../shared/cli-nightly.B9AmABr3.mjs';
 
 const typecheck = defineCommand({
   meta: {
@@ -36,10 +37,9 @@ const typecheck = defineCommand({
     await writeTypes(nuxt);
     await buildNuxt(nuxt);
     await nuxt.close();
-    const jiti = createJiti(cwd);
     const [resolvedTypeScript, resolvedVueTsc] = await Promise.all([
-      jiti.esmResolve("typescript", { try: true }),
-      jiti.esmResolve("vue-tsc/bin/vue-tsc.js", { try: true })
+      resolveModulePath("typescript", { try: true }),
+      resolveModulePath("vue-tsc/bin/vue-tsc.js", { try: true })
     ]);
     if (resolvedTypeScript && resolvedVueTsc) {
       await x(fileURLToPath(resolvedVueTsc), ["--noEmit"], {

package/dist/chunks/upgrade.mjs

@@ -5,18 +5,19 @@ import { colors } from 'consola/utils';
 import { detectPackageManager, addDependency, dedupeDependencies } from 'nypm';
 import { resolve } from 'pathe';
 import { readPackageJSON } from 'pkg-types';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { b as legacyRootDirArgs, l as logLevelArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import { c as cleanupNuxtDirs, n as nuxtVersionToGitIdentifier } from '../shared/cli-nightly.DDBHWicM.mjs';
+import { l as loadKit } from '../shared/cli-nightly.BrKZotr9.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { c as cleanupNuxtDirs, n as nuxtVersionToGitIdentifier } from '../shared/cli-nightly.Bu_9IHj2.mjs';
 import { g as getPackageManagerVersion } from '../shared/cli-nightly.BSm0_9Hr.mjs';
-import 'jiti';
-import 'node:path';
-import 'std-env';
-import 'consola';
+import { l as legacyRootDirArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
 import 'node:url';
+import 'exsolve';
+import 'consola';
 import 'ohash';
-import '../shared/cli-nightly.BnfAj4iy.mjs';
+import '../shared/cli-nightly.DPmMxQ6h.mjs';
 import 'node:child_process';
+import 'node:path';
+import 'std-env';
 
 async function getNuxtVersion(path) {
   try {

package/dist/dev/index.d.mts

@@ -0,0 +1,75 @@
+import * as listhen from 'listhen';
+import { ListenURL, HTTPSOptions, Listener, ListenOptions } from 'listhen';
+import { NuxtConfig } from '@nuxt/schema';
+import { DotenvOptions } from 'c12';
+import { RequestListener, IncomingMessage, ServerResponse } from 'node:http';
+import EventEmitter from 'node:events';
+
+interface NuxtDevContext {
+    cwd: string;
+    public?: boolean;
+    hostname?: string;
+    publicURLs?: string[];
+    args: {
+        clear: boolean;
+        logLevel: string;
+        dotenv: string;
+        envName: string;
+    };
+    proxy?: {
+        url?: string;
+        urls?: ListenURL[];
+        https?: boolean | HTTPSOptions;
+    };
+}
+interface NuxtDevServerOptions {
+    cwd: string;
+    logLevel?: 'silent' | 'info' | 'verbose';
+    dotenv: DotenvOptions;
+    envName?: string;
+    clear?: boolean;
+    defaults: NuxtConfig;
+    overrides: NuxtConfig;
+    port?: string | number;
+    loadingTemplate?: ({ loading }: {
+        loading: string;
+    }) => string;
+    devContext: NuxtDevContext;
+}
+declare class NuxtDevServer extends EventEmitter {
+    private options;
+    private _handler?;
+    private _distWatcher?;
+    private _currentNuxt?;
+    private _loadingMessage?;
+    private _loadingError?;
+    private cwd;
+    loadDebounced: (reload?: boolean, reason?: string) => void;
+    handler: RequestListener;
+    listener: Listener;
+    constructor(options: NuxtDevServerOptions);
+    _renderError(req: IncomingMessage, res: ServerResponse): void;
+    resolveLoadingTemplate(): Promise<(params: {
+        loading: string;
+    }) => string>;
+    _renderLoadingScreen(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    init(): Promise<void>;
+    load(reload?: boolean, reason?: string): Promise<void>;
+    close(): Promise<void>;
+    _load(reload?: boolean, reason?: string): Promise<void>;
+    _watchConfig(): Promise<void>;
+}
+
+interface InitializeOptions {
+    data?: {
+        overrides?: NuxtConfig;
+    };
+}
+declare function initialize(devContext: NuxtDevContext, ctx?: InitializeOptions, listenOptions?: Partial<ListenOptions>): Promise<{
+    listener: listhen.Listener;
+    close: () => Promise<void>;
+    onReady: (callback: (port: number) => void) => void;
+    onRestart: (callback: (devServer: NuxtDevServer) => void) => void;
+}>;
+
+export { initialize };