gofront 1.7.0 → 1.9.0

package/src/compiler.js

@@ -19,26 +19,42 @@
 
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import {
-	buildSourceMap,
-	buildWasmSourceMap,
-	CodeGen,
-} from "./backend/js/index.js";
+import { CodeGen } from "./backend/js/index.js";
 import { compileWasmModule, optimizeWasm } from "./backend/wasm/index.js";
-import { log } from "./colors.js";
+import { log } from "./cli/colors.js";
 import { parseDts } from "./dts-parser.js";
-import { Lexer } from "./lexer.js";
-import { lower } from "./lower/index.js";
+import { Lexer } from "./lexer/lexer.js";
+import { TemplLexer } from "./lexer/templ-lexer.js";
+import {
+	attachSourceMap,
+	buildWasmMap,
+	mergeCompilationChunks,
+	WASM_MAP_URL,
+} from "./link/sourcemap.js";
+import {
+	checkGeneratedGo,
+	finishStdlibJs,
+	importStdlibPackages,
+	mangleCollidingTypes,
+	renameLocalTypes,
+	withOriginalTypeNames,
+} from "./link/stdlib.js";
+import {
+	linkIntoBundle,
+	registerPackageUnit,
+	wasmMarker,
+} from "./link/wasm.js";
+import { lower, takesElementAddress } from "./lower/index.js";
 import { Parser } from "./parser/index.js";
+import { TemplParser } from "./parser/templ.js";
 import {
 	isBuiltinPackage,
 	isLocalPath,
 	resolveAll,
 	resolveGwDir,
+	resolveStdlibSource,
 } from "./resolver.js";
-import { TemplLexer } from "./templ-lexer.js";
-import { TemplParser } from "./templ-parser.js";
-import { TypeCheckError, TypeChecker } from "./typechecker/index.js";
+import { EXCLUDED_STDLIB_PACKAGES, TypeChecker } from "./typechecker/index.js";
 import { WASM_SUPPORTED_STDLIB } from "./typechecker/types.js";
 
 // ── Parse cache ──────────────────────────────────────────────
@@ -46,10 +62,21 @@ import { WASM_SUPPORTED_STDLIB } from "./typechecker/types.js";
 // Map<filePath, { mtime: number, ast: object }>
 const _parseCache = new Map();
 
+// A cached AST keeps everything the build attached to it (checked types,
+// lowered stdlib programs), so a build of a Go-source stdlib importer pins
+// megabytes.  The cache is therefore bounded; the least recently used file goes
+// first.
+const PARSE_CACHE_LIMIT = 16;
+
 export function clearParseCache() {
 	_parseCache.clear();
 }
 
+// Drops one file, e.g. a throwaway source that was deleted after its build.
+export function evictParseCache(filePath) {
+	_parseCache.delete(resolve(filePath));
+}
+
 export function parseCacheSize() {
 	return _parseCache.size;
 }
@@ -57,9 +84,14 @@ export function parseCacheSize() {
 // ── Helpers ──────────────────────────────────────────────────
 
 function parseGoFrontFile(filePath) {
+	const key = resolve(filePath);
 	const mtime = statSync(filePath).mtimeMs;
-	const cached = _parseCache.get(filePath);
-	if (cached && cached.mtime === mtime) return cached.ast;
+	const cached = _parseCache.get(key);
+	if (cached && cached.mtime === mtime) {
+		_parseCache.delete(key);
+		_parseCache.set(key, cached);
+		return cached.ast;
+	}
 
 	const source = readFileSync(filePath, "utf8");
 	const filename = basename(filePath);
@@ -74,7 +106,9 @@ function parseGoFrontFile(filePath) {
 	ast._path = resolve(filePath);
 	// compileFiles overwrites `target` with the resolved one; keep the directive.
 	ast._declaredTarget = ast.target;
-	_parseCache.set(filePath, { mtime, ast });
+	_parseCache.set(key, { mtime, ast });
+	if (_parseCache.size > PARSE_CACHE_LIMIT)
+		_parseCache.delete(_parseCache.keys().next().value);
 	return ast;
 }
 
@@ -89,103 +123,11 @@ export function gwFilesIn(dir, { includeTests = false } = {}) {
 		.map((f) => join(dir, f));
 }
 
-function normalizeChunk(c) {
-	if (typeof c === "string") {
-		return { js: c, sourceFiles: [], sourcesContent: [], mappings: [] };
-	}
-	return c;
-}
-
-function appendChunkMappings(dest, mappings, localToUnifiedIdx, lineOffset) {
-	if (!mappings) return;
-	for (const m of mappings) {
-		dest.push({
-			genLine: m.genLine + lineOffset,
-			srcLine: m.srcLine,
-			srcFileIdx: localToUnifiedIdx[m.srcFileIdx ?? 0] ?? 0,
-		});
-	}
-}
-
-function mergeCompilationChunks(chunks) {
-	const activeChunks = chunks
-		.filter(Boolean)
-		.map(normalizeChunk)
-		.filter((c) => c.js.length > 0);
-
-	if (activeChunks.length === 0) {
-		return { js: "", sourceFiles: [], sourcesContent: [], mappings: [] };
-	}
-
-	const unifiedSources = [];
-	const unifiedSourcesContent = [];
-	const fileIdxMap = new Map();
-
-	function getOrAddFile(filePath, content) {
-		const key = resolve(filePath);
-		let idx = fileIdxMap.get(key);
-		if (idx === undefined) {
-			idx = unifiedSources.length;
-			fileIdxMap.set(key, idx);
-			unifiedSources.push(key);
-			unifiedSourcesContent.push(content);
-		}
-		return idx;
-	}
-
-	const combinedJsParts = [];
-	const mergedMappings = [];
-	let currentLineOffset = 0;
-
-	for (const chunk of activeChunks) {
-		combinedJsParts.push(chunk.js);
-		const localToUnifiedIdx = (chunk.sourceFiles ?? []).map((file, i) =>
-			getOrAddFile(file, chunk.sourcesContent?.[i] ?? ""),
-		);
-		appendChunkMappings(
-			mergedMappings,
-			chunk.mappings,
-			localToUnifiedIdx,
-			currentLineOffset,
-		);
-		currentLineOffset += chunk.js.split("\n").length;
-	}
-
-	return {
-		js: combinedJsParts.join("\n"),
-		sourceFiles: unifiedSources,
-		sourcesContent: unifiedSourcesContent,
-		mappings: mergedMappings,
-	};
-}
-
-function attachSourceMap(merged, outputDir) {
-	const relativeSources = merged.sourceFiles.map((f) => relative(outputDir, f));
-	const mapJson = buildSourceMap(
-		relativeSources,
-		merged.mappings,
-		merged.sourcesContent,
-	);
-	const b64 = Buffer.from(mapJson).toString("base64");
-	merged.js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
-}
-
-const WASM_MAP_URL = "app.wasm.map";
-
-// Function-level `app.wasm.map` (sources relative to the output dir).
-function buildWasmMap(info, outputDir) {
-	if (!info || info.mappings.length === 0) return null;
-	return buildWasmSourceMap(
-		info.sources.map((f) => relative(outputDir, f)),
-		info.mappings,
-	);
-}
-
 // Shared tail of compileFiles / compileSingleFile: link `app.wasm`, run
 // wasm-opt when requested and produce the wasm source map.
 function finishWasm(options, merged, pkgTarget, outputDir) {
 	const wantMap = Boolean(options.sourceMap && !options.isDependency);
-	let { wasm, wat, sourceMapInfo } = linkIntoBundle(
+	let { wasm, wat, sourceMapInfo, stringTable } = linkIntoBundle(
 		options,
 		merged,
 		pkgTarget,
@@ -210,174 +152,19 @@ function finishWasm(options, merged, pkgTarget, outputDir) {
 		wasmOptInfo = opt;
 		if (opt.sourceMap) wasmSourceMap = opt.sourceMap;
 	}
-	return { wasm, wat, wasmOptInfo, wasmSourceMap };
+	return { wasm, wat, wasmOptInfo, wasmSourceMap, stringTable };
 }
 
-// ── WASM linking ──────────────────────────────────────────────
-//
-// Every `wasm`/`both` package reached during a build registers a unit in the
-// shared `options.wasmUnits` array.  The root compile links all units into a
-// single `app.wasm` and splices the generated JS facade into the bundle where
-// the first wasm package's JS would have been.
-
-const WASM_MARKER_RE = /^\/\*__GOFRONT_WASM_UNIT:[^*]*\*\/$/m;
-
-function wasmMarker(pkgName) {
-	return `/*__GOFRONT_WASM_UNIT:${pkgName}*/`;
-}
-
-function registerWasmUnit(options, unit) {
-	const units = options.wasmUnits;
-	if (!units) return;
-	if (units.some((u) => u.key === unit.key)) return;
-	units.push(unit);
-}
-
-// Registers a `wasm`/`both` package as a link unit and returns the target the
-// package's own code is emitted for.  `options.wasmTests` runs a `both`
-// package's tests through the wasm backend (the package is then treated as
-// `wasm` for linking so its test functions are exposed by the facade).
-function registerPackageUnit(options, unit) {
-	const { pkgTarget, programs } = unit;
-	if (pkgTarget !== "wasm" && pkgTarget !== "both") return pkgTarget;
-	const emitTarget =
-		options.wasmTests && options.isTest && pkgTarget === "both"
-			? "wasm"
-			: pkgTarget;
-	registerWasmUnit(options, {
-		...unit,
-		target: emitTarget,
-		programs:
-			emitTarget === pkgTarget
-				? programs
-				: programs.map((p) => ({ ...p, target: emitTarget })),
-	});
-	return emitTarget;
-}
-
-function linkWasmUnits(
-	units,
-	{ emitWat = false, rootTarget = "js", sourceMappingURL = null } = {},
-) {
-	if (!units.some((u) => u.target === "wasm")) return null;
-	checkLinkCollisions(units);
-
-	const types = new Map();
-	const bundledPackages = new Set();
-	const programs = [];
-	for (const u of units) {
-		for (const [k, v] of u.types) types.set(k, v);
-		for (const b of u.bundledPackages) bundledPackages.add(b);
-		programs.push(...u.programs);
-	}
-	const checker = {
-		types,
-		errors: [],
-		err(msg, node) {
-			const e = new TypeCheckError(
-				msg,
-				node,
-				this._currentFile,
-				this._currentSource,
-			);
-			this.errors.push(e);
-			return e;
-		},
-	};
-	const lowerRes = lower(programs, checker);
-	return compileWasmModule(programs, checker, lowerRes, {
-		boundary: true,
-		bundledPackages,
-		emitWat,
-		callMain: rootTarget === "wasm",
-		sourceMappingURL,
-	});
-}
-
-// The linked module is one flat namespace (like the JS bundle), so a top-level
-// name declared by two different packages would silently resolve to whichever
-// was emitted last.  Reject it up front.
-function topLevelDeclNames(decl) {
-	switch (decl.kind) {
-		case "FuncDecl":
-			return [decl.name];
-		case "MethodDecl":
-			return [`${decl.recvType?.name ?? "?"}.${decl.name}`];
-		case "TypeDecl":
-			return [decl.name];
-		case "VarDecl":
-		case "ConstDecl":
-			return (decl.decls ?? []).flatMap((spec) => spec.names ?? []);
-		default:
-			return [];
-	}
-}
-
-function checkLinkCollisions(units) {
-	const owner = new Map(); // name -> pkgName
-	const errors = [];
-	for (const u of units) {
-		for (const p of u.programs) {
-			for (const d of p.decls ?? []) {
-				for (const name of topLevelDeclNames(d)) {
-					if (name === "_") continue;
-					const prev = owner.get(name);
-					if (prev === undefined) owner.set(name, u.pkgName);
-					else if (prev !== u.pkgName)
-						errors.push(
-							`cannot link wasm packages: '${name}' is declared in both '${prev}' and '${u.pkgName}' (linked wasm packages share one namespace)`,
-						);
-				}
-			}
-		}
-	}
-	if (errors.length > 0) throw new Error([...new Set(errors)].join("\n"));
-}
-
-// Replaces the first wasm marker with the facade (dropping the others) and
-// shifts source-map lines that follow it.
-function spliceFacade(merged, facade) {
-	const lines = merged.js.split("\n");
-	const first = lines.findIndex((l) => WASM_MARKER_RE.test(l));
-	if (first < 0) {
-		merged.js = `${facade}\n${merged.js}`;
-		const shift = facade.split("\n").length;
-		for (const m of merged.mappings) m.genLine += shift;
-		return;
-	}
-	const facadeLines = facade.split("\n");
-	const delta = facadeLines.length - 1;
-	for (const m of merged.mappings) {
-		if (m.genLine > first) m.genLine += delta;
-	}
-	const out = [...lines.slice(0, first), ...facadeLines];
-	for (let i = first + 1; i < lines.length; i++) {
-		if (!WASM_MARKER_RE.test(lines[i])) out.push(lines[i]);
-	}
-	merged.js = out.join("\n");
-}
-
-// Root compiles only: link every registered unit into app.wasm and splice the
-// facade into the merged bundle.  Returns `{ wasm, wat, sourceMapInfo }`
-// (nulls when there is nothing to link).
-function linkIntoBundle(options, merged, pkgTarget, { sourceMappingURL } = {}) {
-	const none = { wasm: null, wat: null, sourceMapInfo: null };
-	if (options.isDependency) return none;
-	const linked = linkWasmUnits(options.wasmUnits, {
-		emitWat: options.emitWat,
-		rootTarget: pkgTarget,
-		sourceMappingURL,
-	});
-	if (!linked) return none;
-	spliceFacade(merged, linked.facade);
-	return {
-		wasm: linked.wasm,
-		wat: linked.wat ?? null,
-		sourceMapInfo: linked.sourceMapInfo ?? null,
-	};
+// Prints non-fatal diagnostics (e.g. JS Number precision of a constant).
+function logWarnings(warnings) {
+	for (const w of warnings) log.warn(w);
 }
 
 // ── Import resolution ─────────────────────────────────────────
+
+// What link/stdlib.js needs from this module.  Injected rather than imported
+// so that link/stdlib.js does not depend on compiler.js.
+const STDLIB_DEPS = { gwFilesIn, resolveImports, TypeChecker };
 //
 // Shared by compileFiles (multi-file) and the single-file path in index.js.
 // Mutates checker, jsImports, bundledPackages, and preambles in place.
@@ -417,18 +204,17 @@ function resolveImports(
 							"js: imports are not allowed in wasm packages",
 							impNode,
 						);
-					} else if (path === "gom") {
-						checker.recordBlocker("gom usage", "gom");
-						checker.err(
-							"package 'gom' is not available in wasm packages",
-							impNode,
-						);
 					} else if (path === "gofront/shared" && pkgTarget === "both") {
 						checker.err(
 							"'gofront/shared' requires a wasm-only package (//gofront:target wasm): a both package has no linear memory on the JS side",
 							impNode,
 						);
-					} else if (!isLocalPath(path)) {
+					} else if (
+						!isLocalPath(path) &&
+						!EXCLUDED_STDLIB_PACKAGES.has(path) &&
+						(isBuiltinPackage(path) ||
+							!resolveStdlibSource(path, options.stdlibRoot))
+					) {
 						if (!isBuiltinPackage(path)) {
 							checker.recordBlocker("js: import", path);
 							checker.err(
@@ -469,13 +255,27 @@ function resolveImports(
 		...imp,
 		imports: imp.imports.filter(({ alias }) => alias !== "_"),
 	}));
-	const resolved = resolveAll(allImportsNoSideEffect, fromFile, parseDts);
+	const resolved = resolveAll(
+		allImportsNoSideEffect,
+		fromFile,
+		parseDts,
+		options.stdlibRoot,
+	);
 	for (const [path, info] of resolved) {
 		if (!info) continue;
 		checker.addDefinitions(info.types, info.values);
 		jsImports.set(path, [...info.values.keys()]);
 	}
 
+	importStdlibPackages(
+		programs,
+		checker,
+		preambles,
+		bundledDirs,
+		options,
+		STDLIB_DEPS,
+	);
+
 	// local GoFront packages (./subdir)
 	const seenLocalPaths = new Set();
 	for (const p of programs) {
@@ -501,6 +301,9 @@ function resolveImports(
 					isDependency: true,
 				});
 				if (!alreadyBundled) preambles.push(dep);
+				// A dependency that hands out `&xs[i]` makes whole-element
+				// stores in this package write in place too.
+				if (dep.elemAddrTaken) checker.depElemAddrTaken = true;
 
 				// Target import rules for local packages
 				const impNode = {
@@ -541,7 +344,10 @@ function resolveImports(
 
 				if (alias === "_") continue;
 				if (alias === ".") {
-					checker.addDefinitions(dep.exportedTypes, dep.exportedSymbols);
+					checker.addDefinitions(dep.exportedTypes, dep.exportedSymbols, {
+						external: false,
+						consts: dep.exportedConsts,
+					});
 					continue;
 				}
 				const nameUsed = alias ?? dep.pkgName;
@@ -551,6 +357,7 @@ function resolveImports(
 					dep.exportedSymbols,
 					dep.exportedTypes,
 					dep.target,
+					dep.exportedConsts,
 				);
 				checker.trackImport(nameUsed, { _line }, p._filename, p._source);
 			}
@@ -584,112 +391,29 @@ export function resolvePackageTarget(declared, pkgDir, options = {}) {
 }
 
 export function compileSingleFile(inputPath, options = {}) {
-	const {
-		sourceMap = false,
-		outputFile = null,
-		dumpTokens = false,
-		dumpAst = false,
-	} = options;
-	options = { ...options, wasmUnits: options.wasmUnits ?? [] };
-
-	let source;
-	try {
-		source = readFileSync(inputPath, "utf8");
-	} catch (e) {
-		throw new Error(`cannot read '${inputPath}': ${e.message}`);
-	}
+	const { outputFile = null, dumpTokens = false, dumpAst = false } = options;
 
-	const tokens = new Lexer(source, basename(inputPath)).tokenize();
-	if (dumpTokens) return { tokens };
-
-	const ast = new Parser(tokens, basename(inputPath), source).parse();
-	ast._source = source;
-	ast._path = resolve(inputPath);
-	if (dumpAst) return { ast };
-
-	const outputDir =
-		options.outputDir ??
-		(outputFile ? dirname(resolve(outputFile)) : resolve("."));
-
-	const checker = new TypeChecker();
-	const jsImports = new Map();
-	const bundledPackages = new Set();
-	const preambles = [];
-
-	const pkgTarget = resolvePackageTarget(
-		ast.target ?? options.target ?? "js",
-		dirname(resolve(inputPath)),
-		options,
-	);
-	ast.target = pkgTarget;
-	checker.target = pkgTarget;
-	checker.pkgName = ast.pkg?.name ?? "main";
-
-	resolveImports(
-		[ast],
-		inputPath,
-		checker,
-		jsImports,
-		bundledPackages,
-		preambles,
-		options.bundledDirs ?? new Set(),
-		{ ...options, outputDir },
-	);
-
-	const errors = checker.check(ast);
-	checker.reportUnusedImports();
-	if (errors.length > 0) {
-		throw new Error(errors.map((e) => e.message).join("\n"));
-	}
-	for (const w of checker.warnings) log.warn(w);
-
-	if (pkgTarget === "wasm" || pkgTarget === "both") {
-		registerWasmUnit(options, {
-			key: resolve(inputPath),
-			pkgName: checker.pkgName,
-			target: pkgTarget,
-			programs: [ast],
-			types: checker.types,
-			bundledPackages,
-		});
+	if (dumpTokens || dumpAst) {
+		let source;
+		try {
+			source = readFileSync(inputPath, "utf8");
+		} catch (e) {
+			throw new Error(`cannot read '${inputPath}': ${e.message}`);
+		}
+		const tokens = new Lexer(source, basename(inputPath)).tokenize();
+		if (dumpTokens) return { tokens };
+		const ast = new Parser(tokens, basename(inputPath), source).parse();
+		ast._source = source;
+		ast._path = resolve(inputPath);
+		return { ast };
 	}
 
-	const isStrict = Boolean(options.strict || pkgTarget === "both");
-	const cg = new CodeGen(checker, jsImports, bundledPackages, {
-		target: pkgTarget,
-		strict: isStrict,
+	return compileFiles([resolve(inputPath)], {
+		...options,
+		outputDir:
+			options.outputDir ??
+			(outputFile ? dirname(resolve(outputFile)) : resolve(".")),
 	});
-	const mainJs =
-		pkgTarget === "wasm" ? wasmMarker(checker.pkgName) : cg.generate(ast);
-
-	const mainChunk = {
-		js: mainJs,
-		sourceFiles: [resolve(inputPath)],
-		sourcesContent: [source],
-		mappings: pkgTarget === "wasm" ? [] : cg.getMappings(),
-	};
-
-	const merged = mergeCompilationChunks([...preambles, mainChunk]);
-	const { wasm, wat, wasmOptInfo, wasmSourceMap } = finishWasm(
-		{ ...options, sourceMap },
-		merged,
-		pkgTarget,
-		outputDir,
-	);
-
-	if (sourceMap && !options.isDependency) {
-		attachSourceMap(merged, outputDir);
-	}
-
-	return {
-		js: merged.js,
-		css: cg.getCss(),
-		target: pkgTarget,
-		wasm,
-		wat,
-		wasmOptInfo,
-		wasmSourceMap,
-	};
 }
 
 export function compileDir(dir, options = {}) {
@@ -716,7 +440,12 @@ export function compileFiles(files, options = {}) {
 	options = {
 		...options,
 		wasmUnits: options.wasmUnits ?? [],
+		stdlibCache: options.stdlibCache ?? new Map(),
+		jsRootPrograms: options.jsRootPrograms ?? [],
 		rootDir: options.rootDir ?? fromDir,
+		bundledDirs: options.bundledDirs ?? new Set(),
+		typeOwners: options.typeOwners ?? new Map(),
+		jsonBuild: options.jsonBuild ?? { js: false, wasm: false },
 	};
 	const outputDir =
 		options.outputDir ??
@@ -744,6 +473,15 @@ export function compileFiles(files, options = {}) {
 		);
 	const pkgName = pkgNames[0];
 
+	// Local packages share one flat JS module: a type name another package
+	// already declared is renamed here (`Pt` -> `Pt$$b`).
+	const renamedTypes = mangleLocalTypes(
+		programs,
+		resolve(fromDir),
+		pkgName,
+		options.typeOwners,
+	);
+
 	// Validate target directives across files in this package
 	const declaredTargets = new Map();
 	for (const p of programs) {
@@ -770,6 +508,11 @@ export function compileFiles(files, options = {}) {
 	);
 	for (const p of programs) p.target = pkgTarget;
 
+	// The test runner's driver is a source that exists only in memory: it is
+	// parsed and checked with the package but never written next to it.
+	const driver = testDriverProgram(options, programs, pkgTarget, fromDir);
+	if (driver) programs.push(driver);
+
 	// ── 2. Resolve imports ────────────────────────────────────────
 	const checker = new TypeChecker();
 	checker.target = pkgTarget;
@@ -792,6 +535,13 @@ export function compileFiles(files, options = {}) {
 
 	// ── 3. Type-check ─────────────────────────────────────────────
 	const errors = checker.checkAll(programs);
+	const codecs = checkGeneratedGo(
+		programs,
+		checker,
+		preambles,
+		options,
+		STDLIB_DEPS,
+	);
 	checker.reportUnusedImports();
 	if (errors.length > 0) {
 		const msgs = errors.map((e) => e.message).join("\n");
@@ -804,7 +554,7 @@ export function compileFiles(files, options = {}) {
 		key: resolve(fromDir),
 		pkgName,
 		pkgTarget,
-		programs,
+		programs: [...programs, ...codecs],
 		types: checker.types,
 		bundledPackages,
 	});
@@ -813,13 +563,15 @@ export function compileFiles(files, options = {}) {
 	const codegen = new CodeGen(checker, jsImports, bundledPackages, {
 		target: pkgTarget,
 		strict: isStrict,
+		natives: options.natives,
 	});
 	const mainJs =
 		emitTarget === "wasm"
 			? wasmMarker(pkgName)
-			: codegen.generateAll(programs, {
+			: codegen.generateAll([...programs, ...codecs], {
 					isTest: options.isTest ?? false,
 				});
+	logWarnings(codegen.warnings);
 
 	const mainChunk = {
 		js: mainJs,
@@ -829,7 +581,8 @@ export function compileFiles(files, options = {}) {
 	};
 
 	const merged = mergeCompilationChunks([...preambles, mainChunk]);
-	const { wasm, wat, wasmOptInfo, wasmSourceMap } = finishWasm(
+	finishStdlibJs(merged, options, [...programs, ...codecs], emitTarget);
+	const { wasm, wat, wasmOptInfo, wasmSourceMap, stringTable } = finishWasm(
 		options,
 		merged,
 		pkgTarget,
@@ -848,17 +601,80 @@ export function compileFiles(files, options = {}) {
 	return {
 		pkgName,
 		target: pkgTarget,
+		elemAddrTaken:
+			checker.depElemAddrTaken === true ||
+			programs.some((p) => takesElementAddress(p.decls)),
 		js: merged.js,
 		css: allCss,
 		wasm,
 		wat,
 		wasmOptInfo,
 		wasmSourceMap,
-		programs,
+		stringTable,
+		programs: driver ? programs.filter((p) => p !== driver) : programs,
 		exportedSymbols: checker.getExportedSymbols(),
-		exportedTypes: checker.getExportedTypes(),
+		exportedTypes: withOriginalTypeNames(
+			checker.getExportedTypes(),
+			renamedTypes,
+		),
+		exportedConsts: checker.getExportedConsts(),
 		sourceFiles: merged.sourceFiles,
 		sourcesContent: merged.sourcesContent,
 		mappings: merged.mappings,
 	};
 }
+
+// Parses the in-memory driver source `options.testDriver(programs, target)`
+// returns (null: no driver) as a `_test.go` file of the package.
+function testDriverProgram(options, programs, pkgTarget, fromDir) {
+	if (!options.testDriver || options.isDependency) return null;
+	const source = options.testDriver(programs, pkgTarget);
+	if (!source) return null;
+	const filename = "gofront_testmain_test.go";
+	const ast = new Parser(
+		new Lexer(source, filename).tokenize(),
+		filename,
+		source,
+	).parse();
+	ast._source = source;
+	ast._path = join(fromDir, filename);
+	ast._declaredTarget = ast.target;
+	ast.target = pkgTarget;
+	return ast;
+}
+
+// The renamed ASTs must not be reused from the parse cache by a later build.
+function mangleLocalTypes(programs, pkgKey, pkgName, owners) {
+	const renamed = mangleCollidingTypes(programs, pkgKey, pkgName, owners);
+	const locals = renameLocalTypes(programs);
+	if (renamed.size > 0 || locals)
+		for (const p of programs) _parseCache.delete(p._path);
+	return renamed;
+}
+
+export function compileWasm(source, options = {}) {
+	const filename = options.filename ?? "main.go";
+	const tokens = new Lexer(source, filename).tokenize();
+	const ast = new Parser(tokens, filename, source).parse();
+
+	const checker = new TypeChecker();
+	checker.target = "wasm";
+	checker.pkgName = ast.pkg?.name ?? "main";
+
+	const errors = checker.check(ast);
+	if (errors.length > 0) {
+		return { wasm: null, errors };
+	}
+
+	const lowerRes = lower([ast], checker);
+	const res = compileWasmModule([ast], checker, lowerRes, {
+		...options,
+		exportAll: options.exportAll ?? true,
+	});
+
+	if (checker.errors?.length > 0) {
+		return { wasm: null, errors: checker.errors };
+	}
+
+	return { ...res, errors: [] };
+}