visaljs 0.0.10 → 0.0.11

package/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { createRequire, isBuiltin } from "node:module";
 import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
+import { copyFileSync, 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, promisify } from "node:util";
 import { getHeapStatistics } from "node:v8";
 import ts from "typescript";
 import { RolldownMagicString, rolldown } from "rolldown";
-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
@@ -1359,6 +1359,8 @@ var Converter = class {
 			};
 		}
 		const object = this.expression(node.expression);
+		const element = this.unit?.arrayElement(node.expression);
+		const elem = element ? { elem: element } : {};
 		if (ts.isPropertyAccessExpression(node)) {
 			if (ts.isPrivateIdentifier(node.name)) return {
 				type: "MemberExpression",
@@ -1377,7 +1379,8 @@ var Converter = class {
 				loc,
 				object,
 				property: this.identifier(node.name),
-				computed: false
+				computed: false,
+				...elem
 			};
 		}
 		return {
@@ -1385,7 +1388,8 @@ var Converter = class {
 			loc,
 			object,
 			property: this.expression(node.argumentExpression),
-			computed: true
+			computed: true,
+			...elem
 		};
 	}
 	/** A property name: an identifier or literal naming the key, or a computed expression. */
@@ -2901,6 +2905,21 @@ const STATIC_TYPES = {
 		words: "null"
 	}
 };
+/** Each kind's elements' type, and its kind in C (JS_SARRAY_*). */
+const ARRAY_ELEMS = {
+	number: {
+		type: T.Int32 | T.Double,
+		c: "JS_SARRAY_NUMBER"
+	},
+	string: {
+		type: T.String,
+		c: "JS_SARRAY_STRING"
+	},
+	boolean: {
+		type: T.Boolean,
+		c: "JS_SARRAY_BOOLEAN"
+	}
+};
 /** A declared parameter's type as ERR_INVALID_ARG_TYPE words it: "of type string or undefined",
 *  "an instance of Float64Array". */
 function expectedText(t, view) {
@@ -3106,6 +3125,23 @@ const OPS = {
 		allocates: true
 	},
 	math: pure(1),
+	from_char_code: {
+		...pure(1),
+		allocates: true
+	},
+	array_get: generic(2),
+	array_set: {
+		...generic(3),
+		result: false
+	},
+	array_length: {
+		...generic(1),
+		callsUser: false
+	},
+	array_push: {
+		...generic(2),
+		callsUser: false
+	},
 	int_add: pure(2),
 	int_sub: pure(2),
 	int_mul: pure(2),
@@ -3463,6 +3499,10 @@ function isExceptionalEdge(from, to) {
 }
 //#endregion
 //#region ir/src/builder.ts
+/** A literal's type. */
+function literalType(value) {
+	return value === void 0 ? T.Undefined : value === null ? T.Null : typeof value === "boolean" ? T.Boolean : typeof value === "string" ? T.String : Number.isInteger(value) && Math.abs(value) <= 2147483647 && !Object.is(value, -0) ? T.Int32 : T.Double;
+}
 var FunctionBuilder = class {
 	fn;
 	current;
@@ -3579,10 +3619,9 @@ var FunctionBuilder = class {
 		return instr;
 	}
 	const(value) {
-		const type = value === void 0 ? T.Undefined : value === null ? T.Null : typeof value === "boolean" ? T.Boolean : typeof value === "string" ? T.String : Number.isInteger(value) && Math.abs(value) <= 2147483647 && !Object.is(value, -0) ? T.Int32 : T.Double;
 		return this.emit("const", [], {
 			lit: { value },
-			type
+			type: literalType(value)
 		});
 	}
 	writeVariable(key, value, block = this.current) {
@@ -3798,6 +3837,10 @@ function printFunction(fn) {
 			case "bigint": return `bigint ${i.bigint}n`;
 			case "switch_string": return `switch_string ${name(i.operands[0])}, ${JSON.stringify(i.cases)}`;
 			case "regexp": return `regexp /${i.regexp.pattern}/${i.regexp.flags}`;
+			case "array_get":
+			case "array_set":
+			case "array_length":
+			case "array_push": return `${i.op} ${i.elem}[] ${args}`;
 			case "template_object": return `template_object ${JSON.stringify(i.template.cooked)}, slot ${i.index}`;
 			case "import_meta": return `import_meta ${JSON.stringify(i.target)}, slot ${i.index}`;
 			case "dynamic_import": return `dynamic_import ${args}, from ${JSON.stringify(i.target)}`;
@@ -4052,6 +4095,12 @@ function calleeText(e) {
 		default: return "(intermediate value)";
 	}
 }
+/** `a.push(v)` of a static array: one argument, no spread. */
+function isArrayPush(callee, e) {
+	return callee.elem !== void 0 && !callee.computed && callee.property.name === "push" && e.arguments.length === 1 && e.arguments[0].type !== "SpreadElement";
+}
+/** A static array's element kind in the IR: an i32[]'s elements are Numbers its code converts. */
+const irElem = (elem) => elem === "i32" ? "number" : elem;
 function isConst(key) {
 	return !("op" in key);
 }
@@ -4824,6 +4873,7 @@ var FunctionLowering = class {
 			case "UpdateExpression": return this.isInt(e.argument);
 			case "BinaryExpression": return INT_OPERATORS.has(e.operator) && this.isInt(e.left) && this.isInt(e.right);
 			case "AssignmentExpression": return e.target.type === "Identifier" && this.isInt(e.target);
+			case "MemberExpression": return e.computed && e.elem === "i32";
 			case "ConditionalExpression": return this.isInt(e.consequent) && this.isInt(e.alternate);
 			case "CallExpression": return e.callee.type === "Identifier" && declared(e.callee)?.returnsInt !== void 0;
 			default: return false;
@@ -5754,9 +5804,10 @@ var FunctionLowering = class {
 			};
 		}
 		const p = e.property;
+		const elem = e.type === "MemberExpression" && e.elem && !(e.computed && p.type === "Literal" && typeof p.value === "string") ? { elem: e.elem } : {};
 		let key;
 		if (!e.computed) key = propKey(p.name);
-		else if (p.type === "Literal" && (typeof p.value === "string" || typeof p.value === "number")) key = propKey(p.value);
+		else if (p.type === "Literal" && (typeof p.value === "string" || typeof p.value === "number") && !elem.elem) key = propKey(p.value);
 		else key = this.expression(p);
 		return superCallee ? {
 			obj,
@@ -5764,7 +5815,8 @@ var FunctionLowering = class {
 			superCallee
 		} : {
 			obj,
-			key
+			key,
+			...elem
 		};
 	}
 	getMember(ref) {
@@ -5777,6 +5829,11 @@ var FunctionLowering = class {
 				ref.key
 			]);
 		}
+		if (ref.elem && !isConst(ref.key)) {
+			const v = this.b.emit("array_get", [ref.obj, ref.key], { elem: irElem(ref.elem) });
+			return ref.elem === "i32" ? this.toInt(v, "i32") : v;
+		}
+		if (ref.elem && "name" in ref.key && ref.key.name === "length") return this.b.emit("array_length", [ref.obj], { elem: irElem(ref.elem) });
 		if (isConst(ref.key)) return this.b.emit("get_prop", [ref.obj], { key: ref.key });
 		return this.b.emit("get_elem", [ref.obj, ref.key]);
 	}
@@ -5803,7 +5860,12 @@ var FunctionLowering = class {
 			]);
 			return;
 		}
-		if (isConst(ref.key)) this.b.emit("set_prop", [ref.obj, value], { key: ref.key });
+		if (ref.elem && !isConst(ref.key)) this.b.emit("array_set", [
+			ref.obj,
+			ref.key,
+			ref.elem === "i32" ? this.toInt(value, "i32") : value
+		], { elem: irElem(ref.elem) });
+		else if (isConst(ref.key)) this.b.emit("set_prop", [ref.obj, value], { key: ref.key });
 		else this.b.emit("set_elem", [
 			ref.obj,
 			ref.key,
@@ -6046,6 +6108,12 @@ var FunctionLowering = class {
 	call(e) {
 		const b = this.b;
 		const callee = e.callee;
+		if (callee.type === "MemberExpression" && isArrayPush(callee, e)) {
+			const obj = this.expression(callee.object);
+			const v = this.expression(e.arguments[0]);
+			b.loc = e.loc;
+			return b.emit("array_push", [obj, callee.elem === "i32" ? this.toInt(v, "i32") : v], { elem: irElem(callee.elem) });
+		}
 		if (callee.type === "MemberExpression" || callee.type === "SuperMember") {
 			const ref = this.memberRef(callee);
 			b.loc = callee.loc;
@@ -7040,6 +7108,13 @@ var FunctionEmitter = class {
 		const value = i.operands[2];
 		return i.taView === "f64" && value.repr === "f64" ? `js_tav_put_f64${suffix}(ctx, ${view}, ${args[0]}, ${k}, ${this.as(value, "f64")}, ${strict})` : `js_tav_set_${i.taView}${suffix}(ctx, ${view}, ${args[0]}, ${k}, ${args[2]}, ${strict})`;
 	}
+	/** A static array's index, an int64_t: -1 for a Number that isn't an index. */
+	arrayIndex(key) {
+		if (key.op === "const" && Number.isSafeInteger(key.lit.value) && key.lit.value >= 0) return this.as(key, "i64");
+		if (key.repr === "i32" || key.repr === "i64") return `(int64_t)${this.as(key, key.repr)}`;
+		if (key.repr === "f64") return `js_sarray_index_f64(${this.as(key, "f64")})`;
+		return `js_sarray_index(${this.v(key)})`;
+	}
 	/** A double read of a Float64Array's view: false from the access is an exception. */
 	readDouble(i, args) {
 		this.lines.push(`    { double d; if (JS_UNLIKELY(!${this.viewAccess(i, args)})) { ${this.onException(i.block)} }`, this.hasVar(i) ? `    ${this.name(i)} = ${convert("d", "f64", i.repr)}; }` : "    }");
@@ -7415,6 +7490,23 @@ var FunctionEmitter = class {
 			case "construct_direct":
 				this.constructDirect(i, args);
 				return;
+			case "from_char_code": {
+				const c = i.operands[0];
+				expr = `js_from_char_code_unit(ctx, (uint16_t)${c.repr === "i32" || c.repr === "i64" ? this.as(c, c.repr) : `js_f64_to_int32(${this.as(c, "f64")})`})`;
+				break;
+			}
+			case "array_get":
+				expr = `js_sarray_get(ctx, ${args[0]}, ${this.arrayIndex(i.operands[1])}, ${ARRAY_ELEMS[i.elem].c})`;
+				break;
+			case "array_set":
+				status = `js_sarray_set(ctx, ${args[0]}, ${this.arrayIndex(i.operands[1])}, ${args[2]}, ${ARRAY_ELEMS[i.elem].c})`;
+				break;
+			case "array_length":
+				expr = `js_sarray_length(ctx, ${args[0]})`;
+				break;
+			case "array_push":
+				expr = `js_sarray_push(ctx, ${args[0]}, ${args[1]}, ${ARRAY_ELEMS[i.elem].c})`;
+				break;
 			case "math": {
 				const f = {
 					sqrt: "sqrt",
@@ -8589,6 +8681,7 @@ const REMOVABLE = /* @__PURE__ */ new Set([
 	"construct_result",
 	"char_code_at",
 	"math",
+	"from_char_code",
 	"int_add",
 	"int_sub",
 	"int_mul",
@@ -8781,13 +8874,13 @@ function inlineBuiltin(i) {
 	return null;
 }
 /** What typed code ("use static", which trusts the built-ins to be the standard ones) makes of a
-*  built-in call: s.charCodeAt(i) of a string, or Math's sqrt/abs/floor/ceil/trunc of a Number,
-*  the C helper's suffix; null for anything else. `type`: the values' types. */
+*  built-in call: s.charCodeAt(i) of a string, or Math's sqrt/abs/floor/ceil/trunc or
+*  String.fromCharCode of a Number, the C helper's suffix; null for anything else. `type`: the values' types. */
 function trustedBuiltin(i, type) {
 	if (!isStatic(i.block.fn)) return null;
 	const name = inlineBuiltin(i);
 	if (name === "char_code_at") return isSubtype(type(i.operands[1]), T.String) ? name : null;
-	if (name?.startsWith("math_")) return isSubtype(type(i.operands[2]), Number_) ? name : null;
+	if (name?.startsWith("math_") || name === "from_char_code") return isSubtype(type(i.operands[2]), Number_) ? name : null;
 	return null;
 }
 /** The bitwise operators: ToInt32 (ToUint32) of their operands first. */
@@ -8922,6 +9015,9 @@ const specialize = {
 					if (trusted === "char_code_at") {
 						i.op = "char_code_at";
 						i.operands = [i.operands[1], i.operands[2]];
+					} else if (trusted === "from_char_code") {
+						i.op = "from_char_code";
+						i.operands = [i.operands[2]];
 					} else {
 						i.op = "math";
 						i.target = trusted.slice(5);
@@ -9276,6 +9372,10 @@ function transfer(i, type, sig, bound = null) {
 			if (readsDouble(i)) return T.Int32 | T.Double;
 			if (i.taView && isStatic(i.block.fn)) return T.Int32 | T.Undefined;
 			return Unknown;
+		case "array_get": return ARRAY_ELEMS[i.elem].type;
+		case "array_length":
+		case "array_push": return T.Int32;
+		case "from_char_code": return T.String;
 		case "char_code_at":
 		case "math": return Number_;
 		case "int_add":
@@ -9668,6 +9768,7 @@ function constructorSlots(fn) {
 const promoteGlobals = {
 	name: "promote-globals",
 	run(m, count) {
+		if (isStatic(m.main)) count("folded", "constant", foldConstants(m));
 		const shared = /* @__PURE__ */ new Set();
 		for (const fn of functionsOf(m)) for (const b of fn.blocks) for (const i of b.instrs) if ((i.op === "load_global" || i.op === "store_global") && fn !== m.main || i.op === "template_object" || i.op === "import_meta") shared.add(i.index);
 		const slots = /* @__PURE__ */ new Set();
@@ -9766,6 +9867,44 @@ function promote(fn, slots, m) {
 	removeInstrs(fn, dead);
 	return slots.size;
 }
+/** A stored value that is a literal: a const, or an integer literal an int (i32) binding converts
+*  to itself. */
+function literal(v) {
+	if (v.op === "const") return v.lit.value;
+	const c = v.operands[0];
+	if (c?.op !== "const" || typeof c.lit.value !== "number") return NOT_LITERAL;
+	const n = c.lit.value;
+	if (v.op === "to_i64" && Number.isSafeInteger(n)) return n;
+	if (v.op === "to_i32" && (n | 0) === n) return n;
+	return NOT_LITERAL;
+}
+const NOT_LITERAL = Symbol("not a literal");
+/** Static code's constant module bindings, as literals in the functions that read them. */
+function foldConstants(m) {
+	const stores = /* @__PURE__ */ new Map();
+	for (const fn of functionsOf(m)) for (const b of fn.blocks) for (const i of b.instrs) if (i.op === "store_global" && i.operands[0].op !== "empty") stores.set(i.index, (stores.get(i.index) ?? 0) + 1);
+	const constants = /* @__PURE__ */ new Map();
+	for (const i of m.main.blocks[0].instrs) {
+		if (OPS[i.op].callsUser) break;
+		if (i.op !== "store_global" || stores.get(i.index) !== 1) continue;
+		const value = literal(i.operands[0]);
+		if (value !== NOT_LITERAL) constants.set(i.index, value);
+	}
+	let folded = 0;
+	for (const fn of m.functions) for (const b of fn.blocks) for (const i of b.instrs) {
+		if (i.op !== "load_global" || !constants.has(i.index)) continue;
+		const value = constants.get(i.index);
+		Object.assign(i, {
+			op: "const",
+			operands: [],
+			lit: { value },
+			type: literalType(value),
+			index: void 0
+		});
+		folded++;
+	}
+	return folded;
+}
 //#endregion
 //#region optimizer/src/simplify.ts
 const NUMERIC = /* @__PURE__ */ new Set([
@@ -10883,6 +11022,7 @@ 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 CARES = join(DIR, "third_party", "c-ares");
 const INCLUDE = join(DIR, "include");
 const files$1 = (dir, ext) => readdirSync(dir).filter((f) => f.endsWith(ext)).map((f) => join(dir, f));
 /** Prelude modules may import "visaljs:host". */
@@ -10911,6 +11051,7 @@ const modules = {
 	inspector: join(preludeDir, "inspector.js"),
 	"inspector/promises": join(preludeDir, "inspector_promises.js"),
 	module: join(preludeDir, "module.js"),
+	dgram: join(preludeDir, "dgram.js"),
 	net: join(preludeDir, "net.js"),
 	os: join(preludeDir, "os.js"),
 	path: join(preludeDir, "path.js"),
@@ -10926,6 +11067,7 @@ const modules = {
 	sea: join(preludeDir, "sea.js"),
 	stream: join(preludeDir, "stream.js"),
 	_http_agent: join(preludeDir, "_http_agent.js"),
+	_http_common: join(preludeDir, "_http_common.js"),
 	_http_server: join(preludeDir, "_http_server.js"),
 	_stream_duplex: join(preludeDir, "_stream_duplex.js"),
 	_stream_passthrough: join(preludeDir, "_stream_passthrough.js"),
@@ -10968,6 +11110,14 @@ const implicitModules = [
 		file: join(preludeDir, "internal", "process_stdio.js"),
 		reached: (_code, program) => /\b(?:stdout|stderr)\b/.test(program) && STDIO_STREAM_USE.test(program)
 	},
+	{
+		file: join(preludeDir, "internal", "console_global.js"),
+		reached: (_code, program) => STDIO_WRITE_REPLACED.test(program)
+	},
+	{
+		file: join(preludeDir, "internal", "console_class.js"),
+		reached: (_code, program) => /\bConsole\b/.test(program)
+	},
 	{
 		file: join(preludeDir, "internal", "process_stdin.js"),
 		reached: (_code, program) => /\bstdin\b/.test(program)
@@ -11014,7 +11164,7 @@ const implicitModules = [
 	},
 	{
 		file: join(preludeDir, "internal", "events_on.js"),
-		reached: (_code, program) => EVENTS_ON.test(program)
+		reached: (_code, program) => EVENTS_ON.test(program) || /readline|readLines|createInterface/i.test(program) && /\bfor\s+await\b|\basyncIterator\b/.test(program)
 	},
 	{
 		file: join(preludeDir, "internal", "stream_compose.js"),
@@ -11104,6 +11254,18 @@ const implicitModules = [
 		file: join(preludeDir, "internal", "fs_filehandle.js"),
 		reached: (_code, program) => FS_OPEN.test(program) || /\bFileHandle\b/.test(program) || /\bpromises\b/.test(program) && /\.\s*open\s*\(/.test(program)
 	},
+	{
+		file: join(preludeDir, "internal", "readline_editor.js"),
+		reached: (_code, program) => READLINE_EDITOR.test(program) || /readline|createInterface/i.test(program) && /\b(?:stdin|terminal)\b/.test(program)
+	},
+	{
+		file: join(preludeDir, "internal", "dns_resolver.js"),
+		reached: (_code, program) => DNS_RESOLVER.test(program) || DNS_RESOLVE_RRTYPE.test(program) || DNS_MODULE_RESOLVE.test(program)
+	},
+	{
+		file: join(preludeDir, "internal", "crypto_x509.js"),
+		reached: (_code, program) => /\b(?:X509Certificate|get(?:Peer)?X509Certificate)\b/.test(program)
+	},
 	{
 		file: join(preludeDir, "internal", "process_more.js"),
 		reached: (_code, program) => PROCESS_MORE.test(program)
@@ -11147,6 +11309,11 @@ const implicitModules = [
 ];
 const FETCH = /(?<![.\w$#])fetch\s*\(|[=(,]\s*fetch\s*[;,)\n]|\btypeof\s+fetch\b|\b(?:globalThis|global|self)\s*(?:\.\s*fetch\b|\[\s*["'`]fetch["'`])/;
 const STREAM_OPERATORS = /\.\s*(?:flatMap|toArray|drop|take|asIndexedPairs)\s*\(|\bReadable\b[\s\S]*\.\s*(?:map|filter|forEach|reduce|some|every|find)\s*\(/;
+const DNS_RESOLVER = /\b(?:Resolver|resolve(?:4|6|Any|Caa|Cname|Mx|Naptr|Ns|Ptr|Soa|Srv|Tlsa|Txt)|getServers|setServers|setLocalAddress)\b/;
+const READLINE_EDITOR = /\b(?:emitKeypressEvents|setRawMode|keypress|completer)\b/;
+const DNS_MODULE_RESOLVE = /\b(?:dns|dns_default|require_dns\(\))\s*\.\s*(?:promises\s*\.\s*)?(?:resolve|reverse)\b/;
+const DNS_RESOLVE_RRTYPE = /\.\s*resolve\s*\([^,()]+,\s*["'`](?:A|AAAA|ANY|CAA|CNAME|MX|NAPTR|NS|PTR|SOA|SRV|TLSA|TXT)["'`]/;
+const STDIO_WRITE_REPLACED = /\b(?:stdout|stderr|stream)\s*\.\s*write\s*=(?![=>])|\b_std(?:out|err)\s*=(?!=)|\b(?:channel|subscribe)\s*\(\s*["'`]console\.(?:log|info|debug|warn|error)["'`]/;
 const STDIO_STREAM_USE = /\.\s*(?:pipe|on|once|end|cork|uncork|destroy|removeListener|addListener|prependListener)\s*\(|\b(?:pipeline|finished)\b|\bwritable(?:Length|HighWaterMark|NeedDrain|Ended|Finished)\b/;
 const PROCESS_DISTINCT = "chdir|umask|uptime|cpuUsage|threadCpuUsage|resourceUsage|availableMemory|constrainedMemory|setuid|setgid|seteuid|setegid|getgroups|setgroups|initgroups|reallyExit|execve|getBuiltinModule|loadEnvFile|hasUncaughtExceptionCaptureCallback|setUncaughtExceptionCaptureCallback|allowedNodeEnvironmentFlags|setSourceMapsEnabled|sourceMapsEnabled|getActiveResourcesInfo|moduleLoadList|openStdin|debugPort|dlopen";
 const PROCESS_COMMON = "title|ppid|release|config|ref|unref|abort|report|domain|assert|binding|finalization";
@@ -11423,10 +11590,6 @@ const primitives = {
 		c: "js_host_os_homedir",
 		length: 0
 	},
-	osTmpdir: {
-		c: "js_host_os_tmpdir",
-		length: 0
-	},
 	osMemory: {
 		c: "js_host_os_memory",
 		length: 0
@@ -11495,6 +11658,10 @@ const primitives = {
 		c: "js_util_inspect",
 		length: 2
 	},
+	previewEntries: {
+		c: "js_host_preview_entries",
+		length: 2
+	},
 	utilFormat: {
 		c: "js_util_format",
 		length: 0
@@ -11715,6 +11882,26 @@ const primitives = {
 		c: "js_tls_context_set_key",
 		length: 2
 	},
+	tlsContextAddCredential: {
+		c: "js_tls_context_add_credential",
+		length: 3
+	},
+	tlsContextAllowPartialChain: {
+		c: "js_tls_context_allow_partial_chain",
+		length: 1
+	},
+	tlsContextTicketKeys: {
+		c: "js_tls_context_ticket_keys",
+		length: 2
+	},
+	tlsContextSetSessions: {
+		c: "js_tls_context_set_sessions",
+		length: 3
+	},
+	tlsPkcs12: {
+		c: "js_tls_pkcs12",
+		length: 2
+	},
 	tlsRootCertificates: {
 		c: "js_tls_root_certificates",
 		length: 0
@@ -11723,6 +11910,18 @@ const primitives = {
 		c: "js_tls_ciphers",
 		length: 0
 	},
+	x509Check: {
+		c: "js_x509_check",
+		length: 4
+	},
+	x509CheckIssued: {
+		c: "js_x509_check_issued",
+		length: 2
+	},
+	x509CheckKey: {
+		c: "js_x509_check_key",
+		length: 2
+	},
 	tlsNew: {
 		c: "js_tls_new",
 		length: 7
@@ -11751,6 +11950,10 @@ const primitives = {
 		c: "js_tls_session",
 		length: 1
 	},
+	tlsTicket: {
+		c: "js_tls_ticket",
+		length: 1
+	},
 	tlsExportKeyingMaterial: {
 		c: "js_tls_export_keying_material",
 		length: 4
@@ -11759,6 +11962,14 @@ const primitives = {
 		c: "js_tls_set_no_renegotiation",
 		length: 1
 	},
+	tlsEnableKeylog: {
+		c: "js_tls_enable_keylog",
+		length: 1
+	},
+	tlsSetMaxSendFragment: {
+		c: "js_tls_set_max_send_fragment",
+		length: 2
+	},
 	tlsFinished: {
 		c: "js_tls_finished",
 		length: 2
@@ -11787,6 +11998,10 @@ const primitives = {
 		c: "js_host_http_pending",
 		length: 1
 	},
+	httpWritten: {
+		c: "js_host_http_written",
+		length: 1
+	},
 	httpWatchDrain: {
 		c: "js_host_http_watch_drain",
 		length: 1
@@ -11819,6 +12034,94 @@ const primitives = {
 		c: "js_host_http_date",
 		length: 0
 	},
+	udpOpen: {
+		c: "js_host_udp_open",
+		length: 1
+	},
+	udpOpenFd: {
+		c: "js_host_udp_open_fd",
+		length: 2
+	},
+	udpFd: {
+		c: "js_host_udp_fd",
+		length: 1
+	},
+	udpBind: {
+		c: "js_host_udp_bind",
+		length: 4
+	},
+	udpConnect: {
+		c: "js_host_udp_connect",
+		length: 3
+	},
+	udpDisconnect: {
+		c: "js_host_udp_disconnect",
+		length: 1
+	},
+	udpSend: {
+		c: "js_host_udp_send",
+		length: 4
+	},
+	udpSendQueue: {
+		c: "js_host_udp_send_queue",
+		length: 2
+	},
+	udpRecvStart: {
+		c: "js_host_udp_recv_start",
+		length: 1
+	},
+	udpRecvStop: {
+		c: "js_host_udp_recv_stop",
+		length: 1
+	},
+	udpAddress: {
+		c: "js_host_udp_address",
+		length: 2
+	},
+	udpSetBroadcast: {
+		c: "js_host_udp_set_broadcast",
+		length: 2
+	},
+	udpSetTTL: {
+		c: "js_host_udp_set_ttl",
+		length: 2
+	},
+	udpSetMulticastTTL: {
+		c: "js_host_udp_set_multicast_ttl",
+		length: 2
+	},
+	udpSetMulticastLoopback: {
+		c: "js_host_udp_set_multicast_loopback",
+		length: 2
+	},
+	udpSetMulticastInterface: {
+		c: "js_host_udp_set_multicast_interface",
+		length: 2
+	},
+	udpMembership: {
+		c: "js_host_udp_membership",
+		length: 4
+	},
+	udpSourceMembership: {
+		c: "js_host_udp_source_membership",
+		length: 5
+	},
+	udpBufferSize: {
+		c: "js_host_udp_buffer_size",
+		length: 3
+	},
+	udpClose: {
+		c: "js_host_udp_close",
+		length: 1
+	},
+	udpRef: {
+		c: "js_host_udp_ref",
+		length: 2
+	},
+	udpHasRef: {
+		c: "js_host_udp_has_ref",
+		length: 1
+	},
 	netOpen: {
 		c: "js_host_net_open",
 		length: 2
@@ -11911,6 +12214,46 @@ const primitives = {
 		c: "js_host_dns_lookup",
 		length: 3
 	},
+	dnsLookupService: {
+		c: "js_host_dns_lookup_service",
+		length: 3
+	},
+	dnsChannel: {
+		c: "js_host_dns_channel",
+		length: 3
+	},
+	dnsQuery: {
+		c: "js_host_dns_query",
+		length: 4
+	},
+	dnsReverse: {
+		c: "js_host_dns_reverse",
+		length: 3
+	},
+	dnsParse: {
+		c: "js_host_dns_parse",
+		length: 2
+	},
+	dnsGetServers: {
+		c: "js_host_dns_get_servers",
+		length: 1
+	},
+	dnsSetServers: {
+		c: "js_host_dns_set_servers",
+		length: 2
+	},
+	dnsSetLocalAddress: {
+		c: "js_host_dns_set_local_address",
+		length: 3
+	},
+	dnsCancel: {
+		c: "js_host_dns_cancel",
+		length: 1
+	},
+	dnsStrerror: {
+		c: "js_host_dns_strerror",
+		length: 1
+	},
 	zlibNew: {
 		c: "js_host_zlib_new",
 		length: 1
@@ -12082,6 +12425,21 @@ const UV_PLATFORM = {
 		]
 	}
 };
+const CARES_DIRS = [
+	"",
+	"dsa",
+	"event",
+	"legacy",
+	"record",
+	"str",
+	"util"
+].map((d) => join(CARES, "src", "lib", d));
+const CARES_CONFIG = {
+	linux: "linux",
+	darwin: "darwin",
+	freebsd: "freebsd",
+	openbsd: "openbsd"
+};
 const BROTLI_OS = {
 	linux: "OS_LINUX",
 	darwin: "OS_MACOSX",
@@ -12105,6 +12463,13 @@ function libraries(runtimeInclude, platform = process.platform) {
 		"compress",
 		"decompress"
 	].flatMap((d) => files$1(join(ZSTD, d), ".h"));
+	const caresHeaders = [
+		...files$1(join(CARES, "include"), ".h"),
+		...CARES_DIRS.flatMap((d) => files$1(d, ".h")),
+		...files$1(join(CARES, "src", "lib", "include"), ".h"),
+		...files$1(join(CARES, "src", "lib", "thirdparty", "apple"), ".h"),
+		...CARES_CONFIG[platform] ? files$1(join(CARES, "config", CARES_CONFIG[platform]), ".h") : []
+	];
 	const uvHeaders = [
 		join(UV, "include"),
 		join(UV, "include", "uv"),
@@ -12123,7 +12488,8 @@ function libraries(runtimeInclude, platform = process.platform) {
 				...uvHeaders,
 				...zlibHeaders,
 				...brotliHeaders,
-				...zstdHeaders
+				...zstdHeaders,
+				...caresHeaders
 			],
 			flags: [
 				`-I${INCLUDE}`,
@@ -12132,7 +12498,10 @@ function libraries(runtimeInclude, platform = process.platform) {
 				`-I${join(UV, "include")}`,
 				`-I${ZLIB}`,
 				`-I${join(BROTLI, "include")}`,
-				`-I${ZSTD}`
+				`-I${ZSTD}`,
+				`-I${join(CARES, "include")}`,
+				"-DCARES_STATICLIB",
+				"-DCARES_NO_DEPRECATED"
 			]
 		},
 		{
@@ -12176,6 +12545,32 @@ function libraries(runtimeInclude, platform = process.platform) {
 				`-I${ZSTD}`
 			]
 		},
+		{
+			name: "cares",
+			sources: CARES_DIRS.flatMap((d) => files$1(d, ".c")),
+			headers: caresHeaders,
+			flags: [
+				"-std=gnu11",
+				"-w",
+				"-DCARES_STATICLIB",
+				"-D_LARGEFILE_SOURCE",
+				"-D_FILE_OFFSET_BITS=64",
+				...platform === "win32" ? ["-DCARES_PULL_WS2TCPIP_H=1", "-D_WINSOCK_DEPRECATED_NO_WARNINGS"] : [
+					"-DHAVE_CONFIG_H",
+					"-D_GNU_SOURCE",
+					"-D_DARWIN_USE_64_BIT_INODE=1"
+				],
+				...CARES_CONFIG[platform] ? [`-I${join(CARES, "config", CARES_CONFIG[platform])}`] : [],
+				`-I${join(CARES, "include")}`,
+				`-I${join(CARES, "src", "lib")}`,
+				`-I${join(CARES, "src", "lib", "include")}`
+			],
+			link: platform === "win32" ? [
+				"ws2_32",
+				"iphlpapi",
+				"advapi32"
+			] : []
+		},
 		{
 			name: "uv",
 			sources: uvSources,
@@ -12233,6 +12628,12 @@ const notices$1 = [
 		license: "BSD-3-Clause",
 		files: [join(ZSTD, "LICENSE")]
 	},
+	{
+		name: "c-ares",
+		what: "dns.Resolver's DNS queries",
+		license: "MIT",
+		files: [join(CARES, "LICENSE.md")]
+	},
 	{
 		name: "punycode.js",
 		what: "node:punycode",
@@ -12290,10 +12691,15 @@ const INT_PARAMETERS = {
 function declaredSignatures(checker, sf, out) {
 	for (const st of sf.statements) {
 		if (!ts.isFunctionDeclaration(st) || !st.name) continue;
+		const arrays = [];
 		const types = st.parameters.map((p) => {
 			const kind = intKind(checker, p.type);
 			if (kind) return INT_PARAMETERS[kind];
 			const type = checker.getTypeAtLocation(p);
+			if (checker.isArrayType(type)) {
+				arrays.push(p);
+				return T.Object;
+			}
 			const t = irType(type);
 			if (t === null) throw compileError(p, `parameter '${p.name.getText(sf)}' of '${st.name.text}': ${checker.typeToString(type)} isn't a static type yet`);
 			return t;
@@ -12301,7 +12707,8 @@ function declaredSignatures(checker, sf, out) {
 		const views = st.parameters.map((p) => viewOf(checker.getTypeAtLocation(p).getSymbol()?.name ?? ""));
 		out.set(locKey(st), {
 			types,
-			views
+			views,
+			arrays
 		});
 	}
 }
@@ -12328,6 +12735,56 @@ function irType(t) {
 	if (name) return STATIC_TYPES[name].type;
 	return viewOf(t.getSymbol()?.name ?? "") ? T.Object : null;
 }
+/** The primitive every part of a type is (its literals too), by the name an array's element kind has. */
+function primitiveOf(t) {
+	const parts = t.isUnion() ? t.types : [t];
+	for (const [flags, name] of [
+		[ts.TypeFlags.NumberLike, "number"],
+		[ts.TypeFlags.StringLike, "string"],
+		[ts.TypeFlags.BooleanLike, "boolean"]
+	]) if (parts.every((p) => p.flags & flags)) return name;
+}
+/** The element type an array type annotation writes (T[], Array<T>, readonly T[], an alias of one). */
+function elementNode(checker, node) {
+	if (!node) return void 0;
+	if (ts.isArrayTypeNode(node)) return node.elementType;
+	if (ts.isTypeOperatorNode(node) || ts.isParenthesizedTypeNode(node)) return elementNode(checker, node.type);
+	if (!ts.isTypeReferenceNode(node)) return void 0;
+	const name = node.typeName.getText();
+	if ((name === "Array" || name === "ReadonlyArray") && node.typeArguments?.length === 1) return node.typeArguments[0];
+	let symbol = checker.getSymbolAtLocation(node.typeName);
+	if (symbol && symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+	const declaration = symbol?.declarations?.[0];
+	return declaration && ts.isTypeAliasDeclaration(declaration) ? elementNode(checker, declaration.type) : void 0;
+}
+/** The array type annotation an expression's value was declared with, if one says: a variable's
+*  or parameter's (or its initializer's), a call's declared return type, a cast's. */
+function declaredArrayType(checker, node) {
+	if (ts.isParenthesizedExpression(node) || ts.isNonNullExpression(node)) return declaredArrayType(checker, node.expression);
+	if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) return node.type;
+	if (ts.isCallExpression(node)) {
+		const declaration = checker.getResolvedSignature(node)?.getDeclaration();
+		return declaration && !ts.isJSDocSignature(declaration) ? declaration.type : void 0;
+	}
+	if (!ts.isIdentifier(node)) return void 0;
+	const declaration = checker.getSymbolAtLocation(node)?.valueDeclaration;
+	if (!declaration || !(ts.isVariableDeclaration(declaration) || ts.isParameter(declaration))) return void 0;
+	if (declaration.type) return declaration.type;
+	return declaration.initializer ? declaredArrayType(checker, declaration.initializer) : void 0;
+}
+/** The element kind of the array `node` is, if it is one: number, i32 (the annotation names it:
+*  tsc erases it to number), string, boolean; an array of anything else is an error. */
+function arrayElement(checker, node) {
+	const type = checker.getTypeAtLocation(node);
+	if (!checker.isArrayType(type)) return void 0;
+	const element = checker.getTypeArguments(type)[0];
+	const kind = primitiveOf(element);
+	if (!kind) throw compileError(node, `static code doesn't have arrays of ${checker.typeToString(element)} yet`);
+	if (kind !== "number") return kind;
+	const int = intKind(checker, elementNode(checker, declaredArrayType(checker, node)));
+	if (int === "i64") throw compileError(node, "static code doesn't have int[] yet: an i32[], or a number[]");
+	return int ?? "number";
+}
 //#endregion
 //#region cli/src/static/link.ts
 /** A file's name in locations, as the program's: relative to the working directory. */
@@ -12420,7 +12877,8 @@ function linkUnit(program, files, hostPrimitives) {
 		},
 		linked: (node) => importedFile(checker, node, fileSet) !== void 0,
 		fileName,
-		intKind: (type) => intKind(checker, type)
+		intKind: (type) => intKind(checker, type),
+		arrayElement: (node) => arrayElement(checker, node)
 	};
 	const exports = /* @__PURE__ */ new Map();
 	const exportedFrom = /* @__PURE__ */ new Map();
@@ -12892,7 +13350,7 @@ function findCompilers() {
 		"gcc",
 		"zig cc"
 	]) {
-		const path = onPath(command(cc)[0]);
+		const path = onPath(compilerCommand(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)");
@@ -12915,24 +13373,29 @@ 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) {
+/** The link's flags that write its map to `file`: ld64's, the format size.ts reads. */
+const linkMapFlags = (file) => [`-Wl,-map,${file}`];
+/** A compiler's command line, split like make splits $(CC): "zig cc", "ccache gcc". Zig gets
+*  -mcpu=baseline unless $(CC) names a CPU: its default is this machine's CPU, so what it builds
+*  (a cached library, a program shipped elsewhere) would crash on an older one. */
+function compilerCommand(cc) {
 	const [program = cc, ...args] = cc.trim().split(/\s+/);
+	if (/^zig(\.exe)?$/i.test(basename(program)) && !args.some((a) => /^-m(cpu|arch)=/.test(a))) args.push("-mcpu=baseline");
 	return [program, ...args];
 }
 function runCompiler(cc, args, options) {
-	const [program, ...prefix] = command(cc);
+	const [program, ...prefix] = compilerCommand(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]));
+	return /^zig(\.exe)?$/i.test(basename(compilerCommand(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()}`;
+		return `Zig ${execFileSync(compilerCommand(cc)[0], ["version"], { encoding: "utf8" }).trim()}`;
 	} catch {
 		return cc;
 	}
@@ -12964,7 +13427,7 @@ function libraryArchive(tc, lib, building) {
 	const prebuilt = prebuiltArchive(tc, lib);
 	if (prebuilt) return prebuilt;
 	const hash = createHash("sha256");
-	hash.update(`${tc.cc}\n${compilerVersion(tc.cc)}\n${[
+	hash.update(`${compilerCommand(tc.cc).join(" ")}\n${compilerVersion(tc.cc)}\n${[
 		...COMMON,
 		...CXX,
 		...tc.opt,
@@ -13010,7 +13473,7 @@ function buildArchive(cc, lib, archive, { common = COMMON, flags = [], arFlags =
 		"-o",
 		join(objects, outputs[i])
 	]));
-	const [ar, ...arPrefix] = isZig(cc) ? [command(cc)[0], "ar"] : ["ar"];
+	const [ar, ...arPrefix] = isZig(cc) ? [compilerCommand(cc)[0], "ar"] : ["ar"];
 	execFileSync(ar, [
 		...arPrefix,
 		...arFlags,
@@ -13038,8 +13501,8 @@ const cxx = (common) => [
 ];
 const CXX = cxx(COMMON);
 function compileCommand(cc, src, common) {
-	if (!src.endsWith(".cc")) return [...command(cc), ...common];
-	const cmd = command(cc);
+	if (!src.endsWith(".cc")) return [...compilerCommand(cc), ...common];
+	const cmd = compilerCommand(cc);
 	if (isZig(cc)) return [...cmd.map((w) => w === "cc" ? "c++" : w), ...cxx(common)];
 	return [
 		...cmd,
@@ -13131,7 +13594,7 @@ function regexpCompiler(cc) {
 		join(RUNTIME_DIR, "src", "regexp_anchor.h"),
 		...readdirSync(regexp).filter((f) => f.endsWith(".h")).map((f) => join(regexp, f))
 	];
-	const hash = createHash("sha256").update(`${cc}\n`);
+	const hash = createHash("sha256").update(`${compilerCommand(cc).join(" ")}\n`);
 	for (const f of [...sources, ...headers]) hash.update(f.slice(RUNTIME_DIR.length)).update(readFileSync(f));
 	const tool = join(cacheRoot(), `regexp-compile-${hash.digest("hex").slice(0, 16)}${process.platform === "win32" ? ".exe" : ""}`);
 	if (existsSync(tool)) return tool;
@@ -13156,14 +13619,18 @@ function regexpCompiler(cc) {
 /** A program's archives, in link order: the host packages' libraries, then libjsrt (which they
 *  use), then the system libraries they need (-l…). Each is built the first time; `building`
 *  hears about it. */
+function programLibraries(hosts) {
+	return [...hosts.flatMap((h) => h.libraries(RUNTIME_INCLUDE)).filter((l) => l.sources.length), ...runtimeLibraries()];
+}
 function programArchives(tc, hosts, building) {
-	const libraries = [...hosts.flatMap((h) => h.libraries(RUNTIME_INCLUDE)).filter((l) => l.sources.length), ...runtimeLibraries()];
+	const libraries = programLibraries(hosts);
 	return [...libraries.map((l) => libraryArchive(tc, l, building)), ...libraries.flatMap((l) => l.link ?? []).map((l) => `-l${l}`)];
 }
 /** Compiles the program's C files and links them with `archives` (programArchives), stripping at
 *  this link when asked. A split program's files compile `jobs` at once; `compiled` hears as each
-*  is done. Asynchronous, so the build's report keeps drawing. */
-async function compileProgram(tc, cFiles, output, archives, { extraFlags = [], jobs = compileJobs(), compiled } = {}) {
+*  is done. `mapFile`: the link writes its map there (linkMapFlags), and each C file's object stays
+*  beside it, for the debug info. Asynchronous, so the build's report keeps drawing. */
+async function compileProgram(tc, cFiles, output, archives, { extraFlags = [], jobs = compileJobs(), compiled, mapFile } = {}) {
 	const flags = [
 		...COMMON,
 		...tc.opt,
@@ -13171,20 +13638,17 @@ async function compileProgram(tc, cFiles, output, archives, { extraFlags = [], j
 		...extraFlags
 	];
 	const link = [
-		...archives,
+		...archives.map((a) => a.startsWith("-l") ? a : resolve(a)),
 		"-lm",
 		...LINK,
 		...tc.strip ? STRIP : [],
+		...mapFile ? linkMapFlags(resolve(mapFile)) : [],
 		"-o",
-		output
+		resolve(output)
 	];
-	if (cFiles.length === 1) return runCompilerAsync(tc.cc, [
-		...flags,
-		`-I${RUNTIME_INCLUDE}`,
-		cFiles[0],
-		...link
-	]);
-	const objects = cFiles.map((f) => f.replace(/\.c$/, ".o"));
+	const cwd = dirname(resolve(cFiles[0]));
+	const sources = cFiles.map((f) => relative(cwd, resolve(f)));
+	const objects = sources.map((f) => f.replace(/\.c$/, ".o"));
 	const order = cFiles.map((_, i) => i).sort((a, b) => statSync(cFiles[b]).size - statSync(cFiles[a]).size);
 	let next = 0, done = 0;
 	const worker = async () => {
@@ -13195,10 +13659,10 @@ async function compileProgram(tc, cFiles, output, archives, { extraFlags = [], j
 					...flags,
 					`-I${RUNTIME_INCLUDE}`,
 					"-c",
-					cFiles[i],
+					sources[i],
 					"-o",
 					objects[i]
-				]);
+				], cwd);
 			} catch (e) {
 				next = order.length;
 				throw e;
@@ -13212,7 +13676,7 @@ async function compileProgram(tc, cFiles, output, archives, { extraFlags = [], j
 		...flags,
 		...objects,
 		...link
-	]);
+	], cwd);
 }
 /** How many of a split program's files compile at once: one per processor and per `perJob` bytes
 *  of available memory (a cgroup's limit counts). A file needs up to about 1.1 GB at -O2 with
@@ -13222,15 +13686,18 @@ function compileJobs(perJob = 15e8) {
 }
 /** Runs the compiler; its stderr passes through (but for notes the program can't act on), and its
 *  tail is kept to recognize a broken toolchain. Rejects when it fails. */
-function runCompilerAsync(cc, args) {
+function runCompilerAsync(cc, args, cwd) {
 	return new Promise((resolve, reject) => {
 		let errors = "";
-		const [program, ...prefix] = command(cc);
-		const child = spawn(program, [...prefix, ...args], { stdio: [
-			"ignore",
-			"inherit",
-			"pipe"
-		] });
+		const [program, ...prefix] = compilerCommand(cc);
+		const child = spawn(program, [...prefix, ...args], {
+			cwd,
+			stdio: [
+				"ignore",
+				"inherit",
+				"pipe"
+			]
+		});
 		const filter = new DiagnosticFilter((text) => process.stderr.write(text));
 		child.stderr.on("data", (chunk) => {
 			filter.write(chunk.toString());
@@ -13585,6 +14052,8 @@ function buildTypedUnit(files, primitives) {
 	const exports = {};
 	const exportedFns = /* @__PURE__ */ new Map();
 	for (const [name, loc] of exported) {
+		const array = signatures.get(loc)?.arrays[0];
+		if (array) throw compileError(array, `export '${name}' takes an array: static code doesn't take arrays from JavaScript yet`);
 		const fn = ir.functions.find((f) => at(f) === loc);
 		exportedFns.set(name, fn.name);
 		exports[name] = {
@@ -14577,6 +15046,316 @@ function lineCount(text) {
 	return n;
 }
 //#endregion
+//#region cli/src/size.ts
+const ZEROFILL = /* @__PURE__ */ new Set([
+	"__DATA,__bss",
+	"__DATA,__common",
+	"__DATA,__thread_bss"
+]);
+const CODE = "__TEXT,__text";
+function parseLinkMap(text) {
+	const objects = [], sections = [], symbols = [];
+	let part = "";
+	for (const line of text.split("\n")) {
+		if (line.startsWith("# ")) {
+			part = line.startsWith("# Object files") ? "objects" : line.startsWith("# Sections") ? "sections" : line.startsWith("# Symbols") ? "symbols" : line.startsWith("# Dead Stripped") ? "" : part;
+			continue;
+		}
+		if (part === "objects") {
+			const m = /^\[\s*(\d+)\] (.*)$/.exec(line);
+			if (m) objects[Number(m[1])] = m[2];
+		} else if (part === "sections") {
+			const [address, bytes, segment, section] = line.split("	");
+			if (section) sections.push({
+				address: parseInt(address, 16),
+				size: parseInt(bytes, 16),
+				name: `${segment},${section.trim()}`
+			});
+		} else if (part === "symbols") {
+			const m = /^0x([0-9A-F]+)\t0x([0-9A-F]+)\t\[\s*(\d+)\] (.*)$/.exec(line);
+			if (m) symbols.push({
+				address: parseInt(m[1], 16),
+				size: parseInt(m[2], 16),
+				object: Number(m[3]),
+				name: m[4]
+			});
+		}
+	}
+	return {
+		objects,
+		sections,
+		symbols
+	};
+}
+/** The line table's address ranges, each with its source file, sorted by address. `text` is
+*  `dwarfdump --debug-line`'s output. */
+function parseLineTable(text) {
+	const ranges = [];
+	let dirs = [], files = [];
+	let pendingFile;
+	let prev;
+	for (const line of text.split("\n")) {
+		if (line.startsWith("debug_line[")) {
+			dirs = [];
+			files = [];
+			prev = void 0;
+			continue;
+		}
+		let m = /^include_directories\[\s*(\d+)\] = "(.*)"$/.exec(line);
+		if (m) {
+			dirs[Number(m[1])] = m[2];
+			continue;
+		}
+		m = /^file_names\[\s*(\d+)\]:$/.exec(line);
+		if (m) {
+			pendingFile = Number(m[1]);
+			continue;
+		}
+		m = /^\s+name: "(.*)"$/.exec(line);
+		if (m && pendingFile !== void 0) {
+			files[pendingFile] = m[1];
+			continue;
+		}
+		m = /^\s+dir_index: (\d+)$/.exec(line);
+		if (m && pendingFile !== void 0) {
+			const name = files[pendingFile];
+			files[pendingFile] = isAbsolute(name) ? name : join(dirs[Number(m[1])] ?? "", name);
+			pendingFile = void 0;
+			continue;
+		}
+		m = /^0x([0-9a-f]+)\s+(\d+)\s+\d+\s+(\d+)\s.*$/.exec(line);
+		if (!m) continue;
+		const address = parseInt(m[1], 16);
+		if (prev && address > prev.address) ranges.push({
+			start: prev.address,
+			end: address,
+			file: prev.file,
+			line: prev.line
+		});
+		prev = line.includes("end_sequence") ? void 0 : {
+			address,
+			file: files[Number(m[3])] ?? "?",
+			line: Number(m[2])
+		};
+	}
+	return ranges.sort((a, b) => a.start - b.start);
+}
+/** The bundle's modules by line: its //#region comments, whose paths are relative to the entry's
+*  directory (the bundler's cwd) or a virtual module's id. The source map leaves out what the
+*  bundler generates or converts: JSON modules, CommonJS wrappers, namespace objects. */
+function bundleRegions(code, entryDir) {
+	const { starts, files } = parseRegions(code, entryDir);
+	return (line) => {
+		let lo = 0, hi = starts.length;
+		while (lo < hi) {
+			const mid = lo + hi >> 1;
+			if (starts[mid] <= line) lo = mid + 1;
+			else hi = mid;
+		}
+		return lo ? files[lo - 1] : void 0;
+	};
+}
+/** Each region's first line (1-based) and module; undefined: outside any, or the bundler's own. */
+function parseRegions(code, entryDir) {
+	const starts = [], files = [];
+	const lines = code.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const m = /^\/\/#(region|endregion)(?: (.*))?$/.exec(lines[i]);
+		if (!m) continue;
+		const id = m[2]?.replace(/^(?:\0|\\0)visaljs-[\w-]+:/, "");
+		starts.push(i + 1);
+		files.push(m[1] === "endregion" || id === void 0 || /^(?:\0|\\0)/.test(id) ? void 0 : resolve(entryDir, id));
+	}
+	return {
+		starts,
+		files,
+		lines
+	};
+}
+/** The bundle's bytes by module (--emit bundle): what the compiler is given, before any C. The
+*  "use static" files aren't in it (each is a stub of host imports): they come as `staticFiles`. */
+function bundleSizes(code, entryDir, staticFiles, cwd) {
+	const { starts, files, lines } = parseRegions(code, entryDir);
+	const totals = /* @__PURE__ */ new Map();
+	const add = (group, name, bytes) => {
+		const key = `${group}\0${name}`;
+		(totals.get(key) ?? totals.set(key, {
+			group,
+			name,
+			bytes: 0
+		}).get(key)).bytes += bytes;
+	};
+	let region = -1;
+	for (let i = 0; i < lines.length; i++) {
+		if (starts[region + 1] === i + 1) region++;
+		const file = region >= 0 ? files[region] : void 0;
+		const bytes = Buffer.byteLength(lines[i]) + 1;
+		const { group, name } = jsEntry(file, cwd);
+		add(group, name, bytes);
+	}
+	for (const f of staticFiles) add("\"use static\" files (compiled apart, not in the bundle)", jsModule(f, cwd), statSync(f).size);
+	return [...totals.values()];
+}
+const isCSource = (file) => /\.(?:c|cc|h|inc)$/.test(file);
+/** A JS file's group and module, the same in both reports. `file`: undefined, or the bundle
+*  itself, for code the bundler generated outside any module. */
+function jsEntry(file, cwd) {
+	if (file === void 0 || basename(file) === "bundle.js") return {
+		group: "Bundler glue",
+		name: "rolldown's runtime, imports and exports"
+	};
+	const name = jsModule(file, cwd);
+	return {
+		group: name.startsWith("node:") ? "Node built-ins" : /(?:^|[\\/])node_modules[\\/]/.test(file) ? "npm packages" : "Your code",
+		name
+	};
+}
+/** A JS file's module: a Node built-in, a package, or the program's own file. */
+function jsModule(file, cwd) {
+	const prelude = relative(preludeDir, file);
+	if (!prelude.startsWith("..") && !isAbsolute(prelude)) return `node:${prelude.replace(/\.js$/, "").replaceAll(sep, "/")}`;
+	const packages = [...file.matchAll(/(?:^|[\\/])node_modules[\\/]((?:@[^\\/]+[\\/])?[^\\/]+)/g)].map((m) => m[1].replaceAll("\\", "/"));
+	if (packages.length) return packages.length > 1 ? `${packages.at(-1)} (in ${packages.at(-2)})` : packages[0];
+	const rel = relative(cwd, resolve(cwd, file));
+	return rel.startsWith("..") ? file : rel;
+}
+/** An archive member's library and source: lib<name>.a(<i>.o), or a prebuilt <name>-<key>.a(<i>.o),
+*  is the library's i-th source (buildArchive). */
+function librarySource(object, libraries) {
+	const m = /([^\\/]+)\.a\((\d+)\.o\)$/.exec(object);
+	if (!m) return void 0;
+	const name = m[1].replace(/^lib/, "").replace(/-[0-9a-f]{16,}$/, "");
+	const lib = libraries.find((l) => l.name === name);
+	const src = lib?.sources[Number(m[2])];
+	return {
+		library: `lib${name}`,
+		source: src && lib ? relative(commonDir(lib.sources), src) : `${m[2]}.o`
+	};
+}
+function commonDir(files) {
+	let dir = files[0] ? resolve(files[0], "..") : "";
+	while (dir && !files.every((f) => f.startsWith(dir + sep))) dir = resolve(dir, "..");
+	return dir;
+}
+const EMITTED_DATA = [
+	[/^_\w*?jss_\d+$/, "string constants"],
+	[/^_\w*?jsfi_/, "function descriptors"],
+	[/^_\w*?jsrl?_\d+$/, "compiled regular expressions"],
+	[/^_\w*?mod_/, "module tables (atoms, shapes)"]
+];
+/** A data symbol's kind: ld64 names literals by their kind ("literal string: …", "16-byte-literal"). */
+function dataKind(name) {
+	if (name.startsWith("literal string")) return "C string literals";
+	if (/^\d+-byte-literal/.test(name)) return "number literals";
+	return EMITTED_DATA.find(([re]) => re.test(name))?.[1] ?? "other data";
+}
+/** Each symbol's bytes, attributed: the program's code to its JS modules, its data by kind, a
+*  library's to its source files. `programObjects` are the program's own objects' base names. */
+function attribute(map, lines, libraries, programObjects, cwd, regionOf = () => void 0) {
+	const totals = /* @__PURE__ */ new Map();
+	const add = (group, name, bytes) => {
+		const key = `${group}\0${name}`;
+		const e = totals.get(key) ?? totals.set(key, {
+			group,
+			name,
+			bytes: 0
+		}).get(key);
+		e.bytes += bytes;
+	};
+	const sections = [...map.sections].sort((a, b) => a.address - b.address);
+	const sectionOf = (address) => sections.find((s) => address >= s.address && address < s.address + s.size)?.name ?? "";
+	let next = 0;
+	const bySymbol = [...map.symbols].sort((a, b) => a.address - b.address);
+	for (const sym of bySymbol) {
+		if (sym.size === 0) continue;
+		const section = sectionOf(sym.address);
+		if (ZEROFILL.has(section)) continue;
+		const object = map.objects[sym.object] ?? "";
+		const program = programObjects.has(basename(object));
+		if (program && section === CODE) {
+			while (next < lines.length && lines[next].end <= sym.address) next++;
+			const files = /* @__PURE__ */ new Map();
+			for (let i = next; i < lines.length && lines[i].start < sym.address + sym.size; i++) {
+				const r = lines[i];
+				const bytes = Math.min(r.end, sym.address + sym.size) - Math.max(r.start, sym.address);
+				const file = basename(r.file) === "bundle.js" ? regionOf(r.line) ?? r.file : r.file;
+				if (bytes > 0 && !isCSource(file)) files.set(file, (files.get(file) ?? 0) + bytes);
+			}
+			const js = [...files.values()].reduce((a, b) => a + b, 0);
+			const typed = basename(object) === "typed.o";
+			if (js === 0) add("Runtime helpers (C, compiled with the program)", typed ? "in the \"use static\" unit" : "in the program", sym.size);
+			for (const [file, bytes] of files) {
+				const entry = typed ? {
+					group: "\"use static\" files",
+					name: jsModule(file, cwd)
+				} : jsEntry(file, cwd);
+				add(entry.group, entry.name, sym.size * bytes / js);
+			}
+		} else if (program) add("Program data", dataKind(sym.name), sym.size);
+		else if (sym.object === 0) add("Linker", sym.name.replace(/^_+/, ""), sym.size);
+		else {
+			const lib = librarySource(object, libraries);
+			if (lib) add(lib.library, lib.source, sym.size);
+			else add("Linker", object.endsWith(".tbd") ? "stubs for system libraries" : basename(object), sym.size);
+		}
+	}
+	const listed = /* @__PURE__ */ new Map();
+	for (const sym of bySymbol) {
+		const s = sectionOf(sym.address);
+		listed.set(s, (listed.get(s) ?? 0) + sym.size);
+	}
+	for (const s of sections) {
+		const rest = s.size - (listed.get(s.name) ?? 0);
+		if (!ZEROFILL.has(s.name) && rest > 0) add("Linker", s.name, rest);
+	}
+	return [...totals.values()];
+}
+/** `binary`'s bytes, attributed: linked with linkMapFlags(`mapFile`) and not stripped, while its
+*  `objects` (the program's own) still exist, for dsymutil reads their debug info. */
+function measureSizes(binary, mapFile, dsym, objects, libraries, bundle) {
+	execFileSync("dsymutil", [
+		binary,
+		"-o",
+		dsym
+	], { stdio: [
+		"ignore",
+		"ignore",
+		"inherit"
+	] });
+	const lines = parseLineTable(execFileSync("dwarfdump", ["--debug-line", dsym], {
+		encoding: "utf8",
+		maxBuffer: 1 << 30
+	}));
+	const map = parseLinkMap(readFileSync(mapFile, "latin1"));
+	const regions = bundle ? bundleRegions(bundle.code, bundle.entryDir) : void 0;
+	return attribute(map, lines, libraries, new Set(objects.map((o) => basename(o))), process.cwd(), regions);
+}
+const TOP = 12;
+function formatSizeReport(entries, fileBytes, all) {
+	return `\nWhere the binary's ${size(entries.reduce((a, e) => a + e.bytes, 0))} of code and data come from (the file is ${size(fileBytes)}: the rest is page padding and the linker's tables):\n\n${formatEntries(entries, all)}`;
+}
+function formatBundleSizes(entries, all) {
+	return `\nWhere the program's ${size(entries.reduce((a, e) => a + e.bytes, 0))} of JavaScript come from:\n\n${formatEntries(entries, all)}`;
+}
+function formatEntries(entries, all) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const e of entries) (groups.get(e.group) ?? groups.set(e.group, []).get(e.group)).push(e);
+	const sum = (es) => es.reduce((a, e) => a + e.bytes, 0);
+	const counted = sum(entries);
+	const pct = (bytes) => `${(100 * bytes / counted).toFixed(1).padStart(5)}%`;
+	const width = Math.min(72, Math.max(...entries.map((e) => e.name.length + 6)));
+	const row = (indent, name, bytes) => `${indent}${name.padEnd(width - indent.length)} ${size(Math.round(bytes)).padStart(9)} ${pct(bytes)}\n`;
+	let out = "";
+	for (const [group, es] of [...groups].sort((a, b) => sum(b[1]) - sum(a[1]))) {
+		out += row("  ", group, sum(es));
+		const sorted = [...es].sort((a, b) => b.bytes - a.bytes);
+		const shown = all ? sorted : sorted.slice(0, TOP);
+		for (const e of shown) out += row("      ", e.name, e.bytes);
+		if (shown.length < sorted.length) out += row("      ", `${sorted.length - shown.length} more (--verbose lists them)`, sum(sorted.slice(shown.length)));
+	}
+	return out;
+}
+//#endregion
 //#region cli/src/main.ts
 const VERSION = "0.0.7";
 /** A program's C splits into files of about this many IR instructions. */
@@ -14595,10 +15374,7 @@ TypeScript (.ts, .mts, .cts, .tsx) is compiled too: its types are stripped, not
 for that), with the nearest tsconfig.json's settings (paths, decorators).
 
 options:
-  -o <file>          output binary
-  --emit-c <dir>     stop after C emission
-  --dump-ast         print the syntax tree and stop
-  --dump-ir          print the IR and stop
+  -o <file>          output binary (with --emit: what to write)
   --debug            build without optimization (-O0), keeping symbols and debug info
   --symbols          keep symbols and debug info in the optimized build (for profilers such as perf)
   --no-optimize      skip the IR optimizer (to compare, or to rule it out)
@@ -14617,7 +15393,26 @@ options:
   --verbose          list each place a warning is about
   --version          print the version
   --help             print this help
+
+inspecting the build:
+  --emit <stage>     stop after a stage and write what it made:
+                       bundle  the bundle (tree-shaken) and the "use static" files to the directory
+                               -o names, and how much of the bundle each module and package is
+                       ast     the syntax tree, to stdout or the file -o names
+                       ir      the optimized IR, to stdout or the file -o names
+                       c       the C files, to the directory -o names
+  --report <kind>    build the binary, then report on it (repeatable):
+                       size    where its bytes come from: each module, package, Node built-in and
+                               runtime library (macOS for now; --verbose lists every file)
 `;
+const STAGES = [
+	"bundle",
+	"ast",
+	"ir",
+	"c"
+];
+const WRITES_FILES = /* @__PURE__ */ new Set(["bundle", "c"]);
+const REPORTS = ["size"];
 /** Runs the CLI and returns the process exit code. */
 async function main(argv, io) {
 	let parsed;
@@ -14630,6 +15425,11 @@ async function main(argv, io) {
 					type: "string",
 					short: "o"
 				},
+				emit: { type: "string" },
+				report: {
+					type: "string",
+					multiple: true
+				},
 				"emit-c": { type: "string" },
 				"dump-ast": { type: "boolean" },
 				"dump-ir": { type: "boolean" },
@@ -14680,7 +15480,18 @@ async function main(argv, io) {
 				io.stderr(`visaljs build: expected one entry file or project directory\n${USAGE}`);
 				return 2;
 			}
-			return await build(rest[0] ?? ".", values, io);
+			{
+				const inspect = inspectOptions(values);
+				if (typeof inspect === "string") {
+					io.stderr(`visaljs: ${inspect}\n`);
+					return 2;
+				}
+				return await build(rest[0] ?? ".", {
+					...values,
+					output: inspect.emit ? void 0 : values.output,
+					...inspect
+				}, io);
+			}
 		case "licenses":
 			if (rest.length) {
 				io.stderr(`visaljs licenses: takes no arguments\n${USAGE}`);
@@ -14693,11 +15504,53 @@ async function main(argv, io) {
 			return 2;
 	}
 }
+/** --emit and --report, with the flags they replace (--emit-c <dir>, --dump-ast, --dump-ir), or
+*  what's wrong with them. */
+function inspectOptions(values) {
+	const asked = [];
+	if (values.emit !== void 0) asked.push({
+		stage: values.emit,
+		to: values.output
+	});
+	if (values["emit-c"] !== void 0) asked.push({
+		stage: "c",
+		to: values["emit-c"]
+	});
+	if (values["dump-ast"]) asked.push({
+		stage: "ast",
+		to: void 0
+	});
+	if (values["dump-ir"]) asked.push({
+		stage: "ir",
+		to: void 0
+	});
+	if (asked.length > 1) return "--emit takes one stage: the build stops after it";
+	const reports = values.report ?? [];
+	const unknown = reports.find((r) => !REPORTS.includes(r));
+	if (unknown !== void 0) return `--report takes ${REPORTS.join(", ")}, not '${unknown}'`;
+	if (reports.includes("size") && process.platform !== "darwin") return "--report size reads ld64's link map: it needs macOS for now";
+	const [want] = asked;
+	if (!want) return {
+		emit: void 0,
+		emitTo: void 0,
+		reports
+	};
+	if (!STAGES.includes(want.stage)) return `--emit takes ${STAGES.join(", ")}, not '${want.stage}'`;
+	const stage = want.stage;
+	if (reports.length) return `--report reports on the binary: not with --emit ${stage}, which stops before it`;
+	if (WRITES_FILES.has(stage) && !want.to) return `--emit ${stage} writes files: give their directory with -o`;
+	return {
+		emit: stage,
+		emitTo: want.to,
+		reports: []
+	};
+}
 async function build(entry, options, io) {
-	const dump = options["dump-ast"] === true || options["dump-ir"] === true;
+	const dump = options.emit === "ast" || options.emit === "ir";
 	const style = options.quiet || dump ? void 0 : io.report;
 	const report = new Report(io.stderr, style);
-	const binary = !dump && !options["emit-c"];
+	const emitBundle = options.emit === "bundle" ? options.emitTo : void 0;
+	const binary = options.emit === void 0;
 	const hosts = DEFAULT_HOSTS;
 	let primitives = hostPrimitives(hosts);
 	const nodeEnv = options["node-env"] === "" ? void 0 : options["node-env"] ?? "production";
@@ -14734,7 +15587,12 @@ async function build(entry, options, io) {
 		io.stderr(`visaljs: ${e.message}\n`);
 		return 1;
 	}
-	const bundled = !(options.script === true) && options["no-bundle"] !== true;
+	const script = options.script === true;
+	const bundled = !script && options["no-bundle"] !== true;
+	if (emitBundle !== void 0 && !bundled) {
+		io.stderr(`visaljs: --emit bundle writes the bundle: not with ${script ? "--script" : "--no-bundle"}\n`);
+		return 2;
+	}
 	let map;
 	const typedFiles = /* @__PURE__ */ new Set();
 	let typed;
@@ -14747,6 +15605,12 @@ async function build(entry, options, io) {
 		}), (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 = b.map;
+		if (emitBundle !== void 0) {
+			writeBundle(emitBundle, b.code, b.map, [...typedFiles]);
+			report.finish("📂", (time) => `Wrote the bundle and ${count(typedFiles.size, "\"use static\" file")} to ${displayPath(resolve(emitBundle))} in ${time}`);
+			io.stdout(formatBundleSizes(bundleSizes(b.code, dirname(resolve(entry)), [...typedFiles], process.cwd()), options.verbose === true));
+			return 0;
+		}
 		if (typedFiles.size) {
 			const files = [...typedFiles];
 			typed = await report.step("🧷", "Compiling the typed files", () => buildTypedUnit(files, primitives), (u) => [`Compiled ${count(files.length, "typed file")}: ${count(Object.keys(u.exports).length, "export")}`, ...formatReport(u.report).map((line) => `      • ${line}`)].join("\n"));
@@ -14764,7 +15628,7 @@ async function build(entry, options, io) {
 		io.stderr(`visaljs: --jobs takes a positive whole number, not '${options.jobs}'\n`);
 		return 2;
 	}
-	const emitDir = options["emit-c"];
+	const emitDir = options.emit === "c" ? options.emitTo : void 0;
 	let output = "";
 	if (binary) {
 		output = pipeline?.output ?? options.output ?? basename(entry).replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, "");
@@ -14775,6 +15639,7 @@ async function build(entry, options, io) {
 		}
 	}
 	const dir = emitDir ?? (binary ? scratchDir() : "");
+	let sizes;
 	try {
 		const typedLink = typed ? {
 			atoms: [...typed.atoms],
@@ -14799,7 +15664,8 @@ async function build(entry, options, io) {
 		}
 		compilers = c.compilers;
 		if (typeof c.result === "string") {
-			io.stdout(c.result);
+			if (options.emitTo) writeFileSync(options.emitTo, c.result);
+			else io.stdout(c.result);
 			return 0;
 		}
 		const written = c.result;
@@ -14815,7 +15681,9 @@ async function build(entry, options, io) {
 			cFiles.push(join(dir, "typed.c"));
 		}
 		const opt = [...options.debug ? ["-O0"] : ["-O2"], ...gcCheckFlags()];
-		const strip = !options.debug && !options.symbols;
+		const sizeReport = options.reports.includes("size");
+		const strip = !options.debug && !options.symbols && !sizeReport;
+		const mapFile = sizeReport ? join(dir, "link.map") : void 0;
 		const jobs = options.jobs === void 0 ? compileJobs(strip ? 8e8 : 15e8) : Number(options.jobs);
 		try {
 			await withCompiler(compilers, report, async (cc) => {
@@ -14833,9 +15701,21 @@ async function build(entry, options, io) {
 				const parallel = cFiles.length > 1 ? `${cFiles.length} files, ${Math.min(jobs, cFiles.length)} at a time` : "";
 				await report.step("🔨", parallel ? `${compiling} (${parallel})` : compiling, () => compileProgram(tc, cFiles, output, archives, {
 					jobs,
+					mapFile,
 					compiled: (done, total) => report.relabel(done < total ? `${compiling} (${done}/${total} files, ${Math.min(jobs, total)} at a time)` : `Linking with ${describeCompiler(cc)}`)
 				}), () => `Compiled the binary with ${describeCompiler(cc)} (${[...opt, ...parallel ? [parallel] : []].join(", ")}, ${tc.strip ? "stripped" : "with debug info"})`);
 			});
+			if (mapFile) {
+				sizes = await report.step("📏", "Measuring where the binary's bytes come from", () => measureSizes(output, mapFile, join(dir, "program.dSYM"), cFiles.map((f) => f.replace(/\.c$/, ".o")), programLibraries(hosts), bundled ? {
+					code: source,
+					entryDir: dirname(resolve(entry))
+				} : void 0), (es) => `Measured ${count(es.length, "source")} of the binary's bytes`);
+				if (!options.debug && !options.symbols) execFileSync("strip", [
+					"-S",
+					"-x",
+					output
+				]);
+			}
 		} catch (e) {
 			io.stderr(`visaljs: C compilation failed: ${e.message}\n`);
 			return 1;
@@ -14848,9 +15728,23 @@ 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 (sizes) io.stdout(formatSizeReport(sizes, bytes, options.verbose === true));
 	pipeline?.done(resolve(output));
 	return 0;
 }
+/** --emit bundle's files: the bundle, its map, and each "use static" file at its path from the
+*  current directory under static/ (outside it: by its name). */
+function writeBundle(dir, code, map, staticFiles) {
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(join(dir, "bundle.js"), code);
+	if (map) writeFileSync(join(dir, "bundle.js.map"), map);
+	for (const file of staticFiles) {
+		const rel = relative(process.cwd(), file);
+		const to = join(dir, "static", rel.startsWith("..") || isAbsolute(rel) ? basename(file) : rel);
+		mkdirSync(dirname(to), { recursive: true });
+		copyFileSync(file, to);
+	}
+}
 const WORKER = "visaljs-compile";
 /** compileToC in a worker thread, so its heap (gigabytes for a large program) goes back to the
 *  system for the C compilers when it ends. The worker is this module (bundled: cli.js). */
@@ -14957,7 +15851,7 @@ async function runCompileJob(job) {
 	}
 }
 if (!isMainThread && workerData?.[WORKER]) await runCompileJob(workerData[WORKER]);
-/** The program's C files' names, or the text --dump-ast or --dump-ir prints. Its own function, as
+/** The program's C files' names, or the text --emit ast or --emit ir writes. Its own function, as
 *  is toIR, so the syntax tree and then the IR become garbage: a large program's take gigabytes. */
 async function compileToC(source, entry, map, options, report, primitives, compilers, typed, write) {
 	const program = await toIR(source, entry, map, options, report, primitives, compilers, typed?.calls);
@@ -14995,7 +15889,7 @@ async function compileToC(source, entry, map, options, report, primitives, compi
 }
 async function toIR(source, entry, map, options, report, primitives, compilers, typedCalls) {
 	const ast = await report.step("🌳", "Parsing the JavaScript", () => options.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"]) return JSON.stringify(ast, null, 2) + "\n";
+	if (options.emit === "ast") return JSON.stringify(ast, null, 2) + "\n";
 	const info = analyze(ast);
 	const evalWarn = evalWarning(evalCalls(ast, info), options.verbose === true);
 	if (evalWarn) report.warn(evalWarn);
@@ -15009,7 +15903,7 @@ async function toIR(source, entry, map, options, report, primitives, compilers,
 		if (typedCalls) annotateTypedCalls(lowered, typedCalls);
 		return optimize(lowered, options["no-optimize"] ? [] : void 0, passes);
 	}, (ir) => [`Converted ${count(ir.functions.length + 1, "function")} to IR and optimized them`, ...formatReport(passes).map((line) => `      • ${line}`)].join("\n"));
-	if (options["dump-ir"]) return printModule(ir);
+	if (options.emit === "ir") return printModule(ir);
 	return {
 		ir,
 		names: programNames(ast),