visaljs 0.0.1 → 0.0.3

package/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { isBuiltin } from "node:module";
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 import ts from "typescript";
 import { rolldown } from "rolldown";
-import { execFileSync, spawnSync } from "node:child_process";
+import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { availableParallelism, homedir, tmpdir } from "node:os";
 //#region \0rolldown/runtime.js
@@ -6672,6 +6672,32 @@ function emitModule(m, p, entry, options) {
 //#endregion
 //#region runtime/components.ts
 const COMPONENTS = [
+	{
+		name: "promise",
+		symbol: "js_component_promise",
+		names: ["Promise", "fromAsync"]
+	},
+	{
+		name: "generator",
+		symbol: "js_component_generator",
+		names: ["function*"]
+	},
+	{
+		name: "asynciterator",
+		symbol: "js_component_asynciterator",
+		names: ["async function*", "asyncIterator"],
+		needs: ["promise"]
+	},
+	{
+		name: "weak",
+		symbol: "js_component_weak",
+		names: [
+			"WeakMap",
+			"WeakSet",
+			"WeakRef",
+			"FinalizationRegistry"
+		]
+	},
 	{
 		name: "math",
 		symbol: "js_component_math",
@@ -6810,6 +6836,7 @@ const COMPONENTS = [
 			"CryptoKey"
 		],
 		needs: [
+			"promise",
 			"json",
 			"typedarray",
 			"domexception"
@@ -6834,6 +6861,8 @@ const COMPONENTS = [
 			"TransformStreamDefaultController"
 		],
 		needs: [
+			"promise",
+			"asynciterator",
 			"typedarray",
 			"domexception",
 			"events"
@@ -6843,13 +6872,18 @@ const COMPONENTS = [
 		name: "blob",
 		symbol: "js_component_blob",
 		names: ["Blob", "File"],
-		needs: ["typedarray", "streams"]
+		needs: [
+			"promise",
+			"typedarray",
+			"streams"
+		]
 	},
 	{
 		name: "fetch",
 		symbol: "js_component_fetch",
 		names: ["Request", "Response"],
 		needs: [
+			"promise",
 			"json",
 			"domexception",
 			"url",
@@ -6863,7 +6897,9 @@ const COMPONENTS = [
 ];
 //#endregion
 //#region compiler/src/emit/components.ts
-/** Every identifier name and string literal in the program: the names it can reach built-ins by. */
+/** Every identifier name and string literal in the program: the names it can reach built-ins by.
+*  Syntax adds the names of what it needs: an async function or `await` adds `Promise`, a
+*  generator `function*`, an async generator or `for await` `async function*`. */
 function programNames(program) {
 	const names = /* @__PURE__ */ new Set();
 	namesIn(program.body, names);
@@ -6880,6 +6916,11 @@ function namesIn(node, out) {
 	else if (n.type === "RegExpLiteral") out.add("RegExp");
 	else if (n.type === "BigIntLiteral") out.add("BigInt");
 	else if (n.type === "Literal" && typeof n.value === "string") out.add(n.value);
+	else if (n.type === "FunctionDeclaration" || n.type === "FunctionExpression") {
+		if (n.async) out.add("Promise");
+		if (n.generator) out.add(n.async ? "async function*" : "function*");
+	} else if (n.type === "AwaitExpression" || n.type === "ImportCall") out.add("Promise");
+	else if (n.type === "ForOfStatement" && n.await) out.add("async function*").add("Promise");
 	for (const [key, value] of Object.entries(node)) if (key !== "loc" && value !== null && typeof value === "object") namesIn(value, out);
 }
 /** The optional components the program can reach, and those they need, in COMPONENTS order. */
@@ -6896,6 +6937,8 @@ const RUNTIME_DIR = join(import.meta.dirname, "runtime");
 const RUNTIME_INCLUDE = join(RUNTIME_DIR, "include");
 /** The core-method catalog the compiler reads (ADR 0014). */
 const CORE_DEF = join(RUNTIME_INCLUDE, "js_core.def");
+/** BoringSSL's directory (boringsslLibrary) */
+const BORINGSSL = join(RUNTIME_DIR, "third_party", "boringssl");
 /** Vendored libraries: every .c of these is part of libjsrt. */
 const THIRD_PARTY = [
 	"quickjs-dtoa",
@@ -6904,9 +6947,6 @@ const THIRD_PARTY = [
 	"ada-idna"
 ].map((d) => join(RUNTIME_DIR, "third_party", d));
 const cFiles = (dir, ext) => readdirSync(dir).filter((f) => f.endsWith(ext)).map((f) => join(dir, f));
-const cFilesDeep = (dir, ext) => readdirSync(dir, { withFileTypes: true }).flatMap((e) => e.isDirectory() ? cFilesDeep(join(dir, e.name), ext) : e.name.endsWith(ext) ? [join(dir, e.name)] : []);
-/** BearSSL (ADR 0018): the crypto component's primitives, behind runtime/src/crypto*.c. */
-const BEARSSL = join(RUNTIME_DIR, "third_party", "bearssl");
 /** libjsrt, as a C library the driver builds (the shape host packages give theirs too). */
 function runtimeLibrary() {
 	const src = join(RUNTIME_DIR, "src");
@@ -6921,27 +6961,33 @@ function runtimeLibrary() {
 		flags: [
 			`-I${RUNTIME_INCLUDE}`,
 			...THIRD_PARTY.map((d) => `-I${d}`),
-			`-I${join(BEARSSL, "inc")}`
+			`-I${join(BORINGSSL, "include")}`
 		]
 	};
 }
-/** libbearssl: a library of its own, so runtime changes don't rebuild it. One function per
-*  file: a program links only the primitives it reaches. */
-function bearsslLibrary() {
+/** BoringSSL (ADR 0018, 0019): the crypto component's, node:crypto's and node:tls's primitives,
+*  behind runtime/src/crypto*.c; a library of its own, so runtime changes don't rebuild it. Its
+*  sources are C++ (built without exceptions, RTTI or the C++ library) and per-platform assembly, which guards
+*  itself: every file is compiled everywhere. The lists are BoringSSL's (sources.json, from its
+*  gen/sources.json at the vendored commit). */
+function boringsslLibrary() {
+	const lists = JSON.parse(readFileSync(join(BORINGSSL, "sources.json"), "utf8"));
+	const parts = [
+		"bcm",
+		"crypto",
+		"ssl"
+	].map((k) => lists[k]);
+	const at = (f) => join(BORINGSSL, f);
 	return {
-		name: "bearssl",
-		sources: cFilesDeep(join(BEARSSL, "src"), ".c"),
-		headers: [...cFiles(join(BEARSSL, "inc"), ".h"), ...cFilesDeep(join(BEARSSL, "src"), ".h")],
-		flags: [
-			`-I${join(BEARSSL, "inc")}`,
-			`-I${join(BEARSSL, "src")}`,
-			"-D_DEFAULT_SOURCE"
-		]
+		name: "boringssl",
+		sources: [...parts.flatMap((p) => [...p.srcs, ...p.asm]).map(at), join(RUNTIME_DIR, "src", "boringssl_support.cc")],
+		headers: parts.flatMap((p) => [...p.hdrs ?? [], ...p.internal_hdrs ?? []]).map(at),
+		flags: [`-I${join(BORINGSSL, "include")}`]
 	};
 }
 /** The runtime's libraries, in link order: libjsrt, then the libraries it uses. */
 function runtimeLibraries() {
-	return [runtimeLibrary(), bearsslLibrary()];
+	return [runtimeLibrary(), boringsslLibrary()];
 }
 //#endregion
 //#region compiler/src/emit/core.ts
@@ -7031,6 +7077,8 @@ const modules = {
 	async_hooks: join(preludeDir, "async_hooks.js"),
 	buffer: join(preludeDir, "buffer.js"),
 	crypto: join(preludeDir, "crypto.js"),
+	dns: join(preludeDir, "dns.js"),
+	"dns/promises": join(preludeDir, "dns_promises.js"),
 	events: join(preludeDir, "events.js"),
 	fs: join(preludeDir, "fs.js"),
 	http: join(preludeDir, "http.js"),
@@ -7045,9 +7093,11 @@ const modules = {
 	"stream/promises": join(preludeDir, "stream_promises.js"),
 	"stream/web": join(preludeDir, "stream_web.js"),
 	string_decoder: join(preludeDir, "string_decoder.js"),
+	tls: join(preludeDir, "tls.js"),
 	tty: join(preludeDir, "tty.js"),
 	url: join(preludeDir, "url.js"),
 	util: join(preludeDir, "util.js"),
+	"util/types": join(preludeDir, "util_types.js"),
 	zlib: join(preludeDir, "zlib.js")
 };
 /** The host primitives: the name prelude code imports → its C function (JSNativeFn) and length.
@@ -7085,6 +7135,10 @@ const primitives = {
 		c: "js_host_tty_isatty",
 		length: 1
 	},
+	timerUnref: {
+		c: "js_host_timer_unref",
+		length: 2
+	},
 	osUname: {
 		c: "js_host_os_uname",
 		length: 0
@@ -7141,6 +7195,10 @@ const primitives = {
 		c: "js_util_format_with_options",
 		length: 1
 	},
+	utilTypeTag: {
+		c: "js_util_type_tag",
+		length: 1
+	},
 	cryptoHashNew: {
 		c: "js_crypto_hash_new",
 		length: 2
@@ -7289,6 +7347,26 @@ const primitives = {
 		c: "js_crypto_verify",
 		length: 7
 	},
+	cryptoSignMessage: {
+		c: "js_crypto_sign_message",
+		length: 2
+	},
+	cryptoVerifyMessage: {
+		c: "js_crypto_verify_message",
+		length: 3
+	},
+	cryptoModExp: {
+		c: "js_crypto_mod_exp",
+		length: 4
+	},
+	cryptoGeneratePrime: {
+		c: "js_crypto_generate_prime",
+		length: 4
+	},
+	cryptoCheckPrime: {
+		c: "js_crypto_check_prime",
+		length: 2
+	},
 	cryptoRsaCrypt: {
 		c: "js_crypto_rsa_crypt",
 		length: 6
@@ -7305,29 +7383,177 @@ const primitives = {
 		c: "js_crypto_ec_private",
 		length: 2
 	},
-	httpListen: {
-		c: "js_host_http_listen",
+	tlsContextNew: {
+		c: "js_tls_context_new",
+		length: 6
+	},
+	tlsContextAddRoots: {
+		c: "js_tls_context_add_roots",
+		length: 1
+	},
+	tlsContextAddCA: {
+		c: "js_tls_context_add_ca",
+		length: 2
+	},
+	tlsContextSetCert: {
+		c: "js_tls_context_set_cert",
+		length: 2
+	},
+	tlsContextSetKey: {
+		c: "js_tls_context_set_key",
+		length: 2
+	},
+	tlsRootCertificates: {
+		c: "js_tls_root_certificates",
+		length: 0
+	},
+	tlsCiphers: {
+		c: "js_tls_ciphers",
+		length: 0
+	},
+	tlsNew: {
+		c: "js_tls_new",
 		length: 7
 	},
-	httpAddress: {
-		c: "js_host_http_address",
+	tlsRun: {
+		c: "js_tls_run",
+		length: 3
+	},
+	tlsShutdown: {
+		c: "js_tls_shutdown",
+		length: 1
+	},
+	tlsInfo: {
+		c: "js_tls_info",
+		length: 1
+	},
+	tlsPeerCerts: {
+		c: "js_tls_peer_certs",
+		length: 1
+	},
+	tlsVerifyError: {
+		c: "js_tls_verify_error",
+		length: 1
+	},
+	tlsSession: {
+		c: "js_tls_session",
 		length: 1
 	},
-	httpCloseServer: {
-		c: "js_host_http_close_server",
+	tlsExportKeyingMaterial: {
+		c: "js_tls_export_keying_material",
+		length: 4
+	},
+	tlsSetNoRenegotiation: {
+		c: "js_tls_set_no_renegotiation",
+		length: 1
+	},
+	tlsFinished: {
+		c: "js_tls_finished",
+		length: 2
+	},
+	httpParsers: {
+		c: "js_host_http_parsers",
+		length: 5
+	},
+	httpAttach: {
+		c: "js_host_http_attach",
+		length: 4
+	},
+	httpDetach: {
+		c: "js_host_http_detach",
 		length: 1
 	},
+	httpExpired: {
+		c: "js_host_http_expired",
+		length: 3
+	},
 	httpWrite: {
 		c: "js_host_http_write",
 		length: 2
 	},
-	httpEnd: {
-		c: "js_host_http_end",
-		length: 2
+	httpFlush: {
+		c: "js_host_http_flush",
+		length: 1
 	},
 	httpDate: {
 		c: "js_host_http_date",
 		length: 0
+	},
+	netOpen: {
+		c: "js_host_net_open",
+		length: 2
+	},
+	netGuessHandle: {
+		c: "js_host_net_guess_handle",
+		length: 1
+	},
+	netOpenFd: {
+		c: "js_host_net_open_fd",
+		length: 2
+	},
+	netBind: {
+		c: "js_host_net_bind",
+		length: 4
+	},
+	netChmod: {
+		c: "js_host_net_chmod",
+		length: 2
+	},
+	netListen: {
+		c: "js_host_net_listen",
+		length: 2
+	},
+	netConnect: {
+		c: "js_host_net_connect",
+		length: 3
+	},
+	netCallback: {
+		c: "js_host_net_callback",
+		length: 2
+	},
+	netReadStart: {
+		c: "js_host_net_read_start",
+		length: 1
+	},
+	netReadStop: {
+		c: "js_host_net_read_stop",
+		length: 1
+	},
+	netWrite: {
+		c: "js_host_net_write",
+		length: 2
+	},
+	netShutdown: {
+		c: "js_host_net_shutdown",
+		length: 1
+	},
+	netClose: {
+		c: "js_host_net_close",
+		length: 1
+	},
+	netReset: {
+		c: "js_host_net_reset",
+		length: 1
+	},
+	netRef: {
+		c: "js_host_net_ref",
+		length: 2
+	},
+	netAddress: {
+		c: "js_host_net_address",
+		length: 2
+	},
+	netNoDelay: {
+		c: "js_host_net_no_delay",
+		length: 2
+	},
+	netKeepAlive: {
+		c: "js_host_net_keep_alive",
+		length: 3
+	},
+	dnsLookup: {
+		c: "js_host_dns_lookup",
+		length: 3
 	}
 };
 const UV_COMMON = [
@@ -7470,7 +7696,8 @@ async function bundle(entry, hosts, warn) {
 			const chunk = output[0];
 			return {
 				code: chunk.code,
-				map: chunk.map?.toString() ?? ""
+				map: chunk.map?.toString() ?? "",
+				modules: chunk.moduleIds.filter((id) => !id.startsWith("\0")).length
 			};
 		} finally {
 			await build.close();
@@ -7529,18 +7756,34 @@ function formatLog(log, kind) {
 }
 //#endregion
 //#region cli/src/cc.ts
-/** $CC, else the first of the usual C compilers on the PATH. */
-function findCompiler() {
-	if (process.env.CC) return process.env.CC;
+/** $CC alone, else each of the usual C compilers on the PATH that runs, in order of preference:
+*  a build falls back to the next when one fails. Names for the same program (cc, a link to
+*  gcc) count once. Last comes Zig's clang, which brings its own libc headers and linker: a C
+*  compiler for a machine whose own toolchain is missing or broken. */
+function findCompilers() {
+	if (process.env.CC) {
+		if (!compilerVersion(process.env.CC)) throw new Error(`$CC (${process.env.CC}) doesn't run`);
+		return [process.env.CC];
+	}
+	const found = /* @__PURE__ */ new Map();
 	for (const cc of [
 		"cc",
 		"clang",
-		"gcc"
-	]) try {
-		execFileSync(cc, ["--version"], { stdio: "ignore" });
-		return cc;
+		"gcc",
+		"zig cc"
+	]) {
+		const path = onPath(command(cc)[0]);
+		if (path && !found.has(path) && compilerVersion(cc)) found.set(path, cc);
+	}
+	if (found.size === 0) throw new Error("no C compiler found (set CC)");
+	return [...found.values()];
+}
+/** The program `name` runs from the PATH, links resolved; else undefined. */
+function onPath(name) {
+	const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE").split(delimiter) : [""];
+	for (const dir of (process.env.PATH ?? "").split(delimiter)) for (const ext of exts) try {
+		return realpathSync(join(dir, name + ext));
 	} catch {}
-	throw new Error("no C compiler found (set CC)");
 }
 const COMMON = [
 	"-std=c11",
@@ -7552,18 +7795,57 @@ const COMMON = [
 ];
 const LINK = process.platform === "darwin" ? ["-Wl,-dead_strip"] : ["-Wl,--gc-sections"];
 const STRIP = process.platform === "darwin" ? ["-Wl,-S,-x"] : ["-s"];
+/** A compiler's command line, split like make splits $(CC): "zig cc", "ccache gcc". */
+function command(cc) {
+	const [program = cc, ...args] = cc.trim().split(/\s+/);
+	return [program, ...args];
+}
+/** Runs the compiler with `args`, synchronously (execFileSync's options and result). */
+function runCompiler(cc, args, options) {
+	const [program, ...prefix] = command(cc);
+	return execFileSync(program, [...prefix, ...args], options);
+}
+/** Zig compiles C with its clang, and archives with its own ar: a machine without a C
+*  toolchain usually lacks binutils' ar too. */
+function isZig(cc) {
+	return /^zig(\.exe)?$/i.test(basename(command(cc)[0]));
+}
+/** "GCC 13.3.0", "clang 18.1.3", "Zig 0.16.0": the compiler's name and version, else its command. */
+function describeCompiler(cc) {
+	if (isZig(cc)) try {
+		return `Zig ${execFileSync(command(cc)[0], ["version"], { encoding: "utf8" }).trim()}`;
+	} catch {
+		return cc;
+	}
+	const text = compilerVersion(cc);
+	const first = text.split("\n")[0] ?? "";
+	const version = (/version (\d+\.\d+(?:\.\d+)?)/.exec(first) ?? /(\d+\.\d+(?:\.\d+)?)\S*\s*$/.exec(first))?.[1];
+	if (!version) return cc;
+	if (/clang/i.test(text)) return `${/apple/i.test(text) ? "Apple clang" : "clang"} ${version}`;
+	if (/gcc|free software foundation/i.test(text)) return `GCC ${version}`;
+	return `${cc} ${version}`;
+}
 function compilerVersion(cc) {
 	try {
-		return execFileSync(cc, ["--version"], { encoding: "utf8" });
+		return runCompiler(cc, ["--version"], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		});
 	} catch {
 		return "";
 	}
 }
-/** Builds (or reuses) lib<name>.a for this toolchain; returns its path. */
-function libraryArchive(tc, lib) {
+/** Builds (or reuses) lib<name>.a for this toolchain; returns its path. `building` hears
+*  about a library that isn't cached, before it's built. */
+function libraryArchive(tc, lib, building) {
 	const hash = createHash("sha256");
 	hash.update(`${tc.cc}\n${compilerVersion(tc.cc)}\n${[
 		...COMMON,
+		...CXX,
 		...tc.opt,
 		...lib.flags
 	].join(" ")}\n`);
@@ -7573,13 +7855,13 @@ function libraryArchive(tc, lib) {
 	const dir = join(root, `${lib.name}-${key}`);
 	const archive = join(dir, `lib${lib.name}.a`);
 	if (existsSync(archive)) return archive;
+	building?.(lib.name);
 	const work = join(root, `tmp-${process.pid}-${Date.now()}`);
 	mkdirSync(work, { recursive: true });
 	try {
 		const objects = lib.sources.map((_, i) => join(work, `${i}.o`));
 		compileAll(lib.sources.map((src, i) => [
-			tc.cc,
-			...COMMON,
+			...compileCommand(tc.cc, src),
 			...tc.opt,
 			"-DNDEBUG",
 			...lib.flags,
@@ -7588,7 +7870,9 @@ function libraryArchive(tc, lib) {
 			"-o",
 			objects[i]
 		]));
-		execFileSync("ar", [
+		const [ar, ...arPrefix] = isZig(tc.cc) ? [command(tc.cc)[0], "ar"] : ["ar"];
+		execFileSync(ar, [
+			...arPrefix,
 			"rcs",
 			join(work, `lib${lib.name}.a`),
 			...objects
@@ -7609,6 +7893,25 @@ function libraryArchive(tc, lib) {
 	}
 	return archive;
 }
+const CXX = [
+	"-std=c++17",
+	"-fno-exceptions",
+	"-fno-rtti",
+	...COMMON.filter((f) => !f.startsWith("-std="))
+];
+function compileCommand(cc, src) {
+	if (!src.endsWith(".cc")) return [...command(cc), ...COMMON];
+	const cmd = command(cc);
+	if (isZig(cc)) return [...cmd.map((w) => w === "cc" ? "c++" : w), ...CXX];
+	return [
+		...cmd,
+		"-x",
+		"c++",
+		...CXX
+	];
+}
+/** Runs the compiler commands, as many at once as there are processors (in a child Node process:
+* the driver's API is synchronous; the commands on its stdin). Throws when one fails, after its output. */
 const PARALLEL = `
 const { spawn } = require("node:child_process");
 const jobs = JSON.parse(require("node:fs").readFileSync(0, "utf8"));
@@ -7636,11 +7939,6 @@ function compileAll(commands) {
 		]
 	});
 }
-/** The runtime's archives for this toolchain, in link order: libjsrt.a, then libbearssl.a
-*  (the test262 host links them too). */
-function runtimeArchives(tc) {
-	return runtimeLibraries().map((l) => libraryArchive(tc, l));
-}
 function cacheRoot() {
 	return process.env.VISALJS_CACHE ?? join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "visaljs");
 }
@@ -7664,7 +7962,7 @@ function regexpCompiler(cc) {
 	if (existsSync(tool)) return tool;
 	mkdirSync(cacheRoot(), { recursive: true });
 	const tmp = `${tool}.${process.pid}.tmp`;
-	execFileSync(cc, [
+	runCompiler(cc, [
 		"-std=c11",
 		"-O2",
 		`-I${regexp}`,
@@ -7680,12 +7978,17 @@ function regexpCompiler(cc) {
 	renameSync(tmp, tool);
 	return tool;
 }
-/** Compiles program.c and links it with the host packages' libraries, then libjsrt (which they
-*  use). The linker takes only what the program reaches: a program without I/O links no libuv.
-*  The libraries keep their debug info (-g); stripping, when asked, happens at this link. */
-function compileProgram(tc, cFile, output, hosts, extraFlags = []) {
-	const archives = [...hosts.flatMap((h) => h.libraries(RUNTIME_INCLUDE)).filter((l) => l.sources.length).map((l) => libraryArchive(tc, l)), ...runtimeArchives(tc)];
-	execFileSync(tc.cc, [
+/** A program's archives, in link order: the host packages' libraries, then libjsrt (which they
+*  use). Each is built the first time; `building` hears about it. */
+function programArchives(tc, hosts, building) {
+	return [...hosts.flatMap((h) => h.libraries(RUNTIME_INCLUDE)).filter((l) => l.sources.length), ...runtimeLibraries()].map((l) => libraryArchive(tc, l, building));
+}
+/** Compiles program.c and links it with `archives` (programArchives). The linker takes only
+*  what the program reaches: a program without I/O links no libuv. The libraries keep their
+*  debug info (-g); stripping, when asked, happens at this link. Asynchronous: the build's
+*  report keeps drawing while the compiler runs. */
+function compileProgram(tc, cFile, output, archives, extraFlags = []) {
+	const args = [
 		...COMMON,
 		...tc.opt,
 		...extraFlags,
@@ -7697,11 +8000,29 @@ function compileProgram(tc, cFile, output, hosts, extraFlags = []) {
 		...tc.strip ? STRIP : [],
 		"-o",
 		output
-	], { stdio: [
-		"ignore",
-		"inherit",
-		"inherit"
-	] });
+	];
+	return new Promise((resolve, reject) => {
+		let errors = "";
+		const [program, ...prefix] = command(tc.cc);
+		const child = spawn(program, [...prefix, ...args], { stdio: [
+			"ignore",
+			"inherit",
+			"pipe"
+		] });
+		child.stderr.on("data", (chunk) => {
+			process.stderr.write(chunk);
+			errors = (errors + chunk.toString()).slice(-16384);
+		});
+		child.on("error", reject).on("close", (code) => {
+			if (code === 0) return resolve();
+			const hint = toolchainHint(errors);
+			reject(/* @__PURE__ */ new Error(`${tc.cc} exited with code ${code}${hint ? `\n  hint: ${hint}` : ""}`));
+		});
+	});
+}
+/** A hint for a compiler failure that isn't the program's fault, else undefined. */
+function toolchainHint(stderr) {
+	if (/tapi error|unknown architecture/.test(stderr)) return "the macOS SDK is newer than the linker (Command Line Tools and SDK don't match). Check `xcode-select -p`, `ld -v` and `xcrun --show-sdk-path`; reinstalling the Command Line Tools (`sudo rm -rf /Library/Developer/CommandLineTools && xcode-select --install`) or setting SDKROOT to an older SDK fixes it.";
 }
 function scratchDir() {
 	const dir = join(tmpdir(), `visaljs-${process.pid}-${Date.now()}`);
@@ -7758,8 +8079,117 @@ function compileRegExps(cc, literals) {
 	return bytecode;
 }
 //#endregion
+//#region cli/src/report.ts
+const CLEAR = "\r\x1B[2K";
+const FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+var Report = class {
+	#write;
+	#style;
+	#start = performance.now();
+	#running;
+	#timer;
+	#frame = 0;
+	/** No style: reports nothing (--quiet, and callers that capture the CLI's output). */
+	constructor(write, style) {
+		this.#write = write;
+		this.#style = style;
+	}
+	/** Runs one step: `label` while it runs, then `done(result)`. A failed step is crossed out
+	*  and its error rethrown, for the caller to print. The spinner turns only while the event
+	*  loop is free: an asynchronous step. */
+	async step(icon, label, run, done) {
+		this.#running = {
+			icon,
+			label,
+			since: performance.now()
+		};
+		if (this.#live) {
+			this.#draw();
+			this.#timer = setInterval(() => (this.#frame++, this.#draw()), 80);
+			this.#timer.unref();
+		}
+		let result;
+		try {
+			result = await run();
+		} catch (e) {
+			this.#end(this.#paint("31", `✗ ${label}`));
+			throw e;
+		}
+		this.#end(`${this.#paint("32", "✓")} ${icon} ${done(result)}`);
+		return result;
+	}
+	/** Renames the running step (what it turned out to be doing). */
+	relabel(label) {
+		if (!this.#running) return;
+		this.#running.label = label;
+		if (this.#live) this.#draw();
+	}
+	/** A message from inside a step (a bundler warning): printed even when quiet. */
+	note(text) {
+		if (this.#live && this.#running) this.#write(CLEAR);
+		this.#write(`${text}\n`);
+		if (this.#live && this.#running) this.#draw();
+	}
+	/** The last line, given the whole build's time. */
+	finish(icon, text) {
+		if (this.#style) this.#write(`\n ${icon} ${this.#paint("1", text(since(this.#start)))}\n`);
+	}
+	get #live() {
+		return this.#style?.live === true;
+	}
+	#paint(code, text) {
+		return this.#style?.color ? `\x1b[${code}m${text}\x1b[0m` : text;
+	}
+	#draw() {
+		const { icon, label } = this.#running;
+		this.#write(`${CLEAR} ${this.#paint("36", FRAMES[this.#frame % FRAMES.length])} ${icon} ${this.#paint("2", `${label}…`)}`);
+	}
+	/** A multi-line `line` keeps its time on the first: the rest is detail under it. */
+	#end(line) {
+		clearInterval(this.#timer);
+		const start = this.#running.since;
+		this.#running = void 0;
+		const [first, ...rest] = line.split("\n");
+		if (this.#style) this.#write(`${this.#live ? CLEAR : ""} ${first}  ${this.#paint("2", since(start))}\n${rest.map((l) => `${l}\n`).join("")}`);
+	}
+};
+function since(start) {
+	const ms = performance.now() - start;
+	return ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(2)}s`;
+}
+/** 383.2 kB, 1.2 MB (decimal units). */
+function size(bytes) {
+	if (bytes < 1e3) return `${bytes} B`;
+	return bytes < 1e6 ? `${(bytes / 1e3).toFixed(1)} kB` : `${(bytes / 1e6).toFixed(1)} MB`;
+}
+/** The binary's size, put in scale. */
+function sizeQuip(bytes) {
+	const FLOPPY = 1474560;
+	if (bytes <= 65536) return "small enough for a Commodore 64 🕹️";
+	if (bytes <= FLOPPY) return "fits on a floppy disk 💾";
+	return `${Math.ceil(bytes / FLOPPY)} floppy disks' worth 💾`;
+}
+/** "1 module", "1,204 lines". */
+const count = (n, one, many = `${one}s`) => `${n.toLocaleString("en-US")} ${n === 1 ? one : many}`;
+function lineCount(text) {
+	let n = text.length > 0 && !text.endsWith("\n") ? 1 : 0;
+	for (let i = text.indexOf("\n"); i !== -1; i = text.indexOf("\n", i + 1)) n++;
+	return n;
+}
+//#endregion
 //#region cli/src/main.ts
-const VERSION = "0.0.1";
+const VERSION = "0.0.3";
 const USAGE = `usage: visaljs build <entry.js> [options]
 
 options:
@@ -7772,6 +8202,7 @@ options:
   --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)
   --script           compile as a classic script (sloppy mode, no bundler)
+  -q, --quiet        don't report each step of the build
   --version          print the version
   --help             print this help
 `;
@@ -7795,6 +8226,10 @@ async function main(argv, io) {
 				"all-builtins": { type: "boolean" },
 				"no-bundle": { type: "boolean" },
 				script: { type: "boolean" },
+				quiet: {
+					type: "boolean",
+					short: "q"
+				},
 				version: { type: "boolean" },
 				help: {
 					type: "boolean",
@@ -7815,6 +8250,10 @@ async function main(argv, io) {
 		io.stdout(USAGE);
 		return values.help ? 0 : 2;
 	}
+	if ((io.platform ?? process.platform) === "win32") {
+		io.stderr("visaljs: Windows is not supported yet; use Linux or macOS (on Windows, WSL works)\n");
+		return 1;
+	}
 	const [command, ...rest] = positionals;
 	switch (command) {
 		case "build":
@@ -7836,13 +8275,23 @@ async function build(entry, options, io) {
 		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 binary = !dump && !options["emit-c"];
 	const hosts = DEFAULT_HOSTS;
 	const primitives = hostPrimitives(hosts);
+	let compilers;
+	if (binary) try {
+		compilers = await report.step("🔍", "Detecting C compilers", findCompilers, detected);
+	} catch (e) {
+		io.stderr(`visaljs: ${e.message}\n`);
+		return 1;
+	}
 	const script = options.script === true;
 	const bundled = !script && options["no-bundle"] !== true;
 	let map;
 	if (bundled) try {
-		const b = await bundle(entry, hosts, (message) => io.stderr(`${message}\n`));
+		const b = await report.step("📦", "Rolling the modules into a single file", () => bundle(entry, hosts, (message) => report.note(message)), (b) => `Rolled ${count(b.modules, "module")} into a single file (${size(Buffer.byteLength(b.code))})`);
 		source = b.code;
 		if (b.map) map = new SourceMap(b.map, displayPath);
 	} catch (e) {
@@ -7852,30 +8301,30 @@ async function build(entry, options, io) {
 	}
 	let c;
 	try {
-		const ast = script ? parseScript(source, entry) : parseModule(source, map ? "bundle.js" : entry, map, resolve(entry), primitives);
+		const ast = await report.step("🌳", "Parsing the JavaScript", () => script ? parseScript(source, entry) : parseModule(source, map ? "bundle.js" : entry, map, resolve(entry), primitives), () => `Parsed ${count(lineCount(source), "line")} of JavaScript`);
 		if (options["dump-ast"]) {
 			io.stdout(JSON.stringify(ast, null, 2) + "\n");
 			return 0;
 		}
 		const info = analyze(ast);
 		const literals = regexpLiterals(ast);
-		const regexps = literals.length ? compileRegExps(findCompiler(), literals) : /* @__PURE__ */ new Map();
+		const regexps = literals.length ? await report.step("🧩", "Compiling the regular expressions", () => withCompiler(compilers ??= findCompilers(), report, (cc) => compileRegExps(cc, literals)), () => `Compiled ${count(literals.length, "regular expression")}`) : /* @__PURE__ */ new Map();
 		const unsupported = firstUnsupported(ast);
 		if (unsupported) throw unsupported;
-		const ir = optimize(lower(ast, info));
+		const ir = await report.step("🔧", "Converting to IR and optimizing", () => optimize(lower(ast, info)), (ir) => `Converted ${count(ir.functions.length + 1, "function")} to IR and optimized them`);
 		if (options["dump-ir"]) {
 			io.stdout(printModule(ir));
 			return 0;
 		}
 		const names = programNames(ast);
 		const all = options["all-builtins"] === true;
-		c = emitProgram(ir, {
+		c = await report.step("📝", "Emitting C code", () => emitProgram(ir, {
 			embedSource: options["embed-source"] === true,
 			components: (all ? COMPONENTS : reachableComponents(names)).map((c) => c.symbol),
 			core: all ? void 0 : namedCore(names),
 			regexps,
 			hostPrimitives: primitives
-		});
+		}), (c) => `Emitted ${count(lineCount(c), "line")} of C code (${size(Buffer.byteLength(c))})`);
 	} catch (e) {
 		if (!(e instanceof CompileError)) throw e;
 		io.stderr(`${e.message}\n`);
@@ -7885,18 +8334,28 @@ async function build(entry, options, io) {
 		mkdirSync(options["emit-c"], { recursive: true });
 		writeFileSync(join(options["emit-c"], "program.c"), c);
 		if (bundled) writeFileSync(join(options["emit-c"], "bundle.js"), source);
+		report.finish("📂", (time) => `Wrote ${displayPath(resolve(options["emit-c"], "program.c"))} in ${time}`);
 		return 0;
 	}
 	const output = options.output ?? basename(entry).replace(/\.[cm]?js$/, "");
+	const opt = options.debug ? ["-O0"] : ["-O2"];
 	const dir = scratchDir();
 	try {
 		const file = join(dir, "program.c");
 		writeFileSync(file, c);
-		compileProgram({
-			cc: findCompiler(),
-			opt: options.debug ? ["-O0"] : ["-O2"],
-			strip: !options.debug
-		}, file, output, hosts);
+		await withCompiler(compilers, report, async (cc) => {
+			const tc = {
+				cc,
+				opt,
+				strip: !options.debug
+			};
+			const built = [];
+			const archives = await report.step("📚", "Preparing the runtime libraries", () => programArchives(tc, hosts, (name) => {
+				built.push(`lib${name}`);
+				report.relabel(`Building lib${name} with ${describeCompiler(cc)} (first build only: it's cached after)`);
+			}), () => built.length ? `Built ${built.join(", ")} (cached for next time)` : "Runtime libraries ready (cached ⚡)");
+			await report.step("🔨", `Compiling with ${describeCompiler(cc)}`, () => compileProgram(tc, file, output, archives), () => `Compiled the binary with ${describeCompiler(cc)} (${opt.join(" ")}, ${tc.strip ? "stripped" : "with debug info"})`);
+		});
 	} catch (e) {
 		io.stderr(`visaljs: C compilation failed: ${e.message}\n`);
 		return 1;
@@ -7906,8 +8365,34 @@ async function build(entry, options, io) {
 			force: true
 		});
 	}
+	const bytes = statSync(output).size;
+	report.finish("🎉", (time) => `Built ${displayPath(resolve(output))} in ${time}: ${size(bytes)}, ${sizeQuip(bytes)}`);
 	return 0;
 }
+/** "Detected GCC 13.3.0", else the compilers numbered in the order they're tried, under the
+*  step's line (indented to its text). */
+function detected(compilers) {
+	const names = compilers.map(describeCompiler);
+	if (names.length === 1) return `Detected ${names[0]}${process.env.CC ? " (from $CC)" : ""}`;
+	return [`Detected ${count(names.length, "C compiler")} (tried in this order, falling back to the next if one fails):`, ...names.map((name, i) => `      ${i + 1}. ${name}`)].join("\n");
+}
+/** Runs `run` with each compiler in turn until one succeeds. A failure that isn't the
+*  program's (not a CompileError) is noted and moves on to the next; the compilers that failed
+*  are dropped, so later steps start with the one that worked. The last failure is rethrown. */
+async function withCompiler(compilers, report, run) {
+	for (;;) {
+		const cc = compilers[0];
+		try {
+			return await run(cc);
+		} catch (e) {
+			if (e instanceof CompileError || compilers.length === 1) throw e;
+			compilers.shift();
+			const reason = e.message.split("\n")[0];
+			const why = reason.startsWith("Command failed") ? "" : ` (${reason})`;
+			report.note(` ⚠ ${describeCompiler(cc)} failed${why}, trying ${describeCompiler(compilers[0])}`);
+		}
+	}
+}
 /** How diagnostics and #line name an original file: relative to the working directory when
 *  it's inside it, else absolute. Code the bundler generated keeps its own name. */
 function displayPath(source) {
@@ -7917,9 +8402,14 @@ function displayPath(source) {
 }
 //#endregion
 //#region cli/src/cli.ts
+const tty = process.stderr.isTTY === true;
 process.exitCode = await main(process.argv.slice(2), {
 	stdout: (text) => process.stdout.write(text),
-	stderr: (text) => process.stderr.write(text)
+	stderr: (text) => process.stderr.write(text),
+	report: {
+		live: tty,
+		color: tty && !process.env.NO_COLOR && process.env.TERM !== "dumb"
+	}
 });
 //#endregion
 export {};