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

package/dist/dev/index.d.ts

@@ -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 };

package/dist/dev/index.mjs

@@ -0,0 +1,21 @@
+export { i as initialize } from '../chunks/index.mjs';
+import 'node:process';
+import 'defu';
+import 'node:events';
+import 'chokidar';
+import 'h3';
+import 'listhen';
+import 'pathe';
+import 'perfect-debounce';
+import 'std-env';
+import 'ufo';
+import '../shared/cli-nightly.DPmMxQ6h.mjs';
+import 'node:fs';
+import '../shared/cli-nightly.B9AmABr3.mjs';
+import 'consola';
+import '../shared/cli-nightly.BrKZotr9.mjs';
+import 'node:url';
+import 'exsolve';
+import '../shared/cli-nightly.Bu_9IHj2.mjs';
+import 'ohash';
+import 'youch';

package/dist/index.mjs

@@ -1,7 +1,8 @@
-export { m as main, r as runCommand, h as runMain } from './shared/cli-nightly.CjK7ZDKA.mjs';
+export { m as main, r as runCommand, g as runMain } from './shared/cli-nightly.BgFMCBoq.mjs';
 import 'node:path';
 import 'node:process';
 import 'citty';
 import 'std-env';
 import 'consola';
+import './shared/cli-nightly.B9AmABr3.mjs';
 import 'node:url';

package/dist/shared/{cli-nightly.DTVmTXKJ.mjs → cli-nightly.B4U5vhqQ.mjs}

@@ -1,11 +1,12 @@
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { defineCommand, runCommand as runCommand$1 } from 'citty';
-import { f as commands, c as cwdArgs, a as logger, s as setupGlobalConsole, g as checkEngines } from './cli-nightly.CjK7ZDKA.mjs';
+import { b as commands, c as cwdArgs, s as setupGlobalConsole, f as checkEngines } from './cli-nightly.BgFMCBoq.mjs';
 import nodeCrypto from 'node:crypto';
 import { resolve } from 'node:path';
 import { provider } from 'std-env';
-import { d as description, v as version, n as name } from './cli-nightly.DPQxxyDx.mjs';
+import { d as description, v as version, n as name } from './cli-nightly.Cf9T6EbF.mjs';
+import { l as logger } from './cli-nightly.B9AmABr3.mjs';
 
 if (!globalThis.crypto) {
   globalThis.crypto = nodeCrypto;
@@ -60,10 +61,10 @@ globalThis.__nuxt_cli__ = globalThis.__nuxt_cli__ || {
   // Programmatic usage fallback
   startTime: Date.now(),
   entry: fileURLToPath(
-    new URL(
-      import.meta.url.endsWith(".ts") ? "../bin/nuxi.mjs" : "../../bin/nuxi.mjs",
-      import.meta.url
-    )
+    new URL("../../bin/nuxi.mjs", import.meta.url)
+  ),
+  devEntry: fileURLToPath(
+    new URL("../dev/index.mjs", import.meta.url)
   )
 };
 async function runCommand(name, argv = process.argv.slice(2), data = {}) {

package/dist/shared/cli-nightly.B9AmABr3.mjs

@@ -0,0 +1,5 @@
+import { consola } from 'consola';
+
+const logger = consola.withTag("nuxi");
+
+export { logger as l };

package/dist/shared/{cli-nightly.CjK7ZDKA.mjs → cli-nightly.BgFMCBoq.mjs}

@@ -3,11 +3,12 @@ import process from 'node:process';
 import { defineCommand, runMain as runMain$1, runCommand as runCommand$1 } from 'citty';
 import { provider } from 'std-env';
 import { consola } from 'consola';
+import { l as logger } from './cli-nightly.B9AmABr3.mjs';
 import { fileURLToPath } from 'node:url';
 
 const _rDefault = (r) => r.default || r;
 const commands = {
-  add: () => import('../chunks/add.mjs').then(_rDefault),
+  add: () => import('../chunks/add2.mjs').then(_rDefault),
   analyze: () => import('../chunks/analyze.mjs').then(_rDefault),
   build: () => import('../chunks/build.mjs').then(_rDefault),
   cleanup: () => import('../chunks/cleanup.mjs').then(_rDefault),
@@ -17,7 +18,7 @@ const commands = {
   generate: () => import('../chunks/generate.mjs').then(_rDefault),
   info: () => import('../chunks/info.mjs').then(_rDefault),
   init: () => import('../chunks/init.mjs').then(_rDefault),
-  module: () => import('../chunks/index.mjs').then(_rDefault),
+  module: () => import('../chunks/index2.mjs').then(_rDefault),
   prepare: () => import('../chunks/prepare.mjs').then(_rDefault),
   preview: () => import('../chunks/preview.mjs').then(_rDefault),
   start: () => import('../chunks/preview.mjs').then(_rDefault),
@@ -105,8 +106,6 @@ function setupGlobalConsole(opts = {}) {
   process.on("uncaughtException", (err) => consola.error("[uncaughtException]", err));
 }
 
-const logger = consola.withTag("nuxi");
-
 async function checkEngines() {
   const satisfies = await import('semver/functions/satisfies.js').then(
     (r) => r.default || r
@@ -122,7 +121,7 @@ async function checkEngines() {
 }
 
 const name = "@nuxt/cli-nightly";
-const version = "3.26.0-20250607-210256-59f83b1";
+const version = "3.26.0-20250607-215204-1943f84";
 const description = "Nuxt CLI";
 
 const main = defineCommand({
@@ -174,10 +173,10 @@ globalThis.__nuxt_cli__ = globalThis.__nuxt_cli__ || {
   // Programmatic usage fallback
   startTime: Date.now(),
   entry: fileURLToPath(
-    new URL(
-      import.meta.url.endsWith(".ts") ? "../bin/nuxi.mjs" : "../../bin/nuxi.mjs",
-      import.meta.url
-    )
+    new URL("../../bin/nuxi.mjs", import.meta.url)
+  ),
+  devEntry: fileURLToPath(
+    new URL("../dev/index.mjs", import.meta.url)
   )
 };
 const runMain = () => runMain$1(main);
@@ -194,4 +193,4 @@ async function runCommand(name, argv = process.argv.slice(2), data = {}) {
   });
 }
 
-export { logger as a, legacyRootDirArgs as b, cwdArgs as c, dotEnvArgs as d, envNameArgs as e, commands as f, checkEngines as g, runMain as h, logLevelArgs as l, main as m, runCommand as r, setupGlobalConsole as s };
+export { logLevelArgs as a, commands as b, cwdArgs as c, dotEnvArgs as d, envNameArgs as e, checkEngines as f, runMain as g, legacyRootDirArgs as l, main as m, runCommand as r, setupGlobalConsole as s };

package/dist/shared/{cli-nightly.DlcAx0De.mjs → cli-nightly.BrKZotr9.mjs}

@@ -1,11 +1,14 @@
-import { createJiti } from 'jiti';
+import { pathToFileURL } from 'node:url';
+import { resolveModulePath } from 'exsolve';
 
 async function loadKit(rootDir) {
-  const jiti = createJiti(rootDir);
   try {
-    const localKit = jiti.esmResolve("@nuxt/kit", { try: true });
-    const rootURL = localKit ? rootDir : await tryResolveNuxt(rootDir) || rootDir;
-    let kit = await jiti.import("@nuxt/kit", { parentURL: rootURL });
+    let kitPath = resolveModulePath("@nuxt/kit", { try: true, from: rootDir });
+    if (!kitPath) {
+      const nuxtPath = tryResolveNuxt(rootDir);
+      kitPath = resolveModulePath("@nuxt/kit", { from: nuxtPath || rootDir });
+    }
+    let kit = await import(pathToFileURL(kitPath).href);
     if (!kit.writeTypes) {
       kit = {
         ...kit,
@@ -18,16 +21,15 @@ async function loadKit(rootDir) {
   } catch (e) {
     if (e.toString().includes("Cannot find module '@nuxt/kit'")) {
       throw new Error(
-        "nuxi requires `@nuxt/kit` to be installed in your project. Try installing `nuxt` v3 or `@nuxt/bridge` first."
+        "nuxi requires `@nuxt/kit` to be installed in your project. Try installing `nuxt` v3+ or `@nuxt/bridge` first."
       );
     }
     throw e;
   }
 }
-async function tryResolveNuxt(rootDir) {
-  const jiti = createJiti(rootDir);
+function tryResolveNuxt(rootDir) {
   for (const pkg of ["nuxt-nightly", "nuxt", "nuxt3", "nuxt-edge"]) {
-    const path = jiti.esmResolve(pkg, { try: true });
+    const path = resolveModulePath(pkg, { from: rootDir, try: true });
     if (path) {
       return path;
     }

package/dist/shared/{cli-nightly.DDBHWicM.mjs → cli-nightly.Bu_9IHj2.mjs}

@@ -1,8 +1,8 @@
 import { promises } from 'node:fs';
 import { hash } from 'ohash';
 import { resolve, dirname } from 'pathe';
-import { a as logger } from './cli-nightly.CjK7ZDKA.mjs';
-import { r as rmRecursive } from './cli-nightly.BnfAj4iy.mjs';
+import { l as logger } from './cli-nightly.B9AmABr3.mjs';
+import { r as rmRecursive } from './cli-nightly.DPmMxQ6h.mjs';
 
 async function cleanupNuxtDirs(rootDir, buildDir) {
   logger.info("Cleaning up generated Nuxt files and caches...");

package/dist/shared/{cli-nightly.DPQxxyDx.mjs → cli-nightly.Cf9T6EbF.mjs}

@@ -1,5 +1,5 @@
 const name = "nuxi-nightly";
-const version = "3.26.0-20250607-210236-59f83b1";
+const version = "3.26.0-20250607-215143-1943f84";
 const description = "Nuxt CLI";
 
 export { description as d, name as n, version as v };

package/dist/shared/{cli-nightly.BnfAj4iy.mjs → cli-nightly.DPmMxQ6h.mjs}

@@ -1,6 +1,6 @@
 import { promises, existsSync } from 'node:fs';
 import { join } from 'pathe';
-import { a as logger } from './cli-nightly.CjK7ZDKA.mjs';
+import { l as logger } from './cli-nightly.B9AmABr3.mjs';
 
 async function clearDir(path, exclude) {
   if (!exclude) {

package/dist/shared/cli-nightly.Dc8ncNQ_.mjs

@@ -0,0 +1,27 @@
+import { readFileSync } from 'node:fs';
+import { colors } from 'consola/utils';
+import { resolveModulePath } from 'exsolve';
+import { t as tryResolveNuxt } from './cli-nightly.BrKZotr9.mjs';
+import { l as logger } from './cli-nightly.B9AmABr3.mjs';
+
+function showVersions(cwd) {
+  const { bold, gray, green } = colors;
+  const nuxtDir = tryResolveNuxt(cwd);
+  function getPkgVersion(pkg) {
+    for (const url of [cwd, nuxtDir]) {
+      if (!url) {
+        continue;
+      }
+      const p = resolveModulePath(`${pkg}/package.json`, { from: url, try: true });
+      if (p) {
+        return JSON.parse(readFileSync(p, "utf-8")).version;
+      }
+    }
+    return "";
+  }
+  const nuxtVersion = getPkgVersion("nuxt") || getPkgVersion("nuxt-nightly") || getPkgVersion("nuxt3") || getPkgVersion("nuxt-edge");
+  const nitroVersion = getPkgVersion("nitropack") || getPkgVersion("nitropack-nightly") || getPkgVersion("nitropack-edge");
+  logger.log(gray(green(`Nuxt ${bold(nuxtVersion)}`) + (nitroVersion ? ` with Nitro ${bold(nitroVersion)}` : "")));
+}
+
+export { showVersions as s };

package/dist/shared/{cli-nightly.DdmGgrsK.mjs → cli-nightly.DkO5RR_e.mjs}

@@ -1,5 +1,5 @@
 import process from 'node:process';
-import { a as logger } from './cli-nightly.CjK7ZDKA.mjs';
+import { l as logger } from './cli-nightly.B9AmABr3.mjs';
 
 function overrideEnv(targetEnv) {
   const currentEnv = process.env.NODE_ENV;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxt/cli-nightly",
   "type": "module",
-  "version": "3.26.0-20250607-210256-59f83b1",
+  "version": "3.26.0-20250607-215204-1943f84",
   "description": "Nuxt CLI",
   "license": "MIT",
   "repository": {
@@ -39,6 +39,7 @@
     "clipboardy": "^4.0.0",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
+    "exsolve": "^1.0.5",
     "fuse.js": "^7.1.0",
     "giget": "^2.0.0",
     "h3": "^1.15.3",

package/dist/chunks/dev2.mjs

@@ -1,293 +0,0 @@
-import EventEmitter from 'node:events';
-import process from 'node:process';
-import chokidar from 'chokidar';
-import defu from 'defu';
-import { toNodeListener } from 'h3';
-import { createJiti } from 'jiti';
-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.BnfAj4iy.mjs';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import { l as loadNuxtManifest, r as resolveNuxtManifest, w as writeNuxtManifest } from '../shared/cli-nightly.DDBHWicM.mjs';
-import { Youch } from 'youch';
-
-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._jiti = createJiti(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;
-  _jiti;
-  _loadingError;
-  loadDebounced;
-  handler;
-  listener;
-  _renderError(req, res) {
-    renderError(req, res, this._loadingError);
-  }
-  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._jiti.import("@nuxt/ui-templates").then((r) => r.loading).catch(() => {
-    }) || ((params) => `<h2>${params.loading}</h2>`);
-    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) {
-      logger.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) {
-      logger.info(this._loadingMessage);
-    }
-    await this.close();
-    const kit = await loadKit(this.options.cwd);
-    const devServerDefaults = _getDevServerDefaults({}, 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",
-        async (req, socket, head) => {
-          const nuxt = this._currentNuxt;
-          if (!nuxt)
-            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;
-          }
-          await 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) {
-      logger.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)
-    ]);
-    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 _getDevServerOverrides(listenOptions) {
-  if (listenOptions.public || provider === "codesandbox") {
-    return {
-      devServer: { cors: { origin: "*" } },
-      vite: { server: { allowedHosts: true } }
-    };
-  }
-  return {};
-}
-function _getDevServerDefaults(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 dev = {
-  __proto__: null,
-  _getDevServerDefaults: _getDevServerDefaults,
-  _getDevServerOverrides: _getDevServerOverrides,
-  createNuxtDevServer: createNuxtDevServer
-};
-
-export { _getDevServerOverrides as _, _getDevServerDefaults as a, createNuxtDevServer as c, dev as d, renderError as r };

package/dist/shared/cli-nightly.COGWopdX.mjs

@@ -1,26 +0,0 @@
-import { colors } from 'consola/utils';
-import { readPackageJSON } from 'pkg-types';
-import { t as tryResolveNuxt } from './cli-nightly.DlcAx0De.mjs';
-import { a as logger } from './cli-nightly.CjK7ZDKA.mjs';
-
-async function showVersions(cwd) {
-  const { bold, gray, green } = colors;
-  const nuxtDir = await tryResolveNuxt(cwd);
-  async function getPkgVersion(pkg) {
-    for (const url of [cwd, nuxtDir]) {
-      if (!url) {
-        continue;
-      }
-      const p = await readPackageJSON(pkg, { url }).catch(() => null);
-      if (p) {
-        return p.version;
-      }
-    }
-    return "";
-  }
-  const nuxtVersion = await getPkgVersion("nuxt") || await getPkgVersion("nuxt-nightly") || await getPkgVersion("nuxt3") || await getPkgVersion("nuxt-edge");
-  const nitroVersion = await getPkgVersion("nitropack") || await getPkgVersion("nitropack-nightly") || await getPkgVersion("nitropack-edge");
-  logger.log(gray(green(`Nuxt ${bold(nuxtVersion)}`) + (nitroVersion ? ` with Nitro ${bold(nitroVersion)}` : "")));
-}
-
-export { showVersions as s };