nitro-nightly 3.0.1-alpha.1 → 3.0.1-alpha.2

package/dist/_chunks/{B-D1JOIz.mjs → nitro.mjs}

@@ -1,30 +1,24 @@
-import { i as __toESM } from "./Bqks5huO.mjs";
-import { O as relative, T as normalize, g as resolveModuleURL, h as resolveModulePath, i as loadConfig, k as resolve, l as findWorkspaceDir, t as watchConfig, w as join } from "../_libs/c12.mjs";
-import { a as createUnimport } from "../_libs/unimport.mjs";
-import { t as glob } from "../_libs/tinyglobby.mjs";
+import { $ as resolveModulePath, A as compressPublicAssets, H as d, I as prettyPath, L as resolveNitroPath, M as build, R as writeFile$1, V as a, at as join, ct as resolve, et as resolveModuleURL, j as src_default, k as scanUnprefixedPublicAssets, p as runParallel, q as findWorkspaceDir, st as relative } from "../_build/common.mjs";
+import { n as loadConfig, r as watchConfig } from "../_libs/rc9+c12+dotenv.mjs";
 import { n as resolveCompatibilityDates, r as resolveCompatibilityDatesFromEnv } from "../_libs/compatx.mjs";
 import { t as klona } from "../_libs/klona.mjs";
-import { i as d, r as a } from "../_libs/std-env.mjs";
 import { t as escapeStringRegexp } from "../_libs/escape-string-regexp.mjs";
 import { n as parse, t as TSConfckCache } from "../_libs/tsconfck.mjs";
-import { i as writeFile$1, n as prettyPath, r as resolveNitroPath, t as isDirectory } from "./C7CbzoI1.mjs";
-import { i as scanHandlers, r as scanAndSyncOptions, t as runParallel } from "./ANM1K1bE.mjs";
+import { n as scanHandlers, t as scanAndSyncOptions } from "./nitro2.mjs";
 import { a as findRoute, i as findAllRoutes, n as addRoute, r as createRouter, t as compileRouterToString } from "../_libs/rou3.mjs";
-import { t as src_default } from "../_libs/mime.mjs";
 import { n as z, t as P } from "../_libs/ultrahtml.mjs";
 import { createRequire } from "node:module";
 import consola$1, { consola } from "consola";
 import { Hookable, createDebugger } from "hookable";
-import { existsSync, promises } from "node:fs";
-import { joinURL, parseURL, withBase, withLeadingSlash, withTrailingSlash, withoutBase, withoutTrailingSlash } from "ufo";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
-import fsp, { readFile } from "node:fs/promises";
 import { defu } from "defu";
-import { pkgDir, runtimeDir } from "nitro/meta";
+import { joinURL, parseURL, withBase, withLeadingSlash, withQuery, withTrailingSlash, withoutBase, withoutTrailingSlash } from "ufo";
+import { runtimeDir } from "nitro/meta";
 import { colors } from "consola/utils";
-import { ofetch } from "ofetch";
 import { hash } from "ohash";
-import zlib from "node:zlib";
+import http from "node:http";
 import { toRequest } from "h3";
 
 //#region src/config/defaults.ts
@@ -58,6 +52,7 @@ const NitroDefaults = {
 	virtual: {},
 	compressPublicAssets: false,
 	ignore: [],
+	wasm: {},
 	dev: false,
 	devServer: { watch: [] },
 	watchOptions: { ignoreInitial: true },
@@ -88,6 +83,7 @@ const NitroDefaults = {
 	replace: {},
 	node: true,
 	sourcemap: false,
+	traceDeps: [],
 	typescript: {
 		strict: true,
 		generateRuntimeConfigTypes: false,
@@ -95,7 +91,6 @@ const NitroDefaults = {
 		tsconfigPath: "tsconfig.json",
 		tsConfig: void 0
 	},
-	nodeModulesDirs: [],
 	hooks: {},
 	commands: {},
 	framework: {
@@ -142,6 +137,7 @@ async function resolveCompatibilityOptions(options) {
 //#region src/config/resolvers/database.ts
 async function resolveDatabaseOptions(options) {
 	if (options.experimental.database && options.imports) {
+		options.imports.presets ??= [];
 		options.imports.presets.push({
 			from: "nitro/database",
 			imports: ["useDatabase"]
@@ -163,7 +159,7 @@ async function resolveExportConditionsOptions(options) {
 	options.exportConditions = _resolveExportConditions(options.exportConditions || [], {
 		dev: options.dev,
 		node: options.node,
-		wasm: options.experimental.wasm
+		wasm: options.wasm !== false
 	});
 }
 function _resolveExportConditions(conditions, opts) {
@@ -173,7 +169,7 @@ function _resolveExportConditions(conditions, opts) {
 	if (opts.node) resolvedConditions.push("node");
 	else resolvedConditions.push("wintercg", "worker", "web", "browser", "workerd", "edge-light", "netlify", "edge-routine", "deno");
 	if (opts.wasm) resolvedConditions.push("wasm", "unwasm");
-	resolvedConditions.push("import", "default");
+	resolvedConditions.push("import", "default", "module");
 	if ("Bun" in globalThis) resolvedConditions.push("bun");
 	else if ("Deno" in globalThis) resolvedConditions.push("deno");
 	return resolvedConditions.filter((c, i) => resolvedConditions.indexOf(c) === i);
@@ -239,7 +235,7 @@ async function resolveOpenAPIOptions(options) {
 async function resolveTsconfig(options) {
 	const root = resolve(options.rootDir || ".") + "/";
 	if (!options.typescript.tsConfig) options.typescript.tsConfig = await loadTsconfig(root);
-	if (options.experimental.tsconfigPaths !== false && options.typescript.tsConfig.compilerOptions?.paths) options.alias = {
+	if (options.experimental.tsconfigPaths && options.typescript.tsConfig.compilerOptions?.paths) options.alias = {
 		...tsConfigToAliasObj(options.typescript.tsConfig, root),
 		...options.alias
 	};
@@ -309,12 +305,6 @@ async function resolvePathOptions(options) {
 	options.output.dir = resolveNitroPath(options.output.dir || NitroDefaults.output.dir, options, options.rootDir) + "/";
 	options.output.publicDir = resolveNitroPath(options.output.publicDir || NitroDefaults.output.publicDir, options, options.rootDir) + "/";
 	options.output.serverDir = resolveNitroPath(options.output.serverDir || NitroDefaults.output.serverDir, options, options.rootDir) + "/";
-	options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
-	options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
-	options.nodeModulesDirs.push(resolve(pkgDir, "dist/node_modules"));
-	options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
-	options.nodeModulesDirs.push(resolve(pkgDir, ".."));
-	options.nodeModulesDirs = [...new Set(options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir) + "/"))];
 	options.plugins = options.plugins.map((p) => resolveNitroPath(p, options));
 	if (options.serverDir) options.scanDirs.unshift(options.serverDir);
 	options.scanDirs = options.scanDirs.map((dir) => resolve(options.rootDir, dir));
@@ -330,43 +320,53 @@ async function resolvePathOptions(options) {
 		h.handler = resolveNitroPath(h.handler, options);
 		return [route, h];
 	}));
-	if (!options.routes["/**"] && !options.handlers.some((h) => h.route === "/**")) {
-		const serverEntry = resolveModulePath("./server", {
-			from: [options.rootDir, ...options.scanDirs],
-			extensions: RESOLVE_EXTENSIONS,
-			try: true
-		});
-		if (serverEntry) {
-			if (!(options.handlers.some((h) => h.handler === serverEntry) || Object.values(options.routes).some((r) => r.handler === serverEntry))) {
-				options.routes["/**"] = { handler: serverEntry };
-				consola$1.info(`Using \`${prettyPath(serverEntry)}\` as default route handler.`);
+	if (options.serverEntry !== false) {
+		if (typeof options?.serverEntry === "string") options.serverEntry = { handler: options.serverEntry };
+		if (options.serverEntry?.handler) options.serverEntry.handler = resolveNitroPath(options.serverEntry.handler, options);
+		else {
+			const detected = resolveModulePath("./server", {
+				try: true,
+				from: options.rootDir,
+				extensions: RESOLVE_EXTENSIONS.flatMap((ext) => [ext, `.node${ext}`])
+			});
+			if (detected) {
+				options.serverEntry ??= { handler: "" };
+				options.serverEntry.handler = detected;
+				consola$1.info(`Detected \`${prettyPath(detected)}\` as server entry.`);
 			}
 		}
+		if (options.serverEntry?.handler && !options.serverEntry?.format) {
+			const isNode = /\.(node)\.\w+$/.test(options.serverEntry.handler);
+			options.serverEntry.format = isNode ? "node" : "web";
+		}
 	}
-	if (options.renderer?.handler) options.renderer.handler = resolveModulePath(resolveNitroPath(options.renderer?.handler, options), {
-		from: [options.rootDir, ...options.scanDirs],
-		extensions: RESOLVE_EXTENSIONS
-	});
-	if (options.renderer?.template) options.renderer.template = resolveModulePath(resolveNitroPath(options.renderer?.template, options), {
-		from: [options.rootDir, ...options.scanDirs],
-		extensions: [".html"]
-	});
-	else if (!options.renderer?.handler) {
-		const defaultIndex = resolveModulePath("./index.html", {
+	if (options.renderer === false) options.renderer = void 0;
+	else {
+		if (options.renderer?.handler) options.renderer.handler = resolveModulePath(resolveNitroPath(options.renderer?.handler, options), {
+			from: [options.rootDir, ...options.scanDirs],
+			extensions: RESOLVE_EXTENSIONS
+		});
+		if (options.renderer?.template) options.renderer.template = resolveModulePath(resolveNitroPath(options.renderer?.template, options), {
 			from: [options.rootDir, ...options.scanDirs],
-			extensions: [".html"],
-			try: true
+			extensions: [".html"]
 		});
-		if (defaultIndex) {
+		else if (!options.renderer?.handler) {
+			const defaultIndex = resolveModulePath("./index.html", {
+				from: [options.rootDir, ...options.scanDirs],
+				extensions: [".html"],
+				try: true
+			});
+			if (defaultIndex) {
+				options.renderer ??= {};
+				options.renderer.template = defaultIndex;
+				consola$1.info(`Using \`${prettyPath(defaultIndex)}\` as renderer template.`);
+			}
+		}
+		if (options.renderer?.template && !options.renderer?.handler) {
 			options.renderer ??= {};
-			options.renderer.template = defaultIndex;
-			consola$1.info(`Using \`${prettyPath(defaultIndex)}\` as renderer template.`);
+			options.renderer.handler = join(runtimeDir, "internal/routes/renderer-template" + (options.dev ? ".dev" : ""));
 		}
 	}
-	if (options.renderer?.template && !options.renderer?.handler) {
-		options.renderer ??= {};
-		options.renderer.handler = join(runtimeDir, "internal/routes/renderer-template" + (options.dev ? ".dev" : ""));
-	}
 }
 
 //#endregion
@@ -428,6 +428,7 @@ function normalizeRuntimeConfig(config) {
 			openAPI: config.openAPI
 		}
 	});
+	runtimeConfig.nitro ??= {};
 	runtimeConfig.nitro.routeRules = config.routeRules;
 	checkSerializableRuntimeConfig(runtimeConfig);
 	return runtimeConfig;
@@ -517,16 +518,15 @@ async function resolveUnenv(options) {
 //#endregion
 //#region src/config/resolvers/builder.ts
 const VALID_BUILDERS = [
-	"rollup",
 	"rolldown",
-	"vite",
-	"rolldown-vite"
+	"rollup",
+	"vite"
 ];
 async function resolveBuilder(options) {
 	options.builder ??= process.env.NITRO_BUILDER;
 	if (options.builder) {
 		if (!VALID_BUILDERS.includes(options.builder)) throw new Error(`Invalid nitro builder "${options.builder}". Valid builders are: ${VALID_BUILDERS.join(", ")}.`);
-		const pkg = options.builder === "rolldown-vite" ? "vite" : options.builder;
+		const pkg = options.builder;
 		if (!isPkgInstalled(pkg, options.rootDir)) {
 			if (!await consola$1.prompt(`Nitro builder package \`${pkg}\` is not installed. Would you like to install it?`, {
 				type: "confirm",
@@ -567,8 +567,8 @@ function isPkgInstalled(pkg, root) {
 	}
 }
 async function installPkg(pkg, root) {
-	const { addDevDependency } = await import("../cli/_chunks/dist4.mjs");
-	return addDevDependency(pkg === "rolldown-vite" ? "vite@npm:rolldown-vite" : pkg, { cwd: root });
+	const { addDevDependency } = await import("../_libs/nypm+giget+tinyexec.mjs").then((n) => n.n);
+	return addDevDependency(pkg, { cwd: root });
 }
 
 //#endregion
@@ -702,71 +702,6 @@ async function _resolveNitroModule(mod, nitroOptions) {
 	};
 }
 
-//#endregion
-//#region src/task.ts
-/** @experimental */
-async function runTask(taskEvent, opts) {
-	return await (await _getTasksContext(opts)).devFetch(`/_nitro/tasks/${taskEvent.name}`, {
-		method: "POST",
-		body: taskEvent
-	});
-}
-/** @experimental */
-async function listTasks(opts) {
-	return (await (await _getTasksContext(opts)).devFetch("/_nitro/tasks")).tasks;
-}
-function addNitroTasksVirtualFile(nitro) {
-	nitro.options.virtual["#nitro-internal-virtual/tasks"] = () => {
-		const _scheduledTasks = Object.entries(nitro.options.scheduledTasks || {}).map(([cron, _tasks]) => {
-			return {
-				cron,
-				tasks: (Array.isArray(_tasks) ? _tasks : [_tasks]).filter((name) => {
-					if (!nitro.options.tasks[name]) {
-						nitro.logger.warn(`Scheduled task \`${name}\` is not defined!`);
-						return false;
-					}
-					return true;
-				})
-			};
-		}).filter((e) => e.tasks.length > 0);
-		const scheduledTasks = _scheduledTasks.length > 0 ? _scheduledTasks : false;
-		return `
-export const scheduledTasks = ${JSON.stringify(scheduledTasks)};
-
-export const tasks = {
-  ${Object.entries(nitro.options.tasks).map(([name, task]) => `"${name}": {
-          meta: {
-            description: ${JSON.stringify(task.description)},
-          },
-          resolve: ${task.handler ? `() => import("${normalize(task.handler)}").then(r => r.default || r)` : "undefined"},
-        }`).join(",\n")}
-};`;
-	};
-}
-const _devHint = `(is dev server running?)`;
-async function _getTasksContext(opts) {
-	const buildInfoPath = resolve(resolve(resolve(process.cwd(), opts?.cwd || "."), opts?.buildDir || "node_modules/.nitro"), "nitro.dev.json");
-	if (!existsSync(buildInfoPath)) throw new Error(`Missing info file: \`${buildInfoPath}\` ${_devHint}`);
-	const buildInfo = JSON.parse(await readFile(buildInfoPath, "utf8"));
-	if (!buildInfo.dev?.pid || !buildInfo.dev?.workerAddress) throw new Error(`Missing dev server info in: \`${buildInfoPath}\` ${_devHint}`);
-	if (!_pidIsRunning(buildInfo.dev.pid)) throw new Error(`Dev server is not running (pid: ${buildInfo.dev.pid})`);
-	return {
-		buildInfo,
-		devFetch: ofetch.create({
-			baseURL: `http://${buildInfo.dev.workerAddress.host || "localhost"}:${buildInfo.dev.workerAddress.port || "3000"}`,
-			socketPath: buildInfo.dev.workerAddress.socketPath
-		})
-	};
-}
-function _pidIsRunning(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
 //#endregion
 //#region src/routing.ts
 const isGlobalMiddleware = (h) => !h.method && (!h.route || h.route === "/**");
@@ -805,6 +740,12 @@ function initNitroRouting(nitro) {
 			...nitro.options.handlers,
 			...nitro.scannedHandlers
 		].filter((h) => h && !h.middleware && matchesEnv(h));
+		if (nitro.options.serverEntry && nitro.options.serverEntry.handler) _routes.push({
+			route: "/**",
+			lazy: false,
+			format: nitro.options.serverEntry.format,
+			handler: nitro.options.serverEntry.handler
+		});
 		if (nitro.options.renderer?.handler) _routes.push({
 			route: "/**",
 			lazy: true,
@@ -867,10 +808,17 @@ var Router = class {
 		return this._routes.length > 0;
 	}
 	compileToString(opts) {
-		if (this._compiled) return this._compiled;
-		this._compiled = compileRouterToString(this._router, void 0, opts);
-		if (this.routes.length === 1 && this.routes[0].route === "/**" && this.routes[0].method === "") this._compiled = `/* @__PURE__ */ (() => {const data=${(opts?.serialize || JSON.stringify)(this.routes[0].data)};return ((_m, p)=>{return {data,params:{"_":p.slice(1)}};})})()`;
-		return this._compiled;
+		const key = opts ? hash(opts) : "";
+		this._compiled ||= {};
+		if (this._compiled[key]) return this._compiled[key];
+		this._compiled[key] = compileRouterToString(this._router, void 0, opts);
+		if (this.routes.length === 1 && this.routes[0].route === "/**" && this.routes[0].method === "") {
+			const data = (opts?.serialize || JSON.stringify)(this.routes[0].data);
+			let retCode = `{data,params:{"_":p.slice(1)}}`;
+			if (opts?.matchAll) retCode = `[${retCode}]`;
+			this._compiled[key] = `/* @__PURE__ */ (() => {const data=${data};return ((_m, p)=>{return ${retCode};})})()`;
+		}
+		return this._compiled[key];
 	}
 	match(method, path) {
 		return findRoute(this._router, method, path)?.data;
@@ -917,7 +865,7 @@ async function createNitro(config = {}, opts = {}) {
 	const nitro = {
 		options: await loadOptions(config, opts),
 		hooks: new Hookable(),
-		vfs: {},
+		vfs: /* @__PURE__ */ new Map(),
 		routing: {},
 		logger: consola.withTag("nitro"),
 		scannedHandlers: [],
@@ -935,9 +883,9 @@ async function createNitro(config = {}, opts = {}) {
 	if (nitro.options.debug) createDebugger(nitro.hooks, { tag: "nitro" });
 	if (nitro.options.logLevel !== void 0) nitro.logger.level = nitro.options.logLevel;
 	nitro.hooks.addHooks(nitro.options.hooks);
-	addNitroTasksVirtualFile(nitro);
 	await installModules(nitro);
 	if (nitro.options.imports) {
+		const { createUnimport } = await import("../_build/common.mjs").then((n) => n.v);
 		nitro.unimport = createUnimport(nitro.options.imports);
 		await nitro.unimport.init();
 		nitro.options.virtual["#imports"] = () => nitro.unimport?.toExports() || "";
@@ -948,180 +896,6 @@ async function createNitro(config = {}, opts = {}) {
 	return nitro;
 }
 
-//#endregion
-//#region src/build/build.ts
-async function build(nitro) {
-	switch (nitro.options.builder) {
-		case "rollup": {
-			const { rollupBuild } = await import("../_build/rollup.mjs");
-			return rollupBuild(nitro);
-		}
-		case "rolldown": {
-			const { rolldownBuild } = await import("../_build/rolldown.mjs");
-			return rolldownBuild(nitro);
-		}
-		case "vite":
-		case "rolldown-vite": {
-			const { viteBuild } = await import("../_build/vite.build.mjs");
-			return viteBuild(nitro);
-		}
-		default: throw new Error(`Unknown builder: ${nitro.options.builder}`);
-	}
-}
-
-//#endregion
-//#region src/utils/compress.ts
-async function compressPublicAssets(nitro) {
-	const publicFiles = await glob("**", {
-		cwd: nitro.options.output.publicDir,
-		absolute: false,
-		dot: true,
-		ignore: ["**/*.gz", "**/*.br"]
-	});
-	await Promise.all(publicFiles.map(async (fileName) => {
-		const filePath = resolve(nitro.options.output.publicDir, fileName);
-		if (existsSync(filePath + ".gz") || existsSync(filePath + ".br")) return;
-		const mimeType = src_default.getType(fileName) || "text/plain";
-		const fileContents = await fsp.readFile(filePath);
-		if (fileContents.length < 1024 || fileName.endsWith(".map") || !isCompressibleMime(mimeType)) return;
-		const { gzip, brotli } = nitro.options.compressPublicAssets || {};
-		const encodings = [gzip !== false && "gzip", brotli !== false && "br"].filter(Boolean);
-		await Promise.all(encodings.map(async (encoding) => {
-			const compressedPath = filePath + ("." + (encoding === "gzip" ? "gz" : "br"));
-			if (existsSync(compressedPath)) return;
-			const gzipOptions = { level: zlib.constants.Z_BEST_COMPRESSION };
-			const brotliOptions = {
-				[zlib.constants.BROTLI_PARAM_MODE]: isTextMime(mimeType) ? zlib.constants.BROTLI_MODE_TEXT : zlib.constants.BROTLI_MODE_GENERIC,
-				[zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY,
-				[zlib.constants.BROTLI_PARAM_SIZE_HINT]: fileContents.length
-			};
-			const compressedBuff = await new Promise((resolve$1, reject) => {
-				const cb = (error, result) => error ? reject(error) : resolve$1(result);
-				if (encoding === "gzip") zlib.gzip(fileContents, gzipOptions, cb);
-				else zlib.brotliCompress(fileContents, brotliOptions, cb);
-			});
-			await fsp.writeFile(compressedPath, compressedBuff);
-		}));
-	}));
-}
-function isTextMime(mimeType) {
-	return /text|javascript|json|xml/.test(mimeType);
-}
-const COMPRESSIBLE_MIMES_RE = new Set([
-	"application/dash+xml",
-	"application/eot",
-	"application/font",
-	"application/font-sfnt",
-	"application/javascript",
-	"application/json",
-	"application/opentype",
-	"application/otf",
-	"application/pdf",
-	"application/pkcs7-mime",
-	"application/protobuf",
-	"application/rss+xml",
-	"application/truetype",
-	"application/ttf",
-	"application/vnd.apple.mpegurl",
-	"application/vnd.mapbox-vector-tile",
-	"application/vnd.ms-fontobject",
-	"application/wasm",
-	"application/xhtml+xml",
-	"application/xml",
-	"application/x-font-opentype",
-	"application/x-font-truetype",
-	"application/x-font-ttf",
-	"application/x-httpd-cgi",
-	"application/x-javascript",
-	"application/x-mpegurl",
-	"application/x-opentype",
-	"application/x-otf",
-	"application/x-perl",
-	"application/x-ttf",
-	"font/eot",
-	"font/opentype",
-	"font/otf",
-	"font/ttf",
-	"image/svg+xml",
-	"text/css",
-	"text/csv",
-	"text/html",
-	"text/javascript",
-	"text/js",
-	"text/plain",
-	"text/richtext",
-	"text/tab-separated-values",
-	"text/xml",
-	"text/x-component",
-	"text/x-java-source",
-	"text/x-script",
-	"vnd.apple.mpegurl"
-]);
-function isCompressibleMime(mimeType) {
-	return COMPRESSIBLE_MIMES_RE.has(mimeType);
-}
-
-//#endregion
-//#region src/build/assets.ts
-const NEGATION_RE = /^(!?)(.*)$/;
-const PARENT_DIR_GLOB_RE = /!?\.\.\//;
-async function scanUnprefixedPublicAssets(nitro) {
-	const scannedPaths = [];
-	for (const asset of nitro.options.publicAssets) {
-		if (asset.baseURL && asset.baseURL !== "/" && !asset.fallthrough) continue;
-		if (!await isDirectory(asset.dir)) continue;
-		const publicAssets = await glob(getIncludePatterns(nitro, asset.dir), {
-			cwd: asset.dir,
-			absolute: false,
-			dot: true
-		});
-		scannedPaths.push(...publicAssets.map((file) => join(asset.baseURL || "/", file)));
-	}
-	return scannedPaths;
-}
-async function copyPublicAssets(nitro) {
-	if (nitro.options.noPublicDir) return;
-	for (const asset of nitro.options.publicAssets) {
-		const assetDir = asset.dir;
-		const dstDir = join(nitro.options.output.publicDir, asset.baseURL);
-		if (await isDirectory(assetDir)) {
-			const publicAssets = await glob(getIncludePatterns(nitro, assetDir), {
-				cwd: assetDir,
-				absolute: false,
-				dot: true
-			});
-			await Promise.all(publicAssets.map(async (file) => {
-				const src = join(assetDir, file);
-				const dst = join(dstDir, file);
-				if (!existsSync(dst)) await promises.cp(src, dst);
-			}));
-		}
-	}
-	if (nitro.options.compressPublicAssets) await compressPublicAssets(nitro);
-	nitro.logger.success("Generated public " + prettyPath(nitro.options.output.publicDir));
-}
-function getIncludePatterns(nitro, assetDir) {
-	return ["**", ...nitro.options.ignore.map((p) => {
-		const [_, negation, pattern] = p.match(NEGATION_RE) || [];
-		return (negation ? "" : "!") + (pattern.startsWith("*") ? pattern : relative(assetDir, resolve(nitro.options.rootDir, pattern)));
-	})].filter((p) => !PARENT_DIR_GLOB_RE.test(p));
-}
-
-//#endregion
-//#region src/build/prepare.ts
-async function prepare(nitro) {
-	await prepareDir(nitro.options.output.dir);
-	if (!nitro.options.noPublicDir) await prepareDir(nitro.options.output.publicDir);
-	if (!nitro.options.static) await prepareDir(nitro.options.output.serverDir);
-}
-async function prepareDir(dir) {
-	await fsp.rm(dir, {
-		recursive: true,
-		force: true
-	});
-	await fsp.mkdir(dir, { recursive: true });
-}
-
 //#endregion
 //#region src/prerender/utils.ts
 const allowedExtensions = new Set(["", ".json"]);
@@ -1235,7 +1009,9 @@ async function prerender(nitro) {
 	const scannedPublicAssets = nitro.options.prerender.ignoreUnprefixedPublicAssets ? new Set(await scanUnprefixedPublicAssets(nitro)) : /* @__PURE__ */ new Set();
 	const canPrerender = (route = "/") => {
 		if (generatedRoutes.has(route) || skippedRoutes.has(route)) return false;
-		for (const pattern of nitro.options.prerender.ignore) if (matchesIgnorePattern(route, pattern)) return false;
+		if (nitro.options.prerender.ignore) {
+			for (const pattern of nitro.options.prerender.ignore) if (matchesIgnorePattern(route, pattern)) return false;
+		}
 		if (publicAssetBases.some((base) => route.startsWith(base))) return false;
 		if (scannedPublicAssets.has(route)) return false;
 		if (_getRouteRules(route).prerender === false) return false;
@@ -1322,7 +1098,7 @@ async function prerender(nitro) {
 			nitro._prerenderedRoutes.push(_route);
 		} else _route.skip = true;
 		if (!_route.error && (isImplicitHTML || route.endsWith(".html"))) {
-			const extractedLinks = await extractLinks(dataBuff.toString("utf8"), route, res, nitro.options.prerender.crawlLinks);
+			const extractedLinks = await extractLinks(dataBuff.toString("utf8"), route, res, nitro.options.prerender.crawlLinks ?? false);
 			for (const _link of extractedLinks) if (canPrerender(_link)) routes.add(_link);
 		}
 		await nitro.hooks.callHook("prerender:route", _route);
@@ -1332,7 +1108,7 @@ async function prerender(nitro) {
 	};
 	nitro.logger.info(nitro.options.prerender.crawlLinks ? `Prerendering ${routes.size} initial routes with crawler` : `Prerendering ${routes.size} routes`);
 	await runParallel(routes, generateRoute, {
-		concurrency: nitro.options.prerender.concurrency,
+		concurrency: nitro.options.prerender.concurrency || 1,
 		interval: nitro.options.prerender.interval
 	});
 	await prerenderer.close();
@@ -1352,4 +1128,64 @@ async function prerender(nitro) {
 }
 
 //#endregion
-export { createNitro as a, loadOptions as c, build as i, prepare as n, listTasks as o, copyPublicAssets as r, runTask as s, prerender as t };
+//#region src/task.ts
+/** @experimental */
+async function runTask(taskEvent, opts) {
+	return await (await _getTasksContext(opts)).devFetch(`/_nitro/tasks/${taskEvent.name}`, {
+		method: "POST",
+		body: taskEvent
+	});
+}
+/** @experimental */
+async function listTasks(opts) {
+	return (await (await _getTasksContext(opts)).devFetch("/_nitro/tasks")).tasks;
+}
+const _devHint = `(is dev server running?)`;
+async function _getTasksContext(opts) {
+	const buildInfoPath = resolve(resolve(resolve(process.cwd(), opts?.cwd || "."), opts?.buildDir || "node_modules/.nitro"), "nitro.dev.json");
+	if (!existsSync(buildInfoPath)) throw new Error(`Missing info file: \`${buildInfoPath}\` ${_devHint}`);
+	const buildInfo = JSON.parse(await readFile(buildInfoPath, "utf8"));
+	if (!buildInfo.dev?.pid || !buildInfo.dev?.workerAddress) throw new Error(`Missing dev server info in: \`${buildInfoPath}\` ${_devHint}`);
+	if (!_pidIsRunning(buildInfo.dev.pid)) throw new Error(`Dev server is not running (pid: ${buildInfo.dev.pid})`);
+	const baseURL = `http://${buildInfo.dev.workerAddress.host || "localhost"}:${buildInfo.dev.workerAddress.port || "3000"}`;
+	const socketPath = buildInfo.dev.workerAddress.socketPath;
+	const devFetch = (path, options) => {
+		return new Promise((resolve$1, reject) => {
+			let url = withBase(path, baseURL);
+			if (options?.query) url = withQuery(url, options.query);
+			const request = http.request(url, {
+				socketPath,
+				method: options?.method,
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json"
+				}
+			}, (response) => {
+				if (!response.statusCode || response.statusCode >= 400 && response.statusCode < 600) {
+					reject(new Error(response.statusMessage));
+					return;
+				}
+				let data = "";
+				response.on("data", (chunk) => data += chunk).on("end", () => resolve$1(JSON.parse(data))).on("error", (e) => reject(e));
+			});
+			request.on("error", (e) => reject(e));
+			if (options?.body) request.write(JSON.stringify(options.body));
+			request.end();
+		});
+	};
+	return {
+		buildInfo,
+		devFetch
+	};
+}
+function _pidIsRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { loadOptions as a, createNitro as i, runTask as n, prerender as r, listTasks as t };