gofront 1.5.1 → 1.6.1

package/src/backend/wasm/index.js

@@ -10,15 +10,254 @@ import {
 	collectBoundaryMeta,
 	generateFacade,
 	scanBoundaryImports,
+	wTypeKey,
 } from "./boundary.js";
+import { foldConstExpr } from "./const-fold.js";
 import { FunctionEmitter } from "./emit.js";
 import { encodeModule, isGoFrontWasm } from "./encode.js";
-import { getFuncSignature, isTestingT, toWasmType } from "./types.js";
+import { hasGenerics, monomorphise } from "./monomorph.js";
+import { hasNativeWasmOpt, optimizeWasm } from "./optimize.js";
+import { BINARY_MATH_IMPORTS } from "./stdlib/index.js";
+import {
+	anonIfaceName,
+	ERROR_STRUCT,
+	getFuncSignature,
+	getInterfaceMethodList,
+	getMapKeyValTypes,
+	getReceiverTypeName,
+	goTypeKey,
+	isInterfaceType,
+	isMapType,
+	isNonEmptyInterface,
+	isTestingT,
+	toWasmType,
+} from "./types.js";
 import { emitWat } from "./wat.js";
 
-export { isGoFrontWasm };
+export { hasNativeWasmOpt, isGoFrontWasm, optimizeWasm };
+
+const ERROR_PRODUCING_PKGS = new Set([
+	"errors",
+	"fmt",
+	"strconv",
+	"path",
+	"path/filepath",
+	"io",
+	"strings",
+	"bytes",
+	"time",
+	"sync",
+	"crypto/rand",
+	"rand",
+	"crypto/sha256",
+	"sha256",
+	"encoding/binary",
+	"binary",
+	"encoding/hex",
+	"hex",
+	"encoding/base64",
+	"base64",
+]);
+// Packages whose calls lower to the `env.*` imports in STDLIB_IMPORTS (the
+// matching JS lives in WASM_STDLIB_JS).  Only modules importing one of them
+// declare the imports and ship that JS block.
+const STDLIB_ENV_PKGS = new Set([
+	"strings",
+	"strconv",
+	"unicode/utf8",
+	"fmt",
+	"testing",
+	"unicode",
+	"math/rand",
+	"path",
+	"path/filepath",
+	"html",
+	"bytes",
+	"io",
+	"time",
+	"sync",
+	"crypto/rand",
+	"rand",
+	"crypto/sha256",
+	"sha256",
+	"encoding/binary",
+	"binary",
+	"encoding/hex",
+	"hex",
+	"encoding/base64",
+	"base64",
+]);
+
+function importsAnyOf(programs, pkgs) {
+	const has = (p) => (pkgs instanceof Set ? pkgs.has(p) : pkgs.includes(p));
+	return (programs ?? []).some((p) =>
+		(p.imports ?? []).some((decl) =>
+			(decl.imports ?? [decl]).some((imp) => has(imp.path)),
+		),
+	);
+}
+
+function hasErrorUsage(programs) {
+	return (programs ?? []).some((p) => {
+		let found = false;
+		const scan = (n) => {
+			if (!n || found || typeof n !== "object") return;
+			if (Array.isArray(n)) {
+				for (const x of n) scan(x);
+				return;
+			}
+			if (
+				(n.kind === "Ident" ||
+					n.kind === "TypeName" ||
+					n.kind === "basic" ||
+					n.kind === "interface") &&
+				n.name === "error"
+			) {
+				found = true;
+				return;
+			}
+			for (const k of Object.keys(n)) {
+				if (!k.startsWith("_")) scan(n[k]);
+			}
+		};
+		scan(p);
+		return found;
+	});
+}
 
-export class ModuleEmitter {
+// [name, params, results] for `env.*` imports backing stdlib calls; the JS
+// side lives in WASM_STDLIB_JS (boundary.js).  All are registered eagerly
+// (when any STDLIB_ENV_PKGS package is imported) because the import table is
+// locked before function bodies are emitted.
+const S = "externref";
+const STDLIB_IMPORTS = [
+	// strings
+	["str_trim", [S, S], [S]],
+	["str_trim_left", [S, S], [S]],
+	["str_trim_right", [S, S], [S]],
+	["str_trim_prefix", [S, S], [S]],
+	["str_trim_suffix", [S, S], [S]],
+	["str_cut", [S, S], ["i32"]],
+	["str_cut_before", [], [S]],
+	["str_cut_after", [], [S]],
+	["str_cut_prefix", [S, S], ["i32"]],
+	["str_cut_suffix", [S, S], ["i32"]],
+	["str_replace", [S, S, S, "i32"], [S]],
+	["str_contains_rune", [S, "i32"], ["i32"]],
+	["str_contains_any", [S, S], ["i32"]],
+	["str_index_byte", [S, "i32"], ["i32"]],
+	["str_index_rune", [S, "i32"], ["i32"]],
+	["str_index_any", [S, S], ["i32"]],
+	["str_last_index_byte", [S, "i32"], ["i32"]],
+	["str_last_index_any", [S, S], ["i32"]],
+	["str_title", [S], [S]],
+	["str_split", [S, S], ["i32"]],
+	["str_split_n", [S, S, "i32"], ["i32"]],
+	["str_split_after", [S, S], ["i32"]],
+	["str_split_after_n", [S, S, "i32"], ["i32"]],
+	["str_fields", [S], ["i32"]],
+	["str_part", ["i32"], [S]],
+	["str_replacer_init", [S], []],
+	["str_replacer_add", [S, S], []],
+	["str_replacer_run", [], [S]],
+	// strconv
+	["strconv_atoi", [S], ["i64"]],
+	["strconv_parse_int", [S, "i32", "i32"], ["i64"]],
+	["strconv_parse_float", [S], ["f64"]],
+	["strconv_parse_bool", [S], ["i32"]],
+	["strconv_err", [], [S]],
+	["strconv_err_kind", [], ["i32"]],
+	["strconv_format_float", ["f64", "i32", "i32", "i32"], [S]],
+	["strconv_format_int", ["i64", "i32"], [S]],
+	["strconv_format_uint", ["i64", "i32"], [S]],
+	["strconv_parse_uint", [S, "i32", "i32"], ["i64"]],
+	["strconv_quote", [S], [S]],
+	["strconv_unquote", [S], [S]],
+	// unicode/utf8
+	["utf8_rune_count", [S], ["i32"]],
+	["utf8_rune_len", ["i32"], ["i32"]],
+	["utf8_valid_string", [S], ["i32"]],
+	["utf8_decode_rune", [S, "i32"], ["i32"]],
+	["utf8_decode_size", [], ["i32"]],
+	["utf8_full_rune", [S], ["i32"]],
+	// fmt (arguments travel through the testing_arg_* buffer)
+	["fmt_sprintf", [S], [S]],
+	["fmt_printf", [S], []],
+	["fmt_format_v", [S], [S]],
+	["fmt_sscan_init", [S, "i32"], ["i32"]],
+	["fmt_sscanf_init", [S, S], ["i32"]],
+	["fmt_sscan_has_err", [], ["i32"]],
+	["fmt_sscan_err_msg", [], [S]],
+	["fmt_sscan_token_str", ["i32"], [S]],
+	["fmt_sscan_token_i64", ["i32"], ["i64"]],
+	["fmt_sscan_token_f64", ["i32"], ["f64"]],
+	["fmt_sscan_token_bool", ["i32"], ["i32"]],
+	// testing.T.Run: the harness calls back into the exported __testing_run_cb
+	["testing_run", [S, S, "anyref"], ["i32"]],
+	// unicode
+	["unicode_is_letter", ["i32"], ["i32"]],
+	["unicode_is_digit", ["i32"], ["i32"]],
+	["unicode_is_space", ["i32"], ["i32"]],
+	["unicode_is_upper", ["i32"], ["i32"]],
+	["unicode_is_lower", ["i32"], ["i32"]],
+	["unicode_is_punct", ["i32"], ["i32"]],
+	["unicode_is_control", ["i32"], ["i32"]],
+	["unicode_is_print", ["i32"], ["i32"]],
+	["unicode_is_graphic", ["i32"], ["i32"]],
+	["unicode_to_upper", ["i32"], ["i32"]],
+	["unicode_to_lower", ["i32"], ["i32"]],
+	// html
+	["html_escape", [S], [S]],
+	["html_unescape", [S], [S]],
+	// path
+	["path_base", [S], [S]],
+	["path_dir", [S], [S]],
+	["path_ext", [S], [S]],
+	["path_is_abs", [S], ["i32"]],
+	["path_clean", [S], [S]],
+	["path_split", [S], []],
+	["path_split_dir", [], [S]],
+	["path_split_file", [], [S]],
+	["path_join_init", [], []],
+	["path_join_push", [S], []],
+	["path_join_run", [], [S]],
+	["path_match", [S, S], ["i32"]],
+	["path_match_has_err", [], ["i32"]],
+	["bytes_trim", [S, S, "i32", "i32"], []],
+	["bytes_trim_start", [], ["i32"]],
+	["bytes_trim_end", [], ["i32"]],
+	// time
+	["time_now_ms", [], ["f64"]],
+	["time_timezone_offset", ["f64"], ["i32"]],
+	["time_parse", [S, S], ["f64"]],
+	["time_parse_err", [], [S]],
+	["time_parse_offset", [], ["i32"]],
+	[
+		"time_format",
+		["i32", "i32", "i32", "i32", "i32", "i32", "i32", "i32", "i32", S],
+		[S],
+	],
+	["time_duration_string", ["i64"], [S]],
+	// raw binary buffer for crypto/rand, crypto/sha256, hex, base64
+	["raw_bytes_init", ["i32"], []],
+	["raw_bytes_push", ["i32"], []],
+	["raw_bytes_len", [], ["i32"]],
+	["raw_bytes_get", ["i32"], ["i32"]],
+	// crypto/rand
+	["crypto_rand_fill", ["i32"], ["i32"]],
+	// crypto/sha256
+	["crypto_sha256_sum", [], ["i32"]],
+	// encoding/hex
+	["hex_encode_to_string", [], [S]],
+	["hex_decode_string", [S], ["i32"]],
+	["hex_get_err", [], [S]],
+	// encoding/base64
+	["base64_encode_to_string", ["i32"], [S]],
+	["base64_decode_string", ["i32", S], ["i32"]],
+	["base64_get_err", [], [S]],
+];
+
+class ModuleEmitter {
 	constructor(checker, lowerResult = null, programs = [], options = {}) {
 		this.checker = checker;
 		this.lowerResult = lowerResult;
@@ -34,9 +273,13 @@ export class ModuleEmitter {
 
 		this.structTypes = new Map(); // name -> struct info
 		this.boxTypes = new Map(); // wType key -> box info
+		this.ifaceBoxTypes = new Map(); // key -> iface box info
 		this.arrayTypes = new Map(); // wType key -> array info
 		this.sliceTypes = new Map(); // wType key -> slice info
 		this.sliceTypesByIndex = new Map(); // typeIndex -> slice info
+		this.mapTypes = new Map(); // wType key -> map info
+		this.mapTypesByIndex = new Map(); // typeIndex -> map info
+		this.mapBucketsType = null; // shared (array (mut i32))
 		this.closureTypes = new Map(); // key -> closure info
 		this.envTypes = new Map(); // key -> env info
 
@@ -54,11 +297,19 @@ export class ModuleEmitter {
 		this.funcMap = new Map(); // name -> global func index
 		this.funcParamTypes = new Map(); // name -> param types array
 		this.funcParamGoTypes = new Map(); // name -> param Go types array
+		this.funcReturnTypesByIdx = new Map(); // global func index -> result wasm types
 
 		this.exports = []; // export entries
 		this.stringTable = []; // string literals
 		this.stringCache = new Map();
 
+		// `errors.New` / `fmt.Errorf` / strconv parse failures allocate the
+		// runtime's own error struct; it joins the struct rec group so the
+		// `error.Error` dispatcher can `ref.test` it like any user type.
+		this.hasErrorType =
+			importsAnyOf(programs, ERROR_PRODUCING_PKGS) || hasErrorUsage(programs);
+		this.usesStdlibEnv = importsAnyOf(programs, STDLIB_ENV_PKGS);
+
 		if (programs && programs.length > 0) {
 			this.initTypes(programs);
 		}
@@ -73,6 +324,20 @@ export class ModuleEmitter {
 		const seen = new Set();
 		const aliases = []; // qualified key (pkg.T) -> unqualified struct name
 
+		if (this.hasErrorType) {
+			seen.add(ERROR_STRUCT);
+			rawStructs.push({
+				name: ERROR_STRUCT,
+				structType: {
+					kind: "struct",
+					fields: new Map([
+						["msg", { kind: "basic", name: "string" }],
+						["cause", { kind: "basic", name: "any" }],
+					]),
+				},
+			});
+		}
+
 		for (const p of progs) {
 			for (const d of p.decls ?? []) {
 				if (d.kind === "TypeDecl" && d.type?.kind === "StructType") {
@@ -136,7 +401,8 @@ export class ModuleEmitter {
 		for (let i = 0; i < rawStructs.length; i++) {
 			const s = rawStructs[i];
 			const info = this.structTypes.get(s.name);
-			const resolvedStruct = this.checker?.types?.get(s.name)?.underlying;
+			const resolvedStruct =
+				s.structType ?? this.checker?.types?.get(s.name)?.underlying;
 
 			const fields = [];
 			const fieldIndexMap = new Map();
@@ -211,23 +477,95 @@ export class ModuleEmitter {
 		return this.structTypes.get(name) ?? null;
 	}
 
+	getAnonStructType(fields) {
+		const key = fields.map((f) => `${f.name}:${goTypeKey(f.goType)}`).join(";");
+		const name = `__anon_${key.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+		if (this.structTypes.has(name)) {
+			return this.structTypes.get(name);
+		}
+		const fieldWTypes = fields.map((f) =>
+			toWasmType(f.goType, this.checker, this),
+		);
+		const typeIndex = this._getTotalTypeCount();
+		const typeEntry = {
+			form: "struct",
+			fields: fieldWTypes.map((t) => ({ type: t, mutable: true })),
+		};
+		this._pushType(typeEntry);
+		const info = {
+			name,
+			typeIndex,
+			typeEntry,
+			fields: fields.map((f, i) => ({
+				name: f.name,
+				wType: fieldWTypes[i],
+				goType: f.goType,
+				fieldIndex: i,
+			})),
+			fieldIndexMap: new Map(fields.map((f, i) => [f.name, i])),
+			embeds: [],
+			pkgName: null,
+			pkgTarget: "wasm",
+			isAnon: true,
+		};
+		this.structTypes.set(name, info);
+		return info;
+	}
+
 	getBoxType(goType) {
-		const wType = toWasmType(goType, this.checker, this);
-		const key = typeof wType === "string" ? wType : JSON.stringify(wType);
+		const key = goTypeKey(goType);
 		if (this.boxTypes.has(key)) {
 			return this.boxTypes.get(key);
 		}
+		const wType = toWasmType(goType, this.checker, this);
 		const typeIndex = this._getTotalTypeCount();
 		const typeEntry = {
 			form: "struct",
 			fields: [{ type: wType, mutable: true }],
 		};
 		this._pushType(typeEntry);
-		const boxInfo = { typeIndex, typeEntry, wType };
+		const boxInfo = { key, typeIndex, typeEntry, wType, goType };
 		this.boxTypes.set(key, boxInfo);
 		return boxInfo;
 	}
 
+	getIfaceBoxType(goType) {
+		const key = goTypeKey(goType);
+		if (this.ifaceBoxTypes.has(key)) {
+			return this.ifaceBoxTypes.get(key);
+		}
+		const wType = toWasmType(goType, this.checker, this);
+		const tagIndex = this.ifaceBoxTypes.size;
+		const tagTypeIndex = this._getTotalTypeCount();
+		const tagFields = [];
+		for (let i = 0; i < tagIndex; i++) {
+			tagFields.push({ type: "i32", mutable: false });
+		}
+		this._pushType({
+			form: "struct",
+			fields: tagFields,
+		});
+		const typeIndex = this._getTotalTypeCount();
+		const typeEntry = {
+			form: "struct",
+			fields: [
+				{ type: wType, mutable: true },
+				{
+					type: {
+						kind: "ref",
+						nullable: true,
+						typeIndex: tagTypeIndex,
+					},
+					mutable: false,
+				},
+			],
+		};
+		this._pushType(typeEntry);
+		const boxInfo = { key, typeIndex, typeEntry, wType, goType, tagTypeIndex };
+		this.ifaceBoxTypes.set(key, boxInfo);
+		return boxInfo;
+	}
+
 	getArrayType(elemGoType) {
 		const elemWType = toWasmType(elemGoType, this.checker, this);
 		const key =
@@ -308,6 +646,107 @@ export class ModuleEmitter {
 		return this.sliceTypesByIndex?.get(typeIndex) ?? null;
 	}
 
+	getMapType(keyGoType, valGoType) {
+		const keyWType = toWasmType(keyGoType, this.checker, this);
+		const valWType = toWasmType(valGoType, this.checker, this);
+		const key = `${wTypeKey(keyWType)}:${wTypeKey(valWType)}`;
+		if (this.mapTypes.has(key)) {
+			return this.mapTypes.get(key);
+		}
+
+		if (!this.mapBucketsType) {
+			const typeIndex = this._getTotalTypeCount();
+			this._pushType({
+				form: "array",
+				elemType: "i32",
+				mutable: true,
+			});
+			this.mapBucketsType = { typeIndex };
+		}
+
+		const entryTypeIndex = this._getTotalTypeCount();
+		this._pushType({
+			form: "struct",
+			fields: [
+				{ type: keyWType, mutable: true }, // 0: key
+				{ type: valWType, mutable: true }, // 1: val
+				{ type: "i32", mutable: true }, // 2: next (bucket chain)
+				{ type: "i32", mutable: true }, // 3: order_prev (insertion order)
+				{ type: "i32", mutable: true }, // 4: order_next (insertion order)
+				{ type: "i32", mutable: true }, // 5: active (1 = active, 0 = deleted)
+			],
+		});
+
+		const entriesTypeIndex = this._getTotalTypeCount();
+		this._pushType({
+			form: "array",
+			elemType: { kind: "ref", nullable: true, typeIndex: entryTypeIndex },
+			mutable: true,
+		});
+
+		const mapTypeIndex = this._getTotalTypeCount();
+		this._pushType({
+			form: "struct",
+			fields: [
+				{
+					type: {
+						kind: "ref",
+						nullable: true,
+						typeIndex: this.mapBucketsType.typeIndex,
+					},
+					mutable: true,
+				}, // 0: buckets
+				{
+					type: {
+						kind: "ref",
+						nullable: true,
+						typeIndex: entriesTypeIndex,
+					},
+					mutable: true,
+				}, // 1: entries
+				{ type: "i32", mutable: true }, // 2: len
+				{ type: "i32", mutable: true }, // 3: cap
+				{ type: "i32", mutable: true }, // 4: count
+				{ type: "i32", mutable: true }, // 5: head
+				{ type: "i32", mutable: true }, // 6: tail
+				{ type: "i32", mutable: true }, // 7: free_head
+				{ type: "i32", mutable: true }, // 8: num_buckets
+			],
+		});
+
+		const suffix = key.replace(/[^a-zA-Z0-9_]/g, "_");
+		const mapInfo = {
+			key,
+			suffix,
+			typeIndex: mapTypeIndex,
+			entryTypeIndex,
+			entriesTypeIndex,
+			bucketsTypeIndex: this.mapBucketsType.typeIndex,
+			keyWType,
+			valWType,
+			keyGoType,
+			valGoType,
+			wType: { kind: "ref", nullable: true, typeIndex: mapTypeIndex },
+			makeFuncName: `__map_make_${suffix}`,
+			getFuncName: `__map_get_${suffix}`,
+			getOkFuncName: `__map_get_ok_${suffix}`,
+			setFuncName: `__map_set_${suffix}`,
+			deleteFuncName: `__map_delete_${suffix}`,
+			lenFuncName: `__map_len_${suffix}`,
+			clearFuncName: `__map_clear_${suffix}`,
+			keysFuncName: `__map_keys_${suffix}`,
+			valuesFuncName: `__map_values_${suffix}`,
+			cloneFuncName: `__map_clone_${suffix}`,
+		};
+		this.mapTypes.set(key, mapInfo);
+		this.mapTypesByIndex.set(mapTypeIndex, mapInfo);
+		return mapInfo;
+	}
+
+	getMapTypeByIndex(typeIndex) {
+		return this.mapTypesByIndex?.get(typeIndex) ?? null;
+	}
+
 	getClosureType(goType) {
 		const sig = getFuncSignature(goType, this.checker);
 		const paramWTypes = sig.params
@@ -399,9 +838,11 @@ export class ModuleEmitter {
 
 	_initRuntimeImports() {
 		this._initPanicTag();
+		this._initPanicGlobal();
 		this.getPanicImportIndex(); // env.panic
 		this.internString("runtime error: index out of range");
 		this.internString("runtime error: slice bounds out of range");
+		this.internString("assignment to entry in nil map");
 
 		// String built-ins
 		this.getStringImportIndex(); // env.str
@@ -417,7 +858,51 @@ export class ModuleEmitter {
 		this.getStringSliceImportIndex(); // env.str_slice
 		this.getStringFromCodePointImportIndex(); // env.str_from_code_point
 		this.getStringCodePointAtImportIndex(); // env.str_code_point_at
+		this.getStringHashImportIndex(); // env.str_hash
+		this.getStringToUpperImportIndex();
+		this.getStringToLowerImportIndex();
+		this.getStringTrimSpaceImportIndex();
+		this.getStringContainsImportIndex();
+		this.getStringHasPrefixImportIndex();
+		this.getStringHasSuffixImportIndex();
+		this.getStringIndexImportIndex();
+		this.getStringLastIndexImportIndex();
+		this.getStringRepeatImportIndex();
+		this.getStringReplaceAllImportIndex();
+		this.getStringEqualFoldImportIndex();
+		this.getStringCountImportIndex();
+		this.getStrFromI64ImportIndex();
+		this.getStrFromI32ImportIndex();
+		this.getStrFromF64ImportIndex();
 		this.getIsStringImportIndex(); // env.is_string
+		this.getStrToBytesImportIndex();
+		this.getStrByteAtImportIndex();
+		this.getBytesToStrInitImportIndex();
+		this.getBytesToStrPushImportIndex();
+		this.getBytesToStrFinishImportIndex();
+		this.getTestingCallImportIndex();
+		this.getTestingNameImportIndex();
+		this.getTestingFlagImportIndex();
+		for (const t of ["i32", "i64", "f32", "f64", "externref", "anyref"]) {
+			this.getTestingArgImportIndex(t, false);
+		}
+		this.getTestingArgImportIndex("i32", true);
+		this.getFmtNewArrayIndex();
+		this.getFmtArrayPushIndex();
+		this.getFmtNewMapIndex();
+		this.getFmtMapSetIndex();
+		this.getFmtNewStructIndex();
+		this.getFmtStructSetIndex();
+		this.getFmtBoxI32Index();
+		this.getFmtBoxI64Index();
+		this.getFmtBoxF64Index();
+		this.getFmtBoxBoolIndex();
+		this.getFmtNewBoxIndex();
+		if (this.usesStdlibEnv) {
+			for (const [name, params, results] of STDLIB_IMPORTS) {
+				this.getOrAddFuncImport("env", name, params, results);
+			}
+		}
 
 		// Logging built-ins
 		this.getPrintlnEmptyIndex(); // env.println_empty
@@ -442,12 +927,12 @@ export class ModuleEmitter {
 			"log2",
 			"log10",
 			"round",
+			"cbrt",
 		];
 		for (const m of unaryMath) {
 			this.getMathImportIndex(m, false);
 		}
-		const binaryMath = ["atan2", "pow"];
-		for (const m of binaryMath) {
+		for (const m of BINARY_MATH_IMPORTS) {
 			this.getMathImportIndex(m, true);
 		}
 	}
@@ -461,6 +946,188 @@ export class ModuleEmitter {
 		this.exports.push({ name: "panicTag", kind: "tag", index: 0 });
 	}
 
+	getPanicNodeTypeIndex() {
+		if (this.panicNodeTypeIndex !== undefined) {
+			return this.panicNodeTypeIndex;
+		}
+		const typeIndex = this._getTotalTypeCount();
+		const typeEntry = {
+			form: "rec",
+			types: [
+				{
+					form: "struct",
+					fields: [
+						{
+							type: "anyref",
+							mutable: true,
+						},
+						{
+							type: "i32",
+							mutable: true,
+						},
+						{
+							type: {
+								kind: "ref",
+								nullable: true,
+								typeIndex,
+							},
+							mutable: true,
+						},
+					],
+				},
+			],
+		};
+		this._pushType(typeEntry);
+		this.panicNodeTypeIndex = typeIndex;
+		return typeIndex;
+	}
+
+	_initPanicGlobal() {
+		const pType = this.getPanicNodeTypeIndex();
+		const gIdx = this.globals.length;
+		this.globals.push({
+			type: { kind: "ref", nullable: true, typeIndex: pType },
+			mutable: true,
+			init: [{ op: "ref.null", typeIndex: pType }],
+		});
+		this.panicGlobalIndex = gIdx;
+		this.exports.push({ name: "__panic", kind: "global", index: gIdx });
+	}
+
+	getPanicGlobalIndex() {
+		return this.panicGlobalIndex;
+	}
+
+	// `__deferArmed` is set to 1 immediately before a deferred closure is
+	// invoked and cleared by that closure's prologue.  recover() only takes
+	// effect when the current frame observed the flag, which gives Go's
+	// "recover must be called directly by the deferred function" rule.
+	getDeferArmedGlobalIndex() {
+		if (this.deferArmedGlobalIndex !== undefined) {
+			return this.deferArmedGlobalIndex;
+		}
+		const gIdx = this.globals.length;
+		this.globals.push({
+			type: "i32",
+			mutable: true,
+			init: [{ op: "i32.const", value: 0 }],
+		});
+		this.deferArmedGlobalIndex = gIdx;
+		return gIdx;
+	}
+
+	getRandStateGlobalIndex() {
+		if (this.randStateGlobalIndex !== undefined) {
+			return this.randStateGlobalIndex;
+		}
+		const gIdx = this.globals.length;
+		this.globals.push({
+			type: "i64",
+			mutable: true,
+			init: [{ op: "i64.const", value: 1n }],
+		});
+		this.randStateGlobalIndex = gIdx;
+		return gIdx;
+	}
+
+	getStrconvErrGlobalIndex(field) {
+		if (!this.strconvErrGlobals) this.strconvErrGlobals = new Map();
+		if (this.strconvErrGlobals.has(field)) {
+			return this.strconvErrGlobals.get(field);
+		}
+		const gIdx = this.globals.length;
+		this.globals.push({
+			type: "anyref",
+			mutable: true,
+			init: [{ op: "ref.null", heapType: "any" }],
+		});
+		this.strconvErrGlobals.set(field, gIdx);
+		return gIdx;
+	}
+
+	getPathErrGlobalIndex(field) {
+		if (!this.pathErrGlobals) this.pathErrGlobals = new Map();
+		if (this.pathErrGlobals.has(field)) {
+			return this.pathErrGlobals.get(field);
+		}
+		const gIdx = this.globals.length;
+		this.globals.push({
+			type: "anyref",
+			mutable: true,
+			init: [{ op: "ref.null", heapType: "any" }],
+		});
+		this.pathErrGlobals.set(field, gIdx);
+		return gIdx;
+	}
+
+	getIoErrGlobalIndex(field) {
+		if (!this.ioErrGlobals) this.ioErrGlobals = new Map();
+		if (this.ioErrGlobals.has(field)) {
+			return this.ioErrGlobals.get(field);
+		}
+		const gIdx = this.globals.length;
+		this.globals.push({
+			type: "anyref",
+			mutable: true,
+			init: [{ op: "ref.null", heapType: "any" }],
+		});
+		this.ioErrGlobals.set(field, gIdx);
+		return gIdx;
+	}
+
+	getIoDiscardGlobalIndex() {
+		if (this.ioDiscardGlobalIndex !== undefined) {
+			return this.ioDiscardGlobalIndex;
+		}
+		this.getStructType("io.discard");
+		const gIdx = this.globals.length;
+		this.globals.push({
+			type: "anyref",
+			mutable: true,
+			init: [{ op: "ref.null", heapType: "any" }],
+		});
+		this.ioDiscardGlobalIndex = gIdx;
+		return gIdx;
+	}
+
+	getDeferNodeTypeIndex() {
+		if (this.deferNodeTypeIndex !== undefined) {
+			return this.deferNodeTypeIndex;
+		}
+		const deferClosureSig = { kind: "Signature", params: [], results: [] };
+		const deferClosureInfo = this.getClosureType(deferClosureSig);
+		const typeIndex = this._getTotalTypeCount();
+		const typeEntry = {
+			form: "rec",
+			types: [
+				{
+					form: "struct",
+					fields: [
+						{
+							type: {
+								kind: "ref",
+								nullable: true,
+								typeIndex: deferClosureInfo.typeIndex,
+							},
+							mutable: false,
+						},
+						{
+							type: {
+								kind: "ref",
+								nullable: true,
+								typeIndex,
+							},
+							mutable: true,
+						},
+					],
+				},
+			],
+		};
+		this._pushType(typeEntry);
+		this.deferNodeTypeIndex = typeIndex;
+		return typeIndex;
+	}
+
 	getTypeIndex(params, results) {
 		const key = `${params.map((p) => (typeof p === "object" ? JSON.stringify(p) : p)).join(",")}=>${results.map((r) => (typeof r === "object" ? JSON.stringify(r) : r)).join(",")}`;
 		if (this.typeCache.has(key)) {
@@ -518,6 +1185,32 @@ export class ModuleEmitter {
 		return this.resolveFuncIndex("__bounds_panic");
 	}
 
+	// `gofront/shared` buffers are `(base i32, len i32)` views over the single
+	// exported linear memory, bump-allocated by `__shared_new` during start.
+	getSharedType() {
+		if (this.sharedType) return this.sharedType;
+		const typeIndex = this._getTotalTypeCount();
+		const typeEntry = {
+			form: "struct",
+			fields: [
+				{ type: "i32", mutable: false }, // byte base
+				{ type: "i32", mutable: false }, // element count
+			],
+		};
+		this._pushType(typeEntry);
+		this.memory = { min: 1 };
+		this.exports.push({ name: "memory", kind: "memory", index: 0 });
+		const topGlobalIndex = this.globals.length;
+		this.globals.push({
+			type: "i32",
+			mutable: true,
+			init: [{ op: "i32.const", value: 0 }],
+		});
+		const wType = { kind: "ref", nullable: true, typeIndex };
+		this.sharedType = { typeIndex, typeEntry, wType, topGlobalIndex };
+		return this.sharedType;
+	}
+
 	getSliceBoundsPanicFuncIndex() {
 		return this.resolveFuncIndex("__slice_bounds_panic");
 	}
@@ -526,6 +1219,90 @@ export class ModuleEmitter {
 		return this.getOrAddFuncImport("env", "println_empty", [], []);
 	}
 
+	getFmtNewArrayIndex() {
+		return this.getOrAddFuncImport("env", "fmt_new_array", [], ["externref"]);
+	}
+
+	getFmtArrayPushIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"fmt_array_push",
+			["externref", "externref"],
+			[],
+		);
+	}
+
+	getFmtNewMapIndex() {
+		return this.getOrAddFuncImport("env", "fmt_new_map", [], ["externref"]);
+	}
+
+	getFmtMapSetIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"fmt_map_set",
+			["externref", "externref", "externref"],
+			[],
+		);
+	}
+
+	getFmtNewStructIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"fmt_new_struct",
+			["anyref", "i32"],
+			["externref"],
+		);
+	}
+
+	getFmtStructSetIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"fmt_struct_set",
+			["externref", "i32", "externref"],
+			[],
+		);
+	}
+
+	getFmtBoxI32Index() {
+		return this.getOrAddFuncImport(
+			"env",
+			"fmt_box_i32",
+			["i32"],
+			["externref"],
+		);
+	}
+
+	getFmtBoxI64Index() {
+		return this.getOrAddFuncImport(
+			"env",
+			"fmt_box_i64",
+			["i64"],
+			["externref"],
+		);
+	}
+
+	getFmtBoxF64Index() {
+		return this.getOrAddFuncImport(
+			"env",
+			"fmt_box_f64",
+			["f64"],
+			["externref"],
+		);
+	}
+
+	getFmtBoxBoolIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"fmt_box_bool",
+			["i32"],
+			["externref"],
+		);
+	}
+
+	getFmtNewBoxIndex() {
+		return this.getOrAddFuncImport("env", "fmt_new_box", [], ["externref"]);
+	}
+
 	// `*testing.T` method calls: args are pushed one by one to a JS-side
 	// buffer, then `testing_call(t, methodNameStrIdx)` invokes the method.
 	getTestingArgImportIndex(wType, isBool = false) {
@@ -535,7 +1312,7 @@ export class ModuleEmitter {
 			wType === "externref" ? "str" : wType === "anyref" ? "any" : wType;
 		if (!["i32", "i64", "f32", "f64", "str", "any"].includes(suffix)) {
 			throw new Error(
-				"only primitive, string and any arguments are supported for testing.T methods in wasm packages",
+				"only primitive, string, error and any arguments are supported for fmt and testing.T calls in wasm packages (format slices/structs field by field)",
 			);
 		}
 		return this.getOrAddFuncImport(
@@ -594,9 +1371,15 @@ export class ModuleEmitter {
 					["externref"],
 					[],
 				);
-			case "anyref":
-				return this.getOrAddFuncImport("env", `${prefix}_any`, ["anyref"], []);
 			default:
+				if (typeof wType === "object") {
+					return this.getOrAddFuncImport(
+						"env",
+						`${prefix}_any`,
+						["anyref"],
+						[],
+					);
+				}
 				return this.getOrAddFuncImport("env", `${prefix}_i32`, ["i32"], []);
 		}
 	}
@@ -672,37 +1455,441 @@ export class ModuleEmitter {
 		return this.getOrAddFuncImport("env", "is_string", ["anyref"], ["i32"]);
 	}
 
-	getMathImportIndex(jsName, isBinary = false) {
-		const params = isBinary ? ["f64", "f64"] : ["f64"];
-		return this.getOrAddFuncImport("Math", jsName, params, ["f64"]);
-	}
-
-	resolveFuncIndex(name) {
-		return this.funcMap.get(name) ?? null;
+	getStringHashImportIndex() {
+		return this.getOrAddFuncImport("env", "str_hash", ["externref"], ["i32"]);
 	}
 
-	getFuncParamTypes(name) {
-		return this.funcParamTypes.get(name) ?? [];
+	getStringToUpperImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_to_upper",
+			["externref"],
+			["externref"],
+		);
 	}
 
-	getFuncParamGoTypes(name) {
-		return this.funcParamGoTypes.get(name) ?? [];
+	getStringToLowerImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_to_lower",
+			["externref"],
+			["externref"],
+		);
 	}
 
-	resolveGlobal(name) {
-		return this.globalCache.get(name) ?? null;
+	getStringTrimSpaceImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_trim_space",
+			["externref"],
+			["externref"],
+		);
 	}
 
-	resolveConst(name) {
+	getStringContainsImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_contains",
+			["externref", "externref"],
+			["i32"],
+		);
+	}
+
+	getStringHasPrefixImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_has_prefix",
+			["externref", "externref"],
+			["i32"],
+		);
+	}
+
+	getStringHasSuffixImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_has_suffix",
+			["externref", "externref"],
+			["i32"],
+		);
+	}
+
+	getStringIndexImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_index",
+			["externref", "externref"],
+			["i32"],
+		);
+	}
+
+	getStringLastIndexImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_last_index",
+			["externref", "externref"],
+			["i32"],
+		);
+	}
+
+	getStringRepeatImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_repeat",
+			["externref", "i32"],
+			["externref"],
+		);
+	}
+
+	getStringReplaceAllImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_replace_all",
+			["externref", "externref", "externref"],
+			["externref"],
+		);
+	}
+
+	getStringEqualFoldImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_equal_fold",
+			["externref", "externref"],
+			["i32"],
+		);
+	}
+
+	getStringCountImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_count",
+			["externref", "externref"],
+			["i32"],
+		);
+	}
+
+	getStrFromI64ImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_from_i64",
+			["i64"],
+			["externref"],
+		);
+	}
+
+	getStrFromI32ImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_from_i32",
+			["i32"],
+			["externref"],
+		);
+	}
+
+	getStrFromF64ImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_from_f64",
+			["f64"],
+			["externref"],
+		);
+	}
+
+	getStrToBytesImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_to_bytes",
+			["externref"],
+			["i32"],
+		);
+	}
+
+	getStrByteAtImportIndex() {
+		return this.getOrAddFuncImport("env", "str_byte_at", ["i32"], ["i32"]);
+	}
+
+	getBytesToStrInitImportIndex() {
+		return this.getOrAddFuncImport("env", "bytes_to_str_init", ["i32"], []);
+	}
+
+	getBytesToStrPushImportIndex() {
+		return this.getOrAddFuncImport("env", "bytes_to_str_push", ["i32"], []);
+	}
+
+	getBytesToStrFinishImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"bytes_to_str_finish",
+			[],
+			["externref"],
+		);
+	}
+
+	getMathImportIndex(jsName, isBinary = false) {
+		const params = isBinary ? ["f64", "f64"] : ["f64"];
+		return this.getOrAddFuncImport("Math", jsName, params, ["f64"]);
+	}
+
+	getMathRandomImportIndex() {
+		return this.getOrAddFuncImport("Math", "random", [], ["f64"]);
+	}
+
+	// Imports from the STDLIB_IMPORTS table (strings/strconv/utf8/fmt/testing.Run).
+	getStdlibImportIndex(name) {
+		const idx = this.importCache.get(`env.${name}`);
+		if (idx === undefined) throw new Error(`Unknown runtime import: ${name}`);
+		return idx;
+	}
+
+	getTimezoneOffsetImportIndex() {
+		return this.getStdlibImportIndex("time_timezone_offset");
+	}
+
+	// Closure type of `func(*testing.T)` (the t.Run body).
+	getTestingRunClosureType() {
+		return this.getClosureType({
+			kind: "func",
+			params: [{ kind: "pointer", base: { kind: "named", name: "testing.T" } }],
+			returns: [],
+		});
+	}
+
+	resolveFuncIndex(name) {
+		return this.funcMap.get(name) ?? null;
+	}
+
+	getFuncParamTypes(name) {
+		return this.funcParamTypes.get(name) ?? [];
+	}
+
+	getFuncParamGoTypes(name) {
+		return this.funcParamGoTypes.get(name) ?? [];
+	}
+
+	resolveGlobal(name) {
+		return this.globalCache.get(name) ?? null;
+	}
+
+	resolveConst(name) {
 		return this.constCache.get(name) ?? null;
 	}
 
 	isNonLiteralConst(name) {
 		return this.nonLiteralConsts.has(name);
 	}
+
+	// Interface method dispatch is a `ref.test` chain over every concrete type
+	// that declares `methodName` (no itabs); the static interface type is not
+	// needed to build the candidate list.
+	findInterfaceCandidates(_ifaceType, methodName) {
+		const candidates = [];
+		const seenKeys = new Set();
+
+		// 1. Struct types
+		for (const [sName, sInfo] of this.structTypes.entries()) {
+			const directMethodName = `${sName}.${methodName}`;
+			if (this.funcMap.has(directMethodName)) {
+				const fIdx = this.resolveFuncIndex(directMethodName);
+				const paramGoTypes = this.getFuncParamGoTypes(directMethodName);
+				const paramWTypes = this.getFuncParamTypes(directMethodName);
+				const recvGoType = paramGoTypes[0];
+				const isPtrRecv = recvGoType?.kind === "pointer";
+
+				if (isPtrRecv) {
+					const key = `ptr:${sName}`;
+					if (!seenKeys.has(key)) {
+						seenKeys.add(key);
+						candidates.push({
+							recvTypeName: sName,
+							testTypeIndex: sInfo.typeIndex,
+							isBoxedValue: false,
+							needsValueDeref: false,
+							embedPath: null,
+							funcIndex: fIdx,
+							targetParamTypes: paramWTypes,
+							structInfo: sInfo,
+						});
+					}
+				} else {
+					// Value receiver: both *sName and sName match
+					const ptrKey = `ptr:${sName}`;
+					if (!seenKeys.has(ptrKey)) {
+						seenKeys.add(ptrKey);
+						candidates.push({
+							recvTypeName: sName,
+							testTypeIndex: sInfo.typeIndex,
+							isBoxedValue: false,
+							needsValueDeref: true,
+							embedPath: null,
+							funcIndex: fIdx,
+							targetParamTypes: paramWTypes,
+							targetRecvWType: paramWTypes[0],
+							structInfo: sInfo,
+						});
+					}
+					const box = this.getIfaceBoxType({ kind: "named", name: sName });
+					const valKey = `val:${sName}`;
+					if (box && !seenKeys.has(valKey)) {
+						seenKeys.add(valKey);
+						candidates.push({
+							recvTypeName: sName,
+							testTypeIndex: box.typeIndex,
+							isBoxedValue: true,
+							needsValueDeref: false,
+							embedPath: null,
+							funcIndex: fIdx,
+							targetParamTypes: paramWTypes,
+							targetRecvWType: paramWTypes[0],
+							structInfo: sInfo,
+						});
+					}
+				}
+			}
+
+			// Promoted methods on sName
+			if (sInfo.embeds && sInfo.embeds.length > 0) {
+				for (const embed of sInfo.embeds) {
+					const embedMethodName = `${embed.name}.${methodName}`;
+					if (this.funcMap.has(embedMethodName)) {
+						const fIdx = this.resolveFuncIndex(embedMethodName);
+						const paramGoTypes = this.getFuncParamGoTypes(embedMethodName);
+						const paramWTypes = this.getFuncParamTypes(embedMethodName);
+						const isPtrRecv = paramGoTypes[0]?.kind === "pointer";
+						const embedSInfo = this.getStructType(embed.name);
+
+						const ptrKey = `ptr:${sName}`;
+						if (!seenKeys.has(ptrKey)) {
+							seenKeys.add(ptrKey);
+							candidates.push({
+								recvTypeName: sName,
+								testTypeIndex: sInfo.typeIndex,
+								isBoxedValue: false,
+								needsValueDeref: !isPtrRecv,
+								embedPath: [
+									{
+										parentTypeIndex: sInfo.typeIndex,
+										fieldIndex: embed.fieldIndex,
+									},
+								],
+								funcIndex: fIdx,
+								targetParamTypes: paramWTypes,
+								targetRecvWType: paramWTypes[0],
+								structInfo: embedSInfo,
+							});
+						}
+
+						if (!isPtrRecv) {
+							const box = this.getIfaceBoxType({ kind: "named", name: sName });
+							const valKey = `val:${sName}`;
+							if (box && !seenKeys.has(valKey)) {
+								seenKeys.add(valKey);
+								candidates.push({
+									recvTypeName: sName,
+									testTypeIndex: box.typeIndex,
+									isBoxedValue: true,
+									needsValueDeref: false,
+									embedPath: [
+										{
+											parentTypeIndex: sInfo.typeIndex,
+											fieldIndex: embed.fieldIndex,
+										},
+									],
+									funcIndex: fIdx,
+									targetParamTypes: paramWTypes,
+									targetRecvWType: paramWTypes[0],
+									structInfo: embedSInfo,
+								});
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// 2. Named non-struct types
+		for (const [fnName, fIdx] of this.funcMap.entries()) {
+			if (fnName.endsWith(`.${methodName}`)) {
+				const rName = fnName.slice(0, fnName.length - methodName.length - 1);
+				if (!this.structTypes.has(rName)) {
+					const box = this.getIfaceBoxType({ kind: "named", name: rName });
+					const key = `named:${rName}`;
+					if (box && !seenKeys.has(key)) {
+						seenKeys.add(key);
+						const paramWTypes = this.getFuncParamTypes(fnName);
+						candidates.push({
+							recvTypeName: rName,
+							testTypeIndex: box.typeIndex,
+							isBoxedValue: true,
+							needsValueDeref: false,
+							embedPath: null,
+							funcIndex: fIdx,
+							targetParamTypes: paramWTypes,
+						});
+					}
+				}
+			}
+		}
+
+		return candidates;
+	}
+
+	getTypesImplementingInterface(ifaceType) {
+		const candidates = [];
+		const seen = new Set();
+		const ifaceResolved =
+			this.checker?.resolveType?.(
+				ifaceType?.kind === "named" ? ifaceType.underlying : ifaceType,
+			) ?? ifaceType;
+
+		// 1. Struct types
+		for (const [sName, sInfo] of this.structTypes.entries()) {
+			const namedType = this.checker?.types?.get(sName) ?? {
+				kind: "named",
+				name: sName,
+			};
+			const ptrType = { kind: "pointer", base: namedType };
+
+			// Check pointer to struct
+			if (this.checker?.implements?.(ptrType, ifaceResolved)) {
+				if (!seen.has(sInfo.typeIndex)) {
+					seen.add(sInfo.typeIndex);
+					candidates.push({ name: `*${sName}`, typeIndex: sInfo.typeIndex });
+				}
+			}
+
+			// Check struct value (boxed)
+			if (this.checker?.implements?.(namedType, ifaceResolved)) {
+				const box = this.getIfaceBoxType(namedType);
+				if (box && !seen.has(box.typeIndex)) {
+					seen.add(box.typeIndex);
+					candidates.push({ name: sName, typeIndex: box.typeIndex });
+				}
+			}
+		}
+
+		// 2. Named non-struct types that have methods
+		if (this.checker?.types) {
+			for (const [tName, tVal] of this.checker.types.entries()) {
+				if (
+					tVal?.kind === "named" &&
+					tVal.underlying?.kind !== "struct" &&
+					tVal.underlying?.kind !== "interface"
+				) {
+					if (this.checker.implements(tVal, ifaceResolved)) {
+						const box = this.getIfaceBoxType(tVal);
+						if (box && !seen.has(box.typeIndex)) {
+							seen.add(box.typeIndex);
+							candidates.push({ name: tName, typeIndex: box.typeIndex });
+						}
+					}
+				}
+			}
+		}
+
+		return candidates;
+	}
 }
 
-export function peepholeOptimize(instructions) {
+function peepholeOptimize(instructions) {
 	let changed = true;
 	let current = instructions;
 	while (changed) {
@@ -768,9 +1955,20 @@ export function compileWasmModule(
 	lowerResult = null,
 	options = {},
 ) {
-	const progs = Array.isArray(programs) ? programs : [programs];
-	const resolvedLowerResult = lowerResult ?? lower(progs, checker);
-	const mod = new ModuleEmitter(checker, resolvedLowerResult, progs, {
+	let progs = Array.isArray(programs) ? programs : [programs];
+	let resolvedChecker = checker;
+	let resolvedLowerResult = lowerResult;
+
+	if (hasGenerics(progs)) {
+		const mono = monomorphise(progs, checker);
+		progs = mono.programs;
+		resolvedChecker = mono.checker;
+		resolvedLowerResult = lower(progs, resolvedChecker);
+	} else if (!resolvedLowerResult) {
+		resolvedLowerResult = lower(progs, resolvedChecker);
+	}
+
+	const mod = new ModuleEmitter(resolvedChecker, resolvedLowerResult, progs, {
 		bundledPackages: options.bundledPackages,
 	});
 
@@ -785,6 +1983,7 @@ export function compileWasmModule(
 			if (d.kind === "FuncDecl") {
 				d._pkgName = pkgName;
 				d._pkgTarget = pkgTarget;
+				d._srcFile = p._path ?? p._filename ?? null;
 				if (d.name === "init" || d.name.startsWith("init$")) {
 					const renamed = initCount === 0 ? "init" : `init$${initCount}`;
 					d.name = renamed;
@@ -812,6 +2011,8 @@ export function compileWasmModule(
 					_sourceDecl: d,
 					_pkgName: pkgName,
 					_pkgTarget: pkgTarget,
+					_srcFile: p._path ?? p._filename ?? null,
+					_line: d._line,
 				};
 				funcDecls.push(normFn);
 			}
@@ -846,6 +2047,8 @@ export function compileWasmModule(
 				_isClosure: true,
 				_funcLit: node,
 				_rootFuncDecl: rootFn,
+				_srcFile: rootFn?._srcFile ?? null,
+				_line: typeof node._line === "number" ? node._line : rootFn?._line,
 			};
 			node._liftedFn = liftedFn;
 			closures.push(liftedFn);
@@ -928,8 +2131,19 @@ export function compileWasmModule(
 	}
 	funcDecls.push(...trampolines);
 
+	_collectPackageConsts(progs, mod, checker);
+	if (checker?.errors?.length > 0) {
+		if (options.boundary) {
+			throw new Error(checker.errors.map((e) => e.message).join("\n"));
+		}
+		return {
+			wasm: null,
+			facade: null,
+			stringTable: null,
+			errors: checker.errors,
+		};
+	}
 	const pendingInits = _collectPackageGlobals(progs, mod, checker);
-	_collectPackageConsts(progs, mod);
 	const globalInitFn =
 		pendingInits.length > 0 || initNames.length > 0
 			? _makeGlobalInitFunc(pendingInits, initNames)
@@ -956,7 +2170,370 @@ export function compileWasmModule(
 	};
 	funcDecls.push(sliceBoundsPanicFn);
 
-	// 1d. Boundary metadata (exported surface of wasm packages)
+	const pushPanicFn = {
+		kind: "FuncDecl",
+		name: "__push_panic",
+		params: [{ name: "msg", type: { kind: "basic", name: "string" } }],
+		returnType: null,
+		_isPushPanic: true,
+	};
+	funcDecls.push(pushPanicFn);
+
+	// 1d. Interface dispatchers
+	_collectInterfaceDispatchers(progs, funcDecls, mod, checker);
+
+	// 1e. Map helpers
+	function scanMapTypes(node) {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const item of node) scanMapTypes(item);
+			return;
+		}
+		if (node._type && isMapType(node._type, checker)) {
+			const { keyType, valType } = getMapKeyValTypes(node._type, checker);
+			if (keyType && valType) {
+				mod.getMapType(keyType, valType);
+			}
+		}
+		if (node.kind === "MapType") {
+			const keyGoType = node.key;
+			const valGoType = node.value ?? node.elem;
+			if (keyGoType && valGoType) {
+				mod.getMapType(keyGoType, valGoType);
+			}
+		}
+		for (const key of Object.keys(node)) {
+			if (key.startsWith("_")) continue;
+			scanMapTypes(node[key]);
+		}
+	}
+
+	for (const fn of funcDecls) {
+		if (fn.params) scanMapTypes(fn.params);
+		if (fn.returnType) scanMapTypes(fn.returnType);
+		if (fn.body) scanMapTypes(fn.body);
+	}
+	for (const p of progs) {
+		for (const d of p.decls ?? []) {
+			scanMapTypes(d);
+		}
+	}
+
+	for (const mapInfo of mod.mapTypes.values()) {
+		// make
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.makeFuncName,
+			params: [{ name: "cap", type: { kind: "basic", name: "int32" } }],
+			returnType: mapInfo.wType,
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "make",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+		// get
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.getFuncName,
+			params: [
+				{ name: "m", type: mapInfo.wType },
+				{ name: "k", type: mapInfo.keyGoType },
+			],
+			returnType: mapInfo.valGoType,
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "get",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+		// get_ok
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.getOkFuncName,
+			params: [
+				{ name: "m", type: mapInfo.wType },
+				{ name: "k", type: mapInfo.keyGoType },
+			],
+			returnType: {
+				kind: "tuple",
+				types: [mapInfo.valGoType, { kind: "basic", name: "bool" }],
+			},
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "get_ok",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+		// set
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.setFuncName,
+			params: [
+				{ name: "m", type: mapInfo.wType },
+				{ name: "k", type: mapInfo.keyGoType },
+				{ name: "v", type: mapInfo.valGoType },
+			],
+			returnType: null,
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "set",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+		// delete
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.deleteFuncName,
+			params: [
+				{ name: "m", type: mapInfo.wType },
+				{ name: "k", type: mapInfo.keyGoType },
+			],
+			returnType: null,
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "delete",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+		// len
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.lenFuncName,
+			params: [{ name: "m", type: mapInfo.wType }],
+			returnType: { kind: "basic", name: "int32" },
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "len",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+		// clear
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.clearFuncName,
+			params: [{ name: "m", type: mapInfo.wType }],
+			returnType: null,
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "clear",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+		// keys
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.keysFuncName,
+			params: [{ name: "m", type: mapInfo.wType }],
+			returnType: { kind: "slice", elem: mapInfo.keyGoType },
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "keys",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+		// values
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.valuesFuncName,
+			params: [{ name: "m", type: mapInfo.wType }],
+			returnType: { kind: "slice", elem: mapInfo.valGoType },
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "values",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+		// clone
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: mapInfo.cloneFuncName,
+			params: [{ name: "m", type: mapInfo.wType }],
+			returnType: mapInfo.wType,
+			body: { kind: "Block", stmts: [], list: [] },
+			_isMapHelper: true,
+			_mapHelperKind: "clone",
+			_mapInfo: mapInfo,
+			_rootFuncDecl: null,
+		});
+	}
+
+	// 1e2. `gofront/shared` linear-memory helpers (only when imported).
+	const usesShared = progs.some((p) =>
+		(p.imports ?? []).some((decl) =>
+			(decl.imports ?? [decl]).some((imp) => imp.path === "gofront/shared"),
+		),
+	);
+	if (usesShared) {
+		const sharedWType = mod.getSharedType().wType;
+		const i32 = { kind: "basic", name: "int32" };
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: "__shared_len_panic",
+			params: [],
+			returnType: null,
+			_isRuntimePanic: true,
+			_panicMsg: "runtime error: shared buffer length out of range",
+		});
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: "__shared_new",
+			params: [
+				{ name: "len", type: i32 },
+				{ name: "bytes", type: i32 },
+			],
+			returnType: sharedWType,
+			body: { kind: "Block", stmts: [], list: [] },
+			_isSharedHelper: "new",
+			_rootFuncDecl: null,
+		});
+		funcDecls.push({
+			kind: "FuncDecl",
+			name: "__shared_sub",
+			params: [
+				{ name: "buf", type: sharedWType },
+				{ name: "lo", type: i32 },
+				{ name: "hi", type: i32 },
+				{ name: "bytes", type: i32 },
+			],
+			returnType: sharedWType,
+			body: { kind: "Block", stmts: [], list: [] },
+			_isSharedHelper: "sub",
+			_rootFuncDecl: null,
+		});
+	}
+
+	// 1e3. Runtime helpers: error values, interface equality, t.Run callback.
+	mod.usesTestingRun = funcDecls.some((fn) => _usesTestingRun(fn.body));
+	mod.usesAnyEq = _usesAnyEq(funcDecls, mod);
+	const ANY_T = { kind: "basic", name: "any" };
+	const STR_T = { kind: "basic", name: "string" };
+	const BOOL_T = { kind: "basic", name: "bool" };
+	const helper = (name, params, returnType, kind, extra = {}) => ({
+		kind: "FuncDecl",
+		name,
+		params,
+		returnType,
+		body: { kind: "Block", stmts: [], list: [] },
+		_isRuntimeHelper: kind,
+		_rootFuncDecl: null,
+		...extra,
+	});
+	if (mod.usesAnyEq) {
+		funcDecls.push(
+			helper(
+				"__any_eq",
+				[
+					{ name: "a", type: ANY_T },
+					{ name: "b", type: ANY_T },
+				],
+				BOOL_T,
+				"any_eq",
+			),
+		);
+	}
+	mod.usesAnyHash = false;
+	for (const info of mod.mapTypes.values()) {
+		if (isInterfaceType(info.keyGoType, checker)) {
+			mod.usesAnyHash = true;
+			break;
+		}
+	}
+	if (mod.usesAnyHash) {
+		funcDecls.push(
+			helper(
+				"__any_hash",
+				[{ name: "a", type: ANY_T }],
+				{ kind: "basic", name: "int32" },
+				"any_hash",
+			),
+		);
+	}
+	if (mod.hasErrorType) {
+		const errPtr = {
+			kind: "pointer",
+			base: { kind: "named", name: ERROR_STRUCT },
+		};
+		funcDecls.push(
+			helper(
+				`${ERROR_STRUCT}.Error`,
+				[{ name: "e", type: errPtr }],
+				STR_T,
+				"error_msg",
+				{
+					_isMethod: true,
+					_recvTypeName: ERROR_STRUCT,
+					_methodName: "Error",
+				},
+			),
+			helper(
+				`${ERROR_STRUCT}.Unwrap`,
+				[{ name: "e", type: errPtr }],
+				ANY_T,
+				"error_cause",
+				{
+					_isMethod: true,
+					_recvTypeName: ERROR_STRUCT,
+					_methodName: "Unwrap",
+				},
+			),
+			helper(
+				"__mk_error",
+				[
+					{ name: "msg", type: STR_T },
+					{ name: "cause", type: ANY_T },
+				],
+				ANY_T,
+				"mk_error",
+			),
+			helper("__error_str", [{ name: "e", type: ANY_T }], STR_T, "error_str"),
+			{
+				kind: "FuncDecl",
+				name: "__errors_unwrap",
+				params: [{ name: "__recv", type: ANY_T }],
+				returnType: ANY_T,
+				body: { kind: "Block", stmts: [], list: [] },
+				_isInterfaceDispatcher: true,
+				_softDispatch: true,
+				_ifaceName: "error",
+				_ifaceType: null,
+				_methodName: "Unwrap",
+				_rootFuncDecl: null,
+			},
+			helper(
+				"__errors_is",
+				[
+					{ name: "err", type: ANY_T },
+					{ name: "target", type: ANY_T },
+				],
+				BOOL_T,
+				"errors_is",
+			),
+		);
+	}
+	if (mod.usesTestingRun) {
+		funcDecls.push(
+			helper(
+				"__testing_run_cb",
+				[
+					{ name: "fn", type: ANY_T },
+					{
+						name: "t",
+						type: {
+							kind: "pointer",
+							base: { kind: "named", name: "testing.T" },
+						},
+					},
+				],
+				null,
+				"testing_run_cb",
+				{ _forceExport: true },
+			),
+		);
+	}
+	_registerIoSyntheticMethods(funcDecls, mod, STR_T, progs);
+
+	// 1f. Boundary metadata (exported surface of wasm packages)
 	const boundaryMeta = options.boundary
 		? collectBoundaryMeta(progs, funcDecls, mod)
 		: null;
@@ -1009,14 +2586,21 @@ export function compileWasmModule(
 		const typeIndex = mod.getTypeIndex(paramTypes, returnTypes);
 		fn._typeIndex = typeIndex;
 		fn._globalFuncIndex = globalIdx;
+		mod.funcReturnTypesByIdx.set(globalIdx, returnTypes);
 
 		// Export if public (capitalized) or main
 		if (
-			!fn._isGlobalInit &&
-			(options.exportAll ||
-				fn.name === "main" ||
-				(fn.name[0] >= "A" && fn.name[0] <= "Z") ||
-				(fn._isMethod && fn._methodName[0] >= "A" && fn._methodName[0] <= "Z"))
+			fn._forceExport ||
+			(!fn._isGlobalInit &&
+				!fn._isRuntimeHelper &&
+				!fn._isIoHelper &&
+				!fn._isPhase7Helper &&
+				(options.exportAll ||
+					fn.name === "main" ||
+					(fn.name[0] >= "A" && fn.name[0] <= "Z") ||
+					(fn._isMethod &&
+						fn._methodName[0] >= "A" &&
+						fn._methodName[0] <= "Z")))
 		) {
 			mod.exports.push({ name: fn.name, kind: "func", index: globalIdx });
 			if (fn._isMethod && fn._exportName) {
@@ -1027,6 +2611,16 @@ export function compileWasmModule(
 				});
 			}
 		}
+		if (
+			fn._isPushPanic &&
+			!mod.exports.some((e) => e.name === "__push_panic")
+		) {
+			mod.exports.push({
+				name: "__push_panic",
+				kind: "func",
+				index: globalIdx,
+			});
+		}
 	}
 
 	// 4. Emit function bodies
@@ -1037,7 +2631,31 @@ export function compileWasmModule(
 			const funcIdx = mod.getStringImportIndex();
 			emitter.pushInstruction({ op: "i32.const", value: strIdx });
 			emitter.pushInstruction({ op: "call", funcIndex: funcIdx });
+			emitter.pushInstruction("any.convert_extern");
 			emitter.emitPanicThrow();
+		} else if (fn._isPushPanic) {
+			const panicNodeTypeIndex = mod.getPanicNodeTypeIndex();
+			const panicGlobal = mod.getPanicGlobalIndex();
+			emitter.pushInstruction({ op: "local.get", index: 0 });
+			emitter.pushInstruction("any.convert_extern");
+			emitter.pushInstruction({ op: "i32.const", value: 0 });
+			emitter.pushInstruction({ op: "global.get", index: panicGlobal });
+			emitter.pushInstruction({
+				op: "struct.new",
+				typeIndex: panicNodeTypeIndex,
+			});
+			emitter.pushInstruction({ op: "global.set", index: panicGlobal });
+			emitter.pushInstruction("return");
+		} else if (fn._isInterfaceDispatcher) {
+			emitter.emitInterfaceDispatcher(fn);
+		} else if (fn._isMapHelper) {
+			emitter.emitMapHelper(fn);
+		} else if (fn._isSharedHelper) {
+			emitter.emitSharedHelper(fn);
+		} else if (fn._isRuntimeHelper) {
+			emitter.emitRuntimeHelper(fn);
+		} else if (fn._isIoHelper || fn._isPhase7Helper) {
+			emitter.emitIoHelper(fn);
 		} else if (fn.body) {
 			emitter.emitFunctionBody(fn.body);
 		}
@@ -1061,6 +2679,10 @@ export function compileWasmModule(
 			typeIndex: fn._typeIndex,
 			locals: emitter.localTypes,
 			body,
+			src:
+				fn._srcFile && typeof fn._line === "number"
+					? { file: fn._srcFile, line: fn._line }
+					: null,
 		});
 	}
 
@@ -1071,6 +2693,7 @@ export function compileWasmModule(
 		facade = generateFacade(boundaryMeta, {
 			stringTable: mod.stringTable,
 			callMain: Boolean(options.callMain) && mod.funcMap.has("main"),
+			stdlibEnv: mod.usesStdlibEnv,
 		});
 	}
 
@@ -1082,44 +2705,150 @@ export function compileWasmModule(
 		elements: mod.elements,
 		funcs: mod.funcs,
 		exports: mod.exports,
+		memory: mod.memory ?? null,
 		start: globalInitFn ? globalInitFn._globalFuncIndex : null,
+		sourceMappingURL: options.sourceMappingURL ?? null,
 	};
 
 	const wasmBytes = encodeModule(moduleIR);
 	const watText = options.emitWat ? emitWat(moduleIR) : null;
 
+	// Function-level source positions: `sources` are the absolute Go files,
+	// `mappings` pair each function body's byte offset with its 0-based line.
+	const sources = [];
+	const sourceIndex = new Map();
+	const mappings = [];
+	moduleIR.funcs.forEach((fn, i) => {
+		if (!fn.src) return;
+		let idx = sourceIndex.get(fn.src.file);
+		if (idx === undefined) {
+			idx = sources.length;
+			sources.push(fn.src.file);
+			sourceIndex.set(fn.src.file, idx);
+		}
+		mappings.push({
+			offset: moduleIR.codeOffsets[i],
+			srcFileIdx: idx,
+			srcLine: Math.max(0, fn.src.line - 1),
+		});
+	});
+
 	return {
 		wasm: wasmBytes,
 		wat: watText,
 		stringTable: mod.stringTable,
 		moduleIR,
 		facade,
+		sourceMapInfo: { sources, mappings },
 	};
 }
 
-// Package-level `const` declarations with literal values (iota is already
-// substituted by the parser). Non-literal constant expressions are not
-// supported by the wasm backend yet.
-function _collectPackageConsts(progs, mod) {
+// Package-level `const` declarations (iota is already substituted by the
+// parser).  Literals and expressions the folder can reduce become BasicLits in
+// `constCache`; whatever is left is recorded in `nonLiteralConsts` and later
+// becomes a global initialised by the start function.
+function _collectPackageConsts(progs, mod, checker = null) {
+	const entries = [];
 	for (const p of progs) {
 		for (const d of p.decls ?? []) {
 			if (d.kind !== "ConstDecl") continue;
 			for (const spec of d.decls ?? []) {
 				for (let i = 0; i < spec.names.length; i++) {
-					let lit = spec.value?.[i];
-					if (
-						lit?.kind === "UnaryExpr" &&
-						lit.op === "-" &&
-						lit.operand?.kind === "BasicLit"
-					) {
-						lit = { ...lit.operand, value: `-${lit.operand.value}` };
-					}
-					if (lit?.kind === "BasicLit") mod.constCache.set(spec.names[i], lit);
-					else if (lit) mod.nonLiteralConsts.add(spec.names[i]);
+					if (spec.value?.[i])
+						entries.push({
+							name: spec.names[i],
+							expr: spec.value[i],
+							filename: p._filename,
+							source: p._source,
+						});
 				}
 			}
 		}
 	}
+	const resolve = (name) => mod.constCache.get(name) ?? null;
+	// Iterate to a fixpoint so a constant may refer to one declared later.
+	let pending = entries;
+	let progress = true;
+	while (progress && pending.length > 0) {
+		progress = false;
+		const rest = [];
+		for (const entry of pending) {
+			let lit = null;
+			try {
+				lit = foldConstExpr(entry.expr, resolve);
+			} catch (err) {
+				if (checker?.err) {
+					const savedFile = checker._currentFile;
+					const savedSource = checker._currentSource;
+					if (entry.filename) checker._currentFile = entry.filename;
+					if (entry.source) checker._currentSource = entry.source;
+					checker.err(err.message, entry.expr);
+					checker._currentFile = savedFile;
+					checker._currentSource = savedSource;
+				} else {
+					throw new Error(
+						`Constant expression error for '${entry.name}': ${err.message}`,
+					);
+				}
+				continue;
+			}
+			if (lit) {
+				mod.constCache.set(entry.name, lit);
+				progress = true;
+			} else {
+				rest.push(entry);
+			}
+		}
+		pending = rest;
+	}
+	for (const entry of pending) mod.nonLiteralConsts.add(entry.name);
+}
+
+// Depth-first search over AST nodes (skipping `_`-prefixed annotations).
+function _someNode(node, pred) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some((n) => _someNode(n, pred));
+	if (pred(node)) return true;
+	for (const key of Object.keys(node)) {
+		if (key.startsWith("_")) continue;
+		if (_someNode(node[key], pred)) return true;
+	}
+	return false;
+}
+
+function _usesTestingRun(node) {
+	return _someNode(
+		node,
+		(n) =>
+			n.kind === "CallExpr" &&
+			n.func?.kind === "SelectorExpr" &&
+			n.func.field === "Run" &&
+			isTestingT(n.func.expr?._type),
+	);
+}
+
+// `__any_eq` is only needed when some `==`/`!=` (or switch case) compares
+// anyref operands, a struct with an anyref field is compared, or the error
+// runtime (`errors.Is`) is present.  `_emitAnyEq` throws if this misses a
+// site, so a gap surfaces as a compile error rather than a bad module.
+function _usesAnyEq(funcDecls, mod) {
+	if (mod.hasErrorType) return true;
+	for (const info of mod.mapTypes.values()) {
+		if (isInterfaceType(info.keyGoType, mod.checker)) return true;
+	}
+	for (const info of mod.structTypes.values()) {
+		if (info.fields?.some((f) => f.wType === "anyref")) return true;
+	}
+	const isAnyRef = (n) =>
+		Boolean(n?._type) && toWasmType(n._type, mod.checker, mod) === "anyref";
+	return funcDecls.some((fn) =>
+		_someNode(fn.body, (n) => {
+			if (n.kind === "BinaryExpr" && (n.op === "==" || n.op === "!="))
+				return isAnyRef(n.left) || isAnyRef(n.right);
+			if (n.kind === "SwitchStmt" && n.tag) return isAnyRef(n.tag);
+			return false;
+		}),
+	);
 }
 
 function _scanImportsInBody(node, mod) {
@@ -1158,14 +2887,20 @@ function _scanImportsInBody(node, mod) {
 				Atan: "atan",
 				Atan2: "atan2",
 				Pow: "pow",
+				Mod: "mod",
+				Hypot: "hypot",
+				Cbrt: "cbrt",
 				Exp: "exp",
 				Log: "log",
 				Log2: "log2",
 				Log10: "log10",
 				Round: "round",
+				Sinh: "sinh",
+				Cosh: "cosh",
+				Tanh: "tanh",
 			};
 			if (jsMathMap[func.field]) {
-				const isBinary = func.field === "Atan2" || func.field === "Pow";
+				const isBinary = BINARY_MATH_IMPORTS.has(jsMathMap[func.field]);
 				mod.getMathImportIndex(jsMathMap[func.field], isBinary);
 			}
 		} else if (
@@ -1177,7 +2912,10 @@ function _scanImportsInBody(node, mod) {
 			if (func.field === "Name") mod.getTestingNameImportIndex();
 			else if (func.field === "Failed" || func.field === "Skipped")
 				mod.getTestingFlagImportIndex();
-			else if (func.field !== "Run") {
+			else if (func.field === "Run") {
+				// closure type for func(*testing.T) must exist before bodies are emitted
+				mod.getTestingRunClosureType();
+			} else {
 				mod.getTestingCallImportIndex();
 				for (const arg of args) {
 					mod.getTestingArgImportIndex(
@@ -1228,19 +2966,67 @@ export function compileWasm(source, options = {}) {
 		exportAll: options.exportAll ?? true,
 	});
 
+	if (checker.errors?.length > 0) {
+		return { wasm: null, errors: checker.errors };
+	}
+
 	return { ...res, errors: [] };
 }
 
+function _isPointerGoType(t, mod) {
+	if (!t) return false;
+	if (t.kind === "pointer" || t.kind === "PointerType" || t.kind === "StarExpr")
+		return true;
+	// `type P *T` used as a field type: look through the name.
+	const named =
+		t.kind === "named" || t.kind === "TypeName" || t.kind === "Ident";
+	const under = named
+		? (t.underlying ?? mod.checker?.types?.get(t.name)?.underlying)
+		: null;
+	return under ? _isPointerGoType(under, mod) : false;
+}
+
+// Constant-expression zero value of a struct global. Nested struct values are
+// built in place: a null ref would trap on the first field access.
+function _zeroStructConst(structInfo, mod) {
+	const out = [];
+	for (const f of structInfo.fields) out.push(..._zeroFieldConst(f, mod));
+	out.push({ op: "struct.new", typeIndex: structInfo.typeIndex });
+	return out;
+}
+
+function _zeroFieldConst(f, mod) {
+	const w = f.wType;
+	if (w === "i64") return [{ op: "i64.const", value: 0n }];
+	if (w === "f32" || w === "f64") return [{ op: `${w}.const`, value: 0 }];
+	if (w === "externref") return [{ op: "ref.null", heapType: "extern" }];
+	if (w === "anyref") return [{ op: "ref.null", heapType: "any" }];
+	if (typeof w !== "object" || w === null)
+		return [{ op: "i32.const", value: 0 }];
+	const ti = w.typeIndex;
+	const slice = typeof ti === "number" ? mod.getSliceTypeByIndex(ti) : null;
+	if (slice) return [{ op: "global.get", index: slice.emptyGlobalIndex }];
+	if (typeof ti === "number" && !_isPointerGoType(f.goType, mod)) {
+		for (const s of mod.structTypes.values())
+			if (s.typeIndex === ti) return _zeroStructConst(s, mod);
+	}
+	return [{ op: "ref.null", heapType: ti ?? "any" }];
+}
+
 function _collectPackageGlobals(progs, mod, checker) {
 	const pending = []; // non-constant initializers, run by the start function
+	const pendingConsts = []; // unfoldable consts; they run before any var
 	for (const p of progs) {
 		for (const d of p.decls ?? []) {
-			if (d.kind !== "VarDecl") continue;
+			const isConst = d.kind === "ConstDecl";
+			if (d.kind !== "VarDecl" && !isConst) continue;
 			for (const spec of d.decls ?? d.specs ?? [d]) {
 				const names = spec.names ?? (spec.name ? [spec.name] : []);
 				const values = spec.value ?? (spec.init ? [spec.init] : []);
 				for (let i = 0; i < names.length; i++) {
 					const name = names[i];
+					// Foldable consts live in `constCache`, not in a global.
+					if (isConst && !mod.isNonLiteralConst(name)) continue;
 					const rawType = spec.type ?? values[i]?._type;
 					const wType = toWasmType(rawType, checker, mod);
 					const gIdx = mod.globals.length;
@@ -1270,34 +3056,7 @@ function _collectPackageGlobals(progs, mod, checker) {
 								(s) => s.typeIndex === wType.typeIndex,
 							);
 							if (structInfo) {
-								initInsts = [];
-								for (const f of structInfo.fields) {
-									if (f.wType === "i64")
-										initInsts.push({ op: "i64.const", value: 0n });
-									else if (f.wType === "f32" || f.wType === "f64")
-										initInsts.push({ op: `${f.wType}.const`, value: 0.0 });
-									else if (typeof f.wType === "object") {
-										const fieldSlice =
-											typeof f.wType.typeIndex === "number"
-												? mod.getSliceTypeByIndex(f.wType.typeIndex)
-												: null;
-										if (fieldSlice) {
-											initInsts.push({
-												op: "global.get",
-												index: fieldSlice.emptyGlobalIndex,
-											});
-										} else {
-											initInsts.push({
-												op: "ref.null",
-												heapType: f.wType.typeIndex ?? "any",
-											});
-										}
-									} else initInsts.push({ op: "i32.const", value: 0 });
-								}
-								initInsts.push({
-									op: "struct.new",
-									typeIndex: structInfo.typeIndex,
-								});
+								initInsts = _zeroStructConst(structInfo, mod);
 							} else {
 								initInsts = [
 									{ op: "ref.null", heapType: wType.typeIndex ?? "any" },
@@ -1332,15 +3091,17 @@ function _collectPackageGlobals(progs, mod, checker) {
 					if (litNode && litNode.kind === "BasicLit") {
 						if (litNode.litKind === "INT") {
 							isConstInit = true;
+							const s = String(litNode.value);
+							const clean = /^0[0-7]+$/.test(s) ? `0o${s.slice(1)}` : s;
 							initInsts = [
 								wType === "i64"
 									? {
 											op: "i64.const",
-											value: BigInt(sign) * BigInt(litNode.value),
+											value: BigInt(sign) * BigInt(clean),
 										}
 									: {
 											op: "i32.const",
-											value: (sign * Number(litNode.value)) | 0,
+											value: (sign * Number(clean)) | 0,
 										},
 							];
 						} else if (litNode.litKind === "FLOAT") {
@@ -1362,7 +3123,10 @@ function _collectPackageGlobals(progs, mod, checker) {
 						}
 					}
 					if (values[i] && !isConstInit && names.length === values.length) {
-						pending.push({ name, expr: values[i] });
+						(isConst ? pendingConsts : pending).push({
+							name,
+							expr: values[i],
+						});
 					}
 					mod.globals.push({
 						type: wType,
@@ -1378,7 +3142,26 @@ function _collectPackageGlobals(progs, mod, checker) {
 			}
 		}
 	}
-	return pending;
+	return [..._orderConstInits(pendingConsts), ...pending];
+}
+
+// Orders runtime-initialised consts so each runs after the consts it
+// references (Go allows a constant to use one declared later).
+function _orderConstInits(entries) {
+	const byName = new Map(entries.map((e) => [e.name, e]));
+	const ordered = [];
+	const state = new Map();
+	const visit = (entry) => {
+		if (state.has(entry.name)) return;
+		state.set(entry.name, true);
+		_someNode(entry.expr, (n) => {
+			if (n.kind === "Ident" && byName.has(n.name)) visit(byName.get(n.name));
+			return false;
+		});
+		ordered.push(entry);
+	};
+	for (const e of entries) visit(e);
+	return ordered;
 }
 
 // Synthesises `__init_globals()` assigning every non-constant package-level
@@ -1411,3 +3194,566 @@ function _makeGlobalInitFunc(pending, initNames = []) {
 		_isGlobalInit: true,
 	};
 }
+
+function _scanInterfaceCallNodes(node, interfaceCalls, checker) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node)
+			_scanInterfaceCallNodes(item, interfaceCalls, checker);
+		return;
+	}
+	if (node.kind === "CallExpr" && node.func?.kind === "SelectorExpr") {
+		const recvType = node.func.expr?._type;
+		if (isNonEmptyInterface(recvType, checker)) {
+			const ifaceName = getReceiverTypeName(recvType, node.func.expr) || "anon";
+			const methodName = node.func.field;
+			const key = `${ifaceName}.${methodName}`;
+			if (!interfaceCalls.has(key)) {
+				interfaceCalls.set(key, {
+					ifaceName,
+					ifaceType: recvType,
+					methodName,
+					callNode: node,
+				});
+			}
+		}
+	}
+	for (const key of Object.keys(node)) {
+		if (!key.startsWith("_"))
+			_scanInterfaceCallNodes(node[key], interfaceCalls, checker);
+	}
+}
+
+function _scanInterfaceTypeDecls(progs, interfaceCalls, checker) {
+	for (const p of progs) {
+		for (const d of p.decls ?? []) {
+			if (d.kind !== "TypeDecl") continue;
+			const resolved = checker?.types?.get(d.name) ?? d.type;
+			const underlying =
+				resolved?.kind === "named"
+					? resolved.underlying
+					: d.type?.kind === "InterfaceType"
+						? d.type
+						: resolved;
+			if (!isNonEmptyInterface(underlying, checker)) continue;
+			const methods =
+				underlying.methods instanceof Map
+					? Array.from(underlying.methods.entries())
+					: Array.isArray(underlying.methods)
+						? underlying.methods.map((m) => [m.name ?? m, m])
+						: [];
+			for (const [mName, mSig] of methods) {
+				const key = `${d.name}.${mName}`;
+				if (!interfaceCalls.has(key)) {
+					interfaceCalls.set(key, {
+						ifaceName: d.name,
+						ifaceType: resolved,
+						methodName: mName,
+						methodSig: mSig,
+					});
+				}
+			}
+		}
+	}
+}
+
+function _makeInterfaceDispatcher(info, checker) {
+	let methodSig = info.methodSig;
+	if (!methodSig) {
+		const ifaceResolved =
+			checker?.resolveType?.(
+				info.ifaceType?.kind === "named"
+					? info.ifaceType.underlying
+					: info.ifaceType,
+			) ?? info.ifaceType;
+		if (ifaceResolved?.methods instanceof Map) {
+			methodSig = ifaceResolved.methods.get(info.methodName);
+		}
+	}
+
+	const params = [{ name: "__recv", type: { kind: "basic", name: "any" } }];
+	if (methodSig?.params) {
+		for (let p = 0; p < methodSig.params.length; p++) {
+			params.push({ name: `__arg${p}`, type: methodSig.params[p] });
+		}
+	} else if (info.callNode?.args) {
+		for (let p = 0; p < info.callNode.args.length; p++) {
+			params.push({
+				name: `__arg${p}`,
+				type: info.callNode.args[p]._type ?? {
+					kind: "basic",
+					name: "any",
+				},
+			});
+		}
+	}
+
+	let returnType = info.callNode?._type ?? null;
+	if (methodSig?.returns) {
+		returnType =
+			methodSig.returns.length === 1
+				? methodSig.returns[0]
+				: methodSig.returns.length > 1
+					? { kind: "tuple", types: methodSig.returns }
+					: null;
+	}
+
+	return {
+		kind: "FuncDecl",
+		name: `__dispatch_${info.ifaceName}_${info.methodName}`,
+		params,
+		returnType,
+		body: { kind: "Block", stmts: [], list: [] },
+		_isInterfaceDispatcher: true,
+		_ifaceName: info.ifaceName,
+		_ifaceType: info.ifaceType,
+		_methodName: info.methodName,
+		_rootFuncDecl: null,
+	};
+}
+
+function _scanFuncSigInterfaces(
+	progs,
+	funcDecls,
+	interfaceCalls,
+	checker,
+	mod,
+) {
+	const scanType = (t) => {
+		if (!t) return;
+		if (t.kind === "InterfaceType" || (t.kind === "interface" && !t.name)) {
+			const mList = getInterfaceMethodList(t);
+			if (mList.length === 0) return;
+			const ifaceName = anonIfaceName(t, checker, mod);
+			for (const m of mList) {
+				const key = `${ifaceName}.${m.name}`;
+				if (!interfaceCalls.has(key)) {
+					interfaceCalls.set(key, {
+						ifaceName,
+						ifaceType: t,
+						methodName: m.name,
+						methodSig: {
+							kind: "func",
+							params: m.params,
+							returns: m.returns,
+						},
+					});
+				}
+			}
+		}
+	};
+	for (const fn of funcDecls) {
+		for (const p of fn.params ?? []) scanType(p.type);
+		scanType(fn.returnType);
+	}
+	for (const p of progs) {
+		for (const d of p.decls ?? []) {
+			if (d.kind === "FuncDecl") {
+				for (const param of d.params ?? []) scanType(param.type);
+				scanType(d.returnType);
+			}
+		}
+	}
+}
+
+function _collectInterfaceDispatchers(progs, funcDecls, mod, checker) {
+	const interfaceCalls = new Map();
+	for (const fn of funcDecls) {
+		if (fn.body) _scanInterfaceCallNodes(fn.body, interfaceCalls, checker);
+	}
+	_scanInterfaceTypeDecls(progs, interfaceCalls, checker);
+	_scanFuncSigInterfaces(progs, funcDecls, interfaceCalls, checker, mod);
+
+	// `error.Error()` is reached implicitly by fmt verbs and errors.Is, so
+	// the dispatcher must exist even when user code never calls it.
+	if (mod.hasErrorType && !interfaceCalls.has("error.Error")) {
+		interfaceCalls.set("error.Error", {
+			ifaceName: "error",
+			ifaceType: checker?.types?.get("error") ?? {
+				kind: "interface",
+				name: "error",
+			},
+			methodName: "Error",
+			methodSig: {
+				kind: "func",
+				params: [],
+				returns: [{ kind: "basic", name: "string" }],
+			},
+		});
+	}
+
+	const hasIo = importsAnyOf(progs, [
+		"io",
+		"fmt",
+		"strings",
+		"bytes",
+		"crypto/sha256",
+		"sha256",
+		"encoding/binary",
+		"binary",
+		"encoding/hex",
+		"hex",
+		"encoding/base64",
+		"base64",
+	]);
+	if (hasIo) {
+		const byteSliceType = {
+			kind: "slice",
+			elem: { kind: "basic", name: "byte" },
+		};
+		const intErrReturns = [
+			{ kind: "basic", name: "int" },
+			{ kind: "interface", name: "error" },
+		];
+		if (!interfaceCalls.has("io.Reader.Read")) {
+			interfaceCalls.set("io.Reader.Read", {
+				ifaceName: "io.Reader",
+				ifaceType: checker?.types?.get("io.Reader"),
+				methodName: "Read",
+				methodSig: {
+					kind: "func",
+					params: [byteSliceType],
+					returns: intErrReturns,
+				},
+			});
+		}
+		if (!interfaceCalls.has("io.Writer.Write")) {
+			interfaceCalls.set("io.Writer.Write", {
+				ifaceName: "io.Writer",
+				ifaceType: checker?.types?.get("io.Writer"),
+				methodName: "Write",
+				methodSig: {
+					kind: "func",
+					params: [byteSliceType],
+					returns: intErrReturns,
+				},
+			});
+		}
+	}
+
+	for (const info of interfaceCalls.values()) {
+		funcDecls.push(_makeInterfaceDispatcher(info, checker));
+	}
+}
+
+function _registerIoSyntheticMethods(funcDecls, mod, strType, programs) {
+	const progs = Array.isArray(programs) ? programs : [programs];
+	const hasStrings = importsAnyOf(progs, ["strings"]);
+	const hasBytes = importsAnyOf(progs, ["bytes"]);
+	const hasIo = importsAnyOf(progs, ["io"]);
+
+	const BYTE_SLICE_T = {
+		kind: "slice",
+		elem: { kind: "basic", name: "byte" },
+	};
+	const INT_T = { kind: "basic", name: "int" };
+	const ERR_T = { kind: "interface", name: "error" };
+	const INT_ERR_RET = { kind: "tuple", types: [INT_T, ERR_T] };
+	const ioHelper = (name, params, returnType, kind, extra = {}) => ({
+		kind: "FuncDecl",
+		name,
+		params,
+		returnType,
+		body: { kind: "Block", stmts: [], list: [] },
+		_isIoHelper: kind,
+		_rootFuncDecl: null,
+		...extra,
+	});
+
+	if (hasStrings && mod.structTypes.has("strings.Builder")) {
+		const bPtr = {
+			kind: "pointer",
+			base: { kind: "named", name: "strings.Builder" },
+		};
+		funcDecls.push(
+			ioHelper(
+				"strings.Builder.Write",
+				[
+					{ name: "b", type: bPtr },
+					{ name: "p", type: BYTE_SLICE_T },
+				],
+				INT_ERR_RET,
+				"builder_write",
+				{
+					_isMethod: true,
+					_recvTypeName: "strings.Builder",
+					_methodName: "Write",
+				},
+			),
+			ioHelper(
+				"strings.Builder.WriteString",
+				[
+					{ name: "b", type: bPtr },
+					{ name: "s", type: strType },
+				],
+				INT_ERR_RET,
+				"builder_write_string",
+				{
+					_isMethod: true,
+					_recvTypeName: "strings.Builder",
+					_methodName: "WriteString",
+				},
+			),
+		);
+	}
+	if (hasBytes && mod.structTypes.has("bytes.Buffer")) {
+		const bPtr = {
+			kind: "pointer",
+			base: { kind: "named", name: "bytes.Buffer" },
+		};
+		funcDecls.push(
+			ioHelper(
+				"bytes.Buffer.Write",
+				[
+					{ name: "b", type: bPtr },
+					{ name: "p", type: BYTE_SLICE_T },
+				],
+				INT_ERR_RET,
+				"buffer_write",
+				{
+					_isMethod: true,
+					_recvTypeName: "bytes.Buffer",
+					_methodName: "Write",
+				},
+			),
+			ioHelper(
+				"bytes.Buffer.WriteString",
+				[
+					{ name: "b", type: bPtr },
+					{ name: "s", type: strType },
+				],
+				INT_ERR_RET,
+				"buffer_write_string",
+				{
+					_isMethod: true,
+					_recvTypeName: "bytes.Buffer",
+					_methodName: "WriteString",
+				},
+			),
+			ioHelper(
+				"bytes.Buffer.Read",
+				[
+					{ name: "b", type: bPtr },
+					{ name: "p", type: BYTE_SLICE_T },
+				],
+				INT_ERR_RET,
+				"buffer_read",
+				{
+					_isMethod: true,
+					_recvTypeName: "bytes.Buffer",
+					_methodName: "Read",
+				},
+			),
+		);
+	}
+	if (hasStrings && mod.structTypes.has("strings.Reader")) {
+		const rPtr = {
+			kind: "pointer",
+			base: { kind: "named", name: "strings.Reader" },
+		};
+		funcDecls.push(
+			ioHelper(
+				"strings.Reader.Read",
+				[
+					{ name: "r", type: rPtr },
+					{ name: "p", type: BYTE_SLICE_T },
+				],
+				INT_ERR_RET,
+				"strings_reader_read",
+				{
+					_isMethod: true,
+					_recvTypeName: "strings.Reader",
+					_methodName: "Read",
+				},
+			),
+			ioHelper(
+				"strings.Reader.Len",
+				[{ name: "r", type: rPtr }],
+				INT_T,
+				"strings_reader_len",
+				{
+					_isMethod: true,
+					_recvTypeName: "strings.Reader",
+					_methodName: "Len",
+				},
+			),
+			ioHelper(
+				"strings.Reader.Reset",
+				[
+					{ name: "r", type: rPtr },
+					{ name: "s", type: strType },
+				],
+				null,
+				"strings_reader_reset",
+				{
+					_isMethod: true,
+					_recvTypeName: "strings.Reader",
+					_methodName: "Reset",
+				},
+			),
+		);
+	}
+	if (hasBytes && mod.structTypes.has("bytes.Reader")) {
+		const rPtr = {
+			kind: "pointer",
+			base: { kind: "named", name: "bytes.Reader" },
+		};
+		funcDecls.push(
+			ioHelper(
+				"bytes.Reader.Read",
+				[
+					{ name: "r", type: rPtr },
+					{ name: "p", type: BYTE_SLICE_T },
+				],
+				INT_ERR_RET,
+				"bytes_reader_read",
+				{ _isMethod: true, _recvTypeName: "bytes.Reader", _methodName: "Read" },
+			),
+			ioHelper(
+				"bytes.Reader.Len",
+				[{ name: "r", type: rPtr }],
+				INT_T,
+				"bytes_reader_len",
+				{ _isMethod: true, _recvTypeName: "bytes.Reader", _methodName: "Len" },
+			),
+			ioHelper(
+				"bytes.Reader.Reset",
+				[
+					{ name: "r", type: rPtr },
+					{ name: "b", type: BYTE_SLICE_T },
+				],
+				null,
+				"bytes_reader_reset",
+				{
+					_isMethod: true,
+					_recvTypeName: "bytes.Reader",
+					_methodName: "Reset",
+				},
+			),
+		);
+	}
+	if (hasIo && mod.structTypes.has("io.discard")) {
+		const dPtr = {
+			kind: "pointer",
+			base: { kind: "named", name: "io.discard" },
+		};
+		funcDecls.push(
+			ioHelper(
+				"io.discard.Write",
+				[
+					{ name: "d", type: dPtr },
+					{ name: "p", type: BYTE_SLICE_T },
+				],
+				INT_ERR_RET,
+				"discard_write",
+				{ _isMethod: true, _recvTypeName: "io.discard", _methodName: "Write" },
+			),
+			ioHelper(
+				"io.discard.WriteString",
+				[
+					{ name: "d", type: dPtr },
+					{ name: "s", type: strType },
+				],
+				INT_ERR_RET,
+				"discard_write_string",
+				{
+					_isMethod: true,
+					_recvTypeName: "io.discard",
+					_methodName: "WriteString",
+				},
+			),
+		);
+	}
+	if (hasIo && mod.structTypes.has("io.LimitedReader")) {
+		const lrPtr = {
+			kind: "pointer",
+			base: { kind: "named", name: "io.LimitedReader" },
+		};
+		funcDecls.push(
+			ioHelper(
+				"io.LimitedReader.Read",
+				[
+					{ name: "l", type: lrPtr },
+					{ name: "p", type: BYTE_SLICE_T },
+				],
+				INT_ERR_RET,
+				"limited_reader_read",
+				{
+					_isMethod: true,
+					_recvTypeName: "io.LimitedReader",
+					_methodName: "Read",
+				},
+			),
+		);
+	}
+	const hasSha256 = importsAnyOf(progs, ["crypto/sha256", "sha256"]);
+	if (
+		hasSha256 &&
+		(mod.structTypes.has("sha256.digest") ||
+			mod.structTypes.has("crypto/sha256.digest"))
+	) {
+		const dPtr = {
+			kind: "pointer",
+			base: { kind: "named", name: "sha256.digest" },
+		};
+		funcDecls.push(
+			ioHelper(
+				"sha256.digest.Write",
+				[
+					{ name: "d", type: dPtr },
+					{ name: "p", type: BYTE_SLICE_T },
+				],
+				INT_ERR_RET,
+				"sha256_write",
+				{
+					_isMethod: true,
+					_recvTypeName: "sha256.digest",
+					_methodName: "Write",
+				},
+			),
+			ioHelper(
+				"sha256.digest.Sum",
+				[
+					{ name: "d", type: dPtr },
+					{ name: "b", type: BYTE_SLICE_T },
+				],
+				BYTE_SLICE_T,
+				"sha256_sum",
+				{ _isMethod: true, _recvTypeName: "sha256.digest", _methodName: "Sum" },
+			),
+			ioHelper(
+				"sha256.digest.Reset",
+				[{ name: "d", type: dPtr }],
+				null,
+				"sha256_reset",
+				{
+					_isMethod: true,
+					_recvTypeName: "sha256.digest",
+					_methodName: "Reset",
+				},
+			),
+			ioHelper(
+				"sha256.digest.Size",
+				[{ name: "d", type: dPtr }],
+				INT_T,
+				"sha256_size",
+				{
+					_isMethod: true,
+					_recvTypeName: "sha256.digest",
+					_methodName: "Size",
+				},
+			),
+			ioHelper(
+				"sha256.digest.BlockSize",
+				[{ name: "d", type: dPtr }],
+				INT_T,
+				"sha256_block_size",
+				{
+					_isMethod: true,
+					_recvTypeName: "sha256.digest",
+					_methodName: "BlockSize",
+				},
+			),
+		);
+	}
+}