@nuxt/cli-nightly 3.29.4-20251021-192254-70dcc9b → 3.30.0-20251027-200530-97d8172

package/dist/dev/index.mjs

@@ -1,5 +1,5 @@
 import "../logger-Dk0gkCkX.mjs";
-import { t as initialize } from "../dev-L7lhoThJ.mjs";
+import { t as initialize } from "../dev-DsH3xiyp.mjs";
 import "../fs-ewAp6tjM.mjs";
 import "../kit-xFxVGu6d.mjs";
 import "../nuxt-Cc9ZTk7m.mjs";

package/dist/{dev-CnQwDUaD.mjs → dev-Bv3ZMKhd.mjs}

@@ -1,5 +1,5 @@
 import "./logger-Dk0gkCkX.mjs";
-import { t as initialize } from "./dev-L7lhoThJ.mjs";
+import { t as initialize } from "./dev-DsH3xiyp.mjs";
 import "./fs-ewAp6tjM.mjs";
 import "./kit-xFxVGu6d.mjs";
 import "./nuxt-Cc9ZTk7m.mjs";

package/dist/{dev-BfX9NUUq.mjs → dev-DG7T8nNT.mjs}

@@ -1,6 +1,6 @@
 import { a as legacyRootDirArgs, i as extendsArgs, n as dotEnvArgs, o as logLevelArgs, r as envNameArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
 import { t as logger } from "./logger-Dk0gkCkX.mjs";
-import { a as parseSocketURL, i as isSocketURL, n as resolveLoadingTemplate, r as renderError, t as initialize } from "./dev-L7lhoThJ.mjs";
+import { a as parseSocketURL, i as isSocketURL, n as resolveLoadingTemplate, r as renderError, t as initialize } from "./dev-DsH3xiyp.mjs";
 import "./fs-ewAp6tjM.mjs";
 import { t as loadKit } from "./kit-xFxVGu6d.mjs";
 import "./nuxt-Cc9ZTk7m.mjs";
@@ -13,12 +13,12 @@ import { listen } from "listhen";
 import { request } from "node:http";
 import { isSocketSupported } from "get-port-please";
 import { resolve } from "pathe";
+import { NodeRequest } from "srvx/node";
 import { fork } from "node:child_process";
 import { getArgs, parseArgs } from "listhen/cli";
 import { satisfies } from "semver";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { NodeRequest } from "srvx/node";
 import { Agent } from "undici";
 import { connect } from "node:net";
 

package/dist/{dev-L7lhoThJ.mjs → dev-DsH3xiyp.mjs}

@@ -4,7 +4,7 @@ import { a as writeNuxtManifest, i as resolveNuxtManifest, n as loadNuxtManifest
 import process from "node:process";
 import { provider } from "std-env";
 import { pathToFileURL } from "node:url";
-import defu from "defu";
+import defu, { defu as defu$1 } from "defu";
 import { listen } from "listhen";
 import { Server } from "node:http";
 import { cleanSocket, getSocketAddress } from "get-port-please";
@@ -12,10 +12,10 @@ import EventEmitter from "node:events";
 import { existsSync, statSync, watch } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { resolveModulePath } from "exsolve";
-import { toNodeListener } from "h3";
+import { joinURL } from "ufo";
 import { resolve } from "pathe";
 import { debounce } from "perfect-debounce";
-import { joinURL } from "ufo";
+import { toNodeHandler } from "srvx/node";
 import { Youch } from "youch";
 
 //#region ../nuxi/src/dev/socket.ts
@@ -68,6 +68,265 @@ async function createSocketListener(handler, proxyAddress) {
 	};
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/h3@1.15.4/node_modules/h3/dist/index.mjs
+function hasProp(obj, prop) {
+	try {
+		return prop in obj;
+	} catch {
+		return false;
+	}
+}
+var H3Error = class extends Error {
+	static __h3_error__ = true;
+	statusCode = 500;
+	fatal = false;
+	unhandled = false;
+	statusMessage;
+	data;
+	cause;
+	constructor(message, opts = {}) {
+		super(message, opts);
+		if (opts.cause && !this.cause) this.cause = opts.cause;
+	}
+	toJSON() {
+		const obj = {
+			message: this.message,
+			statusCode: sanitizeStatusCode(this.statusCode, 500)
+		};
+		if (this.statusMessage) obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
+		if (this.data !== void 0) obj.data = this.data;
+		return obj;
+	}
+};
+function createError(input) {
+	if (typeof input === "string") return new H3Error(input);
+	if (isError(input)) return input;
+	const err = new H3Error(input.message ?? input.statusMessage ?? "", { cause: input.cause || input });
+	if (hasProp(input, "stack")) try {
+		Object.defineProperty(err, "stack", { get() {
+			return input.stack;
+		} });
+	} catch {
+		try {
+			err.stack = input.stack;
+		} catch {}
+	}
+	if (input.data) err.data = input.data;
+	if (input.statusCode) err.statusCode = sanitizeStatusCode(input.statusCode, err.statusCode);
+	else if (input.status) err.statusCode = sanitizeStatusCode(input.status, err.statusCode);
+	if (input.statusMessage) err.statusMessage = input.statusMessage;
+	else if (input.statusText) err.statusMessage = input.statusText;
+	if (err.statusMessage) {
+		const originalMessage = err.statusMessage;
+		if (sanitizeStatusMessage(err.statusMessage) !== originalMessage) console.warn("[h3] Please prefer using `message` for longer error messages instead of `statusMessage`. In the future, `statusMessage` will be sanitized by default.");
+	}
+	if (input.fatal !== void 0) err.fatal = input.fatal;
+	if (input.unhandled !== void 0) err.unhandled = input.unhandled;
+	return err;
+}
+function sendError(event, error, debug) {
+	if (event.handled) return;
+	const h3Error = isError(error) ? error : createError(error);
+	const responseBody = {
+		statusCode: h3Error.statusCode,
+		statusMessage: h3Error.statusMessage,
+		stack: [],
+		data: h3Error.data
+	};
+	if (debug) responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
+	if (event.handled) return;
+	setResponseStatus(event, Number.parseInt(h3Error.statusCode), h3Error.statusMessage);
+	event.node.res.setHeader("content-type", MIMES.json);
+	event.node.res.end(JSON.stringify(responseBody, void 0, 2));
+}
+function isError(input) {
+	return input?.constructor?.__h3_error__ === true;
+}
+const RawBodySymbol = Symbol.for("h3RawBody");
+const ParsedBodySymbol = Symbol.for("h3ParsedBody");
+const MIMES = {
+	html: "text/html",
+	json: "application/json"
+};
+const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
+function sanitizeStatusMessage(statusMessage = "") {
+	return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
+}
+function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
+	if (!statusCode) return defaultStatusCode;
+	if (typeof statusCode === "string") statusCode = Number.parseInt(statusCode, 10);
+	if (statusCode < 100 || statusCode > 999) return defaultStatusCode;
+	return statusCode;
+}
+function splitCookiesString(cookiesString) {
+	if (Array.isArray(cookiesString)) return cookiesString.flatMap((c) => splitCookiesString(c));
+	if (typeof cookiesString !== "string") return [];
+	const cookiesStrings = [];
+	let pos = 0;
+	let start$1;
+	let ch;
+	let lastComma;
+	let nextStart;
+	let cookiesSeparatorFound;
+	const skipWhitespace = () => {
+		while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1;
+		return pos < cookiesString.length;
+	};
+	const notSpecialChar = () => {
+		ch = cookiesString.charAt(pos);
+		return ch !== "=" && ch !== ";" && ch !== ",";
+	};
+	while (pos < cookiesString.length) {
+		start$1 = pos;
+		cookiesSeparatorFound = false;
+		while (skipWhitespace()) {
+			ch = cookiesString.charAt(pos);
+			if (ch === ",") {
+				lastComma = pos;
+				pos += 1;
+				skipWhitespace();
+				nextStart = pos;
+				while (pos < cookiesString.length && notSpecialChar()) pos += 1;
+				if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+					cookiesSeparatorFound = true;
+					pos = nextStart;
+					cookiesStrings.push(cookiesString.slice(start$1, lastComma));
+					start$1 = pos;
+				} else pos = lastComma + 1;
+			} else pos += 1;
+		}
+		if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.slice(start$1));
+	}
+	return cookiesStrings;
+}
+function setResponseStatus(event, code, text) {
+	if (code) event.node.res.statusCode = sanitizeStatusCode(code, event.node.res.statusCode);
+	if (text) event.node.res.statusMessage = sanitizeStatusMessage(text);
+}
+function sendStream(event, stream) {
+	if (!stream || typeof stream !== "object") throw new Error("[h3] Invalid stream provided.");
+	event.node.res._data = stream;
+	if (!event.node.res.socket) {
+		event._handled = true;
+		return Promise.resolve();
+	}
+	if (hasProp(stream, "pipeTo") && typeof stream.pipeTo === "function") return stream.pipeTo(new WritableStream({ write(chunk) {
+		event.node.res.write(chunk);
+	} })).then(() => {
+		event.node.res.end();
+	});
+	if (hasProp(stream, "pipe") && typeof stream.pipe === "function") return new Promise((resolve$1, reject) => {
+		stream.pipe(event.node.res);
+		if (stream.on) {
+			stream.on("end", () => {
+				event.node.res.end();
+				resolve$1();
+			});
+			stream.on("error", (error) => {
+				reject(error);
+			});
+		}
+		event.node.res.on("close", () => {
+			if (stream.abort) stream.abort();
+		});
+	});
+	throw new Error("[h3] Invalid or incompatible stream provided.");
+}
+function sendWebResponse(event, response) {
+	for (const [key, value] of response.headers) if (key === "set-cookie") event.node.res.appendHeader(key, splitCookiesString(value));
+	else event.node.res.setHeader(key, value);
+	if (response.status) event.node.res.statusCode = sanitizeStatusCode(response.status, event.node.res.statusCode);
+	if (response.statusText) event.node.res.statusMessage = sanitizeStatusMessage(response.statusText);
+	if (response.redirected) event.node.res.setHeader("location", response.url);
+	if (!response.body) {
+		event.node.res.end();
+		return;
+	}
+	return sendStream(event, response.body);
+}
+const getSessionPromise = Symbol("getSession");
+var H3Event = class {
+	"__is_event__" = true;
+	node;
+	web;
+	context = {};
+	_method;
+	_path;
+	_headers;
+	_requestBody;
+	_handled = false;
+	_onBeforeResponseCalled;
+	_onAfterResponseCalled;
+	constructor(req, res) {
+		this.node = {
+			req,
+			res
+		};
+	}
+	get method() {
+		if (!this._method) this._method = (this.node.req.method || "GET").toUpperCase();
+		return this._method;
+	}
+	get path() {
+		return this._path || this.node.req.url || "/";
+	}
+	get headers() {
+		if (!this._headers) this._headers = _normalizeNodeHeaders(this.node.req.headers);
+		return this._headers;
+	}
+	get handled() {
+		return this._handled || this.node.res.writableEnded || this.node.res.headersSent;
+	}
+	respondWith(response) {
+		return Promise.resolve(response).then((_response) => sendWebResponse(this, _response));
+	}
+	toString() {
+		return `[${this.method}] ${this.path}`;
+	}
+	toJSON() {
+		return this.toString();
+	}
+	/** @deprecated Please use `event.node.req` instead. */
+	get req() {
+		return this.node.req;
+	}
+	/** @deprecated Please use `event.node.res` instead. */
+	get res() {
+		return this.node.res;
+	}
+};
+function createEvent(req, res) {
+	return new H3Event(req, res);
+}
+function _normalizeNodeHeaders(nodeHeaders) {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(nodeHeaders)) if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+	else if (value) headers.set(name, value);
+	return headers;
+}
+const H3Headers = globalThis.Headers;
+const H3Response = globalThis.Response;
+function toNodeListener(app) {
+	const toNodeHandle = async function(req, res) {
+		const event = createEvent(req, res);
+		try {
+			await app.handler(event);
+		} catch (_error) {
+			const error = createError(_error);
+			if (!isError(_error)) error.unhandled = true;
+			setResponseStatus(event, error.statusCode, error.statusMessage);
+			if (app.options.onError) await app.options.onError(error, event);
+			if (event.handled) return;
+			if (error.unhandled || error.fatal) console.error("[h3]", error.fatal ? "[fatal]" : "[unhandled]", error);
+			if (app.options.onBeforeResponse && !event._onBeforeResponseCalled) await app.options.onBeforeResponse(event, { body: error });
+			await sendError(event, error, !!app.options.debug);
+			if (app.options.onAfterResponse && !event._onAfterResponseCalled) await app.options.onAfterResponse(event, { body: error });
+		}
+	};
+	return toNodeHandle;
+}
+
 //#endregion
 //#region ../nuxi/src/dev/error.ts
 async function renderError(req, res, error) {
@@ -257,7 +516,8 @@ var NuxtDevServer = class extends EventEmitter {
 			if (!this._fileChangeTracker.shouldEmitChange(resolve(distDir, file || ""))) return;
 			this.loadDebounced(true, ".nuxt/dist directory has been removed");
 		});
-		this._handler = toNodeListener(this._currentNuxt.server.app);
+		if ("fetch" in this._currentNuxt.server) this._handler = toNodeHandler(this._currentNuxt.server.fetch);
+		else this._handler = toNodeListener(this._currentNuxt.server.app);
 		this.emit("ready", "socketPath" in addr ? formatSocketURL(addr.socketPath, !!this.listener.https) : `http://127.0.0.1:${addr.port}`);
 	}
 	_watchConfig() {

package/dist/{dev-child-CSiX6Uyv.mjs → dev-child-CJxOnht6.mjs}

@@ -25,7 +25,7 @@ var dev_child_default = defineCommand({
 	async run(ctx) {
 		if (!process.send && !isTest) console.warn("`nuxi _dev` is an internal command and should not be used directly. Please use `nuxi dev` instead.");
 		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-		const { initialize } = await import("./dev-CnQwDUaD.mjs");
+		const { initialize } = await import("./dev-Bv3ZMKhd.mjs");
 		await initialize({
 			cwd,
 			args: ctx.args

package/dist/index.mjs

@@ -11,19 +11,19 @@ import { fileURLToPath } from "node:url";
 const _rDefault = (r) => r.default || r;
 const commands = {
 	add: () => import("./add-BGMHIn5L.mjs").then(_rDefault),
-	analyze: () => import("./analyze-CUKAi_IN.mjs").then(_rDefault),
+	analyze: () => import("./analyze-BA0BTFOc.mjs").then(_rDefault),
 	build: () => import("./build-BebJ09xA.mjs").then(_rDefault),
 	cleanup: () => import("./cleanup-8GRakeLu.mjs").then(_rDefault),
-	_dev: () => import("./dev-child-CSiX6Uyv.mjs").then(_rDefault),
-	dev: () => import("./dev-BfX9NUUq.mjs").then(_rDefault),
+	_dev: () => import("./dev-child-CJxOnht6.mjs").then(_rDefault),
+	dev: () => import("./dev-DG7T8nNT.mjs").then(_rDefault),
 	devtools: () => import("./devtools-BLGzUSNU.mjs").then(_rDefault),
 	generate: () => import("./generate-B328yidV.mjs").then(_rDefault),
-	info: () => import("./info-CrSXb5ro.mjs").then(_rDefault),
-	init: () => import("./init-_n9DXzzY.mjs").then(_rDefault),
-	module: () => import("./module-CqBrGD-s.mjs").then(_rDefault),
+	info: () => import("./info-VcLxzwux.mjs").then(_rDefault),
+	init: () => import("./init-CvLYtdn1.mjs").then(_rDefault),
+	module: () => import("./module-BUBa48Be.mjs").then(_rDefault),
 	prepare: () => import("./prepare-B0KOhO-L.mjs").then(_rDefault),
-	preview: () => import("./preview-C5fNqrC6.mjs").then(_rDefault),
-	start: () => import("./preview-C5fNqrC6.mjs").then(_rDefault),
+	preview: () => import("./preview-BEqrL1ey.mjs").then(_rDefault),
+	start: () => import("./preview-BEqrL1ey.mjs").then(_rDefault),
 	test: () => import("./test-CBt1emEB.mjs").then(_rDefault),
 	typecheck: () => import("./typecheck-DCWe7Iej.mjs").then(_rDefault),
 	upgrade: () => import("./upgrade-BMSFcUWJ.mjs").then(_rDefault)
@@ -63,7 +63,7 @@ async function checkEngines() {
 //#endregion
 //#region package.json
 var name = "@nuxt/cli-nightly";
-var version = "3.29.4-20251021-192254-70dcc9b";
+var version = "3.30.0-20251027-200530-97d8172";
 var description = "Nuxt CLI";
 
 //#endregion

package/dist/{info-CrSXb5ro.mjs → info-VcLxzwux.mjs}

@@ -13,7 +13,7 @@ import { detectPackageManager } from "nypm";
 import { readPackageJSON } from "pkg-types";
 
 //#region ../nuxi/package.json
-var version = "3.29.4-20251021-192246-70dcc9b";
+var version = "3.30.0-20251027-200522-97d8172";
 
 //#endregion
 //#region ../nuxi/src/commands/info.ts

package/dist/{init-_n9DXzzY.mjs → init-CvLYtdn1.mjs}

@@ -2,7 +2,7 @@ import { o as logLevelArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
 import { t as logger } from "./logger-Dk0gkCkX.mjs";
 import "./fs-ewAp6tjM.mjs";
 import "./kit-xFxVGu6d.mjs";
-import { n as runCommand$1, t as add_default } from "./add-CRBwIlDF.mjs";
+import { n as runCommand$1, t as add_default } from "./add-CHYEpn7Y.mjs";
 import "./versions-CSy_3o_-.mjs";
 import "./prepare-xI978yFg.mjs";
 import "./_utils-DTrPahho.mjs";

package/dist/{module-CqBrGD-s.mjs → module-BUBa48Be.mjs}

@@ -8,7 +8,7 @@ var module_default = defineCommand({
 	},
 	args: {},
 	subCommands: {
-		add: () => import("./add-hFFIzkcy.mjs").then((r) => r.default || r),
+		add: () => import("./add-qJhPcmZB.mjs").then((r) => r.default || r),
 		search: () => import("./search-DCyXfxzn.mjs").then((r) => r.default || r)
 	}
 });

package/dist/{preview-C5fNqrC6.mjs → preview-BEqrL1ey.mjs}

@@ -7,7 +7,6 @@ import { defineCommand } from "citty";
 import { existsSync, promises } from "node:fs";
 import { resolve as resolve$1 } from "pathe";
 import { box, colors } from "consola/utils";
-import { getArgs } from "listhen/cli";
 import { x } from "tinyexec";
 import { setupDotenv } from "c12";
 
@@ -24,7 +23,8 @@ const command = defineCommand({
 		...extendsArgs,
 		...legacyRootDirArgs,
 		port: {
-			...getArgs().port,
+			type: "string",
+			description: "Port to listen on",
 			alias: ["p"]
 		},
 		...dotEnvArgs
@@ -82,7 +82,7 @@ const command = defineCommand({
 				fileName: envFileName
 			});
 		} else if (ctx.args.dotenv) logger.error(`Cannot find \`${envFileName}\`.`);
-		const { port } = _resolveListenOptions(ctx.args);
+		const port = ctx.args.port ?? process.env.NUXT_PORT ?? process.env.NITRO_PORT ?? process.env.PORT;
 		logger.info(`Starting preview command: \`${nitroJSON.commands.preview}\``);
 		const [command$1, ...commandArgs] = nitroJSON.commands.preview.split(" ");
 		logger.log("");
@@ -101,9 +101,6 @@ const command = defineCommand({
 	}
 });
 var preview_default = command;
-function _resolveListenOptions(args) {
-	return { port: args.port ?? process.env.NUXT_PORT ?? process.env.NITRO_PORT ?? process.env.PORT };
-}
 
 //#endregion
 export { preview_default as default };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxt/cli-nightly",
   "type": "module",
-  "version": "3.29.4-20251021-192254-70dcc9b",
+  "version": "3.30.0-20251027-200530-97d8172",
   "description": "Nuxt CLI",
   "license": "MIT",
   "repository": {
@@ -43,7 +43,6 @@
     "fuse.js": "^7.1.0",
     "get-port-please": "^3.2.0",
     "giget": "^2.0.0",
-    "h3": "^1.15.4",
     "jiti": "^2.6.1",
     "listhen": "^1.9.0",
     "nypm": "^0.6.2",
@@ -65,6 +64,10 @@
     "@nuxt/kit": "^4.1.3",
     "@nuxt/schema": "^4.1.3",
     "@types/node": "^22.18.12",
+    "h3": "^1.15.4",
+    "h3-next": "npm:h3@^2.0.1-rc.4",
+    "nitro": "^3.0.1-alpha.0",
+    "nitropack": "^2.12.7",
     "rollup": "^4.52.5",
     "rollup-plugin-visualizer": "^6.0.5",
     "tsdown": "^0.15.9",

package/dist/analyze-CUKAi_IN.mjs

@@ -1,115 +0,0 @@
-import { a as legacyRootDirArgs, i as extendsArgs, n as dotEnvArgs, o as logLevelArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
-import { t as logger } from "./logger-Dk0gkCkX.mjs";
-import { n as clearDir } from "./fs-ewAp6tjM.mjs";
-import { t as loadKit } from "./kit-xFxVGu6d.mjs";
-import { t as overrideEnv } from "./env-Dz4K_NkM.mjs";
-import process from "node:process";
-import { defineCommand } from "citty";
-import { defu as defu$1 } from "defu";
-import { listen } from "listhen";
-import { promises } from "node:fs";
-import { createApp, eventHandler, lazyEventHandler, toNodeListener } from "h3";
-import { join, resolve } from "pathe";
-
-//#region ../nuxi/src/commands/analyze.ts
-var analyze_default = defineCommand({
-	meta: {
-		name: "analyze",
-		description: "Build nuxt and analyze production bundle (experimental)"
-	},
-	args: {
-		...cwdArgs,
-		...logLevelArgs,
-		...legacyRootDirArgs,
-		...dotEnvArgs,
-		...extendsArgs,
-		name: {
-			type: "string",
-			description: "Name of the analysis",
-			default: "default",
-			valueHint: "name"
-		},
-		serve: {
-			type: "boolean",
-			description: "Serve the analysis results",
-			negativeDescription: "Skip serving the analysis results",
-			default: true
-		}
-	},
-	async run(ctx) {
-		overrideEnv("production");
-		const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-		const name = ctx.args.name || "default";
-		const slug = name.trim().replace(/[^\w-]/g, "_");
-		const startTime = Date.now();
-		const { loadNuxt, buildNuxt } = await loadKit(cwd);
-		const nuxt = await loadNuxt({
-			cwd,
-			dotenv: {
-				cwd,
-				fileName: ctx.args.dotenv
-			},
-			overrides: defu$1(ctx.data?.overrides, {
-				...ctx.args.extends && { extends: ctx.args.extends },
-				build: { analyze: { enabled: true } },
-				vite: { build: { rollupOptions: { output: {
-					chunkFileNames: "_nuxt/[name].js",
-					entryFileNames: "_nuxt/[name].js"
-				} } } },
-				logLevel: ctx.args.logLevel
-			})
-		});
-		const analyzeDir = nuxt.options.analyzeDir;
-		const buildDir = nuxt.options.buildDir;
-		const outDir = nuxt.options.nitro.output?.dir || join(nuxt.options.rootDir, ".output");
-		nuxt.options.build.analyze = defu$1(nuxt.options.build.analyze, { filename: join(analyzeDir, "client.html") });
-		await clearDir(analyzeDir);
-		await buildNuxt(nuxt);
-		const meta = {
-			name,
-			slug,
-			startTime,
-			endTime: Date.now(),
-			analyzeDir,
-			buildDir,
-			outDir
-		};
-		await nuxt.callHook("build:analyze:done", meta);
-		await promises.writeFile(join(analyzeDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
-		logger.info(`Analyze results are available at: \`${analyzeDir}\``);
-		logger.warn("Do not deploy analyze results! Use `nuxi build` before deploying.");
-		if (ctx.args.serve !== false && !process.env.CI) {
-			const app = createApp();
-			const serveFile = (filePath) => lazyEventHandler(async () => {
-				const contents = await promises.readFile(filePath, "utf-8");
-				return eventHandler((event) => {
-					event.node.res.end(contents);
-				});
-			});
-			logger.info("Starting stats server...");
-			app.use("/client", serveFile(join(analyzeDir, "client.html")));
-			app.use("/nitro", serveFile(join(analyzeDir, "nitro.html")));
-			app.use(eventHandler(() => `<!DOCTYPE html>
-        <html lang="en">
-        <head>
-        <meta charset="utf-8">
-        <title>Nuxt Bundle Stats (experimental)</title>
-        </head>
-          <h1>Nuxt Bundle Stats (experimental)</h1>
-          <ul>
-            <li>
-              <a href="/nitro">Nitro server bundle stats</a>
-            </li>
-            <li>
-              <a href="/client">Client bundle stats</a>
-            </li>
-          </ul>
-        </html>
-      `));
-			await listen(toNodeListener(app));
-		}
-	}
-});
-
-//#endregion
-export { analyze_default as default };