visaljs 0.0.9 → 0.0.10

package/cli.js

@@ -1,13 +1,15 @@
 #!/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 { 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, totalmem } from "node:os";
+import { availableParallelism, homedir, tmpdir } from "node:os";
 //#region \0rolldown/runtime.js
 var __defProp$1 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -98,6 +100,19 @@ function hoistHostImports(body) {
 function parseModule(text, file, map, entry, hostPrimitives = {}) {
 	return parse(text, file, true, map, entry, hostPrimitives);
 }
+/** A static unit as one module: its types ignored, its files' top levels one after another.
+*  Its functions can't be printed (Function.prototype.toString): their source is in many files. */
+function convertStaticUnit(unit, hostPrimitives) {
+	const programs = unit.files.map((sf) => new Converter(sf, true, void 0, resolve(sf.fileName), hostPrimitives, unit).program());
+	return {
+		...programs[0],
+		static: true,
+		body: hoistHostImports(programs.flatMap((p) => p.body)),
+		exportedNames: programs.flatMap((p) => p.exportedNames),
+		source: "",
+		unsupported: programs.flatMap((p) => p.unsupported)
+	};
+}
 function parse(text, file, module, map, entry, hostPrimitives = {}) {
 	const setExternalModuleIndicator = (s) => {
 		s.externalModuleIndicator = module ? s : void 0;
@@ -113,15 +128,26 @@ function parse(text, file, module, map, entry, hostPrimitives = {}) {
 	}
 	return new Converter(sf, module, map, resolve(entry ?? file), hostPrimitives).program();
 }
-function locAt(sf, pos, map) {
+function locAt(sf, pos, map, file = normalize(sf.fileName)) {
 	const { line, character } = sf.getLineAndCharacterOfPosition(pos);
 	const loc = {
-		file: normalize(sf.fileName),
+		file,
 		line: line + 1,
 		column: character + 1
 	};
 	return map?.original(loc.line, loc.column) ?? loc;
 }
+/** A numeric literal written as a floating-point one (1.0, 1e3): a double to static code, as in C. */
+function isFloatWritten(raw) {
+	return /[.eE]/.test(raw) && !/^0[xXbBoO]/.test(raw);
+}
+/** `import type …`, or an import of types only (`import { type a }`). */
+function typeOnly(node) {
+	const clause = node.importClause;
+	if (!clause || clause.isTypeOnly) return clause !== void 0;
+	const bindings = clause.namedBindings;
+	return !clause.name && bindings !== void 0 && ts.isNamedImports(bindings) && bindings.elements.every((e) => e.isTypeOnly);
+}
 /** TypeScript rejects `a?.#x` (still parsed as usual); ES2022 allows it. */
 const PRIVATE_IN_OPTIONAL_CHAIN = 18030;
 /** Readable names for constructs the compiler doesn't handle. */
@@ -192,12 +218,15 @@ var Converter = class {
 	map;
 	entry;
 	hostPrimitives;
-	constructor(sf, module, map, entry, hostPrimitives) {
+	/** Converting a static unit's TypeScript: types are skipped, not errors. */
+	unit;
+	constructor(sf, module, map, entry, hostPrimitives, unit) {
 		this.sf = sf;
 		this.module = module;
 		this.map = map;
 		this.entry = entry;
 		this.hostPrimitives = hostPrimitives;
+		this.unit = unit;
 	}
 	/** The absolute path of the original file `node` comes from (for import.meta and import()). */
 	originalFile(node) {
@@ -205,7 +234,7 @@ var Converter = class {
 		return this.map?.originalSource(line + 1, character + 1) ?? resolve(this.sf.fileName);
 	}
 	loc(node) {
-		return locAt(this.sf, node.getStart(this.sf), this.map);
+		return locAt(this.sf, node.getStart(this.sf), this.map, this.unit?.fileName(this.sf));
 	}
 	fail(kind, detail, node) {
 		if (kind === "NotSupported") throw new Deferred(detail, node);
@@ -234,6 +263,7 @@ var Converter = class {
 	}
 	/** TypeScript-only syntax the parser accepts in .js files: a JS syntax error. */
 	noTypes(node) {
+		if (this.unit) return;
 		if (node.type) this.fail("SyntaxError", "type annotations are TypeScript, not JavaScript", node.type);
 		if (node.typeParameters || node.typeArguments) this.fail("SyntaxError", "type arguments are TypeScript, not JavaScript", node);
 	}
@@ -258,7 +288,7 @@ var Converter = class {
 		return {
 			type: "Program",
 			loc: {
-				file: normalize(this.sf.fileName),
+				file: this.unit?.fileName(this.sf) ?? normalize(this.sf.fileName),
 				line: 1,
 				column: 1
 			},
@@ -282,10 +312,12 @@ var Converter = class {
 	}
 	identifier(node) {
 		if (!ts.isIdentifier(node)) this.fail("SyntaxError", "identifier expected", node);
+		const renamed = this.unit?.rename(node);
 		const id = {
 			type: "Identifier",
 			loc: this.loc(node),
-			name: node.text
+			name: renamed ?? node.text,
+			...renamed ? { original: node.text } : {}
 		};
 		if (this.map) {
 			const { line, character } = this.sf.getLineAndCharacterOfPosition(node.getStart(this.sf));
@@ -456,11 +488,12 @@ var Converter = class {
 			kind: flags === ts.NodeFlags.Let ? "let" : flags === ts.NodeFlags.Const ? "const" : "var",
 			declarations: list.declarations.map((d) => {
 				this.noTypes(d);
-				if (d.exclamationToken) this.fail("SyntaxError", "definite assignment assertions are TypeScript", d);
+				if (d.exclamationToken && !this.unit) this.fail("SyntaxError", "definite assignment assertions are TypeScript", d);
+				const fn = d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer)) ? d.initializer : void 0;
 				return {
 					type: "VariableDeclarator",
 					loc: this.loc(d),
-					id: this.bindingPattern(d.name),
+					id: this.declaredInt(this.bindingPattern(d.name), d.type, fn?.type),
 					init: d.initializer ? this.expression(d.initializer) : null
 				};
 			})
@@ -511,8 +544,16 @@ var Converter = class {
 		return this.orUnsupported(node, () => {
 			const loc = this.loc(node);
 			if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "visaljs:host") return this.hostImport(node);
+			if (this.unit && ts.isImportDeclaration(node) && (this.unit.linked(node) || typeOnly(node))) return {
+				type: "EmptyStatement",
+				loc
+			};
 			if (ts.isImportDeclaration(node) || ts.isImportEqualsDeclaration(node)) this.fail("NotSupported", "import declarations: the bundler resolves them", node);
 			if (ts.isExportDeclaration(node)) {
+				if (node.isTypeOnly && this.unit) return {
+					type: "EmptyStatement",
+					loc
+				};
 				if (node.isTypeOnly) this.fail("SyntaxError", "type-only exports are TypeScript", node);
 				if (node.moduleSpecifier) this.fail("NotSupported", "export … from: the bundler resolves them", node);
 				const clause = node.exportClause;
@@ -606,11 +647,12 @@ var Converter = class {
 				return {
 					type: "FunctionDeclaration",
 					loc,
-					id: f.name ? this.identifier(f.name) : {
+					id: f.name ? this.declaredInt(this.identifier(f.name), void 0, f.type) : {
 						type: "Identifier",
 						loc,
 						name: "*default*"
 					},
+					...this.returnsInt(f),
 					...this.parameters(f.parameters),
 					source: this.range(f),
 					body: this.block(f.body),
@@ -796,6 +838,11 @@ var Converter = class {
 			}
 			case ts.SyntaxKind.InterfaceDeclaration:
 			case ts.SyntaxKind.TypeAliasDeclaration:
+				if (this.unit) return {
+					type: "EmptyStatement",
+					loc
+				};
+				return this.fail("SyntaxError", "TypeScript declarations are not JavaScript", node);
 			case ts.SyntaxKind.EnumDeclaration:
 			case ts.SyntaxKind.ModuleDeclaration: return this.fail("SyntaxError", "TypeScript declarations are not JavaScript", node);
 			default: return this.unsupported(node);
@@ -845,14 +892,14 @@ var Converter = class {
 		let rest = null;
 		list.forEach((p, i) => {
 			this.noTypes(p);
-			if (p.questionToken) this.fail("SyntaxError", "optional parameters are TypeScript", p);
+			if (p.questionToken && !this.unit) this.fail("SyntaxError", "optional parameters are TypeScript", p);
 			if (p.dotDotDotToken) {
 				if (i !== list.length - 1) this.fail("SyntaxError", "A rest parameter must be last in a parameter list", p);
 				if (p.initializer) this.fail("SyntaxError", "Rest parameter may not have a default initializer", p);
 				rest = this.bindingPattern(p.name);
 				return;
 			}
-			params.push(this.bindingPattern(p.name));
+			params.push(this.declaredInt(this.bindingPattern(p.name), p.type));
 			defaults.push(p.initializer ? this.expression(p.initializer) : null);
 		});
 		return {
@@ -879,6 +926,7 @@ var Converter = class {
 			type: "FunctionExpression",
 			loc: this.loc(f),
 			id: !method && !ts.isConstructorDeclaration(f) && f.name && ts.isIdentifier(f.name) ? this.identifier(f.name) : null,
+			...this.returnsInt(f),
 			...this.parameters(f.parameters),
 			source: this.range(cls?.ctor && cls.node ? cls.node : f),
 			body: this.block(f.body),
@@ -1187,6 +1235,7 @@ var Converter = class {
 			type: "FunctionExpression",
 			loc,
 			id: null,
+			...this.returnsInt(f),
 			...this.parameters(f.parameters),
 			source: this.range(f),
 			body,
@@ -1201,6 +1250,23 @@ var Converter = class {
 			...this.asyncFlag(f)
 		};
 	}
+	/** Static code: the integers a declaration names, on its identifier: its type's, and (a
+	*  function's name, or a const holding a function) its function's return type's. */
+	declaredInt(id, type, returns) {
+		if (!this.unit || id.type !== "Identifier") return id;
+		const int = this.unit.intKind(type);
+		const returnsInt = this.unit.intKind(returns);
+		return {
+			...id,
+			...int ? { int } : {},
+			...returnsInt ? { returnsInt } : {}
+		};
+	}
+	/** Static code: the integer a function's declared return type names. */
+	returnsInt(f) {
+		const int = this.unit?.intKind(f.type);
+		return int ? { returnsInt: int } : {};
+	}
 	/** `async`: async functions and async generators. */
 	asyncFlag(f) {
 		return f.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ? { async: true } : {};
@@ -1225,6 +1291,7 @@ var Converter = class {
 	}
 	chainLink(node) {
 		if (!ts.isOptionalChain(node)) return this.expression(node);
+		if (ts.isNonNullExpression(node) && this.unit) return this.chainLink(node.expression);
 		if (ts.isNonNullExpression(node)) this.fail("SyntaxError", "non-null assertions are TypeScript, not JavaScript", node);
 		const optional = node.questionDotToken ? { optional: true } : {};
 		const loc = this.loc(node);
@@ -1389,7 +1456,11 @@ var Converter = class {
 					type: "Property",
 					kind: "init",
 					loc,
-					key: this.identifier(p.name),
+					key: {
+						type: "Identifier",
+						loc: this.loc(p.name),
+						name: p.name.text
+					},
 					computed: false,
 					value: this.identifier(p.name),
 					isProto: false
@@ -1412,7 +1483,8 @@ var Converter = class {
 			case ts.SyntaxKind.NumericLiteral: return {
 				type: "Literal",
 				loc,
-				value: Number(node.text)
+				value: Number(node.text),
+				...this.unit && isFloatWritten(node.getText(this.sf)) ? { float: true } : {}
 			};
 			case ts.SyntaxKind.StringLiteral:
 			case ts.SyntaxKind.NoSubstitutionTemplateLiteral: return {
@@ -1691,16 +1763,30 @@ var Converter = class {
 			case ts.SyntaxKind.AsExpression:
 			case ts.SyntaxKind.SatisfiesExpression:
 			case ts.SyntaxKind.NonNullExpression:
-			case ts.SyntaxKind.TypeAssertionExpression: return this.fail("SyntaxError", "type assertions are TypeScript, not JavaScript", node);
+			case ts.SyntaxKind.TypeAssertionExpression:
+				if (this.unit) return this.expression(node.expression);
+				return this.fail("SyntaxError", "type assertions are TypeScript, not JavaScript", node);
 			default: return this.unsupported(node);
 		}
 	}
 };
 //#endregion
 //#region compiler/src/frontend/sourcemap.ts
-const DIGIT = new Map([..."ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"].map((c, i) => [c, i]));
+const FIELDS = 5;
+const GEN_COLUMN = 0;
+const SOURCE = 1;
+const LINE = 2;
+const COLUMN = 3;
+const NAME = 4;
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const DIGIT = (/* @__PURE__ */ new Int8Array(128)).fill(-1);
+for (let i = 0; i < 64; i++) DIGIT[BASE64.charCodeAt(i)] = i;
+const COMMA = 44;
+const SEMICOLON = 59;
 var SourceMap = class {
-	lines = [];
+	segments = new Int32Array(1024 * FIELDS);
+	/** Line n's segments: from lineStarts[n] to lineStarts[n + 1] (segment indexes). */
+	lineStarts = [0];
 	sources;
 	rawSources;
 	names;
@@ -1710,93 +1796,114 @@ var SourceMap = class {
 		this.rawSources = raw.sources.map((s) => s ?? "");
 		this.sources = this.rawSources.map(resolveSource);
 		this.names = raw.names ?? [];
-		let source = 0, line = 0, column = 0, name = 0;
-		for (const text of raw.mappings.split(";")) {
-			const segments = [];
-			let genColumn = 0;
-			for (const seg of text.split(",")) {
-				if (seg === "") continue;
-				const f = decodeVlq(seg);
-				genColumn += f[0];
-				if (f.length < 4) {
-					segments.push([
-						genColumn,
-						-1,
-						0,
-						0,
-						-1
-					]);
-					continue;
+		const mappings = raw.mappings;
+		const fields = [
+			0,
+			0,
+			0,
+			0,
+			0
+		];
+		let count = 0, lineStart = 0, genColumn = 0, source = 0, line = 0, column = 0, name = 0;
+		for (let i = 0; i <= mappings.length; i++) {
+			const c = i < mappings.length ? mappings.charCodeAt(i) : SEMICOLON;
+			if (c !== COMMA && c !== SEMICOLON) continue;
+			const n = decodeVlq(mappings, lineStart, i, fields);
+			if (n > 0) {
+				genColumn += fields[0];
+				if (n >= 4) {
+					source += fields[1];
+					line += fields[2];
+					column += fields[3];
+					if (n >= 5) name += fields[4];
 				}
-				source += f[1];
-				line += f[2];
-				column += f[3];
-				if (f.length >= 5) name += f[4];
-				segments.push([
-					genColumn,
-					source,
-					line,
-					column,
-					f.length >= 5 ? name : -1
-				]);
+				if ((count + 1) * FIELDS > this.segments.length) {
+					const grown = new Int32Array(this.segments.length * 2);
+					grown.set(this.segments);
+					this.segments = grown;
+				}
+				const at = count++ * FIELDS;
+				this.segments[at + GEN_COLUMN] = genColumn;
+				this.segments[at + SOURCE] = n >= 4 ? source : -1;
+				this.segments[at + LINE] = n >= 4 ? line : 0;
+				this.segments[at + COLUMN] = n >= 4 ? column : 0;
+				this.segments[at + NAME] = n >= 5 ? name : -1;
+			}
+			lineStart = i + 1;
+			if (c === SEMICOLON) {
+				this.sortLine(this.lineStarts[this.lineStarts.length - 1], count);
+				this.lineStarts.push(count);
+				genColumn = 0;
 			}
-			segments.sort((a, b) => a[0] - b[0]);
-			this.lines.push(segments);
 		}
+		this.segments = this.segments.slice(0, count * FIELDS);
 	}
 	/** The original location of a 1-based bundle position: the segment at or before it on
 	*  its line (else the line's first), or null where the bundler generated the code. */
 	original(line, column) {
-		const seg = this.segmentAt(line, column, false);
-		if (!seg || seg[1] < 0) return null;
+		const at = this.segmentAt(line, column, false);
+		if (at < 0 || this.segments[at + SOURCE] < 0) return null;
 		return {
-			file: this.sources[seg[1]],
-			line: seg[2] + 1,
-			column: seg[3] + 1
+			file: this.sources[this.segments[at + SOURCE]],
+			line: this.segments[at + LINE] + 1,
+			column: this.segments[at + COLUMN] + 1
 		};
 	}
 	/** The original file of a 1-based bundle position, as the map's `sources` names it (absolute
 	*  paths from the driver), or null. */
 	originalSource(line, column) {
-		const seg = this.segmentAt(line, column, false);
-		return seg && seg[1] >= 0 ? this.rawSources[seg[1]] : null;
+		const at = this.segmentAt(line, column, false);
+		return at >= 0 && this.segments[at + SOURCE] >= 0 ? this.rawSources[this.segments[at + SOURCE]] : null;
 	}
 	/** The original name of the identifier starting exactly at a 1-based bundle position. */
 	originalName(line, column) {
-		const seg = this.segmentAt(line, column, true);
-		return seg && seg[4] >= 0 ? this.names[seg[4]] : void 0;
+		const at = this.segmentAt(line, column, true);
+		return at >= 0 && this.segments[at + NAME] >= 0 ? this.names[this.segments[at + NAME]] : void 0;
 	}
+	/** The offset in `segments` of the segment for a 1-based position, or -1. */
 	segmentAt(line, column, exact) {
-		const segments = this.lines[line - 1];
-		if (!segments || segments.length === 0) return void 0;
+		if (line < 1 || line >= this.lineStarts.length) return -1;
+		const first = this.lineStarts[line - 1], last = this.lineStarts[line] - 1;
+		if (last < first) return -1;
 		const col = column - 1;
-		let lo = 0, hi = segments.length - 1, found = -1;
+		let lo = first, hi = last, found = -1;
 		while (lo <= hi) {
 			const mid = lo + hi >> 1;
-			if (segments[mid][0] <= col) {
+			if (this.segments[mid * FIELDS + GEN_COLUMN] <= col) {
 				found = mid;
 				lo = mid + 1;
 			} else hi = mid - 1;
 		}
-		if (exact) return found >= 0 && segments[found][0] === col ? segments[found] : void 0;
-		return segments[found >= 0 ? found : 0];
+		if (exact) return found >= 0 && this.segments[found * FIELDS + GEN_COLUMN] === col ? found * FIELDS : -1;
+		return (found >= 0 ? found : first) * FIELDS;
+	}
+	/** Segments `from` to `to` in generated column order (maps almost always have them so). */
+	sortLine(from, to) {
+		let sorted = true;
+		for (let s = from + 1; s < to && sorted; s++) sorted = this.segments[(s - 1) * FIELDS] <= this.segments[s * FIELDS];
+		if (sorted) return;
+		const line = [...Array(to - from).keys()].map((k) => this.segments.slice((from + k) * FIELDS, (from + k + 1) * FIELDS));
+		line.sort((a, b) => a[GEN_COLUMN] - b[GEN_COLUMN]);
+		line.forEach((seg, k) => this.segments.set(seg, (from + k) * FIELDS));
 	}
 };
-function decodeVlq(s) {
-	const out = [];
-	let value = 0, shift = 0;
-	for (const c of s) {
-		const digit = DIGIT.get(c);
-		if (digit === void 0) throw new Error(`invalid source map mapping '${s}'`);
+/** Decodes the VLQ fields of mappings[from, to) into `out`; returns how many there are. */
+function decodeVlq(mappings, from, to, out) {
+	let n = 0, value = 0, shift = 0;
+	for (let i = from; i < to; i++) {
+		const c = mappings.charCodeAt(i);
+		const digit = c < 128 ? DIGIT[c] : -1;
+		if (digit < 0) throw new Error(`invalid source map mapping '${mappings.slice(from, to)}'`);
 		value += (digit & 31) << shift;
 		if (digit & 32) shift += 5;
 		else {
-			out.push(value & 1 ? -(value >>> 1) : value >>> 1);
+			if (n < out.length) out[n] = value & 1 ? -(value >>> 1) : value >>> 1;
+			n++;
 			value = 0;
 			shift = 0;
 		}
 	}
-	return out;
+	return n;
 }
 //#endregion
 //#region compiler/src/sema/analyze.ts
@@ -2676,6 +2783,134 @@ var Resolver = class {
 	}
 };
 //#endregion
+//#region ir/src/types.ts
+const T = {
+	None: 0,
+	Undefined: 1,
+	Null: 2,
+	Boolean: 4,
+	Int32: 8,
+	Double: 16,
+	String: 32,
+	Symbol: 64,
+	BigInt: 128,
+	Object: 256,
+	Empty: 512,
+	Int64: 1024
+};
+const Number_ = T.Int32 | T.Double | T.Int64;
+const Primitive = T.Undefined | T.Null | T.Boolean | Number_ | T.String | T.Symbol | T.BigInt;
+const Any = Primitive | T.Object;
+/** Nothing known: any JS value, or EMPTY (what an uninitialized binding reads). */
+const Unknown = Any | T.Empty;
+function isSubtype(a, b) {
+	return (a & ~b) === 0;
+}
+const NAMED$1 = [
+	[Any | T.Empty, "Any|Empty"],
+	[Any, "Any"],
+	[Primitive, "Primitive"],
+	[Number_, "Number"]
+];
+const BITS = [
+	[T.Undefined, "Undefined"],
+	[T.Null, "Null"],
+	[T.Boolean, "Boolean"],
+	[T.Int32, "Int32"],
+	[T.Double, "Double"],
+	[T.String, "String"],
+	[T.Symbol, "Symbol"],
+	[T.BigInt, "BigInt"],
+	[T.Object, "Object"],
+	[T.Empty, "Empty"],
+	[T.Int64, "Int64"]
+];
+function typeName(t) {
+	for (const [bits, name] of NAMED$1) if (t === bits) return name;
+	if (t === T.None) return "None";
+	const parts = [];
+	let rest = t;
+	if ((rest & Number_) === Number_) {
+		parts.push("Number");
+		rest &= ~Number_;
+	}
+	for (const [bit, name] of BITS) if (rest & bit) parts.push(name);
+	return parts.join("|");
+}
+//#endregion
+//#region ir/src/views.ts
+/** Each kind's constructor, and its JSTypedArrayType in C. */
+const VIEWS = {
+	i8: {
+		ctor: "Int8Array",
+		c: "JS_TA_INT8"
+	},
+	u8: {
+		ctor: "Uint8Array",
+		c: "JS_TA_UINT8"
+	},
+	i32: {
+		ctor: "Int32Array",
+		c: "JS_TA_INT32"
+	},
+	f64: {
+		ctor: "Float64Array",
+		c: "JS_TA_FLOAT64"
+	}
+};
+const BY_CTOR = new Map(Object.entries(VIEWS).map(([kind, v]) => [v.ctor, kind]));
+/** The kind whose constructor is named `ctor`. */
+function viewOf(ctor) {
+	return BY_CTOR.get(ctor);
+}
+//#endregion
+//#region ir/src/static.ts
+function isStatic(fn) {
+	return fn.dialect === "static";
+}
+/** By the name the source writes: tsc erases `int` and `i32` to number, so they are known by name. */
+const STATIC_TYPES = {
+	boolean: {
+		type: T.Boolean,
+		words: "boolean"
+	},
+	number: {
+		type: T.Int32 | T.Double,
+		words: "number"
+	},
+	int: {
+		type: T.Int64,
+		int: "i64",
+		words: "number"
+	},
+	i32: {
+		type: T.Int32,
+		int: "i32",
+		words: "i32"
+	},
+	string: {
+		type: T.String,
+		words: "string"
+	},
+	undefined: {
+		type: T.Undefined,
+		words: "undefined"
+	},
+	null: {
+		type: T.Null,
+		words: "null"
+	}
+};
+/** 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) {
+	if (view) return `an instance of ${VIEWS[view].ctor}`;
+	const parts = Object.values(STATIC_TYPES).filter((s) => isSubtype(s.type, t));
+	const widest = parts.filter((s) => !parts.some((o) => o !== s && isSubtype(s.type, o.type)));
+	const names = [...new Set(widest.map((s) => s.words))];
+	return `of type ${names.length > 2 ? `${names.slice(0, -1).join(", ")}, or ${names.at(-1)}` : names.join(" or ")}`;
+}
+//#endregion
 //#region ir/src/ir.ts
 const pure = (arity) => ({
 	arity,
@@ -2866,6 +3101,29 @@ const OPS = {
 		...pure(1),
 		allocates: false
 	},
+	char_code_at: {
+		...pure(2),
+		allocates: true
+	},
+	math: pure(1),
+	int_add: pure(2),
+	int_sub: pure(2),
+	int_mul: pure(2),
+	to_i64: pure(1),
+	to_i32: pure(1),
+	int_div: {
+		...pure(2),
+		mayThrow: true
+	},
+	int_mod: {
+		...pure(2),
+		mayThrow: true
+	},
+	i64: pure(2),
+	identical: pure(2),
+	strict_eq_atom: pure(2),
+	is_type: pure(1),
+	strict_eq_num: pure(2),
 	in: generic(2),
 	instanceof: generic(2),
 	to_property_key: generic(1),
@@ -3136,6 +3394,45 @@ const OPS = {
 	call_runtime: call,
 	take_exception: pure(0)
 };
+/** What a typed parameter of type `t` takes: an int any Number (the function converts it, as C). */
+function accepts(t) {
+	return isSubtype(t, T.Int64) ? Number_ : t;
+}
+/** Whether a direct call of a typed function ("use static") may take its typed entry: each
+*  declared parameter's argument proven of its type (`type`: the types; inference passes the ones
+*  it is inferring). Otherwise the call goes through the checked entry, which throws a TypeError
+*  for an argument that isn't: tsc lets typed code pass a number to an `int`, so a check remains. */
+function declaredCallFits(i, callee, type = (v) => v.type) {
+	const declared = callee.meta?.declared;
+	if (!declared) return true;
+	return declared.every((t, k) => {
+		if (t === void 0) return true;
+		const o = i.operands[k];
+		const a = o ? type(o) & ~T.Empty : T.Undefined;
+		return a !== T.None && isSubtype(a, accepts(t));
+	});
+}
+/** Whether a typed export's call takes its typed entry: as many arguments as it declares, each
+*  proven of its declared type (inference, unboxing and C emission all ask this). A typed array
+*  never is: the type lattice doesn't tell one from any other object. */
+function typedCallFits(i, type = (v) => v.type) {
+	const tc = i.typedCall;
+	if (!tc || i.operands.length - 2 !== tc.params.length || tc.params.some((p) => p.view)) return false;
+	return i.operands.slice(2).every((o, k) => {
+		const t = type(o) & ~T.Empty;
+		return t !== T.None && isSubtype(t, accepts(tc.params[k].type));
+	});
+}
+/** Whether i reads a string's length: its own, read-only property, an int32; reading it runs no code. */
+function isStringLength(i) {
+	const s = i.operands[0];
+	return i.op === "get_prop" && i.key !== void 0 && "name" in i.key && i.key.name === "length" && s !== void 0 && s.type !== T.None && isSubtype(s.type, T.String);
+}
+/** Whether i reads a Float64Array's element in typed code: a double, past the end undefined as
+*  a number (NaN), as its type, number, says. */
+function readsDouble(i) {
+	return i.taView === "f64" && (i.op === "get_index" || i.op === "get_elem") && isStatic(i.block.fn);
+}
 /** The key for `o.name` or `{ 1: v }`: canonical array indices (0 … 2^32 - 2) become index keys. */
 function propKey(v) {
 	const s = String(v);
@@ -3165,59 +3462,6 @@ function isExceptionalEdge(from, to) {
 	return from.handler === to && !normalSuccessors(from).includes(to);
 }
 //#endregion
-//#region ir/src/types.ts
-const T = {
-	None: 0,
-	Undefined: 1,
-	Null: 2,
-	Boolean: 4,
-	Int32: 8,
-	Double: 16,
-	String: 32,
-	Symbol: 64,
-	BigInt: 128,
-	Object: 256,
-	Empty: 512
-};
-const Number_ = T.Int32 | T.Double;
-const Primitive = T.Undefined | T.Null | T.Boolean | Number_ | T.String | T.Symbol | T.BigInt;
-const Any = Primitive | T.Object;
-/** Nothing known: any JS value, or EMPTY (what an uninitialized binding reads). */
-const Unknown = Any | T.Empty;
-function isSubtype(a, b) {
-	return (a & ~b) === 0;
-}
-const NAMED = [
-	[Any | T.Empty, "Any|Empty"],
-	[Any, "Any"],
-	[Primitive, "Primitive"],
-	[Number_, "Number"]
-];
-const BITS = [
-	[T.Undefined, "Undefined"],
-	[T.Null, "Null"],
-	[T.Boolean, "Boolean"],
-	[T.Int32, "Int32"],
-	[T.Double, "Double"],
-	[T.String, "String"],
-	[T.Symbol, "Symbol"],
-	[T.BigInt, "BigInt"],
-	[T.Object, "Object"],
-	[T.Empty, "Empty"]
-];
-function typeName(t) {
-	for (const [bits, name] of NAMED) if (t === bits) return name;
-	if (t === T.None) return "None";
-	const parts = [];
-	let rest = t;
-	if ((rest & Number_) === Number_) {
-		parts.push("Number");
-		rest &= ~Number_;
-	}
-	for (const [bit, name] of BITS) if (rest & bit) parts.push(name);
-	return parts.join("|");
-}
-//#endregion
 //#region ir/src/builder.ts
 var FunctionBuilder = class {
 	fn;
@@ -3528,7 +3772,7 @@ function printFunction(fn) {
 		for (const phi of b.phis) lines.push(`  ${def(phi)}phi ${phi.incoming.map((i) => `[${bb(i.block)}: ${name(i.value)}]`).join(", ")}`);
 		for (const i of b.instrs) {
 			if (i.op === "param") continue;
-			lines.push(`  ${def(i)}${instr(i)}${i.numberFirst ? "  ?number" : ""}${i.builtin ? `  ?${i.builtin}` : ""}${i.mayThrow ? "  !mayThrow" : ""}`);
+			lines.push(`  ${def(i)}${instr(i)}${i.numberFirst ? "  ?number" : ""}${i.builtin ? `  ?${i.builtin}` : ""}${i.keyedSite ? "  ?keyed" : ""}${i.mayThrow ? "  !mayThrow" : ""}`);
 		}
 		if (b.term) lines.push(`  ${term(b.term)}`);
 	}
@@ -3561,6 +3805,11 @@ function printFunction(fn) {
 			case "call_runtime": return `${i.op} ${i.target}(${args})`;
 			case "construct_direct": return `construct_direct ${i.target}(${args})`;
 			case "same_function": return `same_function ${args}, ${i.target}`;
+			case "i64": return `i64 ${i.target} ${args}`;
+			case "is_type": return `${i.index ? "!" : ""}is_type ${args}, ${JSON.stringify(i.target)}`;
+			case "identical":
+			case "strict_eq_atom":
+			case "strict_eq_num": return `${i.index ? "!" : ""}${i.op} ${args}`;
 			case "new_instance": return `new_instance ${args}, ${i.index} slots`;
 			case "get_prop":
 			case "set_prop":
@@ -3706,12 +3955,15 @@ function verify(fn) {
 		boxed: Any | T.Empty,
 		f64: Number_,
 		i32: T.Int32,
+		i64: T.Int64 | T.Int32,
 		bool: T.Boolean
 	};
 	const reprFits = (repr, t) => isSubtype(t, REPR_TYPE[repr]);
+	const int64 = (t) => (t & T.Int64) !== 0 && isSubtype(t, T.Int64 | T.Int32);
 	for (const i of [...fn.params, ...fn.blocks.flatMap((b) => [...b.phis, ...b.instrs])]) {
 		if (!reprFits(i.repr, i.type)) bad(`%${i.id} ${i.op} is ${i.repr} but its type is ${typeName(i.type)}`);
-		if (i.repr !== "boxed" && (i.mayThrow && i.op !== "call_direct" || !OPS[i.op].result)) bad(`%${i.id} ${i.op} is ${i.repr} but can throw or has no result`);
+		if (!isStatic(fn) && int64(i.type)) bad(`%${i.id} ${i.op} is an int64 outside static code`);
+		if (i.repr !== "boxed" && (i.mayThrow && i.op !== "call_direct" && i.op !== "int_div" && i.op !== "int_mod" && !readsDouble(i) && !typedCallFits(i) || !OPS[i.op].result)) bad(`%${i.id} ${i.op} is ${i.repr} but can throw or has no result`);
 	}
 	const ret = fn.returnRepr ?? "boxed";
 	for (const b of fn.blocks) if (b.term?.kind === "return" && !reprFits(ret, b.term.value.type)) bad(`bb${b.id} returns ${typeName(b.term.value.type)} from a function returning ${ret}`);
@@ -3809,6 +4061,21 @@ function hasSpread(items) {
 function notSupported(detail, node) {
 	throw new CompileError("NotSupported", detail, node.loc);
 }
+/** Static code's integer operators: an `i64` (+ - * & | ^ << >> >>>; / and % by a constant other
+*  than 0), or int_div and int_mod. */
+const INT_OPERATORS = /* @__PURE__ */ new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"&",
+	"|",
+	"^",
+	"<<",
+	">>",
+	">>>"
+]);
 /** A function's `name` from its binding: a module's anonymous default export is "default"
 *  (§16.2.3.7), though its hidden binding is `*default*`. */
 function functionName(binding) {
@@ -3859,7 +4126,26 @@ function lower(program, info) {
 		const captured = [...scope.bindings.values()].filter((b) => b.captured);
 		if (captured.length) envs.set(scope, new Map(captured.map((b, i) => [b, i])));
 	}
-	const printAssigned = [...info.references.values()].some((r) => r.id.name === "print" && r.write && !r.binding);
+	const declaredFunctions = /* @__PURE__ */ new Map();
+	const ownNames = /* @__PURE__ */ new Map();
+	for (const fn of info.functions.values()) {
+		const node = fn.node;
+		if (node.type === "FunctionDeclaration") {
+			const binding = info.declarations.get(node.id);
+			if (!declaredFunctions.has(binding)) declaredFunctions.set(binding, fn);
+		} else if (node.type === "FunctionExpression" && node.id) ownNames.set(info.declarations.get(node.id), fn);
+	}
+	const classesById = /* @__PURE__ */ new Map();
+	for (const sc of info.scopes.values()) {
+		const cls = sc.node;
+		if (sc.kind === "class" && cls.id && !classesById.has(cls.id)) classesById.set(cls.id, cls);
+	}
+	let printAssigned = false;
+	const readsOwnName = /* @__PURE__ */ new Set();
+	for (const r of info.references.values()) {
+		if (r.id.name === "print" && r.write && !r.binding) printAssigned = true;
+		if (r.binding && ownNames.get(r.binding) === r.func) readsOwnName.add(r.func);
+	}
 	const m = {
 		info,
 		slots,
@@ -3868,15 +4154,25 @@ function lower(program, info) {
 		inferredNames: /* @__PURE__ */ new Map(),
 		printAssigned,
 		globals,
-		importMetaSlots: /* @__PURE__ */ new Map()
+		importMetaSlots: /* @__PURE__ */ new Map(),
+		declaredFunctions,
+		classesById,
+		readsOwnName,
+		static: program.static === true
 	};
 	const main = new FunctionLowering(m, info.program).run();
 	const functions = [];
-	for (const fn of info.functions.values()) if (fn !== info.program) functions.push(new FunctionLowering(m, fn).run());
-	for (const f of functions) {
-		const node = [...ids].find(([, id]) => id === f.name)[0];
+	const nodes = [];
+	for (const fn of info.functions.values()) {
+		if (fn === info.program) continue;
+		functions.push(new FunctionLowering(m, fn).run());
+		nodes.push(fn.node);
+	}
+	functions.forEach((f, i) => {
+		const node = nodes[i];
 		if (node.type === "FunctionExpression" && !node.id) f.meta.jsName = m.inferredNames.get(node) ?? "";
-	}
+	});
+	if (m.static) for (const fn of [main, ...functions]) fn.dialect = "static";
 	return {
 		main,
 		functions,
@@ -3947,8 +4243,7 @@ var FunctionLowering = class {
 			this.b = new FunctionBuilder("main", [], fn.strict, node.loc);
 			return;
 		}
-		const self = node.type === "FunctionExpression" && node.id ? this.info.declarations.get(node.id) : null;
-		const readsSelf = self !== null && [...this.info.references.values()].some((r) => r.binding === self && r.func === fn);
+		const readsSelf = (node.type === "FunctionExpression" && node.id ? this.info.declarations.get(node.id) : null) !== null && m.readsOwnName.has(fn);
 		const takesArguments = fn.argumentsBinding !== null;
 		const mappedArguments = takesArguments && !fn.strict && fn.simpleParams;
 		const classCtor = node.type === "FunctionExpression" ? node.classCtor : null;
@@ -4085,7 +4380,6 @@ var FunctionLowering = class {
 			name: "arguments"
 		});
 	}
-	/** A parameter with a default: the argument, or the default when it's undefined. */
 	/** After gen_start or async_start: the resume function's first block. */
 	startBody() {
 		const b = this.b;
@@ -4474,6 +4768,7 @@ var FunctionLowering = class {
 		return true;
 	}
 	write(binding, value) {
+		if (this.m.static && binding.node.int && value.op !== "empty") value = this.toInt(value, binding.node.int);
 		if (this.isGlobalVar(binding)) {
 			this.b.emit("set_prop", [this.b.emit("global_this", []), value], { key: propKey(binding.name) });
 			return;
@@ -4516,6 +4811,35 @@ var FunctionLowering = class {
 		});
 		return ref.tdz ? b.emit("check_tdz", [v], { name: binding.name }) : v;
 	}
+	/** Static code: whether `e` is an integer, as C's types say: an int binding, an integer
+	*  literal, a call of a function declared to return one, or integer arithmetic of those. A
+	*  `number` is a double, whatever values it holds. */
+	isInt(e) {
+		if (!this.m.static) return false;
+		const declared = (id) => this.info.references.get(id)?.binding?.node;
+		switch (e.type) {
+			case "Literal": return typeof e.value === "number" && Number.isInteger(e.value) && !e.float;
+			case "Identifier": return declared(e)?.int !== void 0;
+			case "UnaryExpression": return (e.operator === "-" || e.operator === "~") && this.isInt(e.argument);
+			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 "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;
+		}
+	}
+	/** Static code's integer arithmetic, C's: / and % by a constant other than 0 can't throw. */
+	int64(operator, left, right) {
+		if ((operator === "/" || operator === "%") && !(right.op === "const" && right.lit.value !== 0)) return this.b.emit(operator === "/" ? "int_div" : "int_mod", [left, right]);
+		return this.b.emit("i64", [left, right], { target: operator });
+	}
+	/** Static code: `value` converted to an integer, as C converts what is stored in one. */
+	toInt(value, kind) {
+		const op = kind === "i32" ? "to_i32" : "to_i64";
+		if (value.op === op || kind === "i64" && (value.op === "i64" || value.op === "int_div" || value.op === "int_mod")) return value;
+		return this.b.emit(op, [value]);
+	}
 	/** Assigns to an identifier (not a declaration's initialization). */
 	assign(id, value) {
 		const ref = this.info.references.get(id);
@@ -4607,6 +4931,8 @@ var FunctionLowering = class {
 			case "ReturnStatement": {
 				let value = s.argument ? this.expression(s.argument) : b.const(void 0);
 				if (s.argument && this.asyncGenerator) value = b.emit("await", [value]);
+				const returnsInt = this.fn.node.type === "Program" ? void 0 : this.fn.node.returnsInt;
+				if (this.m.static && returnsInt) value = this.toInt(value, returnsInt);
 				if (this.derivedCtor) value = s.argument ? b.emit("derived_return", [value, this.loadBinding(this.fn.thisBinding)]) : this.readThis();
 				b.writeVariable(this.retval, value);
 				return this.transfer({ kind: "return" }, this.frames.length);
@@ -5103,6 +5429,7 @@ var FunctionLowering = class {
 				if (e.operator === "delete") return this.delete(e);
 				const v = e.operator === "typeof" && e.argument.type === "Identifier" ? this.read(this.info.references.get(e.argument), e.argument, true) : this.expression(e.argument);
 				b.loc = e.loc;
+				if ((e.operator === "-" || e.operator === "~") && this.isInt(e.argument)) return e.operator === "-" ? this.int64("-", b.const(0), v) : this.int64("^", v, b.const(-1));
 				switch (e.operator) {
 					case "-": return b.emit("neg", [v]);
 					case "+": return b.emit("to_number", [v]);
@@ -5117,6 +5444,11 @@ var FunctionLowering = class {
 				const target = this.targetRef(e.argument, true);
 				const old = this.readTarget(target);
 				b.loc = e.loc;
+				if (this.isInt(e.argument)) {
+					const updated = this.int64(e.operator === "++" ? "+" : "-", old, b.const(1));
+					this.writeTarget(target, updated);
+					return e.prefix ? updated : old;
+				}
 				const num = b.emit("to_numeric", [old]);
 				const updated = b.emit(e.operator === "++" ? "inc" : "dec", [num]);
 				this.writeTarget(target, updated);
@@ -5131,6 +5463,7 @@ var FunctionLowering = class {
 				const left = this.expression(e.left);
 				const right = this.expression(e.right);
 				b.loc = e.loc;
+				if (this.isInt(e)) return this.int64(e.operator, left, right);
 				return b.emit(BINARY[e.operator], [left, right]);
 			}
 			case "LogicalExpression": return this.logical(e.operator, () => this.expression(e.left), () => this.expression(e.right));
@@ -5400,7 +5733,8 @@ var FunctionLowering = class {
 		const old = this.readTarget(target);
 		const rhs = this.expression(e.value);
 		b.loc = e.loc;
-		const value = b.emit(BINARY[e.operator.slice(0, -1)], [old, rhs]);
+		const operator = e.operator.slice(0, -1);
+		const value = INT_OPERATORS.has(operator) && this.isInt(e.target) && this.isInt(e.value) ? this.int64(operator, old, rhs) : b.emit(BINARY[operator], [old, rhs]);
 		this.writeTarget(target, value);
 		return value;
 	}
@@ -5476,8 +5810,6 @@ var FunctionLowering = class {
 			value
 		]);
 	}
-	/** An assignment target, evaluated once. `readFirst`: a compound assignment or update,
-	*  which converts a computed key once for both the read and the write. */
 	/** A binding's current value, without a TDZ check. */
 	loadBinding(binding) {
 		if (this.isLocal(binding)) return this.b.readVariable(binding);
@@ -5626,6 +5958,8 @@ var FunctionLowering = class {
 		this.exitScope(scope);
 		return ctor;
 	}
+	/** An assignment target, evaluated once. `readFirst`: a compound assignment or update,
+	*  which converts a computed key once for both the read and the write. */
 	targetRef(t, readFirst) {
 		if (t.type === "Identifier") return { id: t };
 		const ref = this.memberRef(t);
@@ -5746,7 +6080,7 @@ var FunctionLowering = class {
 			}
 			return this.genericCall(this.expression(callee), b.const(void 0), e, calleeText(callee));
 		}
-		const target = [...this.info.functions.values()].find((f) => f.node.type === "FunctionDeclaration" && this.info.declarations.get(f.node.id) === binding);
+		const target = this.m.declaredFunctions.get(binding);
 		if (binding.scope !== this.info.program.scope || binding.reassigned || !target || hasSpread(e.arguments) || target.argumentsBinding || target.generator) return this.genericCall(this.expression(callee), b.const(void 0), e, calleeText(callee));
 		const decl = target.node;
 		const args = e.arguments.map((a) => this.expression(a));
@@ -5768,9 +6102,9 @@ var FunctionLowering = class {
 		const binding = this.info.references.get(e.callee)?.binding;
 		if (!binding || binding.reassigned) return null;
 		let ctor;
-		if (binding.kind === "function") ctor = [...this.info.functions.values()].find((f) => f.node.type === "FunctionDeclaration" && this.info.declarations.get(f.node.id) === binding)?.node;
+		if (binding.kind === "function") ctor = this.m.declaredFunctions.get(binding)?.node;
 		else if (binding.kind === "class" || binding.kind === "const" && binding.scope.kind === "class") {
-			const cls = [...this.info.scopes.values()].find((sc) => sc.kind === "class" && sc.node.id === binding.node)?.node;
+			const cls = this.m.classesById.get(binding.node);
 			if (cls && !cls.superClass) ctor = cls.ctor;
 		} else {
 			const init = this.info.initializers.get(binding);
@@ -6032,8 +6366,7 @@ const RUNTIME = {
 function argArray(args) {
 	return args.length ? `(const JSValue[]){ ${args.join(", ")} }` : "NULL";
 }
-/** A C identifier fragment from a JS name. */
-function ident(name) {
+function ident$1(name) {
 	let out = "";
 	for (const ch of name) out += /[A-Za-z0-9_]/.test(ch) ? ch : `_u${ch.codePointAt(0).toString(16)}_`;
 	return out;
@@ -6218,12 +6551,14 @@ const C_TYPE = {
 	boxed: "JSValue",
 	f64: "double",
 	i32: "int32_t",
+	i64: "int64_t",
 	bool: "bool"
 };
 const C_ZERO = {
 	boxed: "JS_UNDEFINED",
 	f64: "0",
 	i32: "0",
+	i64: "0",
 	bool: "false"
 };
 /** What a direct entry returns after a throw: unboxed, any value, the pending
@@ -6232,17 +6567,50 @@ const C_FAIL = {
 	boxed: "JS_EXCEPTION",
 	f64: "0",
 	i32: "0",
+	i64: "0",
 	bool: "false"
 };
 /** A C expression of repr `from` as repr `to`, when the type allows it (an int32_t only ever
 *  holds int32s, so converting to one can't lose anything). */
 function convert(expr, from, to) {
 	if (from === to) return expr;
+	if (from === "i64") return to === "boxed" ? `js_number((double)(${expr}))` : to === "f64" ? `(double)(${expr})` : to === "i32" ? `(int32_t)(${expr})` : `((${expr}) != 0)`;
+	if (to === "i64") return from === "i32" ? `(int64_t)(${expr})` : from === "f64" ? `js_f64_to_i64(${expr})` : from === "bool" ? `(int64_t)(${expr})` : `js_value_to_i64(${expr})`;
 	if (from === "i32") return to === "boxed" ? `js_int32(${expr})` : `(double)(${expr})`;
 	if (to === "boxed") return from === "bool" ? `js_bool(${expr})` : `js_number(${expr})`;
 	if (to === "i32") return from === "f64" ? `(int32_t)(${expr})` : `js_as_int32_value(${expr})`;
 	return to === "bool" ? `js_as_bool(${expr})` : `js_as_number(${expr})`;
 }
+/** The narrowest repr that holds every value of a type: an int32_t, an int64_t, a double, or boxed. */
+function reprOf(t) {
+	if (isSubtype(t, T.Int32)) return "i32";
+	if (isSubtype(t, T.Int64 | T.Int32)) return "i64";
+	return isSubtype(t, Number_) ? "f64" : "boxed";
+}
+/** The operators on proven Numbers (specialize's num_* forms): their C is unboxed() either way. */
+const NUM_OPS = /* @__PURE__ */ new Set([
+	"num_add",
+	"num_sub",
+	"num_mul",
+	"num_div",
+	"num_mod",
+	"num_neg",
+	"num_inc",
+	"num_dec",
+	"num_lt",
+	"num_le",
+	"num_gt",
+	"num_ge",
+	"num_eq",
+	"num_ne",
+	"num_bitand",
+	"num_bitor",
+	"num_bitxor",
+	"num_bitnot",
+	"num_shl",
+	"num_sar",
+	"num_shr"
+]);
 /** Number comparisons: a C bool from doubles or int32s. */
 const BOOL_OPS = /* @__PURE__ */ new Set([
 	"num_lt",
@@ -6252,7 +6620,6 @@ const BOOL_OPS = /* @__PURE__ */ new Set([
 	"num_eq",
 	"num_ne"
 ]);
-/** A Number as a C double literal. */
 function cDouble(d) {
 	if (Number.isNaN(d)) return "NAN";
 	if (d === Infinity) return "INFINITY";
@@ -6261,9 +6628,47 @@ function cDouble(d) {
 	if (Number.isSafeInteger(d)) return `${d}.0`;
 	return hexFloat(d);
 }
-/** Inline caches: one per *_prop site with a named key, in mod_ics[]. */
+/** A charCodeAt whose index inference proved in the string: its result an int32. */
+const inString = (i) => isSubtype(i.type, T.Int32) && i.type !== T.None;
+/** Static code's integer operator on int64_ts, as C's: wrapping (as unsigned), shifts mod 64,
+*  INT64_MIN / -1 wrapping too (C leaves it undefined). */
+function int64Op(op, x, y) {
+	const wrap = (o) => `(int64_t)((uint64_t)${x} ${o} (uint64_t)${y})`;
+	switch (op) {
+		case "+":
+		case "-":
+		case "*": return wrap(op);
+		case "/": return `(${y} == -1 ? (int64_t)(0 - (uint64_t)${x}) : ${x} / ${y})`;
+		case "%": return `(${y} == -1 ? INT64_C(0) : ${x} % ${y})`;
+		case "&":
+		case "|":
+		case "^": return `(${x} ${op} ${y})`;
+		case "<<": return `(int64_t)((uint64_t)${x} << (${y} & 63))`;
+		case ">>": return `(${x} >> (${y} & 63))`;
+		case ">>>": return `(int64_t)((uint64_t)${x} >> (${y} & 63))`;
+		default: throw new Error(`i64 ${op}`);
+	}
+}
+/** `typeof v === name` (or v == null, name "nullish") as a C condition: js_typeof's cases. */
+function isTypeTest(name, v) {
+	switch (name) {
+		case "nullish": return `js_is_nullish(${v})`;
+		case "undefined": return `js_is_undefined(${v})`;
+		case "boolean": return `js_is_bool(${v})`;
+		case "number": return `js_is_number(${v})`;
+		case "string": return `js_is_string(${v})`;
+		case "symbol": return `js_is_symbol(${v})`;
+		case "bigint": return `js_is_bigint(${v})`;
+		case "function": return `js_is_callable(${v})`;
+		case "object": return `(js_is_null(${v}) || (js_is_object(${v}) && !js_is_callable(${v})))`;
+		default: return "false";
+	}
+}
+/** Inline caches: one per *_prop site with a named key, in mod_ics[]; a keyed site's key, in
+*  mod_keys[] (GC roots). */
 var Caches = class {
 	count = 0;
+	keys = 0;
 };
 function constant(v, strings) {
 	if (v === void 0) return "JS_UNDEFINED";
@@ -6278,10 +6683,10 @@ function constant(v, strings) {
 	return `js_double(${hexFloat(v)})`;
 }
 function cFunctionName(fn, isMain, prefix = "") {
-	return isMain ? `${prefix}js_script` : `${prefix}jsf_${ident(fn.name)}`;
+	return isMain ? `${prefix}js_script` : `${prefix}jsf_${ident$1(fn.name)}`;
 }
 function infoName(fnName, prefix) {
-	return `${prefix}jsfi_${ident(fnName)}`;
+	return `${prefix}jsfi_${ident$1(fnName)}`;
 }
 /** A function's `this` parameter in its direct entry (after the environment and the
 *  function object), when it takes one. */
@@ -6300,6 +6705,20 @@ function instanceSlots(fn) {
 	for (const b of fn.blocks) for (const i of b.instrs) if (addsToThis$1(fn, i)) keys.add(i.key.name);
 	return keys.size ? Math.min(keys.size, 16) : 4;
 }
+/** A C test that `v` (evaluated more than once) has one of the kinds in `t`. */
+function typeTest(t, v) {
+	const tests = [];
+	if (t & T.Undefined) tests.push(`js_is_undefined(${v})`);
+	if (t & T.Null) tests.push(`js_is_null(${v})`);
+	if (t & T.Boolean) tests.push(`js_is_bool(${v})`);
+	if ((t & Number_) === Number_ || t & (T.Double | T.Int64)) tests.push(`js_is_number(${v})`);
+	else if (t & T.Int32) tests.push(`js_is_int32(${v})`);
+	if (t & T.String) tests.push(`js_is_string(${v})`);
+	if (t & T.Symbol) tests.push(`js_is_symbol(${v})`);
+	if (t & T.BigInt) tests.push(`js_is_bigint(${v})`);
+	if (t & T.Object) tests.push(`js_is_object(${v})`);
+	return tests.length ? tests.join(" || ") : "false";
+}
 /** The generic entry: unpacks argv into the direct entry's parameters. */
 function genericEntry(fn, prefix) {
 	const meta = fn.meta;
@@ -6324,9 +6743,17 @@ function genericEntry(fn, prefix) {
 	].filter((p) => !(p === "callee" && (meta.takesCallee || meta.takesEnv)) && !(p === "this_val" && meta.takesThis) && !((p === "argc" || p === "argv") && usesArgv) && !(p === "new_target" && meta.takesNewTarget));
 	const call = `${direct}(${["ctx", ...args.map((a, k) => convert(a, "boxed", fn.params[k].repr))].join(", ")})`;
 	const ret = fn.returnRepr ?? "boxed";
+	const hidden = fn.params.length - declared - Number(meta.hasRest);
+	const checks = (meta.declared ?? []).flatMap((t, k) => {
+		if (t === void 0) return [];
+		const v = `(argc > ${k - hidden} ? argv[${k - hidden}] : JS_UNDEFINED)`;
+		const view = meta.declaredViews?.[k];
+		return [`    if (!(${view ? `js_ta_is(ctx, ${v}, ${VIEWS[view].c})` : typeTest(t, v)})) return js_throw_invalid_arg_type(ctx, ${cString(fn.params[k].name ?? `argument ${k - hidden + 1}`)}, ${cString(expectedText(t, view))}, ${v});`];
+	});
 	return [
-		`static JSValue ${direct}__generic(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {`,
+		`${meta.declared ? "" : "static "}JSValue ${direct}__generic(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {`,
 		...unused.length ? [`    ${unused.map((u) => `(void)${u};`).join(" ")}`] : [],
+		...checks,
 		...ret === "boxed" ? [`    return ${call};`] : [`    ${C_TYPE[ret]} r = ${call};`, `    return js_has_exception(ctx) ? JS_EXCEPTION : ${convert("r", ret, "boxed")};`],
 		"}"
 	].join("\n");
@@ -6361,6 +6788,8 @@ function functionInfo(fn, strings, embedSource, shared = false) {
 var Hosts = class {
 	table;
 	used = /* @__PURE__ */ new Set();
+	/** Typed entries of a typed unit this module calls: their prototypes. */
+	typed = /* @__PURE__ */ new Map();
 	constructor(table) {
 		this.table = table;
 	}
@@ -6371,7 +6800,7 @@ var Hosts = class {
 		return host;
 	}
 	decls() {
-		return [...this.used].sort().map((c) => `JSValue ${c}(JSContext *, JSValue, JSValue, uint32_t, const JSValue *, JSValue);  /* host primitive */`);
+		return [...[...this.used].sort().map((c) => `JSValue ${c}(JSContext *, JSValue, JSValue, uint32_t, const JSValue *, JSValue);  /* host primitive */`), ...[...this.typed.values()].sort()];
 	}
 };
 var FunctionEmitter = class {
@@ -6388,6 +6817,9 @@ var FunctionEmitter = class {
 	/** Values something needs: instructions and terminators, and the phis feeding them. */
 	used = /* @__PURE__ */ new Set();
 	labels = /* @__PURE__ */ new Set();
+	/** An exception leaves the function: through one shared return, which GCC compiles faster than
+	*  a return at each check (4% of a large program's compile time). */
+	exits = false;
 	lines = [];
 	lastLoc = null;
 	constructor(fn, cname, strings, caches, hosts, callees) {
@@ -6459,9 +6891,8 @@ var FunctionEmitter = class {
 	v(i) {
 		return this.as(i, "boxed");
 	}
-	/** A value's C variable. */
 	name(i) {
-		return `v${i.id}${i.name ? `_${ident(i.name)}` : ""}`;
+		return `v${i.id}${i.name ? `_${ident$1(i.name)}` : ""}`;
 	}
 	/** A value as a C expression in representation `repr` (the optimizer's unbox pass
 	*  proved the type, so unboxing can't fail). */
@@ -6470,6 +6901,7 @@ var FunctionEmitter = class {
 			const value = i.lit.value;
 			if (repr === "f64") return cDouble(value);
 			if (repr === "i32") return value === -2147483648 ? "INT32_MIN" : `${value}`;
+			if (repr === "i64") return Number.isSafeInteger(value) ? `INT64_C(${value})` : `js_f64_to_i64(${cDouble(value)})`;
 			if (repr === "bool") return value ? "true" : "false";
 			return constant(value, this.strings);
 		}
@@ -6478,9 +6910,21 @@ var FunctionEmitter = class {
 	}
 	/** A num_* operator on unboxed operands: plain C. Doubles; int32s where both operands are
 	*  (an int32 result is one inference proved can't overflow); bitwise ones through ToInt32. */
-	unboxed(i) {
+	unboxed(i, repr = i.repr) {
 		const isInt = (o) => isSubtype(o.type, T.Int32);
-		if (i.operands.every(isInt) && (i.repr === "i32" || BOOL_OPS.has(i.op))) {
+		const isLong = (o) => isSubtype(o.type, T.Int64 | T.Int32);
+		if (BOOL_OPS.has(i.op) && i.operands.every(isLong) && i.operands.some((o) => (o.type & T.Int64) !== 0)) {
+			const [x, y] = i.operands.map((o) => this.as(o, "i64"));
+			switch (i.op) {
+				case "num_lt": return `${x} < ${y}`;
+				case "num_le": return `${x} <= ${y}`;
+				case "num_gt": return `${x} > ${y}`;
+				case "num_ge": return `${x} >= ${y}`;
+				case "num_eq": return `${x} == ${y}`;
+				case "num_ne": return `${x} != ${y}`;
+			}
+		}
+		if (i.operands.every(isInt) && (repr === "i32" || BOOL_OPS.has(i.op))) {
 			const [x, y] = i.operands.map((o) => this.as(o, "i32"));
 			switch (i.op) {
 				case "num_add": return `${x} + ${y}`;
@@ -6497,7 +6941,7 @@ var FunctionEmitter = class {
 		}
 		const [a, b] = i.operands.map((o) => this.as(o, "f64"));
 		const [ia, ib] = i.operands.map((o) => isInt(o) ? this.as(o, "i32") : `js_f64_to_int32(${this.as(o, "f64")})`);
-		const bits = (expr) => i.repr === "i32" ? expr : `(double)(${expr})`;
+		const bits = (expr) => repr === "i32" ? expr : `(double)(${expr})`;
 		switch (i.op) {
 			case "num_add": return `${a} + ${b}`;
 			case "num_sub": return `${a} - ${b}`;
@@ -6554,7 +6998,6 @@ var FunctionEmitter = class {
 		this.labels.add(to);
 		return [...this.copies(from, to), `goto bb${to.id};`].join(" ");
 	}
-	/** Where an exception raised in `b` goes. */
 	/** `new F(…)` of a constructor of this module. When F's value is that
 	*  function (made in this realm), `this` comes from js_new_instance and the constructor's direct
 	*  entry runs; an object it returns wins, as in [[Construct]] (§10.2.2). Anything else, through
@@ -6571,7 +7014,7 @@ var FunctionEmitter = class {
 			...meta.takesNewTarget ? ["c"] : []
 		];
 		const passed = i.operands.slice(1).map((o, k) => this.as(o, callee.params[hidden.length + k]?.repr ?? "boxed"));
-		const call = `${this.strings.prefix}jsf_${ident(callee.name)}(ctx${[...hidden, ...passed].map((a) => `, ${a}`).join("")})`;
+		const call = `${this.strings.prefix}jsf_${ident$1(callee.name)}(ctx${[...hidden, ...passed].map((a) => `, ${a}`).join("")})`;
 		const ret = callee.returnRepr ?? "boxed";
 		const result = out ? `${out} = ` : "";
 		this.lines.push(`    { JSValue c = ${args[0]};`, `    if (JS_LIKELY(js_is_function(c) && js_as_function(c)->info == &${infoName(callee.name, this.strings.prefix)} && js_as_function(c)->realm == ctx)) {`, `        JSValue t = js_new_instance(ctx, c, ${instanceSlots(callee)}, ${this.cache()});`, `        if (JS_UNLIKELY(js_is_exception(t))) { ${fail} }`, ...ret === "boxed" ? [
@@ -6586,6 +7029,72 @@ var FunctionEmitter = class {
 			...out ? [`        ${result}t;`] : []
 		], "    } else {", `        JSValue r = js_construct(ctx, c, ${args.length - 1}, ${argArray(args.slice(1))}, JS_UNDEFINED, ${cString(i.text ?? "")});`, `        if (JS_UNLIKELY(js_is_exception(r))) { ${fail} }`, ...out ? [`        ${result}r;`] : ["        js_discard(r);"], "    } }");
 	}
+	/** An access of a typed array's view (the typed-arrays pass): the variant for its key's repr
+	*  (_l an int64_t, _i an int32_t, _d a double); a set with `strict`, of a double unboxed. A
+	*  double read (readsDouble) stores into `d`. */
+	viewAccess(i, args, strict) {
+		const key = i.operands[1];
+		const [suffix, k] = key.repr === "i64" ? ["_l", this.as(key, "i64")] : key.repr === "i32" ? ["_i", this.as(key, "i32")] : key.repr === "f64" ? ["_d", this.as(key, "f64")] : ["", args[1]];
+		const view = `&${this.name(i.operands[0])}_view`;
+		if (strict === void 0) return readsDouble(i) ? `js_tav_num_f64${suffix}(ctx, ${view}, ${args[0]}, ${k}, &d)` : `js_tav_get_${i.taView}${suffix}(ctx, ${view}, ${args[0]}, ${k})`;
+		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 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)}; }` : "    }");
+	}
+	/** A call returning a JSValue: its exception checked, its result into i's variable. */
+	boxedCall(i, call) {
+		const out = this.hasVar(i) ? this.name(i) : null;
+		this.lines.push(`    { JSValue r = ${call};`, `    if (JS_UNLIKELY(js_is_exception(r))) { ${this.onException(i.block)} }`, ...out ? [`    ${out} = ${convert("r", "boxed", i.repr)}; }`] : ["    js_discard(r); }"]);
+	}
+	/** The string parameters whose units this function reads at indices inference proved in them:
+	*  their units taken once, on entry (strings don't change, and the GC doesn't move cells; a
+	*  rope not yet flattened has none, and each read takes the slow path). */
+	stringViewList = null;
+	stringViews() {
+		this.stringViewList ??= new Set(this.fn.blocks.flatMap((b) => b.instrs).filter((i) => i.op === "char_code_at" && inString(i) && i.operands[0].op === "param").map((i) => i.operands[0]));
+		return this.stringViewList;
+	}
+	/** The typed arrays this function holds views of (the typed-arrays pass). */
+	viewList = null;
+	views() {
+		this.viewList ??= [.../* @__PURE__ */ new Set([...this.fn.params, ...this.fn.blocks.flatMap((b) => b.instrs)])].filter((v) => v.taView && (v.op === "param" || v.op === "new"));
+		return this.viewList;
+	}
+	/** A call of a typed unit's export: its typed entry when the arguments are proven of the
+	*  declared types (as many as it declares); else, for as many arguments as it declares, the
+	*  typed entry when C's tests of them pass; else its checked entry, called directly. */
+	typedCall(i, tc, args) {
+		const operands = i.operands.slice(2);
+		const fits = typedCallFits(i);
+		if (!fits && operands.length !== tc.params.length) {
+			this.genericCall(i, tc, args);
+			return;
+		}
+		this.hosts.typed.set(tc.direct, `${C_TYPE[tc.returnRepr]} ${tc.direct}(JSContext *${tc.params.map((p) => `, ${C_TYPE[p.repr]}`).join("")});  /* typed entry */`);
+		const tests = fits ? [] : operands.flatMap((o, k) => {
+			const { type, view } = tc.params[k];
+			if (view) return [`js_ta_is(ctx, ${args[k + 2]}, ${VIEWS[view].c})`];
+			return isSubtype(o.type & ~T.Empty, type) ? [] : [`(${typeTest(type, args[k + 2])})`];
+		});
+		const call = `${tc.direct}(ctx${operands.map((o, k) => `, ${tests.length ? convert(args[k + 2], "boxed", tc.params[k].repr) : this.as(o, tc.params[k].repr)}`).join("")})`;
+		if (tests.length) this.lines.push(`    if (${tests.join(" && ")}) {`);
+		if (tc.returnRepr === "boxed") this.boxedCall(i, call);
+		else {
+			const out = this.hasVar(i) ? this.name(i) : null;
+			this.lines.push(`    { ${C_TYPE[tc.returnRepr]} r = ${call};`, `    if (JS_UNLIKELY(js_has_exception(ctx))) { ${this.onException(i.block)} }`, ...out ? [`    ${out} = ${convert("r", tc.returnRepr, i.repr)}; }`] : ["    (void)r; }"]);
+		}
+		if (!tests.length) return;
+		this.lines.push("    } else {");
+		this.genericCall(i, tc, args);
+		this.lines.push("    }");
+	}
+	genericCall(i, tc, args) {
+		this.hosts.used.add(tc.generic);
+		this.boxedCall(i, `${tc.generic}(ctx, JS_UNDEFINED, ${args[1]}, ${args.length - 2}, ${argArray(args.slice(2))}, JS_UNDEFINED)`);
+	}
 	/** The values this function calls, or checks as an inlined call's callee. */
 	calledValues = null;
 	called() {
@@ -6596,11 +7105,17 @@ var FunctionEmitter = class {
 		return this.calledValues;
 	}
 	onException(b) {
-		return b.handler ? this.goto(b, b.handler) : `return ${C_FAIL[this.fn.returnRepr ?? "boxed"]};`;
+		if (b.handler) return this.goto(b, b.handler);
+		if (this.gen) return `return ${C_FAIL[this.fn.returnRepr ?? "boxed"]};`;
+		this.exits = true;
+		return "goto exc_;";
 	}
 	key(i) {
 		return keyValue(i.key, this.strings);
 	}
+	keyedCache() {
+		return `&${this.strings.prefix}mod_keys[${this.caches.keys++}], ${this.cache()}`;
+	}
 	cache() {
 		return `&${this.strings.prefix}mod_ics[${this.caches.count++}]`;
 	}
@@ -6675,7 +7190,7 @@ var FunctionEmitter = class {
 					expr = `js_new_arguments(ctx, ${args[0]}, JS_UNDEFINED, JS_UNDEFINED, NULL, 0)`;
 					break;
 				}
-				const table = `${this.strings.prefix}jsam_${ident(this.fn.name)}`;
+				const table = `${this.strings.prefix}jsam_${ident$1(this.fn.name)}`;
 				const entries = i.table.length ? i.table.map((t) => t < 0 ? "UINT32_MAX" : String(t)) : ["UINT32_MAX"];
 				this.strings.decls.push(datum("uint32_t", `${table}[]`, `{ ${entries.join(", ")} }`));
 				expr = `js_new_arguments(ctx, ${args[0]}, ${args[1]}, ${args[2]}, ${table}, ${i.table.length})`;
@@ -6727,7 +7242,7 @@ var FunctionEmitter = class {
 				const length = "name" in i.key && i.key.name === "length";
 				const str = i.operands[0].type !== T.None && isSubtype(i.operands[0].type, T.String);
 				if (str && length) {
-					expr = `js_int32((int32_t)js_string_length(${args[0]}))`;
+					expr = convert(`(int32_t)js_string_length(${this.as(i.operands[0], "boxed")})`, "i32", i.repr);
 					break;
 				}
 				const get = str ? "js_get_string_prop" : length ? "js_get_length" : this.called().has(i) ? "js_get_method" : "js_get_prop";
@@ -6735,19 +7250,37 @@ var FunctionEmitter = class {
 				break;
 			}
 			case "get_elem":
-				expr = `js_get_elem(ctx, ${args[0]}, ${args[1]})`;
+				if (readsDouble(i)) return this.readDouble(i, args);
+				if (i.taView) {
+					expr = this.viewAccess(i, args);
+					break;
+				}
+				expr = i.keyedSite ? `js_get_keyed(ctx, ${args[0]}, ${args[1]}, ${this.keyedCache()})` : `js_get_elem(ctx, ${args[0]}, ${args[1]})`;
 				break;
 			case "get_index":
-				expr = i.operands[1].repr === "f64" ? `js_get_index_f64(ctx, ${args[0]}, ${this.as(i.operands[1], "f64")})` : `js_get_index(ctx, ${args[0]}, ${args[1]})`;
+				if (readsDouble(i)) return this.readDouble(i, args);
+				if (i.taView) {
+					expr = this.viewAccess(i, args);
+					break;
+				}
+				expr = i.operands[1].repr === "f64" || i.operands[1].repr === "i64" ? `js_get_index_ta_f64(ctx, ${args[0]}, ${this.as(i.operands[1], "f64")})` : `js_get_index_ta(ctx, ${args[0]}, ${args[1]})`;
 				break;
 			case "set_prop":
 				status = "name" in i.key ? `${i.addsProp || addsToThis$1(this.fn, i) ? "js_set_prop_add" : "js_set_prop"}(ctx, ${args[0]}, ${this.key(i)}, ${args[1]}, ${strict}, ${this.cache()})` : `js_set_value(ctx, ${args[0]}, ${this.key(i)}, ${args[1]}, ${strict})`;
 				break;
 			case "set_elem":
-				status = `js_set_elem(ctx, ${args[0]}, ${args[1]}, ${args[2]}, ${strict})`;
+				if (i.taView) {
+					status = this.viewAccess(i, args, strict);
+					break;
+				}
+				status = i.keyedSite ? `js_set_keyed(ctx, ${args[0]}, ${args[1]}, ${args[2]}, ${strict}, ${this.keyedCache()})` : `js_set_elem(ctx, ${args[0]}, ${args[1]}, ${args[2]}, ${strict})`;
 				break;
 			case "set_index":
-				status = i.operands[1].repr === "f64" ? `js_set_index_f64(ctx, ${args[0]}, ${this.as(i.operands[1], "f64")}, ${args[2]}, ${strict})` : `js_set_index(ctx, ${args[0]}, ${args[1]}, ${args[2]}, ${strict})`;
+				if (i.taView) {
+					status = this.viewAccess(i, args, strict);
+					break;
+				}
+				status = i.operands[1].repr === "f64" || i.operands[1].repr === "i64" ? `js_set_index_ta_f64(ctx, ${args[0]}, ${this.as(i.operands[1], "f64")}, ${args[2]}, ${strict})` : `js_set_index_ta(ctx, ${args[0]}, ${args[1]}, ${args[2]}, ${strict})`;
 				break;
 			case "delete_prop":
 				expr = `js_delete_value(ctx, ${args[0]}, ${this.key(i)}, ${strict})`;
@@ -6851,6 +7384,18 @@ var FunctionEmitter = class {
 				expr = `js_construct_spread(ctx, ${args[0]}, ${args[1]}, ${cString(i.target)})`;
 				break;
 			case "call":
+				if (i.typedCall) {
+					this.typedCall(i, i.typedCall, args);
+					return;
+				}
+				if (i.builtin === "apply") {
+					expr = `js_call_apply(ctx, ${args[0]}, ${args[1]}, ${args[2] ?? "JS_UNDEFINED"}, ${args[3] ?? "JS_UNDEFINED"}, ${cString(i.target)})`;
+					break;
+				}
+				if (i.builtin === "call") {
+					expr = `js_call_call(ctx, ${args[0]}, ${args[1]}, ${args.length - 2}, ${argArray(args.slice(2))}, ${cString(i.target)})`;
+					break;
+				}
 				if (i.builtin) {
 					expr = `js_call_${i.builtin}(ctx, ${args[0]}, ${args[1]}, ${args[2]}, ${cString(i.target)})`;
 					break;
@@ -6859,6 +7404,10 @@ var FunctionEmitter = class {
 				break;
 			case "new":
 				expr = `js_construct(ctx, ${args[0]}, ${args.length - 1}, ${argArray(args.slice(1))}, JS_UNDEFINED, ${cString(i.target)})`;
+				if (i.taView && this.hasVar(i)) {
+					this.lines.push(`    ${this.name(i)} = ${expr};`, `    if (JS_UNLIKELY(js_is_exception(${this.name(i)}))) { ${this.onException(i.block)} }`, `    ${this.name(i)}_view = js_ta_view(ctx, ${this.name(i)}, ${VIEWS[i.taView].c});`);
+					return;
+				}
 				break;
 			case "check_tdz":
 				expr = `js_check_tdz(ctx, ${args[0]}, ${cString(i.name ?? "variable")})`;
@@ -6866,6 +7415,65 @@ var FunctionEmitter = class {
 			case "construct_direct":
 				this.constructDirect(i, args);
 				return;
+			case "math": {
+				const f = {
+					sqrt: "sqrt",
+					abs: "fabs",
+					floor: "floor",
+					ceil: "ceil",
+					trunc: "trunc"
+				}[i.target];
+				expr = convert(`${f}(${this.as(i.operands[0], "f64")})`, "f64", i.repr);
+				break;
+			}
+			case "int_div":
+			case "int_mod": {
+				const [x, y] = i.operands.map((o) => this.as(o, "i64"));
+				this.lines.push(`    if (JS_UNLIKELY(${y} == 0)) { js_discard(js_throw_range_error(ctx, "Division by zero")); ${this.onException(i.block)} }`);
+				if (this.hasVar(i)) this.lines.push(`    ${this.name(i)} = ${convert(int64Op(i.op === "int_div" ? "/" : "%", x, y), "i64", i.repr)};`);
+				return;
+			}
+			case "i64":
+				expr = convert(int64Op(i.target, this.as(i.operands[0], "i64"), this.as(i.operands[1], "i64")), "i64", i.repr);
+				break;
+			case "to_i32": {
+				const o = i.operands[0];
+				const from = reprOf(o.type);
+				expr = convert(from === "i32" ? this.as(o, "i32") : from === "i64" ? `(int32_t)(uint32_t)${this.as(o, "i64")}` : from === "f64" ? `js_f64_to_int32(${this.as(o, "f64")})` : `(int32_t)(uint32_t)js_value_to_i64(${this.as(o, "boxed")})`, "i32", i.repr);
+				break;
+			}
+			case "to_i64": {
+				const o = i.operands[0];
+				const from = reprOf(o.type);
+				expr = convert(convert(this.as(o, from), from, "i64"), "i64", i.repr);
+				break;
+			}
+			case "int_add":
+			case "int_sub":
+			case "int_mul": {
+				const [x, y] = i.operands.map((o) => `(uint32_t)${this.as(o, "i32")}`);
+				expr = convert(`(int32_t)(${x} ${i.op === "int_add" ? "+" : i.op === "int_sub" ? "-" : "*"} ${y})`, "i32", i.repr);
+				break;
+			}
+			case "char_code_at": {
+				if (!inString(i)) {
+					expr = convert(`js_string_char_code_at(ctx, ${args[0]}, ${this.as(i.operands[1], "f64")})`, "f64", i.repr);
+					break;
+				}
+				const s = i.operands[0];
+				const k = `(uint32_t)${this.as(i.operands[1], "i32")}`;
+				expr = convert(this.stringViews().has(s) ? `(${this.name(s)}_units.length ? (int32_t)js_view_at(${this.name(s)}_units, ${k}) : js_string_unit_at(ctx, ${args[0]}, ${k}))` : `js_string_unit_at(ctx, ${args[0]}, ${k})`, "i32", i.repr);
+				break;
+			}
+			case "identical":
+			case "strict_eq_atom":
+			case "strict_eq_num":
+			case "is_type": {
+				const test = i.op === "identical" ? `js_same_bits(${args[0]}, ${args[1]})` : i.op === "strict_eq_num" ? `js_strict_eq_num(${this.v(i.operands[0])}, ${cDouble(i.operands[1].lit.value)})` : i.op === "strict_eq_atom" ? `js_strict_eq_atom(ctx, ${args[0]}, ${args[1]})` : isTypeTest(i.target, args[0]);
+				const cond = i.index ? `!${test}` : test;
+				expr = i.repr === "bool" ? `(${cond})` : `js_bool(${cond})`;
+				break;
+			}
 			case "same_function": {
 				const cond = `js_is_function(${args[0]}) && js_as_function(${args[0]})->info == &${infoName(i.target, this.strings.prefix)} && js_as_function(${args[0]})->realm == ctx`;
 				expr = i.repr === "bool" ? `(${cond})` : `js_bool(${cond})`;
@@ -6882,8 +7490,13 @@ var FunctionEmitter = class {
 				break;
 			case "call_direct": {
 				const callee = this.callees.get(i.target);
+				if (callee?.meta?.declared && !declaredCallFits(i, callee)) {
+					const hidden = callee.meta.declared.findIndex((t) => t !== void 0);
+					this.boxedCall(i, `${this.strings.prefix}jsf_${ident$1(i.target)}__generic(ctx, JS_UNDEFINED, JS_UNDEFINED, ${i.operands.length - hidden}, ${argArray(i.operands.slice(hidden).map((o) => this.as(o, "boxed")))}, JS_UNDEFINED)`);
+					return;
+				}
 				const passed = i.operands.map((o, k) => this.as(o, callee?.params[k]?.repr ?? "boxed"));
-				const call = `${this.strings.prefix}jsf_${ident(i.target)}(ctx${passed.map((a) => `, ${a}`).join("")})`;
+				const call = `${this.strings.prefix}jsf_${ident$1(i.target)}(ctx${passed.map((a) => `, ${a}`).join("")})`;
 				const ret = callee?.returnRepr ?? "boxed";
 				if (ret === "boxed") {
 					const result = this.hasVar(i) ? this.name(i) : "r";
@@ -6896,6 +7509,12 @@ var FunctionEmitter = class {
 				if (i.mayThrow) this.lines.push(`    if (JS_UNLIKELY(js_has_exception(ctx))) { ${this.onException(i.block)} }`);
 				return;
 			}
+			case "not": {
+				const o = i.operands[0];
+				const bool = o.type !== T.None && isSubtype(o.type, T.Boolean);
+				expr = i.repr === "boxed" && !bool ? `js_not(${args[0]})` : convert(`!(${bool ? this.as(o, "bool") : `js_truthy(${args[0]})`})`, "bool", i.repr);
+				break;
+			}
 			case "call_runtime": {
 				const r = RUNTIME[i.target];
 				if (!r) throw new Error(`unknown runtime function ${i.target}`);
@@ -6907,12 +7526,18 @@ var FunctionEmitter = class {
 					expr = this.unboxed(i);
 					break;
 				}
+				if (NUM_OPS.has(i.op)) {
+					const raw = BOOL_OPS.has(i.op) ? "bool" : reprOf(i.type);
+					expr = convert(this.unboxed(i, raw), raw, "boxed");
+					break;
+				}
 				const [fn, withCtx] = CALLS[i.op];
 				expr = `${fn}${i.numberFirst ? "_fast" : ""}(${[...withCtx ? ["ctx"] : [], ...args].join(", ")})`;
 			}
 		}
 		if (status !== null) {
 			this.lines.push(`    if (JS_UNLIKELY(${status} < 0)) { ${this.onException(i.block)} }`);
+			this.retakeViews(i);
 			return;
 		}
 		expr = expr;
@@ -6921,6 +7546,14 @@ var FunctionEmitter = class {
 			if (i.mayThrow) this.lines.push(`    if (JS_UNLIKELY(js_is_exception(${this.name(i)}))) { ${this.onException(i.block)} }`);
 		} else if (i.mayThrow) this.lines.push(`    if (JS_UNLIKELY(js_is_exception(${expr}))) { ${this.onException(i.block)} }`);
 		else if (i.op === "take_exception" || !OPS[i.op].result || OPS[i.op].callsUser) this.lines.push(`    js_discard(${expr});`);
+		this.retakeViews(i);
+	}
+	/** After an operation that may run code (a call, a getter, valueOf), a parameter's view again:
+	*  that code may have detached or resized its buffer. A view's own accesses take it again on
+	*  their slow paths. */
+	retakeViews(i) {
+		if (!OPS[i.op].callsUser || !i.mayThrow || i.taView) return;
+		for (const p of this.views()) if (p.op === "param") this.lines.push(`    ${this.name(p)}_view = js_ta_view(ctx, ${this.name(p)}, ${VIEWS[p.taView].c});`);
 	}
 	terminator(b) {
 		const t = b.term;
@@ -7016,8 +7649,13 @@ var FunctionEmitter = class {
 		const signature = this.prototype().slice(0, -1);
 		const body = this.emitBlocks(fn.blocks, null);
 		const locals = [];
-		for (const b of fn.blocks) for (const i of [...b.phis, ...b.instrs]) if (this.hasVar(i)) locals.push(`    ${C_TYPE[i.repr]} ${this.name(i)} = ${C_ZERO[i.repr]};`);
+		for (const b of fn.blocks) for (const i of [...b.phis, ...b.instrs]) if (this.hasVar(i)) {
+			locals.push(`    ${C_TYPE[i.repr]} ${this.name(i)} = ${C_ZERO[i.repr]};`);
+			if (i.op === "new" && i.taView) locals.push(`    JSTAView ${this.name(i)}_view = { NULL, 0 };`);
+		}
 		const unusedParams = fn.params.filter((p) => !this.used.has(p)).map((p) => `    (void)${this.name(p)};`);
+		for (const p of this.views().filter((v) => v.op === "param")) locals.push(`    JSTAView ${this.name(p)}_view = js_ta_view(ctx, ${this.name(p)}, ${VIEWS[p.taView].c});`);
+		for (const p of this.stringViews()) locals.push(`    JSStrView ${this.name(p)}_units = { NULL, 0, true }; (void)js_string_units(${this.name(p)}, &${this.name(p)}_units);`);
 		const calls = fn.blocks.some((b) => b.instrs.some((i) => OPS[i.op].callsUser));
 		const usesCtx = calls || body.some((l) => /\bctx\b/.test(l));
 		const ret = fn.returnRepr ?? "boxed";
@@ -7028,11 +7666,12 @@ var FunctionEmitter = class {
 			...unusedParams,
 			...calls ? [ret === "boxed" ? "    JS_CHECK_STACK(ctx);" : `    JS_CHECK_STACK_OR(ctx, ${C_FAIL[ret]});`] : [],
 			...body,
+			...this.exits ? [`exc_: return ${C_FAIL[ret]};`] : [],
 			"}"
 		].join("\n");
 	}
 	linkage() {
-		return this.shared ? "JS_MAYBE_UNUSED " : "static JS_MAYBE_UNUSED ";
+		return this.shared || this.fn.meta?.declared ? "JS_MAYBE_UNUSED " : "static JS_MAYBE_UNUSED ";
 	}
 	/** The entry's prototype: in program.h when it's shared, else in the function's own file. */
 	prototype() {
@@ -7048,13 +7687,60 @@ var FunctionEmitter = class {
 function emitProgram(m, options = {}) {
 	return emitModule(m, "", null, options);
 }
-function prepare(m, p, options) {
-	const strings = new Strings(p, options.regexps, options.harness?.atoms);
-	const caches = new Caches();
-	const hosts = new Hosts(options.hostPrimitives ?? {});
-	const callees = new Map(m.functions.map((fn) => [fn.name, fn]));
-	return {
-		strings,
+/** A test262 harness file, compiled once and linked into the test host: its tables
+*  and `<prefix>js_script` are exported, `<prefix>register(rt)` registers the tables, and the
+*  units run the script. `atoms`: the atoms the harness files before it in the same C file define. */
+function emitHarnessScript(m, prefix, atoms, options = {}) {
+	const e = prepare(m, prefix, {
+		...options,
+		harness: {
+			atoms,
+			register: "",
+			scripts: []
+		}
+	});
+	e.strings.externalInFile = true;
+	e.main.shared = true;
+	const emitters = [...e.functions, e.main];
+	const bodies = emitters.map((f) => f.emit());
+	const infos = m.functions.map((fn) => functionInfo(fn, e.strings, e.embedSource));
+	const nGlobals = Math.max(1, m.globals.length);
+	const cells = e.strings.cells;
+	return {
+		c: [
+			GENERATED,
+			"#include <stdlib.h>",
+			"#include \"js_runtime.h\"",
+			"",
+			...e.hosts.used.size ? [...e.hosts.decls(), ""] : [],
+			...dataLines(m, prefix, `${prefix}register`, options, e, ""),
+			"",
+			...emitters.flatMap((f) => [f.prototype(), ...f.resumePrototype()]),
+			...m.functions.map((fn) => genericPrototype(fn, prefix)),
+			"",
+			...infos,
+			...infos.length ? [""] : [],
+			...bodies.flatMap((b) => [b, ""]),
+			...m.functions.flatMap((fn) => [genericEntry(fn, prefix), ""]),
+			`void ${prefix}register(JSRuntime *rt) {`,
+			...cells.length ? [`    js_register_static_atoms(rt, ${prefix}mod_atoms, ${cells.length});`] : [],
+			...e.caches.count ? [`    js_register_prop_caches(rt, ${prefix}mod_ics, ${e.caches.count});`] : [],
+			...e.caches.keys ? [`    js_register_roots(rt, ${prefix}mod_keys, ${e.caches.keys});  /* zeroed: EMPTY, no key yet */`] : [],
+			`    for (size_t i = 0; i < ${nGlobals}; i++) ${prefix}mod_globals[i] = JS_UNDEFINED;`,
+			`    js_register_roots(rt, ${prefix}mod_globals, ${nGlobals});`,
+			"}",
+			""
+		].join("\n"),
+		atoms: e.strings.atoms
+	};
+}
+function prepare(m, p, options) {
+	const strings = new Strings(p, options.regexps, options.harness?.atoms);
+	const caches = new Caches();
+	const hosts = new Hosts(options.hostPrimitives ?? {});
+	const callees = new Map(m.functions.map((fn) => [fn.name, fn]));
+	return {
+		strings,
 		caches,
 		hosts,
 		functions: m.functions.map((fn) => new FunctionEmitter(fn, cFunctionName(fn, false, p), strings, caches, hosts, callees)),
@@ -7063,7 +7749,7 @@ function prepare(m, p, options) {
 	};
 }
 function genericPrototype(fn, p) {
-	return `static JSValue ${cFunctionName(fn, false, p)}__generic(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);`;
+	return `${fn.meta.declared ? "" : "static "}JSValue ${cFunctionName(fn, false, p)}__generic(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);`;
 }
 /** The module's data, once every function is emitted: globals, literals, caches, tables.
 *  `storage`: "static " in one file; "" in a split program's program.c, which defines them for
@@ -7079,6 +7765,7 @@ function dataLines(m, p, entry, options, e, storage) {
 		...e.embedSource ? [sourceCell(m.source, p).define(storage)] : [],
 		...atoms.length ? [`static const JSString *const ${p}mod_atoms[] = { ${atoms.map((a) => `(const JSString *)&${a}`).join(", ")} };`] : [],
 		...e.caches.count ? [`${storage}JSPropCache ${p}mod_ics[${e.caches.count}];`] : [],
+		...e.caches.keys ? [`${storage}JSValue ${p}mod_keys[${e.caches.keys}];`] : [],
 		...options.components?.length && !entry ? [`static const JSComponent *const ${p}mod_components[] = { ${options.components.map((c) => `&${c}`).join(", ")} };`] : [],
 		...options.core && !entry ? [
 			`static const JSCoreEntry ${p}mod_core[] = {`,
@@ -7096,6 +7783,7 @@ function mainLines(m, p, entry, options, e) {
 		"    JSRuntime *rt = js_runtime_new();",
 		...atoms.length ? [`    js_register_static_atoms(rt, ${p}mod_atoms, ${atoms.length});`] : [],
 		...e.caches.count ? [`    js_register_prop_caches(rt, ${p}mod_ics, ${e.caches.count});`] : [],
+		...e.caches.keys ? [`    js_register_roots(rt, ${p}mod_keys, ${e.caches.keys});  /* zeroed: EMPTY, no key yet */`] : [],
 		...options.harness?.scripts.length ? [`    void ${options.harness.register}(JSRuntime *rt);`, `    ${options.harness.register}(rt);  /* the harness's tables */`] : [],
 		options.core && !entry ? `    js_use_core(rt, ${p}mod_core, ${options.core.length});  /* the core methods it names */` : "    js_use_all_core(rt);  /* every core method */",
 		"    JSContext *ctx = js_context_new(rt);",
@@ -7166,17 +7854,20 @@ function partition(fns, size) {
 	if (used.length <= 1) return null;
 	return new Map(fns.map((fn, i) => [fn, used.indexOf(raw[i]) + 1]));
 }
-/** The program's C files. A program under `options.partSize` instructions is
-*  program.c alone, as emitProgram makes it. A bigger one is program.h (what the files
-*  share), program.c (the data and main()) and program_1.c … program_N.c (the functions),
-*  which compile in parallel. A function another file calls, or makes, isn't static. */
-function emitProgramFiles(m, options = {}) {
+/** The program's C files: program.c alone under `options.partSize` instructions, else
+*  program_1.c … program_N.c (the functions, compiled in parallel), program.h and program.c (the
+*  data and main()). Yielded as each is made, so a caller that writes each away never holds a
+*  large program's C (hundreds of megabytes) at once. */
+function* emitProgramFiles(m, options = {}) {
 	const fns = [...m.functions, m.main];
 	const parts = options.partSize ? partition(fns, options.partSize) : null;
-	if (!parts) return [{
-		name: "program.c",
-		text: emitProgram(m, options)
-	}];
+	if (!parts) {
+		yield {
+			name: "program.c",
+			text: emitProgram(m, options)
+		};
+		return;
+	}
 	const e = prepare(m, "", options);
 	const emitters = new Map(fns.map((fn, i) => [fn, i < m.functions.length ? e.functions[i] : e.main]));
 	const byName = new Map(m.functions.map((fn) => [fn.name, fn]));
@@ -7189,46 +7880,15 @@ function emitProgramFiles(m, options = {}) {
 		if (i.op === "call_direct" || i.op === "construct_direct") emitters.get(target).shared = true;
 		if (i.op !== "call_direct") sharedInfos.add(target);
 	}
-	const bodies = new Map(fns.map((fn) => [fn, emitters.get(fn).emit()]));
-	const infos = new Map(m.functions.map((fn) => [fn, functionInfo(fn, e.strings, e.embedSource, sharedInfos.has(fn))]));
-	const header = [
-		GENERATED,
-		"/* What the program's files share: program.c defines the data, program_N.c the functions. */",
-		"#include <stdlib.h>",
-		"#include \"js_runtime.h\"",
-		"",
-		...e.hosts.used.size ? [...e.hosts.decls(), ""] : [],
-		"#ifndef VISALJS_PROGRAM_DATA  /* program.c has the definitions */",
-		`extern JSValue mod_globals[${Math.max(1, m.globals.length)}];`,
-		...e.caches.count ? [`extern JSPropCache mod_ics[${e.caches.count}];`] : [],
-		...e.strings.decls.map((d) => d.declare),
-		...e.embedSource ? [sourceCell(m.source, "").declare] : [],
-		"#endif",
-		"",
-		...fns.filter((fn) => emitters.get(fn).shared).map((fn) => emitters.get(fn).prototype()),
-		...[...sharedInfos].map((fn) => `extern const JSFunctionInfo ${infoName(fn.name, "")};`),
-		""
-	];
-	const data = [
-		GENERATED,
-		"#define VISALJS_PROGRAM_DATA",
-		"#include \"program.h\"",
-		"",
-		...dataLines(m, "", null, options, e, ""),
-		"",
-		...mainLines(m, "", null, options, e)
-	];
-	const files = [{
-		name: "program.h",
-		text: header.join("\n")
-	}, {
-		name: "program.c",
-		text: data.join("\n")
-	}];
-	const count = Math.max(...parts.values());
-	for (let k = 1; k <= count; k++) {
-		const own = fns.filter((fn) => parts.get(fn) === k);
+	const byPart = /* @__PURE__ */ new Map();
+	for (const fn of fns) {
+		const k = parts.get(fn);
+		if (!byPart.has(k)) byPart.set(k, []);
+		byPart.get(k).push(fn);
+	}
+	for (const [k, own] of byPart) {
 		const made = own.filter((fn) => fn !== m.main);
+		const bodies = own.map((fn) => emitters.get(fn).emit());
 		const text = [
 			GENERATED,
 			"#include \"program.h\"",
@@ -7239,17 +7899,50 @@ function emitProgramFiles(m, options = {}) {
 			}),
 			...made.map((fn) => genericPrototype(fn, "")),
 			"",
-			...made.map((fn) => infos.get(fn)),
+			...made.map((fn) => functionInfo(fn, e.strings, e.embedSource, sharedInfos.has(fn))),
 			...made.length ? [""] : [],
-			...own.flatMap((fn) => [bodies.get(fn), ""]),
+			...bodies.flatMap((body) => [body, ""]),
 			...made.flatMap((fn) => [genericEntry(fn, ""), ""])
 		];
-		files.push({
+		yield {
 			name: `program_${k}.c`,
 			text: text.join("\n")
-		});
+		};
 	}
-	return files;
+	yield {
+		name: "program.h",
+		text: [
+			GENERATED,
+			"/* What the program's files share: program.c defines the data, program_N.c the functions. */",
+			"#include <stdlib.h>",
+			"#include \"js_runtime.h\"",
+			"",
+			...e.hosts.used.size ? [...e.hosts.decls(), ""] : [],
+			"#ifndef VISALJS_PROGRAM_DATA  /* program.c has the definitions */",
+			`extern JSValue mod_globals[${Math.max(1, m.globals.length)}];`,
+			...e.caches.count ? [`extern JSPropCache mod_ics[${e.caches.count}];`] : [],
+			...e.caches.keys ? [`extern JSValue mod_keys[${e.caches.keys}];`] : [],
+			...e.strings.decls.map((d) => d.declare),
+			...e.embedSource ? [sourceCell(m.source, "").declare] : [],
+			"#endif",
+			"",
+			...fns.filter((fn) => emitters.get(fn).shared).map((fn) => emitters.get(fn).prototype()),
+			...[...sharedInfos].map((fn) => `extern const JSFunctionInfo ${infoName(fn.name, "")};`),
+			""
+		].join("\n")
+	};
+	yield {
+		name: "program.c",
+		text: [
+			GENERATED,
+			"#define VISALJS_PROGRAM_DATA",
+			"#include \"program.h\"",
+			"",
+			...dataLines(m, "", null, options, e, ""),
+			"",
+			...mainLines(m, "", null, options, e)
+		].join("\n")
+	};
 }
 //#endregion
 //#region runtime/components.ts
@@ -7795,7 +8488,7 @@ function pauses(fn) {
 *  optimizer's to choose. */
 function closedFunctions(m) {
 	const byName = new Map(m.functions.map((fn) => [fn.name, fn]));
-	const closed = new Set(m.functions.filter((fn) => fn.meta && !pauses(fn)));
+	const closed = new Set(m.functions.filter((fn) => fn.meta && !fn.meta.external && !pauses(fn)));
 	for (const fn of functionsOf(m)) for (const b of fn.blocks) for (const i of b.instrs) {
 		if (i.op !== "make_function" && i.op !== "call_direct") continue;
 		const target = byName.get(i.target);
@@ -7817,6 +8510,35 @@ function callers(m) {
 	return result;
 }
 //#endregion
+//#region optimizer/src/constant-keys.ts
+const constantKeys = {
+	name: "constant-keys",
+	run(m, count) {
+		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 storedOnce = (key) => {
+			const load = key.op === "check_tdz" ? key.operands[0] : key;
+			return load.op === "load_global" && stores.get(load.index) === 1;
+		};
+		for (const fn of functionsOf(m)) for (const b of fn.blocks) for (const i of b.instrs) {
+			if (i.op !== "get_elem" && i.op !== "set_elem") continue;
+			const key = i.operands[1];
+			if (key.op === "const" && typeof key.lit.value === "string") {
+				const k = propKey(key.lit.value);
+				if (!("name" in k)) continue;
+				i.op = i.op === "get_elem" ? "get_prop" : "set_prop";
+				i.key = k;
+				i.operands.splice(1, 1);
+				count("named", "element access", 1, "element accesses");
+			} else if (storedOnce(key)) {
+				i.keyedSite = true;
+				count("cached", "keyed site");
+			}
+		}
+		return m;
+	}
+};
+//#endregion
 //#region optimizer/src/dce.ts
 /** Operations with no effect but their result. */
 const REMOVABLE = /* @__PURE__ */ new Set([
@@ -7864,7 +8586,15 @@ const REMOVABLE = /* @__PURE__ */ new Set([
 	"host_function",
 	"same_function",
 	"function_env",
-	"construct_result"
+	"construct_result",
+	"char_code_at",
+	"math",
+	"int_add",
+	"int_sub",
+	"int_mul",
+	"to_i64",
+	"to_i32",
+	"i64"
 ]);
 const dce = {
 	name: "dce",
@@ -7902,6 +8632,45 @@ function dceFunction(fn) {
 	return dead.size;
 }
 //#endregion
+//#region optimizer/src/typed-arrays.ts
+const typedArrays = {
+	name: "typed-arrays",
+	run(m, count) {
+		for (const fn of functionsOf(m)) {
+			if (pauses(fn)) continue;
+			const made = /* @__PURE__ */ new Map();
+			fn.meta?.declaredViews?.forEach((kind, k) => {
+				if (kind) made.set(fn.params[k], kind);
+			});
+			for (const b of fn.blocks) for (const i of b.instrs) {
+				const ctor = i.operands[0];
+				const kind = i.op === "new" && i.operands.length === 2 && ctor?.op === "global_name" ? viewOf(ctor.target) : void 0;
+				if (kind) made.set(i, kind);
+			}
+			if (!made.size) continue;
+			const accesses = /* @__PURE__ */ new Map();
+			const escape = (v) => made.delete(v);
+			for (const b of fn.blocks) {
+				for (const phi of b.phis) for (const inc of phi.incoming) escape(inc.value);
+				for (const i of b.instrs) i.operands.forEach((o, k) => {
+					if (!made.has(o)) return;
+					if ((i.op === "get_elem" || i.op === "set_elem") && k === 0 && i.operands[1] !== o && i.operands[2] !== o) accesses.set(o, [...accesses.get(o) ?? [], i]);
+					else escape(o);
+				});
+				const t = b.term;
+				if (t?.kind === "branch") escape(t.cond);
+				if (t?.kind === "return" || t?.kind === "throw") escape(t.value);
+			}
+			for (const [array, kind] of made) {
+				array.taView = kind;
+				for (const a of accesses.get(array) ?? []) a.taView = kind;
+				count("viewed", "typed array");
+			}
+		}
+		return m;
+	}
+};
+//#endregion
 //#region optimizer/src/elide-arguments.ts
 const elideArguments = {
 	name: "elide-arguments",
@@ -7937,6 +8706,285 @@ function elide(fn) {
 	return candidates.size;
 }
 //#endregion
+//#region optimizer/src/specialize.ts
+const NUMBER_FORM = {
+	add: "num_add",
+	sub: "num_sub",
+	mul: "num_mul",
+	div: "num_div",
+	mod: "num_mod",
+	neg: "num_neg",
+	inc: "num_inc",
+	dec: "num_dec",
+	lt: "num_lt",
+	le: "num_le",
+	gt: "num_gt",
+	ge: "num_ge",
+	eq: "num_eq",
+	ne: "num_ne",
+	strict_eq: "num_eq",
+	strict_ne: "num_ne",
+	bitand: "num_bitand",
+	bitor: "num_bitor",
+	bitxor: "num_bitxor",
+	bitnot: "num_bitnot",
+	shl: "num_shl",
+	sar: "num_sar",
+	shr: "num_shr"
+};
+/** The generic operators with a Number path (the rest of NUMBER_FORM's, and ToNumeric). */
+const NUMBER_FIRST = /* @__PURE__ */ new Set([
+	"add",
+	"sub",
+	"mul",
+	"div",
+	"mod",
+	"neg",
+	"inc",
+	"dec",
+	"lt",
+	"le",
+	"gt",
+	"ge",
+	"eq",
+	"ne",
+	"bitand",
+	"bitor",
+	"bitxor",
+	"bitnot",
+	"shl",
+	"sar",
+	"shr",
+	"to_numeric"
+]);
+/** Math functions of one Number whose C form generated code may call inline. */
+const MATH_INLINE = /* @__PURE__ */ new Set([
+	"sqrt",
+	"abs",
+	"floor",
+	"ceil",
+	"trunc"
+]);
+/** The built-in a call may run inline, if any: `Math.sqrt(x)` …, `s.charCodeAt(i)`,
+*  `String.fromCharCode(c)` with one argument, `f.apply(…)` and `f.call(…)` (named by its C
+*  helper's suffix). */
+function inlineBuiltin(i) {
+	const callee = i.op === "call" ? i.operands[0] : null;
+	if (callee?.op !== "get_prop" || !("name" in callee.key)) return null;
+	const name = callee.key.name;
+	if ((name === "apply" && i.operands.length <= 4 || name === "call") && i.operands[1] === callee.operands[0]) return name;
+	if (i.operands.length !== 3) return null;
+	const global = (g) => callee.operands[0].op === "global_name" && callee.operands[0].target === g;
+	if (MATH_INLINE.has(name) && global("Math")) return `math_${name}`;
+	if (name === "fromCharCode" && global("String")) return "from_char_code";
+	if (name === "charCodeAt" && i.operands[1] === callee.operands[0]) return "char_code_at";
+	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. */
+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;
+	return null;
+}
+/** The bitwise operators: ToInt32 (ToUint32) of their operands first. */
+const TRUNCATING = /* @__PURE__ */ new Set([
+	"num_bitor",
+	"num_bitand",
+	"num_bitxor",
+	"num_shl",
+	"num_sar",
+	"num_shr"
+]);
+/** Wrapping int32 arithmetic (`(a + b) | 0` of int32s), by the Number operator. */
+const INT_FORM = {
+	num_add: "int_add",
+	num_sub: "int_sub",
+	num_mul: "int_mul",
+	num_inc: "int_add",
+	num_dec: "int_sub"
+};
+/** Whether the Number operator `x` of int32s gives an exact double, whose low 32 bits are then
+*  the wrapping int32 operation's: a sum always; a product only when it stays within 2^53, as
+*  against a constant of at most 2^22 (`h * 16777619 >>> 0`, FNV's prime, rounds). */
+function exactInDouble(x) {
+	if (x.op !== "num_mul") return true;
+	return x.operands.some((o) => o.op === "const" && Math.abs(o.lit.value) <= 2 ** 22);
+}
+/** A constant 1 before `i`, for x++ as x + 1. */
+function one(i) {
+	const b = i.block;
+	const c = {
+		id: nextId(b.fn),
+		op: "const",
+		operands: [],
+		type: T.Int32,
+		repr: "boxed",
+		mayThrow: false,
+		block: b,
+		loc: i.loc,
+		lit: { value: 1 }
+	};
+	b.instrs.splice(b.instrs.indexOf(i), 0, c);
+	return c;
+}
+function nextId(fn) {
+	return 1 + Math.max(0, ...fn.params.map((p) => p.id), ...fn.blocks.flatMap((b) => [...b.phis, ...b.instrs].map((i) => i.id)));
+}
+/** Kinds of value whose === compares contents, not bits: two Numbers (1 and 1.0 boxed
+*  differently, NaN), two strings (equal units in two cells), two BigInts. */
+const BY_CONTENT = Number_ | T.String | T.BigInt;
+const NONE = Symbol("no literal");
+/** A comparison js_strict_equals (js_eq) needn't make: `typeof x === "function"`, `x == null`,
+*  `x === "literal"`, and === where the operands can't both be Numbers, strings or BigInts
+*  (`x === undefined`, objects): a C bool test of boxed values. Rewrites `i`; false: kept. */
+function simplerComparison(i) {
+	const strict = i.op === "strict_eq" || i.op === "strict_ne";
+	if (!strict && i.op !== "eq" && i.op !== "ne") return false;
+	const negated = i.op === "strict_ne" || i.op === "ne" ? 1 : 0;
+	const literal = (v) => v.op === "const" ? v.lit.value : NONE;
+	for (const [x, y] of [[i.operands[0], i.operands[1]], [i.operands[1], i.operands[0]]]) {
+		const lit = literal(y);
+		if (x.op === "typeof" && typeof lit === "string") {
+			Object.assign(i, {
+				op: "is_type",
+				operands: [x.operands[0]],
+				target: lit,
+				index: negated
+			});
+			return true;
+		}
+		if (!strict && (lit === null || lit === void 0)) {
+			Object.assign(i, {
+				op: "is_type",
+				operands: [x],
+				target: "nullish",
+				index: negated
+			});
+			return true;
+		}
+		if (strict && typeof lit === "string") {
+			Object.assign(i, {
+				op: "strict_eq_atom",
+				operands: [x, y],
+				index: negated
+			});
+			return true;
+		}
+		if (strict && typeof lit === "number" && !Number.isNaN(lit) && !(x.op === "const" && typeof x.lit.value === "number")) {
+			Object.assign(i, {
+				op: "strict_eq_num",
+				operands: [x, y],
+				index: negated
+			});
+			return true;
+		}
+	}
+	if (strict && (i.operands[0].type & i.operands[1].type & BY_CONTENT) === 0) {
+		Object.assign(i, {
+			op: "identical",
+			index: negated
+		});
+		return true;
+	}
+	return false;
+}
+const INDEX_FORM = {
+	get_elem: "get_index",
+	set_elem: "set_index"
+};
+const specialize = {
+	name: "specialize",
+	run(m, count) {
+		for (const fn of functionsOf(m)) {
+			let edges = false;
+			const depth = loopDepths(fn);
+			const uses = useCounts(fn);
+			const unread = /* @__PURE__ */ new Set();
+			for (const b of fn.blocks) for (const i of b.instrs) {
+				const trusted = trustedBuiltin(i, (v) => v.type);
+				if (trusted) {
+					edges ||= i.mayThrow;
+					clearMayThrow(i);
+					const method = i.operands[0];
+					if (method.mayThrow) edges = true;
+					if (uses.get(method) === 1) {
+						unread.add(method);
+						const holder = method.operands[0];
+						if (trusted !== "char_code_at" && holder.op === "global_name" && uses.get(holder) === 2) {
+							unread.add(holder);
+							edges = true;
+						}
+					}
+					if (trusted === "char_code_at") {
+						i.op = "char_code_at";
+						i.operands = [i.operands[1], i.operands[2]];
+					} else {
+						i.op = "math";
+						i.target = trusted.slice(5);
+						i.operands = [i.operands[2]];
+					}
+					count("inlined", "built-in call");
+					continue;
+				}
+				if (isStringLength(i) && i.mayThrow) {
+					edges = true;
+					clearMayThrow(i);
+					count("inlined", "string length");
+					continue;
+				}
+				const builtin = inlineBuiltin(i);
+				if (builtin) {
+					i.builtin = builtin;
+					count("inlined", "built-in call");
+					continue;
+				}
+				const index = INDEX_FORM[i.op];
+				if (index && isSubtype(i.operands[1].type, Number_)) {
+					i.op = index;
+					count("inlined", "element access", 1, "element accesses");
+					continue;
+				}
+				const form = NUMBER_FORM[i.op];
+				const numbers = i.operands.every((o) => isSubtype(o.type, Number_) && o.type !== T.None);
+				if (!numbers && simplerComparison(i)) {
+					edges ||= i.mayThrow;
+					clearMayThrow(i);
+					count("simplified", "comparison");
+					continue;
+				}
+				if (!form || !numbers) {
+					if (NUMBER_FIRST.has(i.op) && depth.get(b) > 0 && i.operands.every((o) => o.type & Number_)) {
+						i.numberFirst = true;
+						count("added", "number fast path");
+					}
+					continue;
+				}
+				edges ||= i.mayThrow;
+				clearMayThrow(i);
+				i.op = form;
+				count("inlined", "number operator");
+				if (TRUNCATING.has(form)) {
+					for (const x of i.operands) if (INT_FORM[x.op] && uses.get(x) === 1 && x.operands.every((o) => isSubtype(o.type, T.Int32)) && exactInDouble(x)) {
+						if (x.op === "num_inc" || x.op === "num_dec") x.operands = [x.operands[0], one(x)];
+						x.op = INT_FORM[x.op];
+						count("wrapped", "int operation");
+					}
+				}
+			}
+			if (unread.size) {
+				for (const v of unread) clearMayThrow(v);
+				removeInstrs(fn, unread);
+			}
+			if (edges) removeUnreachable(fn);
+		}
+		return m;
+	}
+};
+//#endregion
 //#region optimizer/src/infer-types.ts
 const inferTypes = {
 	name: "infer-types",
@@ -7965,7 +9013,8 @@ function inferModule(m) {
 	};
 	for (const fn of m.functions) {
 		if (!pauses(fn)) sig.returns.set(fn.name, T.None);
-		for (const p of fn.params) sig.params.set(p, closed.has(fn) ? T.None : Unknown & ~T.Empty);
+		const declared = fn.meta?.declared;
+		fn.params.forEach((p, k) => sig.params.set(p, declared?.[k] ?? (closed.has(fn) ? T.None : Unknown & ~T.Empty)));
 	}
 	const byName = new Map(m.functions.map((fn) => [fn.name, fn]));
 	const callerMap = callers(m);
@@ -7984,7 +9033,7 @@ function inferModule(m) {
 		}
 		for (const b of fn.blocks) for (const i of b.instrs) {
 			const callee = i.op === "call_direct" ? byName.get(i.target) : void 0;
-			if (!callee || !closed.has(callee)) continue;
+			if (!callee || !closed.has(callee) || callee.meta?.declared) continue;
 			callee.params.forEach((p, k) => {
 				const old = sig.params.get(p);
 				const next = old | i.operands[k].type & ~T.Empty;
@@ -8044,7 +9093,11 @@ const BOOLEAN = /* @__PURE__ */ new Set([
 	"delete_prop",
 	"delete_elem",
 	"private_in",
-	"same_function"
+	"same_function",
+	"identical",
+	"strict_eq_atom",
+	"is_type",
+	"strict_eq_num"
 ]);
 const OBJECT = /* @__PURE__ */ new Set([
 	"new_object",
@@ -8096,9 +9149,8 @@ function bounds(fn, type) {
 		while ((v.op === "to_numeric" || v.op === "to_number" || v.op === "check_tdz") && isSubtype(type(v), Number_)) v = v.operands[0];
 		return v;
 	};
-	const bound = (x, at, dir) => {
+	const proves = (x, at, holds) => {
 		idom ??= dominators(fn);
-		if (!int32(x)) return false;
 		for (let a = at;;) {
 			const p = a.preds.length === 1 ? a.preds[0] : null;
 			const term = p?.term;
@@ -8108,12 +9160,7 @@ function bounds(fn, type) {
 				if (rel && (l === x || r === x)) {
 					if (term.else === a) rel = NEGATED[rel];
 					if (r === x) rel = FLIPPED[rel];
-					const other = l === x ? r : l;
-					const lit = other.op === "const" && typeof other.lit.value === "number" ? other.lit.value : null;
-					if (int32(other)) {
-						if (dir === "up" && (rel === "<" || rel === "<=" && lit !== null && lit < 2147483647)) return true;
-						if (dir === "down" && (rel === ">" || rel === ">=" && lit !== null && lit > -2147483648)) return true;
-					}
+					if (holds(rel, l === x ? r : l)) return true;
 				}
 			}
 			const up = idom.get(a);
@@ -8121,7 +9168,30 @@ function bounds(fn, type) {
 			a = up;
 		}
 	};
-	return Object.assign(bound, { root });
+	const bound = (x, at, dir) => int32(x) && proves(x, at, (rel, other) => {
+		const lit = other.op === "const" && typeof other.lit.value === "number" ? other.lit.value : null;
+		if (!int32(other)) return false;
+		if (dir === "up") return rel === "<" || rel === "<=" && lit !== null && lit < 2147483647;
+		return rel === ">" || rel === ">=" && lit !== null && lit > -2147483648;
+	});
+	const nonNegative = (x, seen = /* @__PURE__ */ new Set()) => {
+		x = root(x);
+		if (seen.has(x)) return true;
+		if (x.op === "const") return typeof x.lit.value === "number" && x.lit.value >= 0;
+		if (x.op === "phi") return seen.add(x) && x.incoming.every((inc) => nonNegative(inc.value, seen));
+		if (x.op === "inc" || x.op === "num_inc") return nonNegative(x.operands[0], seen);
+		return false;
+	};
+	const lengthOf = (v) => {
+		v = root(v);
+		const s = v.operands[0];
+		return v.op === "get_prop" && v.key && "name" in v.key && v.key.name === "length" && s && isSubtype(type(s) & ~T.Empty, T.String) && type(s) !== T.None ? root(s) : void 0;
+	};
+	const inString = (s, x, at) => int32(x) && nonNegative(x) && proves(root(x), at, (rel, other) => rel === "<" && lengthOf(other) === root(s));
+	return Object.assign(bound, {
+		root,
+		inString
+	});
 }
 /** x + 1 or x - 1 (`i++`, `i += 1`, `i--`) of an int32 x the branches bound: an int32. */
 function step(i, bound) {
@@ -8157,7 +9227,7 @@ function transfer(i, type, sig, bound = null) {
 		case "bigint": return T.BigInt;
 		case "switch_string": return T.Int32;
 		case "to_number": return Number_;
-		case "to_numeric": return numeric(t(a));
+		case "to_numeric": return isSubtype(t(a), Number_) && t(a) !== T.None ? t(a) : numeric(t(a));
 		case "add": {
 			const ta = t(a), tb = t(b);
 			if (ta === T.String || tb === T.String) return T.String;
@@ -8201,6 +9271,27 @@ function transfer(i, type, sig, bound = null) {
 		case "num_ne": return T.Boolean;
 		case "get_prop": return i.key && "name" in i.key && i.key.name === "length" && isSubtype(t(a), T.String) ? T.Int32 : Unknown;
 		case "call_direct": return sig?.returns.get(i.target) ?? Unknown;
+		case "get_elem":
+		case "get_index":
+			if (readsDouble(i)) return T.Int32 | T.Double;
+			if (i.taView && isStatic(i.block.fn)) return T.Int32 | T.Undefined;
+			return Unknown;
+		case "char_code_at":
+		case "math": return Number_;
+		case "int_add":
+		case "int_sub":
+		case "int_mul": return T.Int32;
+		case "to_i64":
+		case "i64":
+		case "int_div":
+		case "int_mod": return T.Int64;
+		case "to_i32": return T.Int32;
+		case "call": {
+			const trusted = trustedBuiltin(i, t);
+			if (trusted === "char_code_at" && bound?.inString(b, i.operands[2], i.block)) return T.Int32;
+			if (trusted) return Number_;
+			return i.typedCall ? i.typedCall.returns : Unknown;
+		}
 		default: return Unknown;
 	}
 }
@@ -8230,8 +9321,9 @@ function inferFunction(fn, sig = null) {
 }
 //#endregion
 //#region optimizer/src/inline.ts
-/** A callee's largest size, in instructions. */
-const INLINE_SIZE = 40;
+/** A callee's largest size, in instructions. 40 made a large program's C 10% bigger than 20 did
+*  (each copy is C to compile) and ran no faster. */
+const INLINE_SIZE = 20;
 /** A caller's largest size it grows to, in instructions. */
 const CALLER_SIZE = 3e3;
 const ROUNDS = 2;
@@ -8776,123 +9868,18 @@ function foldBranch(b) {
 	return true;
 }
 //#endregion
-//#region optimizer/src/specialize.ts
-/** Each generic operator's Number form. */
-const NUMBER_FORM = {
-	add: "num_add",
-	sub: "num_sub",
-	mul: "num_mul",
-	div: "num_div",
-	mod: "num_mod",
-	neg: "num_neg",
-	inc: "num_inc",
-	dec: "num_dec",
-	lt: "num_lt",
-	le: "num_le",
-	gt: "num_gt",
-	ge: "num_ge",
-	eq: "num_eq",
-	ne: "num_ne",
-	strict_eq: "num_eq",
-	strict_ne: "num_ne",
-	bitand: "num_bitand",
-	bitor: "num_bitor",
-	bitxor: "num_bitxor",
-	bitnot: "num_bitnot",
-	shl: "num_shl",
-	sar: "num_sar",
-	shr: "num_shr"
-};
-/** The generic operators with a Number path (the rest of NUMBER_FORM's, and ToNumeric). */
-const NUMBER_FIRST = /* @__PURE__ */ new Set([
-	"add",
-	"sub",
-	"mul",
-	"div",
-	"mod",
-	"neg",
-	"inc",
-	"dec",
-	"lt",
-	"le",
-	"gt",
-	"ge",
-	"eq",
-	"ne",
-	"bitand",
-	"bitor",
-	"bitxor",
-	"bitnot",
-	"shl",
-	"sar",
-	"shr",
-	"to_numeric"
-]);
-/** Math functions of one Number whose C form generated code may call inline. */
-const MATH_INLINE = /* @__PURE__ */ new Set([
-	"sqrt",
-	"abs",
-	"floor",
-	"ceil",
-	"trunc"
-]);
-/** The built-in a one-argument call may run inline, if any: `Math.sqrt(x)` …,
-*  `s.charCodeAt(i)`, `String.fromCharCode(c)` (named by its C helper's suffix). */
-function inlineBuiltin(i) {
-	const callee = i.op === "call" && i.operands.length === 3 ? i.operands[0] : null;
-	if (callee?.op !== "get_prop" || !("name" in callee.key)) return null;
-	const name = callee.key.name;
-	const global = (g) => callee.operands[0].op === "global_name" && callee.operands[0].target === g;
-	if (MATH_INLINE.has(name) && global("Math")) return `math_${name}`;
-	if (name === "fromCharCode" && global("String")) return "from_char_code";
-	if (name === "charCodeAt" && i.operands[1] === callee.operands[0]) return "char_code_at";
-	return null;
-}
-/** Element access's form for a Number key. */
-const INDEX_FORM = {
-	get_elem: "get_index",
-	set_elem: "set_index"
-};
-const specialize = {
-	name: "specialize",
-	run(m, count) {
-		for (const fn of functionsOf(m)) {
-			let edges = false;
-			const depth = loopDepths(fn);
-			for (const b of fn.blocks) for (const i of b.instrs) {
-				const builtin = inlineBuiltin(i);
-				if (builtin) {
-					i.builtin = builtin;
-					count("inlined", "built-in call");
-					continue;
-				}
-				const index = INDEX_FORM[i.op];
-				if (index && isSubtype(i.operands[1].type, Number_)) {
-					i.op = index;
-					count("inlined", "element access", 1, "element accesses");
-					continue;
-				}
-				const form = NUMBER_FORM[i.op];
-				if (!form || !i.operands.every((o) => isSubtype(o.type, Number_))) {
-					if (NUMBER_FIRST.has(i.op) && depth.get(b) > 0 && i.operands.every((o) => o.type & Number_)) {
-						i.numberFirst = true;
-						count("added", "number fast path");
-					}
-					continue;
-				}
-				edges ||= i.mayThrow;
-				clearMayThrow(i);
-				i.op = form;
-				count("inlined", "number operator");
-			}
-			if (edges) removeUnreachable(fn);
-		}
-		return m;
-	}
-};
-//#endregion
 //#region optimizer/src/unbox.ts
 const F64 = /* @__PURE__ */ new Set([
+	"char_code_at",
+	"math",
+	"int_add",
+	"int_sub",
+	"int_mul",
+	"to_i64",
+	"to_i32",
+	"int_div",
+	"int_mod",
+	"i64",
 	"num_add",
 	"num_sub",
 	"num_mul",
@@ -8917,11 +9904,21 @@ const BOOL = /* @__PURE__ */ new Set([
 	"num_eq",
 	"num_ne"
 ]);
+/** Boolean tests of boxed operands: their result is a C bool, their operands stay boxed. */
+const TESTS = /* @__PURE__ */ new Set([
+	"same_function",
+	"identical",
+	"strict_eq_atom",
+	"is_type",
+	"strict_eq_num"
+]);
+const isBool = (t) => t !== T.None && isSubtype(t, T.Boolean);
 /** How the report names each unboxed repr. */
 const REPR_NOUN = {
 	boxed: "",
 	f64: "double",
 	i32: "int32",
+	i64: "int64",
 	bool: "bool"
 };
 /** Boxing a double for a use, against unboxing a JSValue (per use, before loop weights). */
@@ -8942,6 +9939,7 @@ const unbox = {
 function unboxedRepr(t) {
 	if (t === T.None) return null;
 	if (isSubtype(t, T.Int32)) return "i32";
+	if (isSubtype(t, T.Int64 | T.Int32)) return "i64";
 	if (isSubtype(t, Number_)) return "f64";
 	if (isSubtype(t, T.Boolean)) return "bool";
 	return null;
@@ -8950,7 +9948,7 @@ function unboxModule(m) {
 	const closed = closedFunctions(m);
 	const byName = new Map(m.functions.map((fn) => [fn.name, fn]));
 	const fns = functionsOf(m).filter((fn) => !pauses(fn));
-	for (const fn of closed) {
+	for (const fn of m.functions.filter((fn) => closed.has(fn) || fn.meta?.declared && !pauses(fn))) {
 		const repr = unboxedRepr(fn.blocks.flatMap((b) => b.term?.kind === "return" ? [b.term.value] : []).reduce((u, v) => u | v.type, T.None));
 		if (repr) fn.returnRepr = repr;
 	}
@@ -8988,26 +9986,34 @@ function unboxModule(m) {
 				index: t.kind === "return" ? 1 : 0
 			});
 		}
-		const params = closed.has(fn) ? fn.params : [];
+		const declared = fn.meta?.declared;
+		const params = closed.has(fn) ? fn.params : declared ? fn.params.filter((_, k) => declared[k] !== void 0) : [];
 		for (const v of [...params, ...fn.blocks.flatMap((b) => b.phis)]) {
 			const repr = unboxedRepr(v.type);
 			if (repr === "bool") v.repr = "bool";
 			else if (repr) candidates.push(v);
 		}
-		for (const b of fn.blocks) for (const i of b.instrs) if (F64.has(i.op)) candidates.push(i);
-		else if (BOOL.has(i.op) || i.op === "same_function") i.repr = "bool";
-		else if (i.op === "call_direct") i.repr = byName.get(i.target)?.returnRepr ?? "boxed";
+		for (const b of fn.blocks) for (const i of b.instrs) if (F64.has(i.op) || readsDouble(i) || isStringLength(i)) candidates.push(i);
+		else if (BOOL.has(i.op) || TESTS.has(i.op) || i.op === "not") i.repr = "bool";
+		else if (i.op === "call_direct") {
+			const callee = byName.get(i.target);
+			i.repr = callee && declaredCallFits(i, callee) ? callee.returnRepr ?? "boxed" : "boxed";
+		} else if (typedCallFits(i)) i.repr = i.typedCall.returnRepr === "i64" ? "f64" : i.typedCall.returnRepr;
 	}
-	for (const c of candidates) c.repr = isSubtype(c.type, T.Int32) ? "i32" : "f64";
+	for (const c of candidates) c.repr = isSubtype(c.type, T.Int32) ? "i32" : isSubtype(c.type, T.Int64 | T.Int32) ? "i64" : "f64";
 	const wants = (u) => {
 		if (!u.user) return u.index === 1 ? u.block.fn.returnRepr ?? "boxed" : "boxed";
 		if (u.user.op === "phi") return u.user.repr;
-		if (F64.has(u.user.op) || BOOL.has(u.user.op)) return u.user.repr === "boxed" ? "boxed" : "f64";
+		if (u.user.op === "not") return isBool(u.user.operands[0].type) ? "bool" : "boxed";
+		if (F64.has(u.user.op) || BOOL.has(u.user.op)) return "f64";
 		if ((u.user.op === "get_index" || u.user.op === "set_index") && u.index === 1) return "f64";
+		if ((u.user.op === "set_index" || u.user.op === "set_elem") && u.index === 2 && u.user.taView === "f64") return "f64";
 		if (u.user.op === "call_direct") {
 			const callee = byName.get(u.user.target);
-			return callee && closed.has(callee) ? callee.params[u.index].repr : "boxed";
+			if (callee?.meta?.declared && !declaredCallFits(u.user, callee)) return "boxed";
+			return callee && (closed.has(callee) || callee.meta?.declared?.[u.index] !== void 0) ? callee.params[u.index].repr : "boxed";
 		}
+		if (u.index >= 2 && typedCallFits(u.user)) return u.user.typedCall.params[u.index - 2].repr;
 		return "boxed";
 	};
 	for (let changed = true; changed;) {
@@ -9032,6 +10038,8 @@ const DEFAULT_PASSES = [
 	promoteGlobals,
 	inline,
 	dce,
+	constantKeys,
+	typedArrays,
 	inferTypes,
 	simplify,
 	specialize,
@@ -10299,6 +11307,10 @@ const primitives = {
 		c: "js_host_timer_unref",
 		length: 2
 	},
+	loopNow: {
+		c: "js_host_loop_now",
+		length: 0
+	},
 	timerStart: {
 		c: "js_host_timer_start",
 		length: 4
@@ -11255,9 +12267,259 @@ function hostPrimitives(hosts) {
 	return Object.assign({}, ...hosts.map((h) => h.primitives));
 }
 //#endregion
+//#region cli/src/static/types.ts
+const TYPES_FILE = resolve(import.meta.dirname, "..", "..", "types", "visaljs.d.ts");
+/** The integer a type annotation names: "visaljs"'s `int` or `i32`, through imports and aliases. */
+function intKind(checker, node) {
+	if (!node || !ts.isTypeReferenceNode(node)) return void 0;
+	let symbol = checker.getSymbolAtLocation(node.typeName);
+	if (symbol && symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+	const declaration = symbol?.declarations?.[0];
+	if (!symbol || !declaration || !ts.isTypeAliasDeclaration(declaration)) return void 0;
+	if (resolve(declaration.getSourceFile().fileName) !== TYPES_FILE) return intKind(checker, declaration.type);
+	return Object.hasOwn(STATIC_TYPES, symbol.name) ? STATIC_TYPES[symbol.name].int : void 0;
+}
+/** What a parameter of each integer takes: an int any Number (an int64_t, converted by the
+*  caller as C would); an i32 any Number too, converted to it on entry. */
+const INT_PARAMETERS = {
+	i64: STATIC_TYPES.int.type,
+	i32: STATIC_TYPES.number.type
+};
+/** The declared parameter types of a file's top-level functions, by where each starts: each a
+*  type static code takes, or an error. */
+function declaredSignatures(checker, sf, out) {
+	for (const st of sf.statements) {
+		if (!ts.isFunctionDeclaration(st) || !st.name) continue;
+		const types = st.parameters.map((p) => {
+			const kind = intKind(checker, p.type);
+			if (kind) return INT_PARAMETERS[kind];
+			const type = checker.getTypeAtLocation(p);
+			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;
+		});
+		const views = st.parameters.map((p) => viewOf(checker.getTypeAtLocation(p).getSymbol()?.name ?? ""));
+		out.set(locKey(st), {
+			types,
+			views
+		});
+	}
+}
+/** tsc's primitive types (and their literals), by the name STATIC_TYPES knows them by. */
+const PRIMITIVE_FLAGS = [
+	[ts.TypeFlags.Number | ts.TypeFlags.NumberLiteral, "number"],
+	[ts.TypeFlags.String | ts.TypeFlags.StringLiteral, "string"],
+	[ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral, "boolean"],
+	[ts.TypeFlags.Undefined, "undefined"],
+	[ts.TypeFlags.Null, "null"]
+];
+/** A TypeScript type as the IR's, if static code takes it. */
+function irType(t) {
+	if (t.isUnion()) {
+		let u = T.None;
+		for (const part of t.types) {
+			const p = irType(part);
+			if (p === null) return null;
+			u |= p;
+		}
+		return u;
+	}
+	const name = PRIMITIVE_FLAGS.find(([flags]) => t.flags & flags)?.[1];
+	if (name) return STATIC_TYPES[name].type;
+	return viewOf(t.getSymbol()?.name ?? "") ? T.Object : null;
+}
+//#endregion
+//#region cli/src/static/link.ts
+/** A file's name in locations, as the program's: relative to the working directory. */
+function fileName(sf) {
+	return normalize(relative(process.cwd(), sf.fileName));
+}
+/** A node's position as the adapter writes a location: the key that finds its IR function. */
+function locKey(node) {
+	const sf = node.getSourceFile();
+	const { line, character } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+	return `${fileName(sf)}:${line + 1}:${character + 1}`;
+}
+function compileError(node, detail) {
+	const sf = node.getSourceFile();
+	const { line, character } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+	return new CompileError("SyntaxError", detail, {
+		file: fileName(sf),
+		line: line + 1,
+		column: character + 1
+	});
+}
+/** The file an import names, when it is one of the unit's. */
+function importedFile(checker, node, files) {
+	const symbol = node.moduleSpecifier ? checker.getSymbolAtLocation(node.moduleSpecifier) : void 0;
+	const file = symbol?.valueDeclaration && ts.isSourceFile(symbol.valueDeclaration) ? resolve(symbol.valueDeclaration.fileName) : void 0;
+	return file && files.has(file) ? file : void 0;
+}
+/** The names a file's top level declares, with their symbols. */
+function topLevel(checker, sf) {
+	const out = /* @__PURE__ */ new Map();
+	const add = (name) => {
+		const symbol = checker.getSymbolAtLocation(name);
+		if (symbol) out.set(name.text, symbol);
+	};
+	const addBinding = (b) => {
+		if (ts.isIdentifier(b)) add(b);
+		else for (const e of b.elements) if (!ts.isOmittedExpression(e)) addBinding(e.name);
+	};
+	for (const st of sf.statements) if ((ts.isFunctionDeclaration(st) || ts.isClassDeclaration(st)) && st.name) add(st.name);
+	else if (ts.isVariableStatement(st)) for (const d of st.declarationList.declarations) addBinding(d.name);
+	else if (ts.isImportDeclaration(st) && ts.isStringLiteral(st.moduleSpecifier) && st.moduleSpecifier.text === "visaljs:host") {
+		const bindings = st.importClause?.namedBindings;
+		if (bindings && ts.isNamedImports(bindings)) for (const e of bindings.elements) add(e.name);
+	}
+	return out;
+}
+/** The files in dependency order (an imported file before its importers); a cycle is an error. */
+function ordered(checker, sources, files) {
+	const byFile = new Map(sources.map((sf) => [resolve(sf.fileName), sf]));
+	const out = [];
+	const state = /* @__PURE__ */ new Map();
+	const visit = (sf, from) => {
+		if (state.get(sf) === "done") return;
+		if (state.get(sf) === "visiting") throw compileError(from, `static files import each other in a cycle (${sf.fileName}): their top levels would run in no order`);
+		state.set(sf, "visiting");
+		for (const st of sf.statements) if (ts.isImportDeclaration(st) || ts.isExportDeclaration(st)) {
+			const file = importedFile(checker, st, files);
+			if (file) visit(byFile.get(file), st);
+		}
+		state.set(sf, "done");
+		out.push(sf);
+	};
+	for (const sf of sources) visit(sf, void 0);
+	return out;
+}
+/** Links the unit's files (checked by tsc, and by the subset). */
+function linkUnit(program, files, hostPrimitives) {
+	const checker = program.getTypeChecker();
+	const fileSet = new Set(files.map((f) => resolve(f)));
+	const sources = ordered(checker, files.map((f) => program.getSourceFile(f)), fileSet);
+	const renamed = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	sources.forEach((sf, k) => {
+		for (const [name, symbol] of topLevel(checker, sf)) {
+			if (seen.has(name)) renamed.set(symbol, `${name}$${k}`);
+			seen.add(name);
+		}
+	});
+	const declarationOf = (id) => {
+		const symbol = ts.isShorthandPropertyAssignment(id.parent) && id.parent.name === id ? checker.getShorthandAssignmentValueSymbol(id.parent) : checker.getSymbolAtLocation(id);
+		if (!symbol) return void 0;
+		if (renamed.has(symbol) || !(symbol.flags & ts.SymbolFlags.Alias)) return symbol;
+		return checker.getAliasedSymbol(symbol);
+	};
+	const unit = {
+		files: sources,
+		rename: (id) => {
+			const symbol = declarationOf(id);
+			return symbol ? renamed.get(symbol) : void 0;
+		},
+		linked: (node) => importedFile(checker, node, fileSet) !== void 0,
+		fileName,
+		intKind: (type) => intKind(checker, type)
+	};
+	const exports = /* @__PURE__ */ new Map();
+	const exportedFrom = /* @__PURE__ */ new Map();
+	const exportFunction = (name, at, declaration) => {
+		if (exportedFrom.has(name)) throw compileError(at, `typed unit: '${name}' is exported by ${exportedFrom.get(name)} and ${at.getSourceFile().fileName}`);
+		if (Object.hasOwn(hostPrimitives, name)) throw compileError(at, `typed unit: export '${name}' is a host primitive's name`);
+		if (!declaration || !ts.isFunctionDeclaration(declaration)) throw compileError(at, `typed unit: export '${name}' is not a function declaration whose parameters are all number, string or boolean`);
+		exportedFrom.set(name, at.getSourceFile().fileName);
+		exports.set(name, locKey(declaration));
+	};
+	for (const sf of sources) for (const { name, at } of exportsOf(sf)) exportFunction(name, at, ts.isExportSpecifier(at) ? checker.getExportSpecifierLocalTargetSymbol(at)?.valueDeclaration : ts.isFunctionDeclaration(at.parent) ? at.parent : void 0);
+	return {
+		ast: convertStaticUnit(unit, hostPrimitives),
+		exports
+	};
+}
+/** A static file's exported values, by name: where each is named (a function's name, a
+*  variable's declaration, an export specifier). Read from the syntax alone, for the program's
+*  bundle too (boundary.ts). */
+function exportsOf(sf) {
+	const out = [];
+	for (const st of sf.statements) {
+		const exported = ts.canHaveModifiers(st) && ts.getModifiers(st)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+		if (exported && ts.isFunctionDeclaration(st) && st.name) out.push({
+			name: st.name.text,
+			at: st.name
+		});
+		else if (exported && ts.isVariableStatement(st)) for (const d of st.declarationList.declarations) out.push({
+			name: d.name.getText(sf),
+			at: d
+		});
+		else if (ts.isExportDeclaration(st) && !st.isTypeOnly && !st.moduleSpecifier && st.exportClause && ts.isNamedExports(st.exportClause)) {
+			for (const spec of st.exportClause.elements) if (!spec.isTypeOnly) out.push({
+				name: spec.name.text,
+				at: spec
+			});
+		}
+	}
+	return out;
+}
+//#endregion
+//#region cli/src/static/boundary.ts
+/** A static file's module in the program's bundle: the file's path, then this suffix (messages
+*  name the file). */
+const STATIC_MODULE = "?static";
+const isStaticModule = (id) => id.endsWith(STATIC_MODULE);
+/** A file that starts with the "use static" directive (after comments). */
+const DIRECTIVE = /^(?:\s|\/\/[^\n]*\n|\/\*[\s\S]*?\*\/)*(["'])use static\1/;
+function isStaticFile(file) {
+	return /\.[cm]?tsx?$/.test(file) && DIRECTIVE.test(readFileSync(file, "utf8"));
+}
+/** The program's bundle: a static file's import resolves to its module of host primitives;
+*  `found` collects the static files. */
+function staticImports(found) {
+	return {
+		name: "visaljs-static-imports",
+		async resolveId(source, importer, { kind }) {
+			if (source === "visaljs:host" || !importer || kind !== "import-statement") return null;
+			const r = await this.resolve(source, importer, { skipSelf: true });
+			if (!r || r.external || !isStaticFile(r.id)) return null;
+			found.add(r.id);
+			return r.id + STATIC_MODULE;
+		},
+		load(id) {
+			if (!isStaticModule(id)) return null;
+			const file = id.slice(0, -7);
+			const names = exportsOf(ts.createSourceFile(file, readFileSync(file, "utf8"), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)).map((e) => e.name);
+			return names.length ? `export { ${names.join(", ")} } from ${JSON.stringify(HOST_MODULE)};\n` : "";
+		}
+	};
+}
+/** The program's calls of static exports: a call whose callee is the export's host import (the
+*  host function, or the module binding one store sets to it). Before optimizing. */
+function annotateTypedCalls(m, calls) {
+	const all = [m.main, ...m.functions];
+	const slots = /* @__PURE__ */ new Map();
+	const stores = /* @__PURE__ */ new Map();
+	for (const fn of all) for (const b of fn.blocks) for (const i of b.instrs) {
+		if (i.op !== "store_global" || i.operands[0].op === "empty") continue;
+		stores.set(i.index, (stores.get(i.index) ?? 0) + 1);
+		const v = i.operands[0];
+		if (v.op === "host_function" && Object.hasOwn(calls, v.target)) slots.set(i.index, v.target);
+	}
+	const target = (callee) => {
+		const v = callee.op === "check_tdz" ? callee.operands[0] : callee;
+		if (v.op === "host_function") return Object.hasOwn(calls, v.target) ? v.target : void 0;
+		if (v.op === "load_global" && stores.get(v.index) === 1) return slots.get(v.index);
+	};
+	for (const fn of all) for (const b of fn.blocks) for (const i of b.instrs) {
+		const name = i.op === "call" ? target(i.operands[0]) : void 0;
+		if (name) i.typedCall = calls[name];
+	}
+}
+//#endregion
 //#region cli/src/bundle.ts
 /** A bundling failure, already formatted as `file:line:col: Kind: message` lines. */
 var BundleError = class extends Error {};
+/** Bundles `entry` into one ES module, `node:*` imports resolved to the host packages' modules.
+*  Warnings go to `warn`, with their location ("file:line:col: ", or ""). */
 async function bundle(entry, hosts, warn, extras = {}) {
 	const rollup = (implicit, warn, required) => rollupOnce(entry, hosts, implicit, warn, required, extras);
 	const b = await rollup([], warn, []);
@@ -11273,11 +12535,8 @@ function programCode(code, cwd, hosts) {
 	const preludes = hosts.map((h) => h.preludeDir + sep);
 	return code.replace(/^\/\/#region (.*)\n[^]*?^\/\/#endregion$/gm, (region, path) => preludes.some((dir) => resolve(cwd, path.replace(/^(?:\0|\\0)visaljs-runtime:/, "")).startsWith(dir)) ? "" : region);
 }
-/** The packages a bundle names in a call the bundler couldn't follow as a require() (and those
-*  `given`):
-*  ``a(`react-dom`)``, where `a` is a bundle's createRequire(import.meta.url) (Vite's, for the
-*  packages it left external). Only in code that calls createRequire; a call of a plain name with
-*  one string, naming a package (not a built-in) that resolves from the entry. A call that isn't a
+/** `given`, and the packages a bundle names in ``a(`react-dom`)``, where `a` is a createRequire()
+*  the bundler couldn't follow (Vite's, for the packages it left external). A call that isn't a
 *  require() but names an installed package bundles it needlessly: the build lists them. */
 function requiredPackages(code, entry, given) {
 	if (!/\bcreateRequire\s*\(/.test(code)) return [];
@@ -11307,11 +12566,12 @@ async function rollupOnce(entry, hosts, implicit, warn, required, extras) {
 			cwd: dirname(resolve(entry)),
 			platform: "node",
 			logLevel: "warn",
-			onLog: (_level, log) => log.code !== "EVAL" && warn(logText(log), logWhere(log)),
+			onLog: (_level, log) => log.code !== "EVAL" && !(log.code === "MODULE_LEVEL_DIRECTIVE" && log.message.includes("\"use static\"")) && warn(logText(log), logWhere(log)),
 			...extras.nodeEnv === void 0 ? {} : { transform: { define: { "process.env.NODE_ENV": JSON.stringify(extras.nodeEnv) } } },
 			plugins: [
 				hostModules(hosts),
 				commonJS(),
+				...ignoredModules$1(extras.ignored ?? []),
 				missingRequires(warn),
 				depdWrappers(),
 				implicitEntry(entry, implicit),
@@ -11345,9 +12605,8 @@ async function rollupOnce(entry, hosts, implicit, warn, required, extras) {
 		throw new BundleError(errors.map((log) => formatLog(log, log.code === "PARSE_ERROR" ? "SyntaxError" : "error")).join("\n"));
 	}
 }
-/** Host modules: `node:fs` (or `fs`) resolves to its host package's prelude
-*  module, which is bundled like the program's own code; prelude modules may import the host
-*  primitives. */
+/** `node:fs` (or `fs`) resolves to its host package's prelude module, bundled like the program's
+*  code; only prelude modules may import the host primitives. */
 function hostModules(hosts) {
 	const modules = hostModules$1(hosts);
 	const preludes = hosts.map((h) => h.preludeDir + sep);
@@ -11355,7 +12614,7 @@ function hostModules(hosts) {
 		name: "visaljs-host",
 		resolveId(source, importer, { kind }) {
 			if (source === "visaljs:host") {
-				if (importer && (preludes.some((dir) => importer.startsWith(dir)) || importer.startsWith(RUNTIME_COPY))) return {
+				if (importer && (preludes.some((dir) => importer.startsWith(dir)) || importer.startsWith(RUNTIME_COPY) || isStaticModule(importer))) return {
 					id: source,
 					external: true
 				};
@@ -11386,14 +12645,11 @@ module.exports = m;
 		}
 	};
 }
-/** CommonJS modules, as Node decides it: `.cjs`, or `.js` without module syntax outside a
-*  `"type": "module"` package. Node runs one as sloppy code unless it says "use strict", though the
-*  bundle is an ES module (strict): the bundler wraps each in a function, which gets the compiler's
-*  COMMONJS_DIRECTIVE, so it's sloppy; one that says "use strict" (a directive the bundler drops)
-*  runs in a strict function of its own. One that names `__filename` or `__dirname`
-*  declares them at its top as the original file's absolute path and directory at build time, as
-*  `import.meta`'s `filename` and `dirname` are. ES modules keep them undefined (code tests
-*  `typeof __dirname` to tell which it is). */
+/** CommonJS modules (as Node decides: `.cjs`, or `.js` without module syntax outside a `"type":
+*  "module"` package) run sloppy, though the bundle is strict: each wrapper gets COMMONJS_DIRECTIVE,
+*  and one saying "use strict" (a directive the bundler drops) gets a strict function of its own.
+*  `__filename` and `__dirname` are the file's at build time; ES modules keep them undefined (code
+*  tests `typeof __dirname`). */
 function commonJS() {
 	const types = /* @__PURE__ */ new Map();
 	const packageType = (dir) => {
@@ -11451,15 +12707,14 @@ function commonJS() {
 			}
 			return marked ? {
 				code: s.toString(),
-				map: s.generateMap({ hires: true }).toString()
+				map: s.generateMap({ hires: "boundary" }).toString()
 			} : null;
 		}
 	};
 }
-/** A require() of a file that isn't there, or of a native addon (a .node file), throws when it's
-*  reached, as in Node, instead of failing the build: packages require() files their published
-*  build leaves out (a framework's dev server, in a branch production never takes: Next.js's
-*  standalone output), and addons they fall back from (sharp, in a try). A warning says where. */
+/** A require() of a missing file or a native addon throws when reached, as in Node, instead of
+*  failing the build: packages require() files their published build leaves out (Next.js's dev
+*  server) and addons they fall back from (sharp, in a try). */
 function missingRequires(warn) {
 	return {
 		name: "visaljs-missing-requires",
@@ -11481,10 +12736,59 @@ function missingRequires(warn) {
 	};
 }
 const MISSING = "\0visaljs-missing:";
-/** depd (deprecation warnings: Express 4, body-parser, http-errors, Next.js's send) wraps a
-*  deprecated function with new Function, to give the wrapper the function's arity: a closure
-*  instead, whose length is 0. new Function needs eval; depd's call is the same everywhere it's
-*  bundled or vendored: `new Function("fn", "log", "deprecate", "message", "site", body)(…)`. */
+/** Stand-ins for the `ignored` modules. A "call" one whose export names can't be read is bundled
+*  instead. */
+function ignoredModules$1(ignored) {
+	if (!ignored.length) return [];
+	const matching = (id) => {
+		const path = id.replaceAll("\\", "/");
+		return ignored.find((m) => /\.[cm]?js$/.test(m.module) ? path.endsWith(`/node_modules/${m.module}`) : path.includes(`/node_modules/${m.module}/`));
+	};
+	return [{
+		name: "visaljs-ignored",
+		async resolveId(source, importer, { kind }) {
+			if (kind !== "require-call" || !importer || source.startsWith("\0")) return null;
+			const resolved = await this.resolve(source, importer, { skipSelf: true });
+			const m = resolved && !resolved.external ? matching(resolved.id) : void 0;
+			if (!resolved || !m) return null;
+			const code = m.stub === "call" ? readFileSync(resolved.id, "utf8") : "";
+			const names = m.stub === "call" ? exportNames(code) : [];
+			if (m.stub === "call" && !names.length) return null;
+			return IGNORED + JSON.stringify({
+				module: m.module,
+				reason: m.reason,
+				code: m.code ?? "MODULE_NOT_FOUND",
+				names,
+				esModule: code.includes("Object.defineProperty(exports, \"__esModule\"")
+			});
+		},
+		load(id) {
+			if (!id.startsWith(IGNORED)) return null;
+			const { module, reason, code, names, esModule } = JSON.parse(id.slice(IGNORED.length));
+			if (!names.length) {
+				const message = code === "MODULE_NOT_FOUND" ? `Cannot find module '${module}' (${reason})` : `${module}: ${reason}`;
+				return `throw Object.assign(new Error(${JSON.stringify(message)}), { code: ${JSON.stringify(code)} });\n`;
+			}
+			const message = JSON.stringify(`${module} isn't in the compiled program (${reason})`);
+			return (esModule ? "Object.defineProperty(exports, \"__esModule\", { value: true });\n" : "") + names.map((n) => `exports.${n} = function () { throw new Error(${message}); };\n`).join("");
+		}
+	}];
+}
+const IGNORED = "\0visaljs-ignored:";
+/** A CommonJS module's export names, as compilers write them: `exports.a = …`,
+*  `Object.defineProperty(exports, "a", …)`, and TypeScript's and SWC's `_export(exports, { a: …, b: … })`. */
+function exportNames(code) {
+	const names = /* @__PURE__ */ new Set();
+	for (const m of code.matchAll(/\bexports\.([A-Za-z_$][\w$]*)\s*=(?!=)/g)) names.add(m[1]);
+	for (const m of code.matchAll(/\bObject\.defineProperty\(exports, "([A-Za-z_$][\w$]*)"/g)) names.add(m[1]);
+	const block = /\b_export\(exports, \{\n([\s\S]*?)\n\}\);/.exec(code)?.[1];
+	if (block) for (const m of block.matchAll(/^ {4}([A-Za-z_$][\w$]*): function\(\) \{/gm)) names.add(m[1]);
+	names.delete("__esModule");
+	return [...names];
+}
+/** depd (Express 4, body-parser, Next.js's send) wraps deprecated functions with new Function,
+*  which needs eval, for their arity: a closure instead (length 0). Its call is the same wherever
+*  it's bundled or vendored. */
 function depdWrappers() {
 	const call = /\bnew Function\((?=\s*(["'])fn\1\s*,\s*\1log\1\s*,\s*\1deprecate\1\s*,\s*\1message\1\s*,\s*\1site\1\s*,)/g;
 	const helper = "function __visaljs_depdWrapper() { return function (fn, log, deprecate, message, site) { return function () { log.call(deprecate, message, site); return fn.apply(this, arguments); }; }; }\n";
@@ -11572,10 +12876,10 @@ function gcCheckFlags() {
 	if (mode === "stress") return ["-DJS_GC_STRESS=1"];
 	throw new Error(`VISALJS_GC_CHECKS=${mode}: expected verify or stress`);
 }
-/** $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. */
+/** $CC alone, else each usual C compiler on the PATH that runs, in order of preference: a build
+*  falls back to the next. Clang first: it compiles a large program's C in half GCC's time and
+*  memory, and its code ran faster (7% fewer instructions per HTTP request). Zig's clang comes
+*  last: it brings its own libc headers and linker. */
 function findCompilers() {
 	if (process.env.CC) {
 		if (!compilerVersion(process.env.CC)) throw new Error(`$CC (${process.env.CC}) doesn't run`);
@@ -11583,8 +12887,8 @@ function findCompilers() {
 	}
 	const found = /* @__PURE__ */ new Map();
 	for (const cc of [
-		"cc",
 		"clang",
+		"cc",
 		"gcc",
 		"zig cc"
 	]) {
@@ -11616,7 +12920,6 @@ 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);
@@ -11745,13 +13048,9 @@ function compileCommand(cc, src, common) {
 		...cxx(common)
 	];
 }
-/** Prebuilt libraries (cli/scripts/prebuilt.ts): each platform's third-party libraries, built
-*  ahead with Zig, so a first build doesn't compile them. The published package has them in
-*  prebuilt/<target>/ (hostTarget), beside runtime/ and node/, as <name>-<prebuiltKey>.a: the key
-*  is the library's sources and flags, not the compiler's, so any C compiler for the platform
-*  links them. They're -O2 builds, used when the build is one (not --debug or VISALJS_GC_CHECKS)
-*  and the compiler targets this machine. VISALJS_PREBUILT names another directory of them (a
-*  cross-compiler's target's, or build/prebuilt/<target> in this repository), or 0 for none. */
+/** A prebuilt library (cli/scripts/prebuilt.ts, built with Zig): prebuilt/<target>/<name>-<prebuiltKey>.a.
+*  The key leaves out the compiler, so any C compiler for the platform links it. Only for -O2 builds
+*  whose compiler targets this machine; VISALJS_PREBUILT names another directory, or 0 for none. */
 function prebuiltArchive(tc, lib) {
 	if (tc.opt.join(" ") !== PREBUILT_OPT.join(" ")) return void 0;
 	const env = process.env.VISALJS_PREBUILT;
@@ -11762,9 +13061,9 @@ function prebuiltArchive(tc, lib) {
 }
 [...COMMON.filter((f) => f !== "-g")];
 const PREBUILT_OPT = ["-O2"];
-/** A prebuilt library's key: its sources' and headers' paths (from the directory holding runtime/
-*  and node/: the same in this repository and in the published package) and contents, and its flags (their paths the same way). PREBUILT_COMMON and PREBUILT_OPT are
-*  the format's: changing them changes its version, the key's first line. */
+/** A prebuilt library's key: its files' paths (from runtime/'s parent: the same in this repository
+*  and the package) and contents, and its flags. Changing PREBUILT_COMMON or PREBUILT_OPT bumps
+*  the version, the key's first line. */
 function prebuiltKey(lib) {
 	const root = dirname(RUNTIME_DIR);
 	const portable = (s) => s.split(root).join("<root>").replaceAll("\\", "/");
@@ -11778,13 +13077,13 @@ function hostTarget() {
 	const musl = process.platform === "linux" && !process.report.getReport().header?.glibcVersionRuntime;
 	return `${process.platform}-${process.arch}${musl ? "-musl" : ""}`;
 }
-let installed;
+let installed$1;
 function installedPrebuilt() {
-	if (installed === void 0) {
+	if (installed$1 === void 0) {
 		const dir = join(dirname(RUNTIME_DIR), "prebuilt", hostTarget());
-		installed = existsSync(dir) ? dir : "";
+		installed$1 = existsSync(dir) ? dir : "";
 	}
-	return installed;
+	return installed$1;
 }
 /** 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. */
@@ -11861,17 +13160,14 @@ function programArchives(tc, hosts, building) {
 	const libraries = [...hosts.flatMap((h) => h.libraries(RUNTIME_INCLUDE)).filter((l) => l.sources.length), ...runtimeLibraries()];
 	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). 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.
-*
-*  One file compiles and links in one command. A split program's files compile to
-*  objects, `jobs` at once, then link; `compiled` hears as each one is done. Asynchronous: the
-*  build's report keeps drawing while the compilers run. */
+/** 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 } = {}) {
 	const flags = [
 		...COMMON,
 		...tc.opt,
+		...tc.strip ? ["-g0"] : [],
 		...extraFlags
 	];
 	const link = [
@@ -11918,10 +13214,11 @@ async function compileProgram(tc, cFiles, output, archives, { extraFlags = [], j
 		...link
 	]);
 }
-/** How many of a split program's files compile at once: one per processor, and one per 1.5 GB
-*  of memory (a file of the split needs up to about 1 GB at -O2). */
-function compileJobs() {
-	return Math.max(1, Math.min(availableParallelism(), Math.floor(totalmem() / 15e8)));
+/** 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
+*  debug info, 0.55 GB without. */
+function compileJobs(perJob = 15e8) {
+	return Math.max(1, Math.min(availableParallelism(), Math.floor(process.availableMemory() / perJob)));
 }
 /** 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. */
@@ -12104,8 +13401,244 @@ ${readFileSync(VISALJS_LICENSE, "utf8").trimEnd()}
 ${sections.join("\n")}`;
 }
 //#endregion
-//#region cli/src/entry.ts
-var EntryError = class extends Error {};
+//#region cli/src/static/subset.ts
+const K = ts.SyntaxKind;
+const STATEMENTS = /* @__PURE__ */ new Set([
+	K.FunctionDeclaration,
+	K.VariableStatement,
+	K.VariableDeclarationList,
+	K.VariableDeclaration,
+	K.Block,
+	K.IfStatement,
+	K.ForStatement,
+	K.ForOfStatement,
+	K.WhileStatement,
+	K.DoStatement,
+	K.ReturnStatement,
+	K.BreakStatement,
+	K.ContinueStatement,
+	K.ExpressionStatement,
+	K.SwitchStatement,
+	K.CaseBlock,
+	K.CaseClause,
+	K.DefaultClause,
+	K.ThrowStatement,
+	K.TryStatement,
+	K.CatchClause,
+	K.EmptyStatement,
+	K.LabeledStatement,
+	K.TypeAliasDeclaration,
+	K.InterfaceDeclaration
+]);
+const EXPRESSIONS = /* @__PURE__ */ new Set([
+	K.Identifier,
+	K.NumericLiteral,
+	K.StringLiteral,
+	K.NoSubstitutionTemplateLiteral,
+	K.TemplateExpression,
+	K.TemplateHead,
+	K.TemplateMiddle,
+	K.TemplateTail,
+	K.TemplateSpan,
+	K.TrueKeyword,
+	K.FalseKeyword,
+	K.NullKeyword,
+	K.BinaryExpression,
+	K.PrefixUnaryExpression,
+	K.PostfixUnaryExpression,
+	K.ConditionalExpression,
+	K.CallExpression,
+	K.NewExpression,
+	K.PropertyAccessExpression,
+	K.ElementAccessExpression,
+	K.ArrayLiteralExpression,
+	K.ObjectLiteralExpression,
+	K.PropertyAssignment,
+	K.ShorthandPropertyAssignment,
+	K.ParenthesizedExpression,
+	K.ArrowFunction,
+	K.FunctionExpression,
+	K.TypeOfExpression,
+	K.NonNullExpression,
+	K.AsExpression,
+	K.SatisfiesExpression,
+	K.Parameter
+]);
+/** What isn't allowed yet, in words, for the error. */
+const NAMED = {
+	[K.ClassDeclaration]: "classes",
+	[K.ClassExpression]: "classes",
+	[K.ThisKeyword]: "`this`",
+	[K.SuperKeyword]: "`super`",
+	[K.EnumDeclaration]: "enums",
+	[K.ModuleDeclaration]: "namespaces",
+	[K.Decorator]: "decorators",
+	[K.YieldExpression]: "generators",
+	[K.AwaitExpression]: "async functions",
+	[K.DeleteExpression]: "`delete`",
+	[K.ForInStatement]: "for…in",
+	[K.SpreadElement]: "spread",
+	[K.SpreadAssignment]: "spread",
+	[K.ObjectBindingPattern]: "destructuring",
+	[K.ArrayBindingPattern]: "destructuring",
+	[K.TaggedTemplateExpression]: "tagged templates",
+	[K.RegularExpressionLiteral]: "regular expressions",
+	[K.BigIntLiteral]: "BigInt",
+	[K.VoidExpression]: "`void`",
+	[K.MetaProperty]: "import.meta and new.target",
+	[K.ImportKeyword]: "import()",
+	[K.MethodDeclaration]: "methods",
+	[K.GetAccessor]: "getters",
+	[K.SetAccessor]: "setters",
+	[K.WithStatement]: "`with`",
+	[K.DebuggerStatement]: "`debugger`",
+	[K.ExportAssignment]: "default exports"
+};
+/** A module's top level: declarations only (top-level code runs, in an order across files). */
+const TOP_LEVEL = /* @__PURE__ */ new Set([
+	K.FunctionDeclaration,
+	K.VariableStatement,
+	K.TypeAliasDeclaration,
+	K.InterfaceDeclaration,
+	K.ImportDeclaration,
+	K.ExportDeclaration,
+	K.EmptyStatement
+]);
+const notYet = (what) => `static code doesn't have ${what} yet`;
+/** Checks the unit's files against the subset; throws the first error. */
+function checkSubset(program, files) {
+	const checker = program.getTypeChecker();
+	const fileSet = new Set(files.map((f) => resolve(f)));
+	for (const file of files) program.getSourceFile(file).statements.forEach((st, k) => {
+		if (k === 0 && ts.isExpressionStatement(st) && ts.isStringLiteral(st.expression)) return;
+		if (NAMED[st.kind]) throw compileError(st, notYet(NAMED[st.kind]));
+		if (!TOP_LEVEL.has(st.kind)) throw compileError(st, "a static file only declares: top-level statements would run code, in no order across files");
+		if (ts.isImportDeclaration(st)) return checkImport(checker, st, fileSet);
+		if (ts.isExportDeclaration(st)) {
+			if (st.moduleSpecifier) throw compileError(st, notYet("re-exports (export … from)"));
+			return;
+		}
+		visit(st);
+	});
+}
+function checkImport(checker, st, files) {
+	const specifier = st.moduleSpecifier.text;
+	if (specifier === "visaljs:host" || specifier === "visaljs" || importedFile(checker, st, files)) {
+		if (st.importClause?.name || st.importClause?.namedBindings && ts.isNamespaceImport(st.importClause.namedBindings)) throw compileError(st, notYet("default and namespace imports"));
+		return;
+	}
+	throw compileError(st.moduleSpecifier, `static code imports only static files, "visaljs" and ${HOST_MODULE}: '${specifier}' isn't one`);
+}
+/** A type: anything tsc takes but `any`. */
+function visitType(node) {
+	if (node.kind === K.AnyKeyword) throw compileError(node, "`any` isn't a static type: name the type");
+	ts.forEachChild(node, visitType);
+}
+function visit(node) {
+	if (ts.isTypeNode(node)) return visitType(node);
+	if (NAMED[node.kind]) throw compileError(node, notYet(NAMED[node.kind]));
+	if (ts.isToken(node) || ts.isModifier(node) || ts.isTypeParameterDeclaration(node)) return;
+	if (ts.isFunctionLike(node) && (node.asteriskToken || ts.getModifiers(node)?.some((m) => m.kind === K.AsyncKeyword))) throw compileError(node, notYet("generators and async functions"));
+	if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) return visitType(node);
+	if (!STATEMENTS.has(node.kind) && !EXPRESSIONS.has(node.kind)) throw compileError(node, notYet(ts.SyntaxKind[node.kind]));
+	ts.forEachChild(node, visit);
+}
+/** A function's name in C, as the emitter makes it (its ident). */
+function ident(name) {
+	let out = "";
+	for (const ch of name) out += /[A-Za-z0-9_]/.test(ch) ? ch : `_u${ch.codePointAt(0).toString(16)}_`;
+	return out;
+}
+/** Compiles the typed files as one unit. */
+function buildTypedUnit(files, primitives) {
+	const program = ts.createProgram([...files, TYPES_FILE], {
+		strict: true,
+		noEmit: true,
+		target: ts.ScriptTarget.ESNext,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		allowImportingTsExtensions: true,
+		skipLibCheck: true
+	});
+	checkSubset(program, files);
+	const errors = ts.getPreEmitDiagnostics(program).filter((d) => d.category === ts.DiagnosticCategory.Error && files.includes(d.file?.fileName ?? ""));
+	if (errors.length) throw new Error(ts.formatDiagnostics(errors, {
+		getCanonicalFileName: (f) => f,
+		getCurrentDirectory: () => process.cwd(),
+		getNewLine: () => "\n"
+	}));
+	const checker = program.getTypeChecker();
+	const signatures = /* @__PURE__ */ new Map();
+	for (const file of files) declaredSignatures(checker, program.getSourceFile(file), signatures);
+	const { ast, exports: exported } = linkUnit(program, files, primitives);
+	const ir = lower(ast, analyze(ast));
+	const at = (fn) => fn.loc ? `${fn.loc.file}:${fn.loc.line}:${fn.loc.column}` : "";
+	for (const fn of ir.functions) {
+		const meta = fn.meta;
+		const sig = signatures.get(at(fn));
+		if (!sig) continue;
+		const hidden = fn.params.length - sig.types.length;
+		meta.declared = fn.params.map((_, k) => k < hidden ? void 0 : sig.types[k - hidden]);
+		meta.declaredViews = fn.params.map((_, k) => k < hidden ? void 0 : sig.views[k - hidden]);
+		meta.external = true;
+	}
+	const exports = {};
+	const exportedFns = /* @__PURE__ */ new Map();
+	for (const [name, loc] of exported) {
+		const fn = ir.functions.find((f) => at(f) === loc);
+		exportedFns.set(name, fn.name);
+		exports[name] = {
+			c: `vt_jsf_${ident(fn.name)}__generic`,
+			length: fn.meta.length
+		};
+	}
+	const report = [];
+	const optimized = optimize(ir, void 0, report);
+	const calls = {};
+	for (const [name, fnName] of exportedFns) {
+		const fn = optimized.functions.find((f) => f.name === fnName);
+		const declared = fn.meta.declared;
+		if (declared.some((t) => t === void 0)) continue;
+		let returns = T.None;
+		for (const b of fn.blocks) if (b.term?.kind === "return") returns |= b.term.value.type & ~T.Empty;
+		calls[name] = {
+			direct: `vt_jsf_${ident(fn.name)}`,
+			generic: exports[name].c,
+			params: fn.params.map((p, k) => ({
+				type: declared[k],
+				repr: p.repr,
+				...fn.meta.declaredViews?.[k] ? { view: fn.meta.declaredViews[k] } : {}
+			})),
+			returns: returns === T.None ? T.Undefined : returns & T.Int64 ? returns & ~T.Int64 | T.Int32 | T.Double : returns,
+			returnRepr: fn.returnRepr ?? "boxed"
+		};
+	}
+	const unit = emitHarnessScript(optimized, "vt_", /* @__PURE__ */ new Map(), { hostPrimitives: primitives });
+	return {
+		c: unit.c,
+		atoms: new Map(unit.atoms),
+		exports,
+		calls,
+		report,
+		names: [...programNames(ast)]
+	};
+}
+//#endregion
+//#region cli/src/pipeline/errors.ts
+/** An integration's failure, as the message to print. */
+var IntegrationError = class extends Error {};
+/** A command `ctx.run` ran that failed: its output, for the integration to look into. */
+var CommandError = class extends IntegrationError {
+	output;
+	constructor(message, output) {
+		super(message);
+		this.output = output;
+	}
+};
+//#endregion
+//#region cli/src/integrations/project.ts
+/** The project names no entry, or several. */
+var EntryError = class extends IntegrationError {};
 const NODE_VALUE_OPTIONS = /* @__PURE__ */ new Set([
 	"-r",
 	"--require",
@@ -12203,18 +13736,31 @@ function projectEntry(root) {
 	};
 	throw new EntryError(`no entry file: checked ${existsSync(pkgFile) ? `package.json's "bin", "scripts.start" and "main", and index.js` : "a package.json and index.js"}${missing.length ? ` (${missing.join("; ")})` : ""}`);
 }
+const project = {
+	id: "project",
+	name: "package.json",
+	provides: "entry",
+	detect: () => true,
+	hooks: { prepare(ctx) {
+		const entry = projectEntry(ctx.root);
+		ctx.entryFile = entry.file;
+		ctx.output = join(ctx.root, entry.name);
+		ctx.note(`Entry: ${relative(ctx.root, entry.file).replaceAll("\\", "/")} (${entry.from})`, "📄");
+		if (entry.ignoredArgs.length) ctx.note(`its arguments (${entry.ignoredArgs.join(" ")}) aren't built in: give them when you run the binary`);
+	} }
+};
 //#endregion
-//#region cli/src/frameworks/error.ts
-/** A framework's failure, as the message to print. */
-var FrameworkError = class extends Error {};
-//#endregion
-//#region cli/src/frameworks/project.ts
+//#region cli/src/pipeline/packages.ts
 /** The project's package.json, or {} without one. */
 function packageJson(root) {
 	const file = join(root, "package.json");
-	return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
+	if (!existsSync(file)) return {};
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch (e) {
+		throw new IntegrationError(`cannot read ${file}: ${e.message}`);
+	}
 }
-/** The project's package.json's dependencies and devDependencies. */
 function dependencies(root) {
 	const pkg = packageJson(root);
 	return {
@@ -12222,25 +13768,36 @@ function dependencies(root) {
 		...pkg.dependencies
 	};
 }
+/** Whether `name` is installed for the project in `root`: in node_modules here or in a directory
+*  above (a workspace's), as Node finds it, or in pnpm's store there (node_modules/.pnpm/<name>@…),
+*  where a dependency's dependencies are. */
+function installed(root, name) {
+	const store = `${name.replace("/", "+")}@`;
+	for (let dir = root;; dir = dirname(dir)) {
+		const modules = join(dir, "node_modules");
+		if (existsSync(join(modules, name, "package.json"))) return true;
+		const pnpm = join(modules, ".pnpm");
+		if (existsSync(pnpm) && readdirSync(pnpm).some((d) => d.startsWith(store))) return true;
+		if (dirname(dir) === dir) return false;
+	}
+}
 /** The script a package installed in the project runs as `name` (its package.json's "bin"). */
 function packageBin(root, pkg, name) {
 	let manifest;
 	try {
 		manifest = createRequire(join(root, "package.json")).resolve(`${pkg}/package.json`);
 	} catch {
-		throw new FrameworkError(`${pkg} isn't installed in ${root}: run npm install first`);
+		throw new IntegrationError(`${pkg} isn't installed in ${root}: run npm install first`);
 	}
 	const { bin } = JSON.parse(readFileSync(manifest, "utf8"));
 	const script = typeof bin === "string" ? bin : bin?.[name];
-	if (!script) throw new FrameworkError(`${pkg} has no ${name} command`);
+	if (!script) throw new IntegrationError(`${pkg} has no ${name} command`);
 	return join(dirname(manifest), script);
 }
 //#endregion
-//#region cli/src/frameworks/next.ts
+//#region cli/src/integrations/next.ts
 const TABLE = "\0visaljs-next-table";
 const UNTRACED = "\0visaljs-next-untraced:";
-const UNCALLED_PREFIX = "\0visaljs-next-uncalled:";
-/** next build's config, as the standalone server.js gets it, and its build directory (.next). */
 function serverConfig(root) {
 	for (const distDir of [".next", ...configuredDistDir(root)]) {
 		const file = join(root, distDir, "required-server-files.json");
@@ -12252,10 +13809,9 @@ function serverConfig(root) {
 			};
 		}
 	}
-	if (existsSync(join(root, "out", "index.html")) || existsSync(join(root, "out", "404.html"))) throw new FrameworkError(`${root} is a static export (output: "export" in next.config): it has no server to compile. Serve out/ with any static file server, or remove output: "export" to compile the Next.js server`);
-	throw new FrameworkError(`${root} has no Next.js build (no .next/required-server-files.json): run \`next build\`, or build without --no-framework-build`);
+	if (existsSync(join(root, "out", "index.html")) || existsSync(join(root, "out", "404.html"))) throw new IntegrationError(`${root} is a static export (output: "export" in next.config): it has no server to compile. Serve out/ with any static file server, or remove output: "export" to compile the Next.js server`);
+	throw new IntegrationError(`${root} has no Next.js build (no .next/required-server-files.json): run \`next build\`, or build without --no-framework-build`);
 }
-/** Whether next build used Turbopack (its default since Next.js 16): its chunks' runtime is there. */
 function isTurbopackBuild(root, distDir) {
 	const chunks = join(root, distDir, "server", "chunks");
 	return existsSync(join(chunks, "[turbopack]_runtime.js")) || existsSync(join(chunks, "ssr", "[turbopack]_runtime.js"));
@@ -12263,7 +13819,7 @@ function isTurbopackBuild(root, distDir) {
 function configuredDistDir(root) {
 	return readdirSync(root).filter((d) => d !== ".next" && existsSync(join(root, d, "required-server-files.json")));
 }
-/** Every file under `dir`, by its path relative to it, with "/". */
+/** Every file under `dir`, relative to it, with "/". */
 function files(dir, under = "") {
 	const out = [];
 	for (const entry of readdirSync(join(dir, under))) {
@@ -12273,9 +13829,6 @@ function files(dir, under = "") {
 	}
 	return out;
 }
-/** The table's module (CommonJS: each entry is required when it's first loaded): .next/server's
-*  modules by their path under .next, and its client reference manifests as functions of the
-*  context Next evaluates them in. */
 function tableModule(root, distDir) {
 	const build = join(root, distDir);
 	const server = files(join(build, "server")).filter((f) => f.endsWith(".js")).map((f) => `server/${f}`);
@@ -12284,7 +13837,6 @@ function tableModule(root, distDir) {
 	const manifests = server.filter(manifest).map((f) => `  ${JSON.stringify(f)}: function (globalThis) { var process = globalThis.process;\n${readFileSync(join(build, f), "utf8")}\n},`);
 	return `"use strict";\nexports.modules = {\n${modules.join("\n")}\n};\nexports.manifests = {\n${manifests.join("\n")}\n};\n`;
 }
-/** The files next build traced as the server's and its routes' (their .nft.json files): absolute paths. */
 function tracedFiles(root, distDir) {
 	const build = join(root, distDir);
 	const traces = [...files(build, "").filter((f) => !f.startsWith("standalone/") && !f.startsWith("cache/") && f.endsWith(".nft.json"))];
@@ -12295,9 +13847,9 @@ function tracedFiles(root, distDir) {
 	}
 	return traced;
 }
-/** process.env's variables Next's server reads to pick a route runtime, as this build's server has
-*  them: NEXT_RUNTIME (only the edge runtime sets it), TURBOPACK (next.js sets it for a Turbopack
-*  build) and __NEXT_EXPERIMENTAL_REACT (as next build defines it in the code it compiles). */
+/** The variables Next picks a route runtime by, as this build's server has them: NEXT_RUNTIME (only
+*  the edge runtime sets it), TURBOPACK (set for a Turbopack build), __NEXT_EXPERIMENTAL_REACT (as
+*  next build defines it). */
 function runtimeVariables(root, config) {
 	let experimental;
 	try {
@@ -12312,25 +13864,106 @@ function runtimeVariables(root, config) {
 		...experimental ? {} : { __NEXT_EXPERIMENTAL_REACT: "undefined" }
 	};
 }
-/** Whether the build has middleware or edge functions: the edge sandbox runs them. */
+function hasPagesRoutes(root, distDir) {
+	const file = join(root, distDir, "server", "pages-manifest.json");
+	if (!existsSync(file)) return true;
+	return Object.values(JSON.parse(readFileSync(file, "utf8"))).some((f) => f.endsWith(".js"));
+}
 function hasMiddleware(root, distDir) {
 	const file = join(root, distDir, "server", "middleware-manifest.json");
 	if (!existsSync(file)) return true;
 	const { middleware = {}, functions = {} } = JSON.parse(readFileSync(file, "utf8"));
 	return Object.keys(middleware).length > 0 || Object.keys(functions).length > 0;
 }
-const DEV_ONLY = [
-	["next/dist/server/next.js", "./dev/next-dev-server"],
-	["next/dist/server/lib/router-server.js", "./router-utils/setup-dev-bundler"],
-	["next/dist/client/components/app-router.js", "../dev/hot-reloader/app/hot-reloader-app"],
-	["next/dist/server/lib/router-server.js", "../../telemetry/storage"]
-];
-const UNCALLED = [[
-	"next/dist/server/config.js",
-	"../build/next-config-ts/transpile-config",
-	["transpileConfig"]
-]];
+function ignoredModules(root, distDir) {
+	const dev = "Next's dev mode: visaljs builds its production server";
+	return [
+		{
+			module: "next/dist/server/dev/next-dev-server.js",
+			reason: dev
+		},
+		{
+			module: "next/dist/server/lib/router-utils/setup-dev-bundler.js",
+			reason: dev
+		},
+		{
+			module: "next/dist/telemetry/storage.js",
+			reason: dev
+		},
+		{
+			module: "next/dist/client/dev/hot-reloader/app/hot-reloader-app.js",
+			reason: dev
+		},
+		{
+			module: "next/dist/server/next-typescript.js",
+			reason: "Next's TypeScript plugin for editors"
+		},
+		{
+			module: "next/dist/build/next-config-ts/transpile-config.js",
+			stub: "call",
+			reason: "the server gets the config next build saved"
+		},
+		{
+			module: "next/dist/build/swc/index.js",
+			stub: "call",
+			reason: "SWC is a native addon, which visaljs can't load"
+		},
+		...hasPagesRoutes(root, distDir) ? [] : [{
+			module: "next/dist/server/route-modules/pages/module.compiled.js",
+			reason: "the Pages Router's renderer, and this build has no Pages routes"
+		}],
+		...hasMiddleware(root, distDir) ? [] : [{
+			module: "next/dist/server/web/sandbox/index.js",
+			reason: "the edge sandbox runs middleware, which this build has none of"
+		}]
+	];
+}
 const RUNTIME_PICKERS = /[\\/]next[\\/]dist[\\/]server[\\/]route-modules[\\/](?:[\w-]+[\\/]module\.compiled|app-page[\\/]vendored[\\/]\w+[\\/]entrypoints)\.js$/;
+function constants(root, config) {
+	const testProxy = config.experimental?.testProxy;
+	const runners = testRunners(root);
+	return [
+		...runners ? [{
+			file: /[\\/]next[\\/]dist[\\/]server[\\/]config-schema\.js$/,
+			find: "const _nexttest = require(\"../cli/next-test\");",
+			replace: `const _nexttest = { SUPPORTED_TEST_RUNNERS_LIST: ${runners} };`
+		}] : [],
+		{
+			file: /[\\/]next[\\/]dist[\\/]server[\\/]lib[\\/]start-server\.js$/,
+			find: "const { dir, isDev, hostname,",
+			replace: "const isDev = false, { dir, hostname,"
+		},
+		...testProxy ? [] : [
+			{
+				file: /[\\/]next[\\/]dist[\\/]server[\\/]next-server\.js$/,
+				find: "this.serverOptions.experimentalTestProxy",
+				replace: "false"
+			},
+			{
+				file: /[\\/]next[\\/]dist[\\/]server[\\/]lib[\\/]router-server\.js$/,
+				find: "config.experimental.testProxy",
+				replace: "false"
+			},
+			{
+				file: /[\\/]next[\\/]dist[\\/]server[\\/]web[\\/]adapter\.js$/,
+				find: "process.env.NEXT_PRIVATE_TEST_PROXY === 'true'",
+				replace: "false"
+			}
+		]
+	].map((c) => ({
+		...c,
+		missing: "skip"
+	}));
+}
+function testRunners(root) {
+	try {
+		const file = createRequire(join(root, "package.json")).resolve("next/dist/cli/next-test.js");
+		const list = /\bconst SUPPORTED_TEST_RUNNERS_LIST = (\[[\s\w'",]*\]);/.exec(readFileSync(file, "utf8"))?.[1];
+		return list && JSON.stringify(JSON.parse(list.replaceAll("'", "\"").replace(/,\s*\]$/, "]")));
+	} catch {
+		return;
+	}
+}
 const LOADS = [
 	{
 		file: /[\\/]next[\\/]dist[\\/]server[\\/]require\.js$/,
@@ -12348,42 +13981,8 @@ const LOADS = [
 		replace: "globalThis.__visaljs_next.evaluate(path, contextObject, () => (0, _vm.runInNewContext)(content, contextObject))"
 	}
 ];
-const next = {
-	name: "Next.js",
-	detect: (root) => "next" in dependencies(root) && !("vinext" in dependencies(root)),
-	async build(root) {
-		const bin = packageBin(root, "next", "next");
-		const standalone = join(root, ".next", "standalone");
-		const hadStandalone = existsSync(standalone);
-		try {
-			const env = {
-				...process.env,
-				NEXT_PRIVATE_STANDALONE: "1",
-				NEXT_TELEMETRY_DISABLED: "1",
-				FORCE_COLOR: "0"
-			};
-			await promisify(execFile)(process.execPath, [bin, "build"], {
-				cwd: root,
-				maxBuffer: 64 << 20,
-				env
-			});
-		} catch (e) {
-			const { stdout = "", stderr = "" } = e;
-			throw new FrameworkError(`next build failed in ${root}:\n${`${stdout}${stderr}`.trimEnd().split("\n").slice(-30).join("\n")}`);
-		} finally {
-			if (!hadStandalone) rmSync(standalone, {
-				recursive: true,
-				force: true
-			});
-		}
-		return "Built the app with next build, as a standalone build (.next/)";
-	},
-	entry(root) {
-		const { config, distDir } = serverConfig(root);
-		if (!existsSync(join(root, distDir, "server", "app")) && !existsSync(join(root, distDir, "server", "pages"))) throw new FrameworkError(`${root}'s ${distDir}/server has no app/ or pages/: this Next.js build isn't supported yet`);
-		if (config.output !== "standalone") throw new FrameworkError(`${root}'s ${distDir} isn't a standalone build, whose traces visaljs bundles from: build without --no-framework-build (visaljs runs next build as one, without changing next.config), or set output: "standalone"`);
-		if (!isTurbopackBuild(root, distDir)) throw new FrameworkError(`${root}'s ${distDir} was built with webpack (next build --webpack): visaljs compiles Turbopack builds, next build's default, for now. Build without --webpack`);
-		return `import { modules, manifests } from ${JSON.stringify(TABLE)};
+function entrySource(config, distDir) {
+	return `import { modules, manifests } from ${JSON.stringify(TABLE)};
 const config = ${JSON.stringify(config)};
 const key = (path) => {
   const p = String(path).replaceAll("\\\\", "/");
@@ -12418,67 +14017,102 @@ await startServer({
   process.exit(1);
 });
 `;
-	},
-	plugins(root) {
-		const { config, distDir } = serverConfig(root);
-		const traced = tracedFiles(root, distDir);
-		const variables = runtimeVariables(root, config);
-		const read = new RegExp(`\\bprocess\\.env\\.(${Object.keys(variables).join("|")})\\b(?!\\s*(?:=[^=]|\\?\\?=|\\|\\|=|&&=))`, "g");
-		const sandbox = !hasMiddleware(root, distDir);
-		const packages = join(root, "node_modules") + sep;
-		return [{
-			name: "visaljs-next",
-			async resolveId(source, importer, { kind }) {
-				if (source === TABLE) return source;
-				if (kind !== "require-call" || source.startsWith("\0") || !importer?.startsWith(packages)) return null;
-				const from = importer.replaceAll("\\", "/");
-				if (DEV_ONLY.some(([file, s]) => s === source && from.endsWith(`/node_modules/${file}`))) return UNTRACED + source;
-				const uncalled = UNCALLED.find(([file, s]) => s === source && from.endsWith(`/node_modules/${file}`));
-				if (uncalled) return UNCALLED_PREFIX + JSON.stringify([source, uncalled[2]]);
-				if (sandbox && source === "./web/sandbox" && /[\\/]next[\\/]dist[\\/]server[\\/]next-server\.js$/.test(importer)) return UNTRACED + source;
-				const resolved = await this.resolve(source, importer, { skipSelf: true });
-				if (!resolved || resolved.external || !resolved.id.startsWith(packages) || traced.has(resolved.id)) return resolved;
-				return UNTRACED + source;
-			},
-			load(id) {
-				if (id === TABLE) return tableModule(root, distDir);
-				if (id.startsWith(UNCALLED_PREFIX)) {
-					const [source, names] = JSON.parse(id.slice(23));
-					const message = JSON.stringify(`${source} isn't in the compiled server: visaljs builds Next's production server, which doesn't call it`);
-					return names.map((n) => `exports.${n} = function () { throw new Error(${message}); };\n`).join("");
-				}
-				if (!id.startsWith(UNTRACED)) return null;
-				const message = `Cannot find module '${id.slice(23)}' (next build didn't trace it as the server's)`;
-				return `throw Object.assign(new Error(${JSON.stringify(message)}), { code: "MODULE_NOT_FOUND" });\n`;
-			},
-			transform: {
-				filter: { id: /(?:require|load-manifest\.external|_runtime|module\.compiled|entrypoints)\.js$/ },
-				handler(code, id) {
-					if (RUNTIME_PICKERS.test(id)) return {
-						code: code.replace(read, (_, name) => variables[name]),
-						map: null
-					};
-					const load = LOADS.find((l) => l.file.test(id));
-					if (!load) return null;
-					if (!code.includes(load.find)) this.error(`${relative(root, id)} no longer loads the build as visaljs expects (${load.find}): this Next.js version isn't supported yet`);
-					return {
-						code: code.replaceAll(load.find, load.replace),
-						map: null
-					};
-				}
+}
+function buildModules(root, distDir) {
+	const traced = tracedFiles(root, distDir);
+	const packages = join(root, "node_modules") + sep;
+	return {
+		name: "visaljs-next",
+		async resolveId(source, importer, { kind }) {
+			if (source === TABLE) return source;
+			if (kind !== "require-call" || source.startsWith("\0") || !importer?.startsWith(packages)) return null;
+			const resolved = await this.resolve(source, importer, { skipSelf: true });
+			if (!resolved || resolved.external || !resolved.id.startsWith(packages) || traced.has(resolved.id)) return resolved;
+			return UNTRACED + source;
+		},
+		load(id) {
+			if (id === TABLE) return tableModule(root, distDir);
+			if (!id.startsWith(UNTRACED)) return null;
+			const message = `Cannot find module '${id.slice(23)}' (next build didn't trace it as the server's)`;
+			return `throw Object.assign(new Error(${JSON.stringify(message)}), { code: "MODULE_NOT_FOUND" });\n`;
+		}
+	};
+}
+const next = {
+	id: "next",
+	name: "Next.js",
+	provides: "entry",
+	detect: (project) => project.packages.has("next"),
+	hooks: {
+		async frameworkBuild(ctx) {
+			const bin = packageBin(ctx.root, "next", "next");
+			const standalone = join(ctx.root, ".next", "standalone");
+			const hadStandalone = existsSync(standalone);
+			try {
+				await ctx.run([bin, "build"], { env: {
+					NEXT_PRIVATE_STANDALONE: "1",
+					NEXT_TELEMETRY_DISABLED: "1"
+				} });
+			} finally {
+				if (!hadStandalone) rmSync(standalone, {
+					recursive: true,
+					force: true
+				});
 			}
-		}];
-	},
-	notes(root, output) {
-		const { distDir } = serverConfig(root);
-		const inside = relative(root, output);
-		const bin = !inside.startsWith("..") && !isAbsolute(inside) ? `./${inside.replaceAll("\\", "/")}` : output;
-		const project = relative(process.cwd(), root);
-		return [`Run it in the project: it serves ${distDir}/ and public/ from the working directory, as \`next start\` does: ${project && project !== "." ? `cd ${project.startsWith("..") ? root : project} && ` : ""}PORT=3000 ${bin}`, `To deploy it, copy ${basename(output)}, ${distDir}/ (without ${distDir}/cache) and public/ to the server, and run it there the same way`];
+			return "Built the app with next build, as a standalone build (.next/)";
+		},
+		prepare(ctx) {
+			const { root } = ctx;
+			const { config, distDir } = serverConfig(root);
+			if (!existsSync(join(root, distDir, "server", "app")) && !existsSync(join(root, distDir, "server", "pages"))) throw new IntegrationError(`${root}'s ${distDir}/server has no app/ or pages/: this Next.js build isn't supported yet`);
+			if (config.output !== "standalone") throw new IntegrationError(`${root}'s ${distDir} isn't a standalone build, whose traces visaljs bundles from: build without --no-framework-build (visaljs runs next build as one, without changing next.config), or set output: "standalone"`);
+			if (!isTurbopackBuild(root, distDir)) throw new IntegrationError(`${root}'s ${distDir} was built with webpack (next build --webpack): visaljs compiles Turbopack builds, next build's default, for now. Build without --webpack`);
+			ctx.entrySource = entrySource(config, distDir);
+			return {
+				config,
+				distDir
+			};
+		},
+		bundle(ctx, { config, distDir }) {
+			for (const m of ignoredModules(ctx.root, distDir)) ctx.ignore(m);
+			const variables = runtimeVariables(ctx.root, config);
+			const read = new RegExp(`\\bprocess\\.env\\.(${Object.keys(variables).join("|")})\\b(?!\\s*(?:=[^=]|\\?\\?=|\\|\\|=|&&=))`, "g");
+			ctx.rewrite({
+				file: RUNTIME_PICKERS,
+				find: read,
+				replace: (_, name) => variables[name],
+				missing: "skip"
+			});
+			for (const r of [...constants(ctx.root, config), ...LOADS]) ctx.rewrite(r);
+			ctx.plugin(buildModules(ctx.root, distDir));
+		},
+		done(ctx, { distDir }) {
+			const { root, output } = ctx;
+			const inside = relative(root, output);
+			const bin = !inside.startsWith("..") && !isAbsolute(inside) ? `./${inside.replaceAll("\\", "/")}` : output;
+			const project = relative(process.cwd(), root);
+			const cd = project && project !== "." ? `cd ${project.startsWith("..") ? root : project} && ` : "";
+			ctx.note(`Run it in the project: it serves ${distDir}/ and public/ from the working directory, as \`next start\` does: ${cd}PORT=3000 ${bin}`);
+			ctx.note(`To deploy it, copy ${basename(output)}, ${distDir}/ (without ${distDir}/cache) and public/ to the server, and run it there the same way`);
+		}
 	}
 };
 //#endregion
-//#region cli/src/frameworks/vinext.ts
+//#region cli/src/integrations/sharp.ts
+const sharp = {
+	id: "sharp",
+	name: "sharp",
+	detect: (project) => project.installed("sharp"),
+	hooks: { bundle(ctx) {
+		ctx.ignore({
+			module: "sharp",
+			reason: "sharp is a native addon, which visaljs can't load",
+			code: "ERR_DLOPEN_FAILED"
+		});
+	} }
+};
+//#endregion
+//#region cli/src/integrations/vinext.ts
 /** The Vite config file and mode the project's build script gives `vite build` (-c, -m), if any. */
 function buildScriptOptions(root) {
 	const words = packageJson(root).scripts?.build?.split(/\s+/) ?? [];
@@ -12498,7 +14132,6 @@ const WORKERS_FILES = [
 	"wrangler.toml",
 	"cloudflare.config.ts"
 ];
-/** Whether the project is made for Cloudflare Workers: its own build makes a Worker. */
 function isWorkersProject(root) {
 	return WORKERS_FILES.some((f) => existsSync(join(root, f))) || "@cloudflare/vite-plugin" in dependencies(root);
 }
@@ -12520,81 +14153,262 @@ const flat = async (plugins) => (await Promise.all((plugins ?? []).map(async (p)
 const plugins = (await flat(loaded?.config.plugins)).filter((p) => !p.name?.startsWith("vite-plugin-cloudflare"));
 export default { ...loaded?.config, root, plugins };
 `;
+const BUILD_IMPORT = {
+	file: /[\\/]vinext[\\/]dist[\\/]server[\\/]prod-server\.js$/,
+	find: "import(resolveServerEntryImportUrl(entryPath))"
+};
 const MARKER = join("dist", "server", "vinext-server.json");
 const BUILD_ENTRIES = ["dist/server/index.js", "dist/server/entry.js"];
 //#endregion
-//#region cli/src/frameworks/index.ts
-const FRAMEWORKS = [{
-	name: "vinext",
-	detect: (root) => "vinext" in dependencies(root),
-	async build(root) {
-		const vite = packageBin(root, "vite", "vite");
-		const { config, mode } = buildScriptOptions(root);
-		const workers = isWorkersProject(root);
-		const args = [vite, "build"];
-		if (mode) args.push("--mode", mode);
-		const env = {
-			...process.env,
-			FORCE_COLOR: "0"
+//#region cli/src/integrations/index.ts
+const INTEGRATIONS = [
+	{
+		id: "vinext",
+		name: "vinext",
+		provides: "entry",
+		overrides: ["next"],
+		detect: (project) => project.packages.has("vinext"),
+		hooks: {
+			async frameworkBuild(ctx) {
+				const { root } = ctx;
+				const vite = packageBin(root, "vite", "vite");
+				const { config, mode } = buildScriptOptions(root);
+				const workers = isWorkersProject(root);
+				const args = [vite, "build"];
+				if (mode) args.push("--mode", mode);
+				const env = {};
+				const wrapper = join(root, "node_modules", ".visaljs", "vite.config.mjs");
+				if (workers) {
+					mkdirSync(dirname(wrapper), { recursive: true });
+					writeFileSync(wrapper, WORKERS_CONFIG);
+					args.push("--config", wrapper);
+					if (config) env.VISALJS_VITE_CONFIG = join(root, config);
+					if (mode) env.VISALJS_VITE_MODE = mode;
+				} else if (config) args.push("--config", config);
+				try {
+					await ctx.run(args, { env });
+				} catch (e) {
+					if (!(e instanceof CommandError)) throw e;
+					const cloudflare = /failed to resolve import "(cloudflare:[\w-]+)" from "([^"]+)"/.exec(e.output);
+					if (workers && cloudflare) throw new IntegrationError(`${relative(root, cloudflare[2])} imports ${cloudflare[1]}: Cloudflare Workers' own APIs (bindings: env, KV, D1, …) have no Node equivalent, so visaljs can't build this app for Node`);
+					throw e;
+				} finally {
+					if (workers) rmSync(dirname(wrapper), {
+						recursive: true,
+						force: true
+					});
+				}
+				return workers ? "Built the app for Node with vite build, without its Cloudflare plugin (dist/)" : "Built the app with vite build (dist/)";
+			},
+			prepare(ctx) {
+				const { root } = ctx;
+				if (!existsSync(join(root, MARKER))) throw new IntegrationError(`${root} has no vinext build (no ${MARKER}): run \`vite build\`, or build without --no-framework-build`);
+				if (!BUILD_ENTRIES.some((f) => existsSync(join(root, f)))) throw new IntegrationError(isWorkersProject(root) ? `${root}'s dist/ is a Cloudflare Workers build, which has no Node server: build without --no-framework-build, and visaljs builds the app for Node` : `${root}'s vinext build has no Node server (${BUILD_ENTRIES.join(", ")}): this vinext setup isn't supported yet`);
+				ctx.entrySource = "import { startProdServer } from \"vinext/server/prod-server\";\nawait startProdServer();\n";
+			},
+			bundle(ctx) {
+				const { root } = ctx;
+				const choose = BUILD_ENTRIES.filter((f) => existsSync(join(root, f))).map((f) => `entryPath.replaceAll("\\\\", "/").endsWith(${JSON.stringify("/" + f)}) ? import(${JSON.stringify(join(root, f))}) : `).join("");
+				ctx.rewrite({
+					...BUILD_IMPORT,
+					replace: `(${choose}Promise.reject(new Error("visaljs: the build has no " + entryPath)))`
+				});
+				const externals = join(root, "dist", "server", "vinext-externals.json");
+				if (existsSync(externals)) for (const name of JSON.parse(readFileSync(externals, "utf8"))) ctx.require(name);
+			},
+			done(ctx) {
+				ctx.note("It serves ./dist under the working directory, as `vinext start` does: run it from the project");
+				if (isWorkersProject(ctx.root)) ctx.note("Built for Node, not Workers: the project's own build still makes its Worker");
+			}
+		}
+	},
+	next,
+	sharp
+];
+/** The entry when the project uses no framework. */
+const FALLBACK = project;
+//#endregion
+//#region cli/src/pipeline/index.ts
+/** The stages before bundling, for the project in `root` (absolute). `output` is -o's. */
+async function runPipeline(root, options) {
+	const { flags, report } = options;
+	const project = {
+		root,
+		pkg: packageJson(root),
+		packages: new Set(Object.keys(dependencies(root))),
+		installed: (name) => installed(root, name),
+		flags
+	};
+	const detected = (options.integrations ?? INTEGRATIONS).filter((i) => i.detect(project));
+	const replaced = new Set(detected.flatMap((i) => i.overrides ?? []));
+	const kept = detected.filter((i) => !replaced.has(i.id));
+	const frameworks = kept.filter((i) => i.provides === "entry");
+	if (frameworks.length > 1) throw new IntegrationError(`the project uses ${frameworks.map((f) => f.name).join(" and ")}: visaljs builds one framework's server`);
+	const framework = frameworks[0] ?? options.fallback ?? FALLBACK;
+	if (frameworks.length) report.info(` 🧭 A ${framework.name} app: compiling its production server`);
+	const used = [framework, ...kept.filter((i) => i !== framework)];
+	const open = (fields) => {
+		let closed = false;
+		const guard = () => {
+			if (closed) throw new Error("an integration's context was used after its stage was over");
 		};
-		const wrapper = join(root, "node_modules", ".visaljs", "vite.config.mjs");
-		if (workers) {
-			mkdirSync(dirname(wrapper), { recursive: true });
-			writeFileSync(wrapper, WORKERS_CONFIG);
-			args.push("--config", wrapper);
-			if (config) env.VISALJS_VITE_CONFIG = join(root, config);
-			if (mode) env.VISALJS_VITE_MODE = mode;
-		} else if (config) args.push("--config", config);
-		try {
-			await promisify(execFile)(process.execPath, args, {
-				cwd: root,
-				maxBuffer: 64 << 20,
-				env
-			});
-		} catch (e) {
-			const { stdout = "", stderr = "" } = e;
-			const cloudflare = /failed to resolve import "(cloudflare:[\w-]+)" from "([^"]+)"/.exec(stdout + stderr);
-			if (workers && cloudflare) throw new FrameworkError(`${relative(root, cloudflare[2])} imports ${cloudflare[1]}: Cloudflare Workers' own APIs (bindings: env, KV, D1, …) have no Node equivalent, so visaljs can't build this app for Node`);
-			throw new FrameworkError(`vite build failed in ${root}:\n${`${stdout}${stderr}`.trimEnd().split("\n").slice(-30).join("\n")}`);
-		} finally {
-			if (workers) rmSync(dirname(wrapper), {
-				recursive: true,
-				force: true
-			});
+		const context = {
+			...project,
+			note(text, icon) {
+				guard();
+				report.info(icon ? ` ${icon} ${text}` : `    • ${text}`);
+			},
+			warn(message) {
+				guard();
+				report.warn(message);
+			}
+		};
+		return {
+			ctx: Object.defineProperties(context, Object.getOwnPropertyDescriptors(fields(guard))),
+			close: () => closed = true
+		};
+	};
+	if (!flags.skipFrameworkBuild) for (const i of used) {
+		const hook = i.hooks.frameworkBuild;
+		if (!hook) continue;
+		const { ctx, close } = open((guard) => ({ async run(args, { env } = {}) {
+			guard();
+			try {
+				return await promisify(execFile)(process.execPath, args, {
+					cwd: root,
+					maxBuffer: 64 << 20,
+					env: {
+						...process.env,
+						FORCE_COLOR: "0",
+						...env
+					}
+				});
+			} catch (e) {
+				const { stdout = "", stderr = "" } = e;
+				const output = `${stdout}${stderr}`;
+				throw new CommandError(`${[basename(args[0] ?? "").replace(/\.[cm]?js$/, ""), args[1]].filter(Boolean).join(" ")} failed in ${root}:\n${output.trimEnd().split("\n").slice(-30).join("\n")}`, output);
+			}
+		} }));
+		await report.step("🏗️ ", `Building the ${i.name} app`, () => hook(ctx), (what) => what || `Built the ${i.name} app`);
+		close();
+	}
+	const decided = {};
+	const states = /* @__PURE__ */ new Map();
+	for (const i of used) {
+		const hook = i.hooks.prepare;
+		if (!hook) continue;
+		const decide = (guard) => {
+			guard();
+			if (i !== framework) throw new Error(`${i.name} sets the entry or the output, which only the integration that provides the entry sets`);
+		};
+		const { ctx, close } = open((guard) => ({
+			get entryFile() {
+				return decided.entryFile;
+			},
+			set entryFile(file) {
+				decide(guard);
+				decided.entryFile = file;
+			},
+			get entrySource() {
+				return decided.entrySource;
+			},
+			set entrySource(source) {
+				decide(guard);
+				decided.entrySource = source;
+			},
+			get output() {
+				return decided.output;
+			},
+			set output(file) {
+				decide(guard);
+				decided.output = file;
+			}
+		}));
+		states.set(i, await hook(ctx));
+		close();
+	}
+	const entry = decided.entryFile ?? join(root, "visaljs-entry.js");
+	const output = options.output ?? decided.output ?? join(root, basename(root));
+	const rewrites = [];
+	const plugins = [];
+	const requires = [];
+	const ignored = [];
+	for (const i of used) {
+		const hook = i.hooks.bundle;
+		if (!hook) continue;
+		const { ctx, close } = open((guard) => ({
+			entry,
+			output,
+			rewrite(r) {
+				guard();
+				rewrites.push({
+					...r,
+					by: i.name
+				});
+			},
+			plugin(p) {
+				guard();
+				plugins.push(p);
+			},
+			require(name) {
+				guard();
+				requires.push(name);
+			},
+			ignore(m) {
+				guard();
+				ignored.push(m);
+			}
+		}));
+		await hook(ctx, states.get(i));
+		close();
+	}
+	return {
+		entry,
+		output,
+		extras: {
+			...decided.entrySource !== void 0 && { source: decided.entrySource },
+			plugins: [...rewritePlugin(root, rewrites), ...plugins],
+			requires,
+			ignored
+		},
+		done(binary) {
+			for (const i of used) {
+				const hook = i.hooks.done;
+				if (!hook) continue;
+				const { ctx, close } = open(() => ({
+					entry,
+					output: binary
+				}));
+				hook(ctx, states.get(i));
+				close();
+			}
 		}
-		return workers ? "Built the app for Node with vite build, without its Cloudflare plugin (dist/)" : "Built the app with vite build (dist/)";
-	},
-	entry(root) {
-		if (!existsSync(join(root, MARKER))) throw new FrameworkError(`${root} has no vinext build (no ${MARKER}): run \`vite build\`, or build without --no-framework-build`);
-		if (!BUILD_ENTRIES.some((f) => existsSync(join(root, f)))) throw new FrameworkError(isWorkersProject(root) ? `${root}'s dist/ is a Cloudflare Workers build, which has no Node server: build without --no-framework-build, and visaljs builds the app for Node` : `${root}'s vinext build has no Node server (${BUILD_ENTRIES.join(", ")}): this vinext setup isn't supported yet`);
-		return "import { startProdServer } from \"vinext/server/prod-server\";\nawait startProdServer();\n";
-	},
-	plugins(root) {
-		const choose = BUILD_ENTRIES.filter((f) => existsSync(join(root, f))).map((f) => `entryPath.replaceAll("\\\\", "/").endsWith(${JSON.stringify("/" + f)}) ? import(${JSON.stringify(join(root, f))}) : `).join("");
-		return [{
-			name: "visaljs-vinext",
-			transform: {
-				filter: { id: /[\\/]vinext[\\/]dist[\\/]server[\\/]prod-server\.js$/ },
-				handler(code) {
-					const call = "import(resolveServerEntryImportUrl(entryPath))";
-					if (!code.includes(call)) this.error("vinext's prod-server.js no longer imports its build as visaljs expects: this vinext version isn't supported yet");
-					return {
-						code: code.replace(call, `(${choose}Promise.reject(new Error("visaljs: the build has no " + entryPath)))`),
-						map: null
-					};
+	};
+}
+function rewritePlugin(root, rewrites) {
+	if (!rewrites.length) return [];
+	return [{
+		name: "visaljs-rewrites",
+		transform: {
+			filter: { id: rewrites.map((r) => r.file) },
+			handler(code, id) {
+				let text = code;
+				for (const r of rewrites) {
+					if (!r.file.test(id)) continue;
+					if (typeof r.find === "string" ? !text.includes(r.find) : text.search(r.find) < 0) {
+						if (r.missing === "skip") continue;
+						this.error(`${relative(root, id)} no longer has the code visaljs rewrites (${String(r.find)}): this ${r.by} version isn't supported yet`);
+					}
+					const replace = typeof r.replace === "string" ? () => r.replace : r.replace;
+					text = typeof r.find === "string" ? text.replaceAll(r.find, replace) : text.replace(r.find, replace);
 				}
+				return text === code ? null : {
+					code: text,
+					map: null
+				};
 			}
-		}];
-	},
-	requires(root) {
-		const file = join(root, "dist", "server", "vinext-externals.json");
-		return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : [];
-	},
-	notes: (root) => ["It serves ./dist under the working directory, as `vinext start` does: run it from the project", ...isWorkersProject(root) ? ["Built for Node, not Workers: the project's own build still makes its Worker"] : []]
-}, next];
-/** The framework of the project in `root`, or undefined. */
-function detectFramework(root) {
-	return FRAMEWORKS.find((f) => f.detect(root));
+		}
+	}];
 }
 //#endregion
 //#region cli/src/regexp.ts
@@ -12708,6 +14522,10 @@ var Report = class {
 		this.#write(`${text}\n`);
 		if (this.#live && this.#running) this.#draw();
 	}
+	/** A line of the report, as `note`, but only when reporting (not --quiet). */
+	info(text) {
+		if (this.#style) this.note(text);
+	}
 	/** A warning, after its location (`where`, if any): printed even when quiet, its label in yellow. */
 	warn(message, where = "") {
 		this.note(`${where}${this.#paint("1;33", "warning:")} ${message}`);
@@ -12763,7 +14581,6 @@ function lineCount(text) {
 const VERSION = "0.0.7";
 /** A program's C splits into files of about this many IR instructions. */
 const PART_SIZE = 2e4;
-/** A TypeScript file, by its extension: the bundler strips its types. */
 const TYPESCRIPT = /\.(?:[cm]?ts|tsx)$/;
 const USAGE = `usage: visaljs build [entry.js | entry.ts | project directory] [options]
        visaljs licenses   print the licenses to ship with a binary you distribute
@@ -12785,6 +14602,7 @@ options:
   --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)
+  --no-static        compile "use static" files as plain TypeScript (to compare)
   -j, --jobs <n>     compile at most n C files at once (default: one per processor, memory permitting)
   --embed-source     embed the source text: Function.prototype.toString returns it
   --all-builtins     install every built-in, not only those the program names
@@ -12818,6 +14636,7 @@ async function main(argv, io) {
 				debug: { type: "boolean" },
 				symbols: { type: "boolean" },
 				"no-optimize": { type: "boolean" },
+				"no-static": { type: "boolean" },
 				jobs: {
 					type: "string",
 					short: "j"
@@ -12875,33 +14694,30 @@ async function main(argv, io) {
 	}
 }
 async function build(entry, options, io) {
-	let framework;
-	let project;
-	let source = "";
+	const dump = options["dump-ast"] === true || options["dump-ir"] === true;
+	const style = options.quiet || dump ? void 0 : io.report;
+	const report = new Report(io.stderr, style);
+	const binary = !dump && !options["emit-c"];
+	const hosts = DEFAULT_HOSTS;
+	let primitives = hostPrimitives(hosts);
+	const nodeEnv = options["node-env"] === "" ? void 0 : options["node-env"] ?? "production";
+	let pipeline;
 	if (statSync(entry, { throwIfNoEntry: false })?.isDirectory()) {
-		const root = resolve(entry);
-		const fw = detectFramework(root);
-		if (fw) {
-			framework = {
-				fw,
-				root
-			};
-			entry = join(root, "visaljs-entry.js");
-		} else {
-			try {
-				project = {
-					...projectEntry(root),
-					root
-				};
-			} catch (e) {
-				if (!(e instanceof EntryError)) throw e;
-				io.stderr(`visaljs: ${entry === "." ? "the current directory" : entry}: ${e.message}: give an entry file\n`);
-				return 1;
-			}
-			entry = project.file;
+		try {
+			pipeline = await runPipeline(resolve(entry), {
+				flags: { skipFrameworkBuild: options["no-framework-build"] === true },
+				output: options.output,
+				report
+			});
+		} catch (e) {
+			if (!(e instanceof IntegrationError)) throw e;
+			io.stderr(e instanceof EntryError ? `visaljs: ${entry === "." ? "the current directory" : entry}: ${e.message}: give an entry file\n` : `visaljs: ${e.message}\n`);
+			return 1;
 		}
+		entry = pipeline.entry;
 	}
-	if (!framework) try {
+	let source = pipeline?.extras.source;
+	if (source === void 0) try {
 		source = readFileSync(entry, "utf8");
 	} catch (e) {
 		io.stderr(`visaljs: cannot read ${entry}: ${e.message}\n`);
@@ -12911,35 +14727,6 @@ async function build(entry, options, io) {
 		io.stderr(`visaljs: ${entry} is TypeScript: it's compiled through the bundler, without ${options.script ? "--script" : "--no-bundle"}\n`);
 		return 1;
 	}
-	const dump = options["dump-ast"] === true || options["dump-ir"] === true;
-	const style = options.quiet || dump ? void 0 : io.report;
-	const report = new Report(io.stderr, style);
-	const binary = !dump && !options["emit-c"];
-	const hosts = DEFAULT_HOSTS;
-	const primitives = hostPrimitives(hosts);
-	let frameworkExtras = {};
-	const nodeEnv = options["node-env"] === "" ? void 0 : options["node-env"] ?? "production";
-	if (project && style) {
-		report.note(` 📄 Entry: ${relative(project.root, project.file).replaceAll("\\", "/")} (${project.from})`);
-		if (project.ignoredArgs.length) report.note(`    • its arguments (${project.ignoredArgs.join(" ")}) aren't built in: give them when you run the binary`);
-	}
-	if (framework) {
-		const { fw, root } = framework;
-		if (style) report.note(` 🧭 A ${fw.name} app: compiling its production server`);
-		try {
-			if (fw.build && options["no-framework-build"] !== true) await report.step("🏗️ ", `Building the ${fw.name} app`, () => fw.build(root), (what) => what);
-			source = fw.entry(root);
-		} catch (e) {
-			if (!(e instanceof FrameworkError)) throw e;
-			io.stderr(`visaljs: ${e.message}\n`);
-			return 1;
-		}
-		frameworkExtras = {
-			source,
-			plugins: fw.plugins?.(root) ?? [],
-			requires: fw.requires?.(root) ?? []
-		};
-	}
 	let compilers;
 	if (binary) try {
 		compilers = await report.step("🔍", "Detecting C compilers", findCompilers, detected);
@@ -12947,122 +14734,295 @@ async function build(entry, options, io) {
 		io.stderr(`visaljs: ${e.message}\n`);
 		return 1;
 	}
-	const script = options.script === true;
-	const bundled = !script && options["no-bundle"] !== true;
+	const bundled = !(options.script === true) && options["no-bundle"] !== true;
 	let map;
+	const typedFiles = /* @__PURE__ */ new Set();
+	let typed;
 	if (bundled) try {
 		const b = await report.step("📦", "Rolling the modules into a single file", () => bundle(entry, hosts, (message, where) => report.warn(message, where), {
-			...frameworkExtras,
+			...pipeline?.extras,
 			nodeEnv,
-			allFeatures: options["all-features"] === true
+			allFeatures: options["all-features"] === true,
+			plugins: [...pipeline?.extras.plugins ?? [], ...options["no-static"] ? [] : [staticImports(typedFiles)]]
 		}), (b) => `Rolled ${count(b.modules, "module")} into a single file (${size(Buffer.byteLength(b.code))})` + (b.required.length ? `; for a require() at run time: ${b.required.join(", ")}` : ""));
 		source = b.code;
-		if (b.map) map = new SourceMap(b.map, displayPath);
+		if (b.map) map = b.map;
+		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"));
+			primitives = {
+				...primitives,
+				...typed.exports
+			};
+		}
 	} catch (e) {
 		if (!(e instanceof BundleError)) throw e;
 		io.stderr(`${e.message}\n`);
 		return 1;
 	}
-	const jobs = options.jobs === void 0 ? compileJobs() : Number(options.jobs);
-	if (!Number.isInteger(jobs) || jobs < 1) {
+	if (options.jobs !== void 0 && (!Number.isInteger(Number(options.jobs)) || Number(options.jobs) < 1)) {
 		io.stderr(`visaljs: --jobs takes a positive whole number, not '${options.jobs}'\n`);
 		return 2;
 	}
-	let files;
+	const emitDir = options["emit-c"];
+	let output = "";
+	if (binary) {
+		output = pipeline?.output ?? options.output ?? basename(entry).replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, "");
+		if (process.platform === "win32" && !extname(output)) output += ".exe";
+		if (resolve(output) === resolve(entry) || statSync(output, { throwIfNoEntry: false })?.isDirectory()) {
+			io.stderr(`visaljs: the binary would be ${displayPath(resolve(output))}, which is ${resolve(output) === resolve(entry) ? "the entry file" : "a directory"}: give another with -o\n`);
+			return 1;
+		}
+	}
+	const dir = emitDir ?? (binary ? scratchDir() : "");
 	try {
-		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");
+		const typedLink = typed ? {
+			atoms: [...typed.atoms],
+			prefix: "vt_",
+			names: typed.names,
+			calls: typed.calls
+		} : void 0;
+		const c = await compileInWorker({
+			source,
+			entry,
+			map,
+			options,
+			primitives,
+			compilers,
+			dir,
+			emitDir,
+			typed: typedLink
+		}, report);
+		if ("compileError" in c) {
+			io.stderr(`${c.compileError}\n`);
+			return 1;
+		}
+		compilers = c.compilers;
+		if (typeof c.result === "string") {
+			io.stdout(c.result);
 			return 0;
 		}
-		const info = analyze(ast);
-		const evalWarn = evalWarning(evalCalls(ast, info), options.verbose === true);
-		if (evalWarn) report.warn(evalWarn);
-		const literals = regexpLiterals(ast);
-		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 passes = [];
-		const ir = await report.step("🔧", "Converting to IR and optimizing", () => optimize(lower(ast, info), 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"]) {
-			io.stdout(printModule(ir));
+		const written = c.result;
+		if (emitDir) {
+			if (bundled) writeFileSync(join(emitDir, "bundle.js"), source);
+			if (typed) writeFileSync(join(emitDir, "typed.c"), typed.c);
+			report.finish("📂", (time) => `Wrote ${written.length > 1 ? `${written.length} files to ${displayPath(resolve(emitDir))}` : displayPath(resolve(emitDir, "program.c"))} in ${time}`);
 			return 0;
 		}
-		const names = programNames(ast);
-		const all = options["all-builtins"] === true;
-		files = await report.step("📝", "Emitting C code", () => emitProgramFiles(ir, {
-			embedSource: options["embed-source"] === true,
-			components: (all ? COMPONENTS : reachableComponents(names)).map((c) => c.symbol),
-			core: all ? void 0 : namedCore(names),
-			regexps,
-			hostPrimitives: primitives,
-			partSize: Number(process.env.VISALJS_PART_SIZE) || PART_SIZE
-		}), (files) => `Emitted ${count(files.reduce((n, f) => n + lineCount(f.text), 0), "line")} of C code (${size(files.reduce((n, f) => n + Buffer.byteLength(f.text), 0))}${files.length > 1 ? `, in ${files.length} files` : ""})`);
-	} catch (e) {
-		if (!(e instanceof CompileError)) throw e;
-		io.stderr(`${e.message}\n`);
-		return 1;
-	}
-	if (options["emit-c"]) {
-		mkdirSync(options["emit-c"], { recursive: true });
-		for (const f of files) writeFileSync(join(options["emit-c"], f.name), f.text);
-		if (bundled) writeFileSync(join(options["emit-c"], "bundle.js"), source);
-		report.finish("📂", (time) => `Wrote ${files.length > 1 ? `${files.length} files to ${displayPath(resolve(options["emit-c"]))}` : displayPath(resolve(options["emit-c"], "program.c"))} in ${time}`);
-		return 0;
-	}
-	let output = options.output ?? (framework ? join(framework.root, basename(framework.root)) : project ? join(project.root, project.name) : basename(entry).replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, ""));
-	if (process.platform === "win32" && !extname(output)) output += ".exe";
-	if (resolve(output) === resolve(entry) || statSync(output, { throwIfNoEntry: false })?.isDirectory()) {
-		io.stderr(`visaljs: the binary would be ${displayPath(resolve(output))}, which is ${resolve(output) === resolve(entry) ? "the entry file" : "a directory"}: give another with -o\n`);
-		return 1;
-	}
-	const opt = [...options.debug ? ["-O0"] : ["-O2"], ...gcCheckFlags()];
-	const dir = scratchDir();
-	try {
-		for (const f of files) writeFileSync(join(dir, f.name), f.text);
-		const cFiles = files.filter((f) => f.name.endsWith(".c")).map((f) => join(dir, f.name));
-		await withCompiler(compilers, report, async (cc) => {
-			const tc = {
-				cc,
-				opt,
-				strip: !options.debug && !options.symbols
-			};
-			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 ⚡)");
-			const compiling = `Compiling with ${describeCompiler(cc)}`;
-			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,
-				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"})`);
-		});
-	} catch (e) {
-		io.stderr(`visaljs: C compilation failed: ${e.message}\n`);
-		return 1;
+		const cFiles = written.filter((name) => name.endsWith(".c")).map((name) => join(dir, name));
+		if (typed) {
+			writeFileSync(join(dir, "typed.c"), typed.c);
+			cFiles.push(join(dir, "typed.c"));
+		}
+		const opt = [...options.debug ? ["-O0"] : ["-O2"], ...gcCheckFlags()];
+		const strip = !options.debug && !options.symbols;
+		const jobs = options.jobs === void 0 ? compileJobs(strip ? 8e8 : 15e8) : Number(options.jobs);
+		try {
+			await withCompiler(compilers, report, async (cc) => {
+				const tc = {
+					cc,
+					opt,
+					strip
+				};
+				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 ⚡)");
+				const compiling = `Compiling with ${describeCompiler(cc)}`;
+				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,
+					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"})`);
+			});
+		} catch (e) {
+			io.stderr(`visaljs: C compilation failed: ${e.message}\n`);
+			return 1;
+		}
 	} finally {
-		rmSync(dir, {
+		if (binary) rmSync(dir, {
 			recursive: true,
 			force: true
 		});
 	}
 	const bytes = statSync(output).size;
 	report.finish("🎉", (time) => `Built ${displayPath(resolve(output))} in ${time}: ${size(bytes)}, ${sizeQuip(bytes)}`);
-	if (framework?.fw.notes && style) for (const note of framework.fw.notes(framework.root, resolve(output))) report.note(`    • ${note}`);
+	pipeline?.done(resolve(output));
 	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). */
+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). */
+function compileInWorker(job, report) {
+	const heap = Math.floor(getHeapStatistics().heap_size_limit / 2 ** 20);
+	const worker = new Worker(new URL(import.meta.url), {
+		workerData: { [WORKER]: job },
+		resourceLimits: { maxOldGenerationSizeMb: heap }
+	});
+	return new Promise((resolve, reject) => {
+		let step;
+		let result;
+		worker.on("message", (m) => {
+			switch (m.kind) {
+				case "step":
+					report.step(m.icon, m.label, () => new Promise((done, fail) => step = {
+						done,
+						fail: () => fail(new Error(m.label))
+					}), (text) => text).catch(() => {});
+					break;
+				case "done":
+					step?.done(m.text);
+					break;
+				case "fail":
+					step?.fail();
+					break;
+				case "relabel":
+					report.relabel(m.label);
+					break;
+				case "note":
+					report.note(m.text);
+					break;
+				case "warn":
+					report.warn(m.message, m.where);
+					break;
+				case "result":
+					result = m.result;
+					worker.terminate();
+					break;
+				case "crash": reject(Object.assign(new Error(m.stack.split("\n")[0]), { stack: m.stack }));
+			}
+		});
+		worker.on("error", reject);
+		worker.on("exit", () => result ? resolve(result) : reject(/* @__PURE__ */ new Error("the compiler's worker stopped without a result")));
+	});
+}
+async function runCompileJob(job) {
+	const post = (m) => parentPort.postMessage(m);
+	const reporter = {
+		async step(icon, label, run, done) {
+			post({
+				kind: "step",
+				icon,
+				label
+			});
+			try {
+				const result = await run();
+				post({
+					kind: "done",
+					text: done(result)
+				});
+				return result;
+			} catch (e) {
+				post({ kind: "fail" });
+				throw e;
+			}
+		},
+		relabel: (label) => post({
+			kind: "relabel",
+			label
+		}),
+		note: (text) => post({
+			kind: "note",
+			text
+		}),
+		warn: (message, where = "") => post({
+			kind: "warn",
+			message,
+			where
+		})
+	};
+	let compilers = job.compilers;
+	try {
+		const map = job.map === void 0 ? void 0 : new SourceMap(job.map, displayPath);
+		post({
+			kind: "result",
+			result: {
+				result: await compileToC(job.source, job.entry, map, job.options, reporter, job.primitives, () => compilers ??= findCompilers(), job.typed, (f) => {
+					if (job.emitDir) mkdirSync(job.emitDir, { recursive: true });
+					writeFileSync(join(job.dir, f.name), f.text);
+				}),
+				compilers
+			}
+		});
+	} catch (e) {
+		if (e instanceof CompileError) post({
+			kind: "result",
+			result: { compileError: e.message }
+		});
+		else post({
+			kind: "crash",
+			stack: e.stack ?? String(e)
+		});
+	}
+}
+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
+*  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);
+	if (typeof program === "string") return program;
+	const { ir, regexps } = program;
+	const names = /* @__PURE__ */ new Set([...program.names, ...typed?.names ?? []]);
+	const all = options["all-builtins"] === true;
+	return (await report.step("📝", "Emitting C code", () => {
+		const files = emitProgramFiles(ir, {
+			embedSource: options["embed-source"] === true,
+			components: (all ? COMPONENTS : reachableComponents(names)).map((c) => c.symbol),
+			core: all ? void 0 : namedCore(names),
+			regexps,
+			hostPrimitives: primitives,
+			...typed ? { harness: {
+				atoms: new Map(typed.atoms),
+				register: `${typed.prefix}register`,
+				scripts: [typed.prefix]
+			} } : {},
+			partSize: Number(process.env.VISALJS_PART_SIZE) || PART_SIZE
+		});
+		const out = {
+			names: [],
+			lines: 0,
+			bytes: 0
+		};
+		for (const f of files) {
+			write(f);
+			out.names.push(f.name);
+			out.lines += lineCount(f.text);
+			out.bytes += Buffer.byteLength(f.text);
+		}
+		return out;
+	}, ({ names, lines, bytes }) => `Emitted ${count(lines, "line")} of C code (${size(bytes)}${names.length > 1 ? `, in ${names.length} files` : ""})`)).names;
+}
+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";
+	const info = analyze(ast);
+	const evalWarn = evalWarning(evalCalls(ast, info), options.verbose === true);
+	if (evalWarn) report.warn(evalWarn);
+	const literals = regexpLiterals(ast);
+	const regexps = literals.length ? await report.step("🧩", "Compiling the regular expressions", () => withCompiler(compilers(), report, (cc) => compileRegExps(cc, literals)), () => `Compiled ${count(literals.length, "regular expression")}`) : /* @__PURE__ */ new Map();
+	const unsupported = firstUnsupported(ast);
+	if (unsupported) throw unsupported;
+	const passes = [];
+	const ir = await report.step("🔧", "Converting to IR and optimizing", () => {
+		const lowered = lower(ast, info);
+		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);
+	return {
+		ir,
+		names: programNames(ast),
+		regexps
+	};
+}
 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. */
+/** Runs `run` with each compiler until one succeeds. A failure that isn't the program's (not a
+*  CompileError) moves on to the next, dropping the failed one from `compilers` for later steps. */
 async function withCompiler(compilers, report, run) {
 	for (;;) {
 		const cc = compilers[0];
@@ -13077,8 +15037,7 @@ async function withCompiler(compilers, report, run) {
 		}
 	}
 }
-/** 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. */
+/** How diagnostics and #line name an original file. */
 function displayPath(source) {
 	if (source.startsWith("\0")) return source.slice(1);
 	const rel = relative(process.cwd(), source);
@@ -13086,14 +15045,16 @@ 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),
-	report: {
-		live: tty,
-		color: tty && !process.env.NO_COLOR && process.env.TERM !== "dumb"
-	}
-});
+if (isMainThread) {
+	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),
+		report: {
+			live: tty,
+			color: tty && !process.env.NO_COLOR && process.env.TERM !== "dumb"
+		}
+	});
+}
 //#endregion
 export {};