gofront 1.5.1 → 1.6.0

package/src/backend/wasm/index.js

@@ -10,15 +10,94 @@ import {
 	collectBoundaryMeta,
 	generateFacade,
 	scanBoundaryImports,
+	wTypeKey,
 } from "./boundary.js";
 import { FunctionEmitter } from "./emit.js";
+import { BINARY_MATH_IMPORTS } from "./emit-stdlib.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 {
+	ERROR_STRUCT,
+	getFuncSignature,
+	getMapKeyValTypes,
+	getReceiverTypeName,
+	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"]);
+// 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",
+]);
+
+function importsAnyOf(programs, pkgs) {
+	return (programs ?? []).some((p) =>
+		(p.imports ?? []).some((decl) =>
+			(decl.imports ?? [decl]).some((imp) => pkgs.has(imp.path)),
+		),
+	);
+}
 
-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_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_title", [S], [S]],
+	["str_split", [S, S], ["i32"]],
+	["str_fields", [S], ["i32"]],
+	["str_part", ["i32"], [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_format_float", ["f64", "i32", "i32", "i32"], [S]],
+	["strconv_format_int", ["i64", "i32"], [S]],
+	["strconv_quote", [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], []],
+	// testing.T.Run: the harness calls back into the exported __testing_run_cb
+	["testing_run", [S, S, "anyref"], ["i32"]],
+];
+
+class ModuleEmitter {
 	constructor(checker, lowerResult = null, programs = [], options = {}) {
 		this.checker = checker;
 		this.lowerResult = lowerResult;
@@ -37,6 +116,9 @@ export class ModuleEmitter {
 		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 +136,18 @@ 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);
+		this.usesStdlibEnv = importsAnyOf(programs, STDLIB_ENV_PKGS);
+
 		if (programs && programs.length > 0) {
 			this.initTypes(programs);
 		}
@@ -73,6 +162,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 +239,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();
@@ -308,6 +412,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 +604,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 +624,35 @@ 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.getTestingCallImportIndex();
+		this.getTestingNameImportIndex();
+		this.getTestingFlagImportIndex();
+		for (const t of ["i32", "i64", "f32", "f64", "externref", "anyref"]) {
+			this.getTestingArgImportIndex(t, false);
+		}
+		this.getTestingArgImportIndex("i32", true);
+		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 +677,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 +696,114 @@ 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;
+	}
+
+	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 +861,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");
 	}
@@ -535,7 +904,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 +963,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,11 +1047,166 @@ export class ModuleEmitter {
 		return this.getOrAddFuncImport("env", "is_string", ["anyref"], ["i32"]);
 	}
 
+	getStringHashImportIndex() {
+		return this.getOrAddFuncImport("env", "str_hash", ["externref"], ["i32"]);
+	}
+
+	getStringToUpperImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_to_upper",
+			["externref"],
+			["externref"],
+		);
+	}
+
+	getStringToLowerImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_to_lower",
+			["externref"],
+			["externref"],
+		);
+	}
+
+	getStringTrimSpaceImportIndex() {
+		return this.getOrAddFuncImport(
+			"env",
+			"str_trim_space",
+			["externref"],
+			["externref"],
+		);
+	}
+
+	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"],
+		);
+	}
+
 	getMathImportIndex(jsName, isBinary = false) {
 		const params = isBinary ? ["f64", "f64"] : ["f64"];
 		return this.getOrAddFuncImport("Math", jsName, params, ["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;
+	}
+
+	// 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;
 	}
@@ -700,9 +1230,220 @@ export class ModuleEmitter {
 	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.getBoxType({ 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.getBoxType({ 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.getBoxType({ 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.getBoxType(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.getBoxType(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 +1509,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 +1537,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 +1565,8 @@ export function compileWasmModule(
 					_sourceDecl: d,
 					_pkgName: pkgName,
 					_pkgTarget: pkgTarget,
+					_srcFile: p._path ?? p._filename ?? null,
+					_line: d._line,
 				};
 				funcDecls.push(normFn);
 			}
@@ -846,6 +1601,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);
@@ -956,7 +1713,352 @@ 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",
+			),
+		);
+	}
+	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 },
+			),
+		);
+	}
+
+	// 1f. Boundary metadata (exported surface of wasm packages)
 	const boundaryMeta = options.boundary
 		? collectBoundaryMeta(progs, funcDecls, mod)
 		: null;
@@ -1009,14 +2111,19 @@ 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 &&
+				(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 +2134,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 +2154,29 @@ 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.body) {
 			emitter.emitFunctionBody(fn.body);
 		}
@@ -1061,6 +2200,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 +2214,7 @@ export function compileWasmModule(
 		facade = generateFacade(boundaryMeta, {
 			stringTable: mod.stringTable,
 			callMain: Boolean(options.callMain) && mod.funcMap.has("main"),
+			stdlibEnv: mod.usesStdlibEnv,
 		});
 	}
 
@@ -1082,18 +2226,41 @@ 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 },
 	};
 }
 
@@ -1122,6 +2289,50 @@ function _collectPackageConsts(progs, mod) {
 	}
 }
 
+// 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.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) {
 	if (!node || typeof node !== "object") return;
 
@@ -1158,6 +2369,9 @@ function _scanImportsInBody(node, mod) {
 				Atan: "atan",
 				Atan2: "atan2",
 				Pow: "pow",
+				Mod: "mod",
+				Hypot: "hypot",
+				Cbrt: "cbrt",
 				Exp: "exp",
 				Log: "log",
 				Log2: "log2",
@@ -1165,7 +2379,7 @@ function _scanImportsInBody(node, mod) {
 				Round: "round",
 			};
 			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 +2391,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(
@@ -1231,6 +2448,46 @@ export function compileWasm(source, options = {}) {
 	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
 	for (const p of progs) {
@@ -1270,34 +2527,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" },
@@ -1411,3 +2641,150 @@ 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 _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);
+
+	// `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" }],
+			},
+		});
+	}
+
+	for (const info of interfaceCalls.values()) {
+		funcDecls.push(_makeInterfaceDispatcher(info, checker));
+	}
+}