visaljs 0.0.4 → 0.0.6

package/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { isBuiltin } from "node:module";
+import { createRequire, isBuiltin } from "node:module";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
-import { parseArgs } from "node:util";
+import { parseArgs, promisify } from "node:util";
 import ts from "typescript";
 import { rolldown } from "rolldown";
-import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { availableParallelism, homedir, tmpdir } from "node:os";
 //#region \0rolldown/runtime.js
@@ -6661,7 +6661,7 @@ function emitModule(m, p, entry, options) {
 		`    for (size_t i = 0; i < ${Math.max(1, nGlobals)}; i++) ${p}mod_globals[i] = JS_UNDEFINED;`,
 		`    js_register_roots(rt, ${p}mod_globals, ${Math.max(1, nGlobals)});`,
 		`    int status = js_run_event_loop(ctx, ${p}js_script(ctx));  /* then the microtasks (ADR 0008) */`,
-		...entry ? [] : ["    if (status == 0) status = js_host_exit_code();  /* process.exitCode */"],
+		...entry ? [] : ["    status = js_host_exit(ctx, status);  /* process's beforeExit and exit, process.exitCode */"],
 		"    js_context_free(ctx);",
 		"    js_runtime_free(rt);",
 		"    return status;",
@@ -7066,14 +7066,19 @@ function optimize(m, passes = DEFAULT_PASSES) {
 //#endregion
 //#region node/index.ts
 var node_exports = /* @__PURE__ */ __exportAll({
+	implicitModules: () => implicitModules,
 	libraries: () => libraries,
 	modules: () => modules,
 	preludeDir: () => preludeDir,
-	primitives: () => primitives
+	primitives: () => primitives,
+	requireTable: () => requireTable$1
 });
 const DIR = join(import.meta.dirname, "node");
 const UV = join(DIR, "third_party", "libuv");
 const LLHTTP = join(DIR, "third_party", "llhttp");
+const ZLIB = join(DIR, "third_party", "zlib");
+const BROTLI = join(DIR, "third_party", "brotli");
+const ZSTD = join(DIR, "third_party", "zstd");
 const INCLUDE = join(DIR, "include");
 const files = (dir, ext) => readdirSync(dir).filter((f) => f.endsWith(ext)).map((f) => join(dir, f));
 /** Prelude modules may import "visaljs:host". */
@@ -7083,22 +7088,28 @@ const modules = {
 	async_hooks: join(preludeDir, "async_hooks.js"),
 	buffer: join(preludeDir, "buffer.js"),
 	crypto: join(preludeDir, "crypto.js"),
+	diagnostics_channel: join(preludeDir, "diagnostics_channel.js"),
 	dns: join(preludeDir, "dns.js"),
 	"dns/promises": join(preludeDir, "dns_promises.js"),
 	events: join(preludeDir, "events.js"),
 	fs: join(preludeDir, "fs.js"),
+	"fs/promises": join(preludeDir, "fs_promises.js"),
 	http: join(preludeDir, "http.js"),
 	http2: join(preludeDir, "http2.js"),
 	module: join(preludeDir, "module.js"),
 	net: join(preludeDir, "net.js"),
 	os: join(preludeDir, "os.js"),
 	path: join(preludeDir, "path.js"),
+	"path/posix": join(preludeDir, "path_posix.js"),
+	"path/win32": join(preludeDir, "path_win32.js"),
 	process: join(preludeDir, "process.js"),
 	querystring: join(preludeDir, "querystring.js"),
 	stream: join(preludeDir, "stream.js"),
 	"stream/promises": join(preludeDir, "stream_promises.js"),
 	"stream/web": join(preludeDir, "stream_web.js"),
 	string_decoder: join(preludeDir, "string_decoder.js"),
+	timers: join(preludeDir, "timers.js"),
+	"timers/promises": join(preludeDir, "timers_promises.js"),
 	tls: join(preludeDir, "tls.js"),
 	tty: join(preludeDir, "tty.js"),
 	url: join(preludeDir, "url.js"),
@@ -7106,6 +7117,36 @@ const modules = {
 	"util/types": join(preludeDir, "util_types.js"),
 	zlib: join(preludeDir, "zlib.js")
 };
+/** Prelude modules a program gets without importing them, run before its own code, when its
+*  bundled code may use what they add (`reached` tests the code's text, conservatively). */
+const implicitModules = [
+	{
+		file: join(preludeDir, "internal", "process_events.js"),
+		reached: (code) => /\bprocess\b/.test(code) && EMITTER_METHOD.test(code)
+	},
+	{
+		file: join(preludeDir, "internal", "process_signals.js"),
+		reached: (code) => /\bprocess\b/.test(code) && /["'`]SIG[A-Z0-9]+["'`]|\.kill\b/.test(code)
+	},
+	{
+		file: join(preludeDir, "internal", "timers_global.js"),
+		reached: (code) => TIMER_USE.test(code)
+	},
+	{
+		file: join(preludeDir, "internal", "zlib_brotli.js"),
+		reached: (_code, program) => /brotli/i.test(program)
+	},
+	{
+		file: join(preludeDir, "internal", "zlib_zstd.js"),
+		reached: (_code, program) => /zstd/i.test(program)
+	}
+];
+const TIMER_USE = /\.(?:unref|hasRef|refresh)\s*\(|\bclass Timeout\b/;
+const EMITTER_METHOD = /(?:\.|\[\s*["'`])\s*(?:on|once|off|emit|addListener|prependListener|prependOnceListener|removeListener|removeAllListeners|listeners|rawListeners|listenerCount|eventNames|setMaxListeners|getMaxListeners)\b/;
+/** The table createRequire's require() looks packages up in (node:module): the Symbol.for key
+*  on globalThis of a Map, name → a function giving the module's exports, which the bundler
+*  sets with the packages it finds a program may require() at run time. */
+const requireTable$1 = "visaljs.requireTable";
 /** The host primitives: the name prelude code imports → its C function (JSNativeFn) and length.
 *  Failures return -errno (a number), which the prelude turns into Node's error. */
 const primitives = {
@@ -7125,6 +7166,18 @@ const primitives = {
 		c: "js_host_fs_unlink",
 		length: 1
 	},
+	fsStat: {
+		c: "js_host_fs_stat",
+		length: 2
+	},
+	fsReaddir: {
+		c: "js_host_fs_readdir",
+		length: 1
+	},
+	fsReadAt: {
+		c: "js_host_fs_read_at",
+		length: 3
+	},
 	errnoName: {
 		c: "js_host_errno_name",
 		length: 1
@@ -7145,6 +7198,26 @@ const primitives = {
 		c: "js_host_timer_unref",
 		length: 2
 	},
+	timerStart: {
+		c: "js_host_timer_start",
+		length: 4
+	},
+	timerRef: {
+		c: "js_host_timer_ref",
+		length: 2
+	},
+	timerClear: {
+		c: "js_host_timer_clear",
+		length: 1
+	},
+	asyncContextGet: {
+		c: "js_host_async_context_get",
+		length: 0
+	},
+	asyncContextSet: {
+		c: "js_host_async_context_set",
+		length: 1
+	},
 	osUname: {
 		c: "js_host_os_uname",
 		length: 0
@@ -7189,6 +7262,18 @@ const primitives = {
 		c: "js_host_os_constants",
 		length: 0
 	},
+	signalStart: {
+		c: "js_host_signal_start",
+		length: 2
+	},
+	signalStop: {
+		c: "js_host_signal_stop",
+		length: 1
+	},
+	processKill: {
+		c: "js_host_process_kill",
+		length: 2
+	},
 	utilInspect: {
 		c: "js_util_inspect",
 		length: 2
@@ -7560,6 +7645,74 @@ const primitives = {
 	dnsLookup: {
 		c: "js_host_dns_lookup",
 		length: 3
+	},
+	zlibNew: {
+		c: "js_host_zlib_new",
+		length: 1
+	},
+	zlibInit: {
+		c: "js_host_zlib_init",
+		length: 6
+	},
+	zlibWrite: {
+		c: "js_host_zlib_write",
+		length: 9
+	},
+	zlibParams: {
+		c: "js_host_zlib_params",
+		length: 3
+	},
+	zlibReset: {
+		c: "js_host_zlib_reset",
+		length: 1
+	},
+	zlibClose: {
+		c: "js_host_zlib_close",
+		length: 1
+	},
+	zlibCrc32: {
+		c: "js_host_zlib_crc32",
+		length: 2
+	},
+	brotliNew: {
+		c: "js_host_brotli_new",
+		length: 1
+	},
+	brotliInit: {
+		c: "js_host_brotli_init",
+		length: 2
+	},
+	brotliWrite: {
+		c: "js_host_brotli_write",
+		length: 9
+	},
+	brotliReset: {
+		c: "js_host_brotli_reset",
+		length: 1
+	},
+	brotliClose: {
+		c: "js_host_brotli_close",
+		length: 1
+	},
+	zstdNew: {
+		c: "js_host_zstd_new",
+		length: 1
+	},
+	zstdInit: {
+		c: "js_host_zstd_init",
+		length: 4
+	},
+	zstdWrite: {
+		c: "js_host_zstd_write",
+		length: 9
+	},
+	zstdReset: {
+		c: "js_host_zstd_reset",
+		length: 1
+	},
+	zstdClose: {
+		c: "js_host_zstd_close",
+		length: 1
 	}
 };
 const UV_COMMON = [
@@ -7664,10 +7817,28 @@ const UV_PLATFORM = {
 		]
 	}
 };
+const BROTLI_OS = {
+	linux: "OS_LINUX",
+	darwin: "OS_MACOSX",
+	freebsd: "OS_FREEBSD"
+};
 /** The C libraries to build and link (before libjsrt, which they use). */
 function libraries(runtimeInclude) {
 	const uv = UV_PLATFORM[process.platform];
 	const uvSources = uv ? [...UV_COMMON, ...uv.sources].map((f) => join(UV, "src", `${f}.c`)) : [];
+	const zlibHeaders = [...files(ZLIB, ".h"), ...files(join(ZLIB, "contrib", "optimizations"), ".h")];
+	const brotliHeaders = [
+		"common",
+		"dec",
+		"enc",
+		join("include", "brotli")
+	].flatMap((d) => files(join(BROTLI, d), ".h"));
+	const zstdHeaders = [
+		"",
+		"common",
+		"compress",
+		"decompress"
+	].flatMap((d) => files(join(ZSTD, d), ".h"));
 	const uvHeaders = [
 		join(UV, "include"),
 		join(UV, "include", "uv"),
@@ -7675,37 +7846,87 @@ function libraries(runtimeInclude) {
 		join(UV, "src", "unix"),
 		join(UV, "src", "win")
 	].flatMap((d) => files(d, ".h"));
-	return [{
-		name: "jsnode",
-		sources: [...files(join(DIR, "src"), ".c"), ...files(LLHTTP, ".c")],
-		headers: [
-			...files(INCLUDE, ".h"),
-			...files(runtimeInclude, ".h"),
-			...files(LLHTTP, ".h"),
-			...uvHeaders
-		],
-		flags: [
-			`-I${INCLUDE}`,
-			`-I${runtimeInclude}`,
-			`-I${LLHTTP}`,
-			`-I${join(UV, "include")}`
-		]
-	}, {
-		name: "uv",
-		sources: uvSources,
-		headers: uvHeaders,
-		flags: [
-			"-std=gnu11",
-			"-w",
-			"-fno-strict-aliasing",
-			"-D_FILE_OFFSET_BITS=64",
-			"-D_LARGEFILE_SOURCE",
-			...(uv?.defines ?? []).map((d) => `-D${d}`),
-			`-I${join(UV, "include")}`,
-			`-I${join(UV, "src")}`
-		],
-		link: uv?.link ?? []
-	}];
+	return [
+		{
+			name: "jsnode",
+			sources: [...files(join(DIR, "src"), ".c"), ...files(LLHTTP, ".c")],
+			headers: [
+				...files(INCLUDE, ".h"),
+				...files(runtimeInclude, ".h"),
+				...files(LLHTTP, ".h"),
+				...uvHeaders,
+				...zlibHeaders,
+				...brotliHeaders,
+				...zstdHeaders
+			],
+			flags: [
+				`-I${INCLUDE}`,
+				`-I${runtimeInclude}`,
+				`-I${LLHTTP}`,
+				`-I${join(UV, "include")}`,
+				`-I${ZLIB}`,
+				`-I${join(BROTLI, "include")}`,
+				`-I${ZSTD}`
+			]
+		},
+		{
+			name: "zlib",
+			sources: files(ZLIB, ".c"),
+			headers: zlibHeaders,
+			flags: [
+				"-w",
+				"-DCPU_NO_SIMD",
+				"-DHAVE_HIDDEN",
+				`-I${ZLIB}`
+			]
+		},
+		{
+			name: "brotli",
+			sources: [
+				"common",
+				"dec",
+				"enc"
+			].flatMap((d) => files(join(BROTLI, d), ".c")),
+			headers: brotliHeaders,
+			flags: [
+				"-w",
+				...BROTLI_OS[process.platform] ? [`-D${BROTLI_OS[process.platform]}`] : [],
+				`-I${join(BROTLI, "include")}`
+			]
+		},
+		{
+			name: "zstd",
+			sources: [
+				"common",
+				"compress",
+				"decompress"
+			].flatMap((d) => files(join(ZSTD, d), ".c")),
+			headers: zstdHeaders,
+			flags: [
+				"-w",
+				"-DXXH_NAMESPACE=ZSTD_",
+				"-DZSTD_MULTITHREAD",
+				"-DZSTD_DISABLE_ASM",
+				`-I${ZSTD}`
+			]
+		},
+		{
+			name: "uv",
+			sources: uvSources,
+			headers: uvHeaders,
+			flags: [
+				"-std=gnu11",
+				"-w",
+				"-fno-strict-aliasing",
+				"-D_FILE_OFFSET_BITS=64",
+				"-D_LARGEFILE_SOURCE",
+				...(uv?.defines ?? []).map((d) => `-D${d}`),
+				`-I${join(UV, "include")}`,
+				`-I${join(UV, "src")}`
+			],
+			link: uv?.link ?? []
+		}
+	];
 }
 //#endregion
 //#region cli/src/hosts.ts
@@ -7725,17 +7946,56 @@ function hostPrimitives(hosts) {
 //#region cli/src/bundle.ts
 /** A bundling failure, already formatted as `file:line:col: Kind: message` lines. */
 var BundleError = class extends Error {};
-/** Bundles `entry` with the ADR 0009 configuration, `node:*` imports resolved to the host
-*  packages' modules. Warnings go to `warn`, with their location ("file:line:col: ", or ""). */
-async function bundle(entry, hosts, warn) {
+async function bundle(entry, hosts, warn, extras = {}) {
+	const rollup = (implicit, warn, required) => rollupOnce(entry, hosts, implicit, warn, required, extras);
+	const b = await rollup([], warn, []);
+	const program = programCode(b.code, dirname(resolve(entry)), hosts);
+	const implicit = hosts.flatMap((h) => h.implicitModules ?? []).filter((m) => m.reached(b.code, program)).map((m) => m.file);
+	const required = hosts.some((h) => h.requireTable) ? requiredPackages(b.code, entry, extras.requires ?? []) : [];
+	if (required.length) implicit.unshift(REQUIRE_TABLE);
+	return implicit.length ? rollup(implicit, () => {}, required) : b;
+}
+/** A bundle's code without its host prelude modules: rolldown marks each module's code with
+*  `//#region <path, relative to cwd>` … `//#endregion`. */
+function programCode(code, cwd, hosts) {
+	const preludes = hosts.map((h) => h.preludeDir + sep);
+	return code.replace(/^\/\/#region (.*)\n[^]*?^\/\/#endregion$/gm, (region, path) => preludes.some((dir) => resolve(cwd, path).startsWith(dir)) ? "" : region);
+}
+/** The packages a bundle names in a call the bundler couldn't follow as a require() (and those
+*  `given`):
+*  ``a(`react-dom`)``, where `a` is a bundle's createRequire(import.meta.url) (Vite's, for the
+*  packages it left external). Only in code that calls createRequire; a call of a plain name with
+*  one string, naming a package (not a built-in) that resolves from the entry. A call that isn't a
+*  require() but names an installed package bundles it needlessly: the build lists them. */
+function requiredPackages(code, entry, given) {
+	if (!/\bcreateRequire\s*\(/.test(code)) return [];
+	const require = createRequire(resolve(entry));
+	const names = /* @__PURE__ */ new Set();
+	const called = code.matchAll(/(?<![.\w$])[\w$]+\s*\(\s*(["'`])((?:@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(?:\/[\w.-]+)*)\1\s*\)/g);
+	for (const name of [...given, ...Array.from(called, (m) => m[2])]) {
+		if (names.has(name) || isBuiltin(name)) continue;
+		try {
+			require.resolve(name);
+			names.add(name);
+		} catch {}
+	}
+	return [...names].sort();
+}
+async function rollupOnce(entry, hosts, implicit, warn, required, extras) {
 	try {
 		const build = await rolldown({
-			input: resolve(entry),
+			input: implicit.length ? IMPLICIT_ENTRY : resolve(entry),
 			cwd: dirname(resolve(entry)),
 			platform: "node",
 			logLevel: "warn",
 			onLog: (_level, log) => log.code !== "EVAL" && warn(logText(log), logWhere(log)),
-			plugins: [hostModules(hosts)]
+			plugins: [
+				hostModules(hosts),
+				implicitEntry(entry, implicit),
+				requireTable(hosts, required),
+				...generatedEntry(entry, extras.source),
+				...extras.plugins ?? []
+			]
 		});
 		try {
 			const { output } = await build.generate({
@@ -7750,7 +8010,8 @@ async function bundle(entry, hosts, warn) {
 			return {
 				code: chunk.code,
 				map: chunk.map?.toString() ?? "",
-				modules: chunk.moduleIds.filter((id) => !id.startsWith("\0")).length
+				modules: chunk.moduleIds.filter((id) => !id.startsWith("\0")).length,
+				required: [...required]
 			};
 		} finally {
 			await build.close();
@@ -7783,6 +8044,7 @@ function hostModules(hosts) {
 			if (!source.startsWith("node:") && !isBuiltin(source)) return null;
 			const name = source.replace(/^node:/, "");
 			const file = Object.hasOwn(modules, name) ? modules[name] : void 0;
+			if (file && importer === ROLLDOWN_RUNTIME) return RUNTIME_COPY + file;
 			if (file) return kind === "require-call" ? REQUIRED + file : file;
 			const provided = Object.keys(modules).sort().map((m) => `node:${m}`).join(", ");
 			this.error({
@@ -7791,17 +8053,50 @@ function hostModules(hosts) {
 			});
 		},
 		load(id) {
+			if (id.startsWith(RUNTIME_COPY)) return readFileSync(id.slice(RUNTIME_COPY.length), "utf8");
 			if (!id.startsWith(REQUIRED)) return null;
 			return `const ns = require(${JSON.stringify(id.slice(REQUIRED.length))});
 const m = ns.default;
-for (const k of Object.keys(ns)) if (k !== "default" && !Object.hasOwn(m, k)) m[k] = ns[k];
+for (const k of Object.keys(ns)) if (k !== "default" && !(k in m)) m[k] = ns[k];
 module.exports = m;
 `;
 		}
 	};
 }
+/** The entry when the program gets implicit modules: they, then the program's entry. */
+const IMPLICIT_ENTRY = "\0visaljs-entry";
+function implicitEntry(entry, implicit) {
+	return {
+		name: "visaljs-implicit",
+		resolveId: (source) => source === IMPLICIT_ENTRY ? source : null,
+		load: (id) => id === IMPLICIT_ENTRY ? [...implicit, resolve(entry)].map((f) => `import ${JSON.stringify(f)};\n`).join("") : null
+	};
+}
+/** A generated entry: `entry`'s path (its imports resolve from there), `source` its code. */
+function generatedEntry(entry, source) {
+	if (source === void 0) return [];
+	const id = resolve(entry);
+	return [{
+		name: "visaljs-generated-entry",
+		resolveId: (s) => s === id ? id : null,
+		load: (i) => i === id ? source : null
+	}];
+}
+/** The module that registers the packages a require() made at run time reaches: run first. */
+const REQUIRE_TABLE = "\0visaljs-require-table";
+function requireTable(hosts, required) {
+	const table = hosts.findLast((h) => h.requireTable)?.requireTable;
+	return {
+		name: "visaljs-require-table",
+		resolveId: (source) => source === REQUIRE_TABLE ? source : null,
+		load: (id) => id === REQUIRE_TABLE && table ? `Object.defineProperty(globalThis, Symbol.for(${JSON.stringify(table)}), { value: new Map([\n` + required.map((name) => `  [${JSON.stringify(name)}, () => require(${JSON.stringify(name)})],\n`).join("") + "]) });\n" : null
+	};
+}
 /** The prefix of the CommonJS module a require() of a built-in resolves to (hostModules.load). */
 const REQUIRED = "\0visaljs-require:";
+/** rolldown's runtime helpers, and the prefix of the copy of a host module they import (hostModules). */
+const ROLLDOWN_RUNTIME = "\0rolldown/runtime.js";
+const RUNTIME_COPY = "\0visaljs-runtime:";
 /** rolldown's messages carry ANSI colors and a code frame: keep the first line, without the `[CODE]` tag. */
 function formatLog(log, kind) {
 	return `${logWhere(log)}${kind}: ${logText(log)}`;
@@ -8153,6 +8448,89 @@ function packageOf(file) {
 	return name.startsWith("@") && i + 2 < parts.length ? `${name}/${parts[i + 2]}` : name;
 }
 //#endregion
+//#region cli/src/frameworks/vinext.ts
+/** The project's package.json's dependencies and devDependencies. */
+function dependencies(root) {
+	const file = join(root, "package.json");
+	if (!existsSync(file)) return {};
+	const pkg = JSON.parse(readFileSync(file, "utf8"));
+	return {
+		...pkg.devDependencies,
+		...pkg.dependencies
+	};
+}
+/** The script a package installed in the project runs as `name` (its package.json's "bin"). */
+function packageBin(root, pkg, name) {
+	let manifest;
+	try {
+		manifest = createRequire(join(root, "package.json")).resolve(`${pkg}/package.json`);
+	} catch {
+		throw new FrameworkError(`${pkg} isn't installed in ${root}: run npm install first`);
+	}
+	const { bin } = JSON.parse(readFileSync(manifest, "utf8"));
+	const script = typeof bin === "string" ? bin : bin?.[name];
+	if (!script) throw new FrameworkError(`${pkg} has no ${name} command`);
+	return join(dirname(manifest), script);
+}
+const MARKER = join("dist", "server", "vinext-server.json");
+const BUILD_ENTRIES = ["dist/server/index.js", "dist/server/entry.js"];
+const vinext = {
+	name: "vinext",
+	detect: (root) => "vinext" in dependencies(root),
+	async build(root) {
+		const vite = packageBin(root, "vite", "vite");
+		try {
+			await promisify(execFile)(process.execPath, [vite, "build"], {
+				cwd: root,
+				maxBuffer: 64 << 20,
+				env: {
+					...process.env,
+					FORCE_COLOR: "0"
+				}
+			});
+		} catch (e) {
+			const { stdout = "", stderr = "" } = e;
+			throw new FrameworkError(`vite build failed in ${root}:\n${`${stdout}${stderr}`.trimEnd().split("\n").slice(-30).join("\n")}`);
+		}
+		return "Built the app with vite build (dist/)";
+	},
+	entry(root) {
+		if (!existsSync(join(root, MARKER))) throw new FrameworkError(`${root} has no vinext build (no ${MARKER}): run \`vite build\`, or build without --no-framework-build`);
+		return "import { startProdServer } from \"vinext/server/prod-server\";\nawait startProdServer();\n";
+	},
+	plugins(root) {
+		const choose = BUILD_ENTRIES.filter((f) => existsSync(join(root, f))).map((f) => `entryPath.replaceAll("\\\\", "/").endsWith(${JSON.stringify("/" + f)}) ? import(${JSON.stringify(join(root, f))}) : `).join("");
+		return [{
+			name: "visaljs-vinext",
+			transform: {
+				filter: { id: /[\\/]vinext[\\/]dist[\\/]server[\\/]prod-server\.js$/ },
+				handler(code) {
+					const call = "import(resolveServerEntryImportUrl(entryPath))";
+					if (!code.includes(call)) this.error("vinext's prod-server.js no longer imports its build as visaljs expects: this vinext version isn't supported yet");
+					return {
+						code: code.replace(call, `(${choose}Promise.reject(new Error("visaljs: the build has no " + entryPath)))`),
+						map: null
+					};
+				}
+			}
+		}];
+	},
+	requires(root) {
+		const file = join(root, "dist", "server", "vinext-externals.json");
+		return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : [];
+	},
+	notes: () => ["It serves ./dist under the working directory, as `vinext start` does: run it from the project"]
+};
+//#endregion
+//#region cli/src/frameworks/index.ts
+/** A framework's failure, as the message to print. */
+var FrameworkError = class extends Error {};
+const FRAMEWORKS = [vinext];
+/** The framework of the project in `root`, or undefined. */
+function detectFramework(root) {
+	return FRAMEWORKS.find((f) => f.detect(root));
+}
+//#endregion
 //#region cli/src/regexp.ts
 /** The program's regex literals, in source order. */
 function regexpLiterals(program) {
@@ -8316,8 +8694,11 @@ function lineCount(text) {
 }
 //#endregion
 //#region cli/src/main.ts
-const VERSION = "0.0.4";
-const USAGE = `usage: visaljs build <entry.js> [options]
+const VERSION = "0.0.6";
+const USAGE = `usage: visaljs build [entry.js | project directory] [options]
+
+A project (the current directory when none is given) builds its framework's production server: a
+vinext app is built with its own \`vite build\` first, then its server is compiled.
 
 options:
   -o <file>          output binary
@@ -8328,6 +8709,7 @@ options:
   --embed-source     embed the source text: Function.prototype.toString returns it
   --all-builtins     install every built-in, not only those the program names
   --no-bundle        skip the bundler: the input is one ES module (a bundle)
+  --no-framework-build  a project: compile its existing build output, without building it first
   --script           compile as a classic script (sloppy mode, no bundler)
   -q, --quiet        don't report each step of the build
   --verbose          list each place a warning is about
@@ -8353,6 +8735,7 @@ async function main(argv, io) {
 				"embed-source": { type: "boolean" },
 				"all-builtins": { type: "boolean" },
 				"no-bundle": { type: "boolean" },
+				"no-framework-build": { type: "boolean" },
 				script: { type: "boolean" },
 				quiet: {
 					type: "boolean",
@@ -8382,29 +8765,61 @@ async function main(argv, io) {
 	const [command, ...rest] = positionals;
 	switch (command) {
 		case "build":
-			if (rest.length !== 1) {
-				io.stderr(`visaljs build: expected one entry file\n${USAGE}`);
+			if (rest.length > 1) {
+				io.stderr(`visaljs build: expected one entry file or project directory\n${USAGE}`);
 				return 2;
 			}
-			return await build(rest[0], values, io);
+			return await build(rest[0] ?? ".", values, io);
 		default:
 			io.stderr(`visaljs: unknown command '${command}'\n${USAGE}`);
 			return 2;
 	}
 }
 async function build(entry, options, io) {
-	let source;
-	try {
+	let framework;
+	let source = "";
+	if (statSync(entry, { throwIfNoEntry: false })?.isDirectory()) {
+		const root = resolve(entry);
+		const fw = detectFramework(root);
+		if (!fw) {
+			io.stderr(`visaljs: ${entry === "." ? "the current directory" : entry} isn't a project of a framework visaljs knows (${FRAMEWORKS.map((f) => f.name).join(", ")}): give an entry file\n`);
+			return 1;
+		}
+		framework = {
+			fw,
+			root
+		};
+		entry = join(root, "visaljs-entry.js");
+	} else try {
 		source = readFileSync(entry, "utf8");
 	} catch (e) {
 		io.stderr(`visaljs: cannot read ${entry}: ${e.message}\n`);
 		return 1;
 	}
 	const dump = options["dump-ast"] === true || options["dump-ir"] === true;
-	const report = new Report(io.stderr, options.quiet || dump ? void 0 : io.report);
+	const style = options.quiet || dump ? void 0 : io.report;
+	const report = new Report(io.stderr, style);
 	const binary = !dump && !options["emit-c"];
 	const hosts = DEFAULT_HOSTS;
 	const primitives = hostPrimitives(hosts);
+	let frameworkExtras = {};
+	if (framework) {
+		const { fw, root } = framework;
+		if (style) report.note(` 🧭 A ${fw.name} app: compiling its production server`);
+		try {
+			if (fw.build && options["no-framework-build"] !== true) await report.step("🏗️ ", `Building the ${fw.name} app`, () => fw.build(root), (what) => what);
+			source = fw.entry(root);
+		} catch (e) {
+			if (!(e instanceof FrameworkError)) throw e;
+			io.stderr(`visaljs: ${e.message}\n`);
+			return 1;
+		}
+		frameworkExtras = {
+			source,
+			plugins: fw.plugins?.(root) ?? [],
+			requires: fw.requires?.(root) ?? []
+		};
+	}
 	let compilers;
 	if (binary) try {
 		compilers = await report.step("🔍", "Detecting C compilers", findCompilers, detected);
@@ -8416,7 +8831,7 @@ async function build(entry, options, io) {
 	const bundled = !script && options["no-bundle"] !== true;
 	let map;
 	if (bundled) try {
-		const b = await report.step("📦", "Rolling the modules into a single file", () => bundle(entry, hosts, (message, where) => report.warn(message, where)), (b) => `Rolled ${count(b.modules, "module")} into a single file (${size(Buffer.byteLength(b.code))})`);
+		const b = await report.step("📦", "Rolling the modules into a single file", () => bundle(entry, hosts, (message, where) => report.warn(message, where), frameworkExtras), (b) => `Rolled ${count(b.modules, "module")} into a single file (${size(Buffer.byteLength(b.code))})` + (b.required.length ? `; for a require() at run time: ${b.required.join(", ")}` : ""));
 		source = b.code;
 		if (b.map) map = new SourceMap(b.map, displayPath);
 	} catch (e) {
@@ -8464,7 +8879,7 @@ async function build(entry, options, io) {
 		report.finish("📂", (time) => `Wrote ${displayPath(resolve(options["emit-c"], "program.c"))} in ${time}`);
 		return 0;
 	}
-	let output = options.output ?? basename(entry).replace(/\.[cm]?js$/, "");
+	let output = options.output ?? (framework ? join(framework.root, basename(framework.root)) : basename(entry).replace(/\.[cm]?js$/, ""));
 	if (process.platform === "win32" && !extname(output)) output += ".exe";
 	const opt = options.debug ? ["-O0"] : ["-O2"];
 	const dir = scratchDir();
@@ -8495,6 +8910,7 @@ async function build(entry, options, io) {
 	}
 	const bytes = statSync(output).size;
 	report.finish("🎉", (time) => `Built ${displayPath(resolve(output))} in ${time}: ${size(bytes)}, ${sizeQuip(bytes)}`);
+	if (framework?.fw.notes && style) for (const note of framework.fw.notes(framework.root)) report.note(`    • ${note}`);
 	return 0;
 }
 /** "Detected GCC 13.3.0", else the compilers numbered in the order they're tried, under the