gofront 1.4.0 → 1.6.0

package/src/backend/wasm/boundary.js

@@ -0,0 +1,1798 @@
+// src/backend/wasm/boundary.js
+// JS <-> WASM boundary: type classification, marshalling helpers (WASM IR)
+// and the generated JS facade that exposes a wasm package to JS callers.
+//
+// Boundary v1 rules (docs/v1.5.0/wasm-mvp-plan.md, Phase 5):
+//   - primitives: bool <-> i32, narrow ints <-> i32, int/int64 <-> f64 at the
+//     boundary (i64 inside; exact for |v| <= 2^53, which the facade already
+//     enforces, and keeps BigInt boxing off hot paths), floats direct,
+//     string externref, any anyref (crossing as externref).
+//   - every GC reference (struct/array/closure/anyref) crosses as externref
+//     and exports are bound to module-level consts: V8 only inlines JS->wasm
+//     calls (floats unboxed) for const callees with i32/i64/f32/f64/externref
+//     signatures outside try/catch.  Panics are raised through `env.panic`
+//     (a JS Error) rather than a wasm `throw`, so no guard wrapper is needed.
+//   - struct values from `both` packages: copied field-by-field into the JS
+//     copy class (`new T(...)`); `*T` params are copied in and written back.
+//   - struct values from `wasm` packages: opaque handles with stable identity
+//     (class `T` wrapping the WasmGC ref, WeakMap keyed registry).
+//   - slices / arrays: element-wise copy (plain JS arrays on the JS side,
+//     TypedArray inputs accepted). No copy-back for slices.
+//   - func values: JS callbacks wrapped into wasm closures via thunks; wasm
+//     closures exposed to JS as callable functions.
+//   - named non-empty interfaces (Task H5.2): wasm values reach JS as their
+//     handle class / live view when the dynamic type is an exported `*T`,
+//     otherwise as a facade whose methods call the wasm dispatchers.  Only
+//     wasm-owned values (`__ref`) go back in; JS-implemented values are
+//     rejected (no cross-boundary itab proxies).
+//   - maps, anonymous interfaces, error, pointers to non-structs: rejected
+//     with a compile error (planned for a later boundary version).
+//   - `gofront/shared` buffers (Task H6.1): `(base, len)` views over the
+//     module's exported linear memory; JS sees a zero-copy TypedArray over
+//     `memory.buffer`.  Only TypedArrays that already alias that memory (ones
+//     handed out by this facade) may be passed back in.
+//   - `*testing.T`: the harness's JS test object, passed as an opaque
+//     externref (test methods are routed back to JS via `env.testing_*`).
+
+import { HELPER_SPRINTF, HELPER_STRCONV } from "../js/runtime.js";
+import { getSharedInfo, isTestingT } from "./types.js";
+
+// ── Type classification ──────────────────────────────────────
+
+const I32_INTS = new Set([
+	"int8",
+	"int16",
+	"int32",
+	"uint8",
+	"uint16",
+	"uint32",
+	"byte",
+	"rune",
+]);
+const I64_INTS = new Set(["int", "uint", "int64", "uint64", "uintptr"]);
+const UNSIGNED = new Set([
+	"uint",
+	"uint8",
+	"uint16",
+	"uint32",
+	"uint64",
+	"uintptr",
+	"byte",
+]);
+
+export function wTypeKey(wType) {
+	if (typeof wType === "string") return wType;
+	if (wType && typeof wType.typeIndex === "number")
+		return `r${wType.typeIndex}`;
+	return `h${wType?.heapType ?? "any"}`;
+}
+
+function toRef(info) {
+	return { kind: "ref", nullable: true, typeIndex: info.typeIndex };
+}
+
+function structDesc(info, ptr) {
+	return { k: "struct", name: info.name, ptr, info, wType: toRef(info) };
+}
+
+function funcSigFromAst(t) {
+	return {
+		kind: "func",
+		params: (t.params ?? []).map((p) => p.type ?? p),
+		returns: t.returnType
+			? t.returnType.kind === "TupleType" || t.returnType.kind === "tuple"
+				? t.returnType.types
+				: [t.returnType]
+			: [],
+	};
+}
+
+// Classifies a Go type (AST node or checker type) for boundary marshalling.
+// Returns a descriptor `{ k, ... }`; `k === "unsupported"` carries `what`.
+function classifyType(goType, mod) {
+	if (!goType) return { k: "void" };
+	if (isTestingT(goType)) return { k: "extern", wType: "externref" };
+
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const info = mod.getStructType(goType.name);
+		if (info) return structDesc(info, false);
+		const resolved = mod.checker?.types?.get(goType.name);
+		if (resolved) return classifyType(resolved, mod);
+		return classifyBasic(goType.name);
+	}
+
+	const t = normalizeAstType(goType);
+	switch (t.kind) {
+		case "named":
+			return classifyNamed(t, mod);
+		case "shared":
+			return classifyShared(t, mod);
+		case "untyped":
+			return classifyBasic(t.base);
+		case "basic":
+			return classifyBasic(t.name);
+		case "pointer":
+			return classifyPointer(t, mod);
+		case "slice":
+			return classifySlice(t, mod);
+		case "array":
+			return classifyArray(t, mod);
+		case "func":
+			return classifyFunc(t, mod);
+		case "interface":
+			return classifyInterface(t, mod);
+		default:
+			return {
+				k: "unsupported",
+				what: UNSUPPORTED_KINDS[t.kind] ?? `type kind '${t.kind}'`,
+			};
+	}
+}
+
+const UNSUPPORTED_KINDS = {
+	map: "map",
+	MapType: "map",
+	struct: "anonymous struct",
+	StructType: "anonymous struct",
+	InterfaceType: "interface",
+	ChanType: "chan",
+	chan: "chan",
+};
+
+// Maps parser AST type nodes onto the checker's type shapes.
+function normalizeAstType(t) {
+	switch (t.kind) {
+		case "PointerType":
+		case "StarExpr":
+			return { kind: "pointer", base: t.base ?? t.expr ?? t.operand };
+		case "SliceType":
+			return { kind: "slice", elem: t.elem };
+		case "ArrayType":
+			return { kind: "array", elem: t.elem, size: t.size };
+		case "FuncType":
+			return funcSigFromAst(t);
+		case "InterfaceType":
+			return {
+				kind: "interface",
+				name: t.name,
+				methods: new Set((t.methods ?? []).map((m) => m.name ?? m)),
+			};
+		default:
+			return t;
+	}
+}
+
+const BASIC_DESCS = {
+	void: { k: "void" },
+	bool: { k: "bool", wType: "i32" },
+	float32: { k: "f32", wType: "f32" },
+	float64: { k: "f64", wType: "f64" },
+	string: { k: "string", wType: "externref" },
+	any: { k: "any", wType: "anyref" },
+	error: { k: "unsupported", what: "error" },
+};
+
+function classifyBasic(n) {
+	if (I32_INTS.has(n))
+		return { k: "i32", unsigned: UNSIGNED.has(n), wType: "i32" };
+	if (I64_INTS.has(n))
+		return { k: "i64", unsigned: UNSIGNED.has(n), wType: "i64" };
+	const d = BASIC_DESCS[n];
+	return d ? { ...d } : { k: "unsupported", what: `type '${n}'` };
+}
+
+function classifyNamed(t, mod) {
+	const info = mod.getStructType(t.name);
+	if (info) return structDesc(info, false);
+	if (t.underlying) return classifyType(t.underlying, mod);
+	return { k: "unsupported", what: `named type '${t.name}'` };
+}
+
+function classifyPointer(t, mod) {
+	const base = classifyType(t.base, mod);
+	if (base.k === "struct" && !base.ptr) return { ...base, ptr: true };
+	const what = base.k === "unsupported" ? base.what : (t.base?.name ?? base.k);
+	return { k: "unsupported", what: `pointer to ${what}` };
+}
+
+function classifyShared(t, mod) {
+	const info = getSharedInfo(t, mod.checker);
+	return {
+		k: "shared",
+		key: info.key,
+		ctor: info.ctor,
+		bytes: info.bytes,
+		wType: mod.getSharedType().wType,
+	};
+}
+
+function classifySlice(t, mod) {
+	const elem = classifyType(t.elem, mod);
+	if (elem.k === "unsupported") return elem;
+	const sliceInfo = mod.getSliceType(t.elem);
+	return {
+		k: "slice",
+		elem,
+		sliceInfo,
+		key: wTypeKey(sliceInfo.elemWType),
+		wType: { kind: "ref", nullable: true, typeIndex: sliceInfo.typeIndex },
+	};
+}
+
+function arraySize(t) {
+	if (typeof t.size === "number") return t.size;
+	if (t.size?.value !== undefined) return Number(t.size.value);
+	return t.len ?? 0;
+}
+
+function classifyArray(t, mod) {
+	const elem = classifyType(t.elem, mod);
+	if (elem.k === "unsupported") return elem;
+	const arrInfo = mod.getArrayType(t.elem);
+	return {
+		k: "array",
+		elem,
+		size: arraySize(t),
+		arrInfo,
+		key: wTypeKey(arrInfo.elemWType),
+		wType: { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex },
+	};
+}
+
+function classifySig(t, mod) {
+	const params = (t.params ?? []).map((p) => classifyType(p, mod));
+	const returns = (t.returns ?? [])
+		.map((r) => classifyType(r, mod))
+		.filter((d) => d.k !== "void");
+	const bad = [...params, ...returns].find((d) => d.k === "unsupported");
+	return bad ?? { params, returns };
+}
+
+function classifyFunc(t, mod) {
+	const sig = classifySig(t, mod);
+	if (sig.k === "unsupported") return sig;
+	const closureInfo = mod.getClosureType(t);
+	return {
+		k: "func",
+		params: sig.params,
+		returns: sig.returns,
+		closureInfo,
+		key: `c${closureInfo.typeIndex}`,
+		wType: { kind: "ref", nullable: true, typeIndex: closureInfo.typeIndex },
+	};
+}
+
+function classifyInterface(t, mod) {
+	if (t.name === "error") return { k: "unsupported", what: "error" };
+	if (!t.methods || t.methods.size === 0) return { k: "any", wType: "anyref" };
+	if (!t.name || !(t.methods instanceof Map))
+		return { k: "unsupported", what: "anonymous interface" };
+	mod._boundaryIfaces ??= new Map();
+	return mod._boundaryIfaces.get(t.name) ?? classifyNamedInterface(t, mod);
+}
+
+function classifyNamedInterface(t, mod) {
+	const desc = {
+		k: "iface",
+		name: t.name,
+		key: t.name,
+		wType: "anyref",
+		methods: [],
+		concrete: [],
+	};
+	// Cached before the walk so self-referencing method signatures terminate.
+	mod._boundaryIfaces.set(t.name, desc);
+	for (const [mName, sigType] of t.methods) {
+		const sig = classifySig(sigType, mod);
+		if (sig.k === "unsupported") {
+			const err = {
+				k: "unsupported",
+				what: `${sig.what} (in method ${t.name}.${mName})`,
+			};
+			mod._boundaryIfaces.set(t.name, err);
+			return err;
+		}
+		desc.methods.push({
+			name: mName,
+			dispatch: `__dispatch_${t.name}_${mName}`,
+			...sig,
+		});
+	}
+	return desc;
+}
+
+// ── Export metadata ──────────────────────────────────────────
+
+function isExported(name) {
+	return name[0] >= "A" && name[0] <= "Z";
+}
+
+function returnDescs(returnType, mod) {
+	if (!returnType) return [];
+	const list =
+		returnType.kind === "TupleType" || returnType.kind === "tuple"
+			? returnType.types
+			: [returnType];
+	return list.map((t) => classifyType(t, mod)).filter((d) => d.k !== "void");
+}
+
+function literalConst(spec, i) {
+	let node = spec.value?.[i];
+	let sign = "";
+	if (node?.kind === "UnaryExpr" && node.op === "-" && node.operand) {
+		node = node.operand;
+		sign = "-";
+	}
+	if (node?.kind !== "BasicLit") return null;
+	switch (node.litKind) {
+		case "INT":
+		case "FLOAT":
+			return `${sign}${node.value}`;
+		case "STRING":
+			return JSON.stringify(String(node.value));
+		case "BOOL":
+			return node.value === "true" ? "true" : "false";
+		default:
+			return null;
+	}
+}
+
+function unsupportedMsg(where, what) {
+	return `${where}: ${what} is not yet supported across the wasm boundary (planned)`;
+}
+
+// Builds the boundary metadata for every exported symbol of `wasm`-target
+// packages (plus struct descriptors of `both` packages they expose).
+// Throws a compile error for unsupported boundary types.
+export function collectBoundaryMeta(progs, funcDecls, mod) {
+	const meta = {
+		structs: [],
+		funcs: [],
+		consts: [],
+		vars: [], // exported package-level shared buffers of wasm packages
+		structByName: new Map(),
+		_mod: mod,
+	};
+	const errors = [];
+
+	for (const p of progs) {
+		const pkgName = p.pkg?.name ?? "main";
+		const pkgTarget = p.target ?? "wasm";
+		for (const d of p.decls ?? []) {
+			if (d.kind === "TypeDecl" && d.type?.kind === "StructType") {
+				collectStructDecl(d, pkgName, pkgTarget, meta, mod);
+			} else if (d.kind === "ConstDecl" && pkgTarget === "wasm") {
+				collectConstDecl(d, pkgName, meta, errors);
+			} else if (d.kind === "VarDecl" && pkgTarget === "wasm") {
+				collectSharedVarDecl(d, meta, mod);
+			}
+		}
+	}
+
+	for (const fn of funcDecls) {
+		if (fn._isClosure || fn._pkgTarget !== "wasm") continue;
+		if (fn._isMethod) collectMethodMeta(fn, meta, errors, mod);
+		else collectFuncMeta(fn, meta, errors, mod);
+	}
+
+	if (errors.length > 0) throw new Error([...new Set(errors)].join("\n"));
+	return meta;
+}
+
+function collectStructDecl(d, pkgName, pkgTarget, meta, mod) {
+	if (!isExported(d.name) || meta.structByName.has(d.name)) return;
+	const info = mod.getStructType(d.name);
+	if (!info) return;
+	const s = { name: d.name, pkgName, pkgTarget, info, methods: [] };
+	meta.structs.push(s);
+	meta.structByName.set(d.name, s);
+}
+
+function collectConstDecl(d, pkgName, meta, errors) {
+	for (const spec of d.decls ?? []) {
+		for (let i = 0; i < spec.names.length; i++) {
+			const name = spec.names[i];
+			if (!isExported(name)) continue;
+			const value = literalConst(spec, i);
+			if (value !== null) meta.consts.push({ name, value });
+			else
+				errors.push(
+					unsupportedMsg(
+						`${pkgName}.${name}`,
+						"a constant with a non-literal value",
+					),
+				);
+		}
+	}
+}
+
+function checkDesc(desc, where, errors) {
+	if (desc.k === "unsupported") errors.push(unsupportedMsg(where, desc.what));
+	return desc;
+}
+
+// Exported `var Buf = shared.NewFloat32(n)` globals are exposed to JS as
+// TypedArray views (read once after instantiation; sizing is fixed).
+function collectSharedVarDecl(d, meta, mod) {
+	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];
+			if (!isExported(name)) continue;
+			const goType = spec.type ?? values[i]?._type;
+			if (!getSharedInfo(goType, mod.checker)) continue;
+			meta.vars.push({ name, desc: classifyType(goType, mod) });
+		}
+	}
+}
+
+function collectMethodMeta(fn, meta, errors, mod) {
+	if (!isExported(fn._methodName)) return;
+	const s = meta.structByName.get(fn._recvTypeName);
+	if (!s) return;
+	const where = `${fn._recvTypeName}.${fn._methodName}`;
+	s.methods.push({
+		name: fn._methodName,
+		exportName: fn._exportName,
+		fnName: fn.name,
+		ptrRecv: fn.params[0].type?.kind === "pointer",
+		params: fn.params
+			.slice(1)
+			.map((p) => checkDesc(classifyType(p.type, mod), where, errors)),
+		returns: returnDescs(fn.returnType, mod).map((d) =>
+			checkDesc(d, where, errors),
+		),
+	});
+}
+
+function collectFuncMeta(fn, meta, errors, mod) {
+	if (!isExported(fn.name)) return;
+	const where = `${fn._pkgName}.${fn.name}`;
+	meta.funcs.push({
+		name: fn.name,
+		exportName: fn.name,
+		pkgName: fn._pkgName,
+		params: (fn.params ?? []).map((p) =>
+			checkDesc(classifyType(p.type, mod), where, errors),
+		),
+		returns: returnDescs(fn.returnType, mod).map((d) =>
+			checkDesc(d, where, errors),
+		),
+	});
+}
+
+// ── Descriptor walk ──────────────────────────────────────────
+
+function visitStructNeed(desc, needs, errors, mod) {
+	if (needs.structs.has(desc.name)) return;
+	const entry = { info: desc.info, fields: [] };
+	needs.structs.set(desc.name, entry);
+	for (const f of desc.info.fields) {
+		const fd = classifyType(f.goType, mod);
+		if (fd.k === "unsupported")
+			errors.push(unsupportedMsg(`${desc.name}.${f.name}`, fd.what));
+		entry.fields.push({ name: f.name, desc: fd });
+		visitNeed(fd, needs, errors, mod);
+	}
+}
+
+function visitNeed(desc, needs, errors, mod) {
+	if (!desc || desc.k === "void") return;
+	switch (desc.k) {
+		case "struct":
+			visitStructNeed(desc, needs, errors, mod);
+			return;
+		case "slice":
+		case "array": {
+			const map = desc.k === "slice" ? needs.slices : needs.arrays;
+			if (map.has(desc.key)) return;
+			map.set(desc.key, desc);
+			visitNeed(desc.elem, needs, errors, mod);
+			return;
+		}
+		case "func":
+			if (needs.funcs.has(desc.key)) return;
+			needs.funcs.set(desc.key, desc);
+			visitSignatureNeeds(desc, needs, errors, mod);
+			return;
+		case "iface":
+			if (needs.ifaces.has(desc.key)) return;
+			needs.ifaces.set(desc.key, desc);
+			for (const m of desc.methods) visitSignatureNeeds(m, needs, errors, mod);
+			return;
+		case "shared":
+			needs.shared = true;
+			return;
+		default:
+			return;
+	}
+}
+
+// Exported `*T` types (already on the boundary surface) whose JS class exposes
+// every interface method: such values reach JS as the handle / live view
+// itself, so type switches and identity still work.  `__itag` matches by
+// `ref.test`, so a struct is only chosen for values that really hold it.
+function concreteCandidates(desc, needs, meta, mod) {
+	const out = [];
+	for (const [name, { info }] of needs.structs) {
+		const both = info.pkgTarget === "both";
+		const names = both
+			? [...(mod.checker?.types?.get(name)?.underlying?.methods?.keys() ?? [])]
+			: (meta.structByName.get(name)?.methods ?? []).map((m) => m.name);
+		const have = new Set(names);
+		if (!desc.methods.every((m) => have.has(m.name))) continue;
+		out.push({ name, typeIndex: info.typeIndex, both });
+	}
+	return out;
+}
+
+function visitSignatureNeeds(sig, needs, errors, mod) {
+	for (const p of sig.params) visitNeed(p, needs, errors, mod);
+	for (const r of sig.returns) visitNeed(r, needs, errors, mod);
+}
+
+// Collects every descriptor reachable from the exported surface so helpers are
+// emitted once per struct / slice key / array key / closure key.
+function collectNeeds(meta) {
+	const mod = meta._mod;
+	const needs = {
+		structs: new Map(), // name -> { info, fields: [{ name, desc }] }
+		slices: new Map(), // key -> desc
+		arrays: new Map(), // key -> desc
+		funcs: new Map(), // key -> desc
+		ifaces: new Map(), // interface name -> desc
+		shared: false, // any shared buffer on the surface
+	};
+	const errors = [];
+	for (const s of meta.structs) {
+		if (s.pkgTarget === "wasm")
+			visitNeed(structDesc(s.info, false), needs, errors, mod);
+		for (const m of s.methods) visitSignatureNeeds(m, needs, errors, mod);
+	}
+	for (const f of meta.funcs) visitSignatureNeeds(f, needs, errors, mod);
+	for (const v of meta.vars ?? []) visitNeed(v.desc, needs, errors, mod);
+	if (errors.length > 0) throw new Error([...new Set(errors)].join("\n"));
+	for (const desc of needs.ifaces.values())
+		desc.concrete = concreteCandidates(desc, needs, meta, mod);
+	return needs;
+}
+
+// ── WASM-side helpers ────────────────────────────────────────
+
+// Pre-lock: registers env imports for JS callbacks (`__invoke$<key>`).
+export function scanBoundaryImports(mod, meta) {
+	const needs = collectNeeds(meta);
+	meta._needs = needs;
+	for (const [key, desc] of needs.funcs) {
+		mod.getOrAddFuncImport(
+			"env",
+			`__invoke$${key}`,
+			["externref", ...desc.closureInfo.paramWTypes.map(extType)],
+			desc.closureInfo.returnWTypes.map(extType),
+		);
+	}
+}
+
+// Boundary representation of a wasm value type.  i64 crosses as f64 so JS
+// never sees (or allocates) a BigInt for Go `int`; every GC reference (struct,
+// array, closure, anyref) crosses as externref.  V8 only inlines the
+// JS→wasm wrapper (passing f32/f64 unboxed) when the signature holds nothing
+// but i32/i64/f32/f64/externref: a single anyref or `(ref $T)` in the
+// signature costs a 16-byte HeapNumber per float argument and result.
+function isGcRef(wType) {
+	return wType === "anyref" || (typeof wType === "object" && wType !== null);
+}
+function extType(wType) {
+	if (wType === "i64") return "f64";
+	if (isGcRef(wType)) return "externref";
+	return wType;
+}
+function needsConv(wTypes) {
+	return wTypes.some((w) => w === "i64" || isGcRef(w));
+}
+// Instructions converting the value on the stack from its boundary form.
+function fromExt(wType) {
+	if (wType === "i64") return [{ op: "i64.trunc_sat_f64_s" }];
+	if (wType === "anyref") return [{ op: "any.convert_extern" }];
+	if (isGcRef(wType)) {
+		const out = [{ op: "any.convert_extern" }];
+		if (wType.typeIndex !== undefined)
+			out.push({ op: "ref.cast_null", typeIndex: wType.typeIndex });
+		return out;
+	}
+	return [];
+}
+// Instructions converting the value on the stack to its boundary form.
+function toExt(wType) {
+	if (wType === "i64") return [{ op: "f64.convert_i64_s" }];
+	if (isGcRef(wType)) return [{ op: "extern.convert_any" }];
+	return [];
+}
+// Rewrites the values on top of the stack (types `wTypes`) with `conv`,
+// spilling through locals starting at `localBase` when more than one.
+function convertResults(wTypes, conv, localBase) {
+	if (wTypes.length === 0 || !needsConv(wTypes)) return [];
+	if (wTypes.length === 1) return conv(wTypes[0]);
+	const out = [];
+	for (let i = wTypes.length - 1; i >= 0; i--)
+		out.push({ op: "local.set", index: localBase + i });
+	for (let i = 0; i < wTypes.length; i++)
+		out.push({ op: "local.get", index: localBase + i }, ...conv(wTypes[i]));
+	return out;
+}
+
+function zeroInstr(wType) {
+	if (wType === "i64") return { op: "i64.const", value: 0n };
+	if (wType === "f32" || wType === "f64")
+		return { op: `${wType}.const`, value: 0 };
+	if (typeof wType === "object" && wType !== null) {
+		return {
+			op: "ref.null",
+			heapType: wType.typeIndex ?? wType.heapType ?? "any",
+		};
+	}
+	if (wType === "externref") return { op: "ref.null", heapType: "extern" };
+	if (wType === "anyref") return { op: "ref.null", heapType: "any" };
+	return { op: "i32.const", value: 0 };
+}
+
+// Type entry at a flat type index (rec groups hold several entries each).
+function typeAt(mod, index) {
+	if (index === undefined) return null;
+	let i = 0;
+	for (const entry of mod.types) {
+		const group = entry.form === "rec" ? entry.types : [entry];
+		if (index < i + group.length) return group[index - i];
+		i += group.length;
+	}
+	return null;
+}
+
+// Post user functions: appends marshalling helper functions and exports them.
+export function addBoundaryHelpers(mod, meta) {
+	const needs = meta._needs ?? collectNeeds(meta);
+	const importFuncCount = mod.imports.filter((i) => i.kind === "func").length;
+
+	const addFunc = (
+		name,
+		params,
+		results,
+		body,
+		exported = true,
+		locals = [],
+	) => {
+		const idx = importFuncCount + mod.funcs.length;
+		const typeIndex = mod.getTypeIndex(params, results);
+		mod.funcs.push({
+			typeIndex,
+			locals,
+			body: [...body, { op: "return" }],
+		});
+		mod.funcMap.set(name, idx);
+		if (exported) mod.exports.push({ name, kind: "func", index: idx });
+		return idx;
+	};
+	const get = (i) => ({ op: "local.get", index: i });
+	// Parameter `i` converted from its boundary form.
+	const getIn = (i, wType) => [get(i), ...fromExt(wType)];
+	const EXT = "externref";
+
+	for (const [name, { info }] of needs.structs) {
+		const ref = toRef(info);
+		const ti = info.typeIndex;
+		const fieldWTypes = info.fields.map((f) => f.wType);
+		addFunc(
+			`__new_${name}`,
+			fieldWTypes.map(extType),
+			[EXT],
+			[
+				...fieldWTypes.flatMap((w, i) => getIn(i, w)),
+				{ op: "struct.new", typeIndex: ti },
+				...toExt(ref),
+			],
+		);
+		addFunc(
+			`__zero_${name}`,
+			[],
+			[EXT],
+			[
+				...fieldWTypes.map((w) => zeroInstr(w)),
+				{ op: "struct.new", typeIndex: ti },
+				...toExt(ref),
+			],
+		);
+		addFunc(
+			`__clone_${name}`,
+			[EXT],
+			[EXT],
+			[
+				...fieldWTypes.flatMap((_, i) => [
+					...getIn(0, ref),
+					{ op: "struct.get", typeIndex: ti, fieldIndex: i },
+				]),
+				{ op: "struct.new", typeIndex: ti },
+				...toExt(ref),
+			],
+		);
+		for (let i = 0; i < info.fields.length; i++) {
+			const f = info.fields[i];
+			addFunc(
+				`__get_${name}_${f.name}`,
+				[EXT],
+				[extType(f.wType)],
+				[
+					...getIn(0, ref),
+					{ op: "struct.get", typeIndex: ti, fieldIndex: i },
+					...toExt(f.wType),
+				],
+			);
+			addFunc(
+				`__set_${name}_${f.name}`,
+				[EXT, extType(f.wType)],
+				[],
+				[
+					...getIn(0, ref),
+					...getIn(1, f.wType),
+					{ op: "struct.set", typeIndex: ti, fieldIndex: i },
+				],
+			);
+		}
+	}
+
+	for (const [key, desc] of needs.arrays) {
+		const { arrInfo } = desc;
+		const ref = desc.wType;
+		addFunc(
+			`__array_new_${key}`,
+			["i32"],
+			[EXT],
+			[
+				get(0),
+				{ op: "array.new_default", typeIndex: arrInfo.typeIndex },
+				...toExt(ref),
+			],
+		);
+		addFunc(
+			`__array_len_${key}`,
+			[EXT],
+			["i32"],
+			[...getIn(0, ref), { op: "array.len" }],
+		);
+		addFunc(
+			`__array_get_${key}`,
+			[EXT, "i32"],
+			[extType(arrInfo.elemWType)],
+			[
+				...getIn(0, ref),
+				get(1),
+				{ op: "array.get", typeIndex: arrInfo.typeIndex },
+				...toExt(arrInfo.elemWType),
+			],
+		);
+		addFunc(
+			`__array_set_${key}`,
+			[EXT, "i32", extType(arrInfo.elemWType)],
+			[],
+			[
+				...getIn(0, ref),
+				get(1),
+				...getIn(2, arrInfo.elemWType),
+				{ op: "array.set", typeIndex: arrInfo.typeIndex },
+			],
+		);
+	}
+
+	for (const [key, desc] of needs.slices) {
+		const { sliceInfo } = desc;
+		const ref = desc.wType;
+		const arrTI = sliceInfo.arrInfo.typeIndex;
+		const sTI = sliceInfo.typeIndex;
+		const elemAddr = [
+			...getIn(0, ref),
+			{ op: "struct.get", typeIndex: sTI, fieldIndex: 0 },
+			...getIn(0, ref),
+			{ op: "struct.get", typeIndex: sTI, fieldIndex: 1 },
+			get(1),
+			{ op: "i32.add" },
+		];
+		addFunc(
+			`__slice_new_${key}`,
+			["i32"],
+			[EXT],
+			[
+				get(0),
+				{ op: "array.new_default", typeIndex: arrTI },
+				{ op: "i32.const", value: 0 },
+				get(0),
+				get(0),
+				{ op: "struct.new", typeIndex: sTI },
+				...toExt(ref),
+			],
+		);
+		addFunc(
+			`__slice_len_${key}`,
+			[EXT],
+			["i32"],
+			[...getIn(0, ref), { op: "struct.get", typeIndex: sTI, fieldIndex: 2 }],
+		);
+		addFunc(
+			`__slice_get_${key}`,
+			[EXT, "i32"],
+			[extType(sliceInfo.elemWType)],
+			[
+				...elemAddr,
+				{ op: "array.get", typeIndex: arrTI },
+				...toExt(sliceInfo.elemWType),
+			],
+		);
+		addFunc(
+			`__slice_nil_${key}`,
+			[],
+			[EXT],
+			[{ op: "global.get", index: sliceInfo.emptyGlobalIndex }, ...toExt(ref)],
+		);
+		addFunc(
+			`__slice_is_nil_${key}`,
+			[EXT],
+			["i32"],
+			[
+				...getIn(0, ref),
+				{ op: "struct.get", typeIndex: sTI, fieldIndex: 0 },
+				{ op: "ref.is_null" },
+			],
+		);
+		addFunc(
+			`__slice_set_${key}`,
+			[EXT, "i32", extType(sliceInfo.elemWType)],
+			[],
+			[
+				...elemAddr,
+				...getIn(2, sliceInfo.elemWType),
+				{ op: "array.set", typeIndex: arrTI },
+			],
+		);
+	}
+
+	for (const [key, desc] of needs.funcs) {
+		const ci = desc.closureInfo;
+		const invokeIdx = mod.importCache.get(`env.__invoke$${key}`);
+		const nParams = ci.paramWTypes.length;
+		// Thunk: wasm closure body calling the JS callback (boundary forms out, back in).
+		const thunkIdx = addFunc(
+			`__jsthunk$${key}`,
+			["anyref", ...ci.paramWTypes],
+			ci.returnWTypes,
+			[
+				get(0),
+				{ op: "extern.convert_any" },
+				...ci.paramWTypes.flatMap((w, i) => [get(i + 1), ...toExt(w)]),
+				{ op: "call", funcIndex: invokeIdx },
+				...convertResults(ci.returnWTypes, fromExt, nParams + 1),
+			],
+			false,
+			ci.returnWTypes.length > 1 ? ci.returnWTypes.map(extType) : [],
+		);
+		mod.addRefFuncElement(thunkIdx);
+		addFunc(
+			`__wrap_fn$${key}`,
+			[EXT],
+			[EXT],
+			[
+				{ op: "ref.func", funcIndex: thunkIdx },
+				get(0),
+				{ op: "any.convert_extern" },
+				{ op: "struct.new", typeIndex: ci.typeIndex },
+				...toExt(desc.wType),
+			],
+		);
+		// JS calling a wasm closure (boundary forms in, results out).
+		addFunc(
+			`__call_fn$${key}`,
+			[EXT, ...ci.paramWTypes.map(extType)],
+			ci.returnWTypes.map(extType),
+			[
+				...getIn(0, desc.wType),
+				{ op: "struct.get", typeIndex: ci.typeIndex, fieldIndex: 1 },
+				...ci.paramWTypes.flatMap((w, i) => getIn(i + 1, w)),
+				...getIn(0, desc.wType),
+				{ op: "struct.get", typeIndex: ci.typeIndex, fieldIndex: 0 },
+				{ op: "call_ref", typeIndex: ci.funcTypeIndex },
+				...convertResults(ci.returnWTypes, toExt, nParams + 1),
+			],
+			true,
+			ci.returnWTypes.length > 1 ? ci.returnWTypes : [],
+		);
+	}
+
+	// Exported user functions / methods whose signature carries i64 or GC refs
+	// get a trampoline (`__x_<export>`) with the boundary signature; the facade
+	// calls that instead of the raw export.
+	const addTrampoline = (entry) => {
+		// Methods are keyed `T.M` in funcMap but exported as `T_M`.
+		const fnIdx = mod.funcMap.get(entry.fnName ?? entry.exportName);
+		if (fnIdx === undefined) return;
+		const sig = typeAt(mod, mod.funcs[fnIdx - importFuncCount]?.typeIndex);
+		if (sig?.form !== "func") return;
+		const paramW = sig.params;
+		const resultW = sig.results;
+		if (!needsConv(paramW) && !needsConv(resultW)) return;
+		entry.callName = `__x_${entry.exportName}`;
+		addFunc(
+			entry.callName,
+			paramW.map(extType),
+			resultW.map(extType),
+			[
+				...paramW.flatMap((w, i) => getIn(i, w)),
+				{ op: "call", funcIndex: fnIdx },
+				...convertResults(resultW, toExt, paramW.length),
+			],
+			true,
+			resultW.length > 1 ? resultW : [],
+		);
+	};
+	for (const s of meta.structs) for (const m of s.methods) addTrampoline(m);
+	for (const f of meta.funcs) addTrampoline(f);
+	for (const desc of needs.ifaces.values())
+		addIfaceHelpers(desc, mod, addFunc, addTrampoline);
+
+	if (needs.shared) {
+		const { wType, typeIndex } = mod.getSharedType();
+		addFunc(
+			"__shared_base",
+			[EXT],
+			["i32"],
+			[...getIn(0, wType), { op: "struct.get", typeIndex, fieldIndex: 0 }],
+		);
+		addFunc(
+			"__shared_len",
+			[EXT],
+			["i32"],
+			[...getIn(0, wType), { op: "struct.get", typeIndex, fieldIndex: 1 }],
+		);
+		// JS-side views (e.g. a `subarray`) go back in as a fresh (base, len).
+		addFunc(
+			"__shared_make",
+			["i32", "i32"],
+			[EXT],
+			[get(0), get(1), { op: "struct.new", typeIndex }, ...toExt(wType)],
+		);
+		for (const v of meta.vars ?? []) {
+			const g = mod.resolveGlobal(v.name);
+			if (!g) continue;
+			addFunc(
+				`__var_${v.name}`,
+				[],
+				[EXT],
+				[{ op: "global.get", index: g.index }, ...toExt(wType)],
+			);
+		}
+	}
+}
+
+// `(externref) -> i32`: `ref.test`s param 0 against each type index and
+// returns `resultFor(i)` for the first match, 0 otherwise.
+function refTestChain(typeIndices, resultFor) {
+	const body = typeIndices.flatMap((ti, i) => [
+		{ op: "local.get", index: 0 },
+		{ op: "any.convert_extern" },
+		{ op: "ref.test", typeIndex: ti },
+		{ op: "if", blockType: "void" },
+		{ op: "i32.const", value: resultFor(i) },
+		{ op: "return" },
+		{ op: "end" },
+	]);
+	body.push({ op: "i32.const", value: 0 });
+	return body;
+}
+
+// Type indices (incl. unexported and boxed-value types) whose method set
+// covers the interface, from the same candidate search the dispatchers use.
+function implementingTypeIndices(desc, mod) {
+	let acc = null;
+	for (const m of desc.methods) {
+		const have = new Set(
+			mod.findInterfaceCandidates(null, m.name).map((c) => c.testTypeIndex),
+		);
+		acc = acc === null ? have : new Set([...acc].filter((t) => have.has(t)));
+	}
+	return [...(acc ?? [])];
+}
+
+// Interfaces: method calls go through the existing `ref.test` dispatchers;
+// `__impl$<I>` tells whether a wasm value implements I (guards JS inputs);
+// `__itag$<I>` reports which exported `*T` (1-based) a value holds, 0 if none.
+function addIfaceHelpers(desc, mod, addFunc, addTrampoline) {
+	for (const m of desc.methods) {
+		const entry = { exportName: m.dispatch };
+		addTrampoline(entry);
+		if (!entry.callName)
+			throw new Error(
+				`internal: no wasm dispatcher for interface method ${desc.name}.${m.name}`,
+			);
+		m.callName = entry.callName;
+	}
+	addFunc(
+		`__impl$${desc.key}`,
+		["externref"],
+		["i32"],
+		refTestChain(implementingTypeIndices(desc, mod), () => 1),
+	);
+	if (desc.concrete.length === 0) return;
+	addFunc(
+		`__itag$${desc.key}`,
+		["externref"],
+		["i32"],
+		refTestChain(
+			desc.concrete.map((c) => c.typeIndex),
+			(i) => i + 1,
+		),
+	);
+}
+
+// ── JS facade generation ─────────────────────────────────────
+
+const P = "__gfw_"; // facade helper prefix
+
+// JS expression converting JS value `v` into the wasm representation.
+function inExpr(desc, v) {
+	switch (desc.k) {
+		case "bool":
+			return `(${v} ? 1 : 0)`;
+		case "i32":
+			return `(${v} | 0)`;
+		case "i64":
+			return `${P}i64in(${v})`;
+		case "f32":
+		case "f64":
+			return `(+${v})`;
+		case "string":
+			return `${P}strin(${v})`;
+		case "any":
+			return `(${v} === undefined ? null : ${v})`;
+		case "struct":
+			if (desc.info.pkgTarget === "both")
+				return `${P}to_${desc.name}(${v}, ${desc.ptr ? "false" : "true"})`;
+			return desc.ptr
+				? `${P}href_${desc.name}(${v})`
+				: `${P}hval_${desc.name}(${v})`;
+		case "slice":
+			return `${P}slin_${desc.key}(${v})`;
+		case "array":
+			return `${P}arrin_${desc.key}(${v})`;
+		case "func":
+			return `${P}fnin_${desc.key}(${v})`;
+		case "iface":
+			return `${P}ifin_${desc.key}(${v})`;
+		case "shared":
+			return `${P}shin(${v}, ${desc.ctor})`;
+		default:
+			return v;
+	}
+}
+
+// JS expression converting wasm value `v` into the JS representation.
+function outExpr(desc, v) {
+	switch (desc.k) {
+		case "bool":
+			return `(${v} !== 0)`;
+		case "i32":
+			return desc.unsigned ? `(${v} >>> 0)` : v;
+		case "i64":
+			return desc.unsigned ? `${P}u64out(${v})` : `${P}i64out(${v})`;
+		case "string":
+			return `(${v} ?? "")`;
+		case "struct":
+			return desc.info.pkgTarget === "both"
+				? `${P}from_${desc.name}(${v})`
+				: `${desc.name}.__wrap(${v})`;
+		case "slice":
+			return `${P}slout_${desc.key}(${v})`;
+		case "array":
+			return `${P}arrout_${desc.key}(${v})`;
+		case "func":
+			return `${P}fnout_${desc.key}(${v})`;
+		case "iface":
+			return `${P}ifout_${desc.key}(${v})`;
+		case "shared":
+			return `${P}shout(${v}, ${desc.ctor})`;
+		default:
+			return v;
+	}
+}
+
+function zeroExpr(desc) {
+	switch (desc.k) {
+		case "bool":
+			return "false";
+		case "i32":
+		case "i64":
+		case "f32":
+		case "f64":
+			return "0";
+		case "string":
+			return '""';
+		case "struct":
+			return desc.ptr ? "null" : `new ${desc.name}()`;
+		case "array":
+			return `${P}arrzero_${desc.key}(${desc.size})`;
+		default:
+			return "null";
+	}
+}
+
+// JS expression exposing wasm storage `v` reached through a handle field as a
+// *live* JS value: aggregate fields alias the wasm object instead of copying
+// it, so `h.Pos.X = 1` and `h.Items[0] = 2` reach wasm like they do in Go.
+function viewExpr(desc, v) {
+	switch (desc.k) {
+		case "struct":
+			return desc.info.pkgTarget === "both"
+				? `${P}view_${desc.name}(${v})`
+				: `${desc.name}.__wrap(${v})`;
+		case "slice":
+			return `${P}slview_${desc.key}(${v})`;
+		case "array":
+			return `${P}arrview_${desc.key}(${v})`;
+		default:
+			return outExpr(desc, v);
+	}
+}
+
+function isPtrBoth(d) {
+	return d.k === "struct" && d.ptr && d.info.pkgTarget === "both";
+}
+
+function isBothStruct(d) {
+	return d.k === "struct" && d.info.pkgTarget === "both";
+}
+
+function returnLines(returns, resultExpr) {
+	if (returns.length === 0) return [];
+	if (returns.length === 1)
+		return [`\treturn ${outExpr(returns[0], resultExpr)};`];
+	return [
+		`\treturn [${returns.map((d, i) => outExpr(d, `${resultExpr}[${i}]`)).join(", ")}];`,
+	];
+}
+
+// Generates the body of a JS wrapper calling `__w.<exportName>(leadArgs..., params...)`.
+function genFuncBody(exportName, params, returns, leadArgs = []) {
+	const names = params.map((_, i) => `a${i}`);
+	const lines = [];
+	const argExprs = [...leadArgs];
+	const writeBack = params.some(isPtrBoth);
+	if (writeBack) lines.push("\tconst __m = new Map();");
+	for (let i = 0; i < params.length; i++) {
+		const d = params[i];
+		if (isPtrBoth(d)) {
+			lines.push(`\tconst __p${i} = ${P}to_${d.name}(a${i}, false, __m);`);
+			argExprs.push(`__p${i}`);
+		} else {
+			argExprs.push(inExpr(d, names[i]));
+		}
+	}
+	const call = `__w.${exportName}(${argExprs.join(", ")})`;
+	lines.push("\ttry {");
+	if (!writeBack) {
+		if (returns.length === 0) lines.push(`\t\t${call};`);
+		else if (returns.length === 1)
+			lines.push(...returnLines(returns, call).map((l) => `\t${l}`));
+		else {
+			lines.push(`\t\tconst __r = ${call};`);
+			lines.push(...returnLines(returns, "__r").map((l) => `\t${l}`));
+		}
+	} else {
+		lines.push(`\t\tconst __r = ${call};`);
+		for (let i = 0; i < params.length; i++) {
+			if (isPtrBoth(params[i]))
+				lines.push(`\t\t${P}back_${params[i].name}(__p${i}, a${i});`);
+		}
+		lines.push(...returnLines(returns, "__r").map((l) => `\t${l}`));
+	}
+	lines.push(`\t} catch (e) { throw ${P}mapTrap(e); }`);
+	return { names, body: lines.join("\n") };
+}
+
+function indent(text, prefix) {
+	return text.replace(/^/gm, prefix);
+}
+
+// Runtime import table shared by the facade and glue.js (single source so
+// the tests exercise the same env the shipped bundle uses).  Written to
+// survive the built-in mangler: no shorthand destructuring, import keys
+// quoted, helpers prefixed with `__`.
+export const WASM_IMPORTS_JS = `const ${P}MAX = 9007199254740991n;
+function ${P}imports(stringTable, extraEnv, tag, write) {
+	let lineBuf = "";
+	let targs = [];
+	const late = { exports: null };
+	const flush = () => { write(lineBuf); lineBuf = ""; };
+	const print = (v) => {
+		const s = String(v);
+		if (lineBuf.length > 0 && !lineBuf.endsWith(" ") && !s.startsWith(" ")) {
+			lineBuf += " ";
+		}
+		lineBuf += s;
+	};
+	const println = (v) => {
+		const s = String(v);
+		if (lineBuf.length > 0 && !lineBuf.endsWith(" ") && !s.startsWith(" ")) {
+			lineBuf += " ";
+		}
+		lineBuf += s;
+		flush();
+	};
+	const targ = (v) => { targs.push(v); };
+	const env = {
+		"panicTag": tag,
+		"panic": (msg) => {
+			let str;
+			try {
+				str = String(msg);
+			} catch {
+				str = "[panic object]";
+			}
+			throw new Error(str);
+		},
+		"str": (i) => stringTable[i] ?? "",
+		"str_len": (s) => (s ? s.length : 0),
+		"str_concat": (a, b) => (a ?? "") + (b ?? ""),
+		"str_eq": (a, b) => (a === b ? 1 : 0),
+		"str_ne": (a, b) => (a !== b ? 1 : 0),
+		"str_lt": (a, b) => ((a ?? "") < (b ?? "") ? 1 : 0),
+		"str_le": (a, b) => ((a ?? "") <= (b ?? "") ? 1 : 0),
+		"str_gt": (a, b) => ((a ?? "") > (b ?? "") ? 1 : 0),
+		"str_ge": (a, b) => ((a ?? "") >= (b ?? "") ? 1 : 0),
+		"str_get": (s, i) => (s ? s.charCodeAt(i) : 0),
+		"str_slice": (s, a, b) => (s ? s.slice(a, b) : ""),
+		"str_from_code_point": (c) => String.fromCodePoint(c),
+		"str_code_point_at": (s, i) => (s ? s.codePointAt(i) : 0),
+		"str_hash": (s) => {
+			if (!s) return 0;
+			let h = 0;
+			for (let i = 0; i < s.length; i++) {
+				h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+			}
+			return h;
+		},
+		"str_to_upper": (s) => (s ? s.toUpperCase() : ""),
+		"str_to_lower": (s) => (s ? s.toLowerCase() : ""),
+		"str_trim_space": (s) => (s ? s.trim() : ""),
+		"str_contains": (s, sub) => (s && sub !== undefined ? (s.includes(sub) ? 1 : 0) : 0),
+		"str_has_prefix": (s, pre) => (s && pre !== undefined ? (s.startsWith(pre) ? 1 : 0) : 0),
+		"str_has_suffix": (s, suf) => (s && suf !== undefined ? (s.endsWith(suf) ? 1 : 0) : 0),
+		"str_index": (s, sub) => (s ? s.indexOf(sub) : -1),
+		"str_last_index": (s, sub) => (s ? s.lastIndexOf(sub) : -1),
+		"str_repeat": (s, n) => (s && n > 0 ? s.repeat(Number(n)) : ""),
+		"str_replace_all": (s, o, n) => (s ? s.replaceAll(o, n) : ""),
+		"str_equal_fold": (a, b) => ((a ?? "").toLowerCase() === (b ?? "").toLowerCase() ? 1 : 0),
+		"str_count": (s, sep) => {
+			if (!s) return sep === "" ? 1 : 0;
+			if (sep === "") return s.length + 1;
+			return s.split(sep).length - 1;
+		},
+		"str_from_i64": (n) => String(n),
+		"str_from_i32": (n) => String(n),
+		"str_from_f64": (f) => String(f),
+		"is_string": (v) => (typeof v === "string" ? 1 : 0),
+		"print_i32": print, "print_i64": print, "print_f32": print, "print_f64": print,
+		"print_str": print, "print_any": print,
+		"print_bool": (b) => print(b !== 0 ? "true" : "false"),
+		"println_i32": println, "println_i64": println, "println_f32": println, "println_f64": println,
+		"println_str": println, "println_any": println,
+		"println_bool": (b) => println(b !== 0 ? "true" : "false"),
+		"println_empty": flush,
+		"testing_arg_i32": targ, "testing_arg_f32": targ, "testing_arg_f64": targ,
+		"testing_arg_str": targ, "testing_arg_any": targ,
+		"testing_arg_i64": (v) => targ(v > ${P}MAX || v < -${P}MAX ? v : Number(v)),
+		"testing_arg_bool": (v) => targ(v !== 0),
+		"testing_call": (t, i) => { const a = targs; targs = []; t[stringTable[i]](...a); },
+		"testing_name": (t) => t.Name(),
+		"testing_flag": (t, i) => (t[stringTable[i]]() ? 1 : 0),
+	};
+	// Stdlib imports (strings/strconv/utf8/fmt/t.Run) are a separate block so
+	// modules that never call them do not ship it (see WASM_STDLIB_JS).
+	if (typeof ${P}stdlib === "function") {
+		Object.assign(env, ${P}stdlib(stringTable, {
+			"take": () => { const a = targs; targs = []; return a; },
+			"printf": (s) => {
+				lineBuf += s;
+				const nl = lineBuf.lastIndexOf("\\n");
+				if (nl >= 0) { write(lineBuf.slice(0, nl)); lineBuf = lineBuf.slice(nl + 1); }
+			},
+			"late": late,
+		}));
+	}
+	Object.assign(env, extraEnv);
+	const m = {};
+	for (const k of ["sin", "cos", "tan", "asin", "acos", "atan", "atan2", "pow", "exp", "log", "log2", "log10", "cbrt", "hypot"]) m[k] = Math[k];
+	m.mod = (x, y) => x % y;
+	// Go rounds half away from zero; Math.round rounds half toward +Infinity.
+	m.round = (x) => Math.sign(x) * Math.round(Math.abs(x));
+	// Exports are needed by imports that call back into the module (t.Run).
+	return { "env": env, "Math": m, "__bind": (ex) => { late.exports = ex; } };
+}`;
+
+// JS side of the STDLIB_IMPORTS table (index.js); emitted only when the
+// module imports one of the packages that use it.
+export const WASM_STDLIB_JS = `${HELPER_SPRINTF}
+${HELPER_STRCONV}
+function ${P}stdlib(stringTable, io) {
+	let parts = [];
+	let strconvErr = null;
+	let decodeSize = 0;
+	return {
+		"testing_run": (t, name, fn) => (t.Run(name, (sub) => { io.late.exports.__testing_run_cb(fn, sub); }) ? 1 : 0),
+		"fmt_sprintf": (f) => __sprintf(f ?? "", ...io.take()),
+		"fmt_printf": (f) => { io.printf(__sprintf(f ?? "", ...io.take())); },
+		"str_trim": (s, c) => ${P}trim(s ?? "", c ?? "", true, true),
+		"str_trim_left": (s, c) => ${P}trim(s ?? "", c ?? "", true, false),
+		"str_trim_right": (s, c) => ${P}trim(s ?? "", c ?? "", false, true),
+		"str_trim_prefix": (s, p) => (s && p && s.startsWith(p) ? s.slice(p.length) : (s ?? "")),
+		"str_trim_suffix": (s, p) => (s && p && s.endsWith(p) ? s.slice(0, s.length - p.length) : (s ?? "")),
+		"str_replace": (s, o, n, cnt) => {
+			s = s ?? ""; o = o ?? ""; n = n ?? "";
+			if (cnt < 0) return s.replaceAll(o, n);
+			let out = "", from = 0;
+			for (let k = 0; k < cnt; k++) {
+				const at = s.indexOf(o, from);
+				if (at < 0) break;
+				out += s.slice(from, at) + n;
+				from = at + o.length;
+				if (o === "") { if (from >= s.length) break; out += s[from]; from++; }
+			}
+			return out + s.slice(from);
+		},
+		"str_contains_rune": (s, r) => ((s ?? "").includes(String.fromCodePoint(r)) ? 1 : 0),
+		"str_contains_any": (s, cs) => { for (const c of (cs ?? "")) if ((s ?? "").includes(c)) return 1; return 0; },
+		"str_index_byte": (s, b) => (s ?? "").indexOf(String.fromCharCode(b)),
+		"str_index_rune": (s, r) => (s ?? "").indexOf(String.fromCodePoint(r)),
+		"str_index_any": (s, cs) => { s = s ?? ""; let best = -1; for (const c of (cs ?? "")) { const i = s.indexOf(c); if (i >= 0 && (best < 0 || i < best)) best = i; } return best; },
+		"str_last_index_byte": (s, b) => (s ?? "").lastIndexOf(String.fromCharCode(b)),
+		"str_title": (s) => (s ?? "").replace(/(^|[^\\p{L}\\p{N}_'])(\\p{Ll})/gu, (m, a, b) => a + b.toUpperCase()),
+		"str_split": (s, sep) => { parts = (s ?? "").split(sep ?? ""); return parts.length; },
+		"str_fields": (s) => { parts = (s ?? "").split(/\\s+/).filter((p) => p !== ""); return parts.length; },
+		"str_part": (i) => parts[i] ?? "",
+		"strconv_atoi": (s) => { const r = __strconv_atoi(s ?? ""); strconvErr = r[1]; return r[0]; },
+		"strconv_parse_int": (s, base, bits) => { const r = __strconv_parse_int(s ?? "", base, bits); strconvErr = r[1]; return r[0]; },
+		"strconv_parse_float": (s) => { const r = __strconv_parse_float(s ?? ""); strconvErr = r[1]; return r[0]; },
+		"strconv_parse_bool": (s) => { const r = __strconv_parse_bool(s ?? ""); strconvErr = r[1]; return r[0] ? 1 : 0; },
+		"strconv_err": () => strconvErr,
+		"strconv_format_float": (f, fmtc, prec, _bits) => __strconv_format_float(f, fmtc, prec),
+		"strconv_format_int": (n, base) => n.toString(base),
+		"strconv_quote": (s) => JSON.stringify(s ?? ""),
+		"utf8_rune_count": (s) => { let n = 0; for (const _ of (s ?? "")) n++; return n; },
+		"utf8_rune_len": (r) => (r < 0 || r > 0x10ffff || (r >= 0xd800 && r <= 0xdfff) ? -1 : r < 0x80 ? 1 : r < 0x800 ? 2 : r < 0x10000 ? 3 : 4),
+		"utf8_valid_string": (s) => (s ?? "").isWellFormed ? ((s ?? "").isWellFormed() ? 1 : 0) : (/[\\uD800-\\uDFFF]/.test((s ?? "").replace(/[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g, "")) ? 0 : 1),
+		"utf8_decode_rune": (s, last) => {
+			s = s ?? "";
+			if (s.length === 0) { decodeSize = 0; return 0xfffd; }
+			let cp;
+			if (last) { const tail = s.codePointAt(s.length - 1); cp = (tail >= 0xdc00 && tail <= 0xdfff && s.length >= 2) ? s.codePointAt(s.length - 2) : tail; }
+			else cp = s.codePointAt(0);
+			if (cp >= 0xd800 && cp <= 0xdfff) { decodeSize = 1; return 0xfffd; }
+			// Size is in UTF-16 code units, matching the JS backend (strings are JS strings).
+			decodeSize = cp > 0xffff ? 2 : 1;
+			return cp;
+		},
+		"utf8_decode_size": () => decodeSize,
+		"utf8_full_rune": (s) => { s = s ?? ""; if (s.length === 0) return 0; const c = s.charCodeAt(0); return (c >= 0xd800 && c <= 0xdbff && s.length < 2) ? 0 : 1; },
+	};
+}
+function ${P}trim(s, cutset, left, right) {
+	const cs = Array.from(cutset);
+	const chars = Array.from(s);
+	let a = 0, b = chars.length;
+	if (left) while (a < b && cs.includes(chars[a])) a++;
+	if (right) while (b > a && cs.includes(chars[b - 1])) b--;
+	return chars.slice(a, b).join("");
+}`;
+
+// Runtime loader emitted at the top of the facade.
+const wasmLoaderJs = (stdlibEnv) => `${WASM_IMPORTS_JS}
+${stdlibEnv ? WASM_STDLIB_JS : ""}
+async function ${P}fetch(url) {
+	const res = await fetch(url);
+	if (!res.ok) throw new Error("GoFront: failed to fetch " + url + " (" + res.status + ")");
+	return res.arrayBuffer();
+}
+async function ${P}instantiate(imports) {
+	const bytes = globalThis.__GOFRONT_WASM_BYTES;
+	if (bytes) return WebAssembly.instantiate(bytes, imports);
+	// Resolve relative to the bundle so the app works from any page path.
+	const url = globalThis.__GOFRONT_WASM_URL ?? new URL("app.wasm", import.meta.url).href;
+	if (typeof WebAssembly.instantiateStreaming === "function") {
+		try { return await WebAssembly.instantiateStreaming(fetch(url), imports); }
+		catch { /* fall through: wrong MIME type or no streaming support */ }
+	}
+	return WebAssembly.instantiate(await ${P}fetch(url), imports);
+}
+async function ${P}load(stringTable, extraEnv) {
+	if (typeof WebAssembly === "undefined" || typeof WebAssembly.Tag !== "function") {
+		throw new Error("GoFront: this runtime lacks the WebAssembly GC / exception support required by app.wasm");
+	}
+	const tag = new WebAssembly.Tag({ "parameters": ["externref"] });
+	const imports = ${P}imports(stringTable, extraEnv, tag, (s) => console.log(s));
+	// Panics arrive as plain JS Errors thrown by env.panic (also from the
+	// start function while package-level initializers run), so exports are
+	// returned raw: no try/catch wrapper, which keeps JS→wasm calls inlinable.
+	const result = await ${P}instantiate(imports);
+	imports.__bind(result.instance.exports);
+	return result.instance.exports;
+}
+// Go int/int64 cross the boundary as f64 (exact within the safe-integer range).
+const ${P}i64in = (v) => (typeof v === "bigint" ? Number(v) : +v);
+const ${P}i64out = (v) => {
+	if (v > ${P}MAX || v < -${P}MAX) throw new RangeError("GoFront: int64 value " + v + " exceeds the safe JS integer range");
+	return v;
+};
+const ${P}u64out = (v) => {
+	if (v < 0 || v > ${P}MAX) throw new RangeError("GoFront: uint64 value exceeds the safe JS integer range");
+	return v;
+};
+const ${P}strin = (v) => (v == null ? "" : String(v));
+const ${P}href = (h) => (h == null ? null : h.__ref);
+// Tags a struct pointer held in an interface (same marker as the JS backend's __ifp).
+const ${P}ptag = (h) => {
+	if (h !== null && h.__p !== true && Object.isExtensible(h)) Object.defineProperty(h, "__p", { "value": true, "configurable": true });
+	return h;
+};
+const ${P}NIL_DEREF_PATTERNS = [
+	"dereferencing a null pointer", // V8
+	"dereferencing null pointer", // SpiderMonkey
+	"null pointer dereference", // SpiderMonkey
+	"null dereference", // JavaScriptCore
+];
+function ${P}mapTrap(e) {
+	if (typeof WebAssembly !== "undefined" && e instanceof WebAssembly.RuntimeError) {
+		const msg = e.message || "";
+		for (const p of ${P}NIL_DEREF_PATTERNS) {
+			if (msg.includes(p)) {
+				return new Error("runtime error: invalid memory address or nil pointer dereference");
+			}
+		}
+	}
+	return e;
+}
+// Live index view over a wasm array/slice (reads and writes go through to wasm).
+function ${P}idxview(n, getAt, setAt) {
+	const inRange = (k) => { if (typeof k !== "string") return -1; const i = +k; return i === (i | 0) && i >= 0 && i < n ? i : -1; };
+	return new Proxy(new Array(n), {
+		"get": (t, k, r) => { const i = inRange(k); return i < 0 ? Reflect.get(t, k, r) : getAt(i); },
+		"set": (t, k, v, r) => { const i = inRange(k); if (i < 0) return Reflect.set(t, k, v, r); setAt(i, v); return true; },
+		"has": (t, k) => inRange(k) >= 0 || Reflect.has(t, k),
+		"getOwnPropertyDescriptor": (t, k) => {
+			const i = inRange(k);
+			if (i < 0) return Reflect.getOwnPropertyDescriptor(t, k);
+			return { "value": getAt(i), "writable": true, "enumerable": true, "configurable": true };
+		},
+		"ownKeys": (t) => { const keys = []; for (let i = 0; i < n; i++) keys.push(String(i)); keys.push("length"); return keys; },
+	});
+}`;
+
+// Generates the JS facade for the linked wasm module.
+export function generateFacade(
+	meta,
+	{ stringTable = [], callMain = false, stdlibEnv = true } = {},
+) {
+	const needs = meta._needs ?? collectNeeds(meta);
+	const out = [wasmLoaderJs(stdlibEnv)];
+
+	// JS callback imports (registered before instantiation; bodies run after).
+	out.push(`const ${P}env = {};`);
+	for (const [key, desc] of needs.funcs) {
+		const names = desc.params.map((_, i) => `a${i}`);
+		const args = desc.params.map((d, i) =>
+			isPtrBoth(d) ? `${P}view_${d.name}(${names[i]})` : outExpr(d, names[i]),
+		);
+		const call = `fn(${args.join(", ")})`;
+		let body;
+		if (desc.returns.length === 0) body = `${call};`;
+		else if (desc.returns.length === 1)
+			body = `return ${inExpr(desc.returns[0], call)};`;
+		else
+			body = `const __r = ${call}; return [${desc.returns
+				.map((d, i) => inExpr(d, `__r[${i}]`))
+				.join(", ")}];`;
+		const sig = ["fn", ...names].join(", ");
+		out.push(
+			`${P}env["__invoke$${key}"] = (${sig}) => { try { ${body} } catch (__e) { if (__w && __w.__push_panic) __w.__push_panic(__e.message ?? String(__e)); throw __e; } };`,
+		);
+	}
+	out.push(
+		`const __w = await ${P}load(${JSON.stringify(stringTable)}, ${P}env);`,
+	);
+
+	for (const [name, { info, fields }] of needs.structs) {
+		if (info.pkgTarget === "both") genBothStruct(out, name, fields);
+		else {
+			const methods = meta.structByName.get(name)?.methods ?? [];
+			genHandleStruct(out, name, fields, methods);
+		}
+	}
+
+	for (const [key, desc] of needs.slices) {
+		out.push(`function ${P}slin_${key}(arr) {
+	if (arr == null) return __w.__slice_nil_${key}();
+	const n = arr.length;
+	const s = __w.__slice_new_${key}(n);
+	for (let i = 0; i < n; i++) __w.__slice_set_${key}(s, i, ${inExpr(desc.elem, "arr[i]")});
+	return s;
+}
+function ${P}slout_${key}(s) {
+	if (s == null || __w.__slice_is_nil_${key}(s)) return null;
+	const n = __w.__slice_len_${key}(s);
+	const out = new Array(n);
+	for (let i = 0; i < n; i++) out[i] = ${outExpr(desc.elem, `__w.__slice_get_${key}(s, i)`)};
+	return out;
+}
+function ${P}slview_${key}(s) {
+	if (s == null || __w.__slice_is_nil_${key}(s)) return null;
+	return ${P}idxview(__w.__slice_len_${key}(s), (i) => ${viewExpr(desc.elem, `__w.__slice_get_${key}(s, i)`)}, (i, v) => __w.__slice_set_${key}(s, i, ${inExpr(desc.elem, "v")}));
+}`);
+	}
+	for (const [key, desc] of needs.arrays) {
+		out.push(`function ${P}arrzero_${key}(n) {
+	const out = new Array(n);
+	for (let i = 0; i < n; i++) out[i] = ${zeroExpr(desc.elem)};
+	return out;
+}
+function ${P}arrin_${key}(arr) {
+	if (arr == null) return null;
+	const n = arr.length;
+	const a = __w.__array_new_${key}(n);
+	for (let i = 0; i < n; i++) __w.__array_set_${key}(a, i, ${inExpr(desc.elem, "arr[i]")});
+	return a;
+}
+function ${P}arrout_${key}(a) {
+	if (a == null) return null;
+	const n = __w.__array_len_${key}(a);
+	const out = new Array(n);
+	for (let i = 0; i < n; i++) out[i] = ${outExpr(desc.elem, `__w.__array_get_${key}(a, i)`)};
+	return out;
+}
+function ${P}arrview_${key}(a) {
+	if (a == null) return null;
+	return ${P}idxview(__w.__array_len_${key}(a), (i) => ${viewExpr(desc.elem, `__w.__array_get_${key}(a, i)`)}, (i, v) => __w.__array_set_${key}(a, i, ${inExpr(desc.elem, "v")}));
+}`);
+	}
+
+	for (const [key, desc] of needs.funcs) {
+		const { names, body } = genFuncBody(
+			`__call_fn$${key}`,
+			desc.params,
+			desc.returns,
+			["c"],
+		);
+		out.push(`const ${P}fn_j2w_${key} = new WeakMap();
+const ${P}fn_w2j_${key} = new WeakMap();
+function ${P}fnin_${key}(fn) {
+	if (fn == null) return null;
+	let c = ${P}fn_j2w_${key}.get(fn);
+	if (!c) {
+		c = __w.__wrap_fn$${key}(fn);
+		${P}fn_j2w_${key}.set(fn, c);
+		${P}fn_w2j_${key}.set(c, fn);
+	}
+	return c;
+}
+function ${P}fnout_${key}(c) {
+	if (c == null) return null;
+	let fn = ${P}fn_w2j_${key}.get(c);
+	if (!fn) {
+		fn = (${names.join(", ")}) => {
+${indent(body, "\t")}
+		};
+		fn.__ref = c;
+		${P}fn_w2j_${key}.set(c, fn);
+		${P}fn_j2w_${key}.set(fn, c);
+	}
+	return fn;
+}`);
+	}
+
+	for (const [key, desc] of needs.ifaces) genIfaceFacade(out, key, desc);
+
+	if (needs.shared) {
+		// Zero-copy TypedArray views over the exported memory.  Memory never
+		// grows after the start function (allocation is startup-only), but the
+		// cached view is still re-validated against the live buffer.
+		out.push(`const ${P}shc = new WeakMap();
+function ${P}shout(r, Ctor) {
+	if (r == null) return null;
+	let v = ${P}shc.get(r);
+	if (!v || v.buffer !== __w.memory.buffer) {
+		v = new Ctor(__w.memory.buffer, __w.__shared_base(r), __w.__shared_len(r));
+		${P}shc.set(r, v);
+	}
+	return v;
+}
+function ${P}shin(v, Ctor) {
+	if (v == null) return null;
+	if (!(v instanceof Ctor) || v.buffer !== __w.memory.buffer) throw new TypeError("GoFront: expected a " + Ctor.name + " view over the wasm shared memory");
+	return __w.__shared_make(v.byteOffset, v.length);
+}`);
+	}
+
+	for (const c of meta.consts) out.push(`const ${c.name} = ${c.value};`);
+	for (const v of meta.vars ?? [])
+		out.push(
+			`const ${v.name} = ${P}shout(__w.__var_${v.name}(), ${v.desc.ctor});`,
+		);
+
+	for (const f of meta.funcs) {
+		const { names, body } = genFuncBody(
+			f.callName ?? f.exportName,
+			f.params,
+			f.returns,
+		);
+		out.push(`function ${f.name}(${names.join(", ")}) {\n${body}\n}`);
+	}
+
+	if (callMain) out.push("__w.main();");
+	return bindExports(out.join("\n"));
+}
+
+// Rewrites `__w.name(...)` into calls through module-level `const` bindings.
+// V8 only inlines a JS→wasm call (and so passes f32/f64 arguments unboxed)
+// when the callee is a compile-time constant; a property load off the exports
+// object is not, and every float argument then costs a 16-byte HeapNumber.
+function bindExports(src) {
+	const loadLine = "const __w = await ";
+	const at = src.indexOf(loadLine);
+	if (at < 0) return src;
+	const eol = src.indexOf("\n", at);
+	const head = src.slice(0, eol + 1);
+	let tail = src.slice(eol + 1);
+	const names = new Set();
+	tail = tail.replace(/__w\.([A-Za-z_$][\w$]*)/g, (_, n) => {
+		names.add(n);
+		return `__w$${n}`;
+	});
+	const binds = [...names].map((n) => `const __w$${n} = __w.${n};`).join("\n");
+	return `${head}${binds}\n${tail}`;
+}
+
+function genBothStruct(out, name, fields) {
+	const toArgs = fields.map((f) => {
+		const v = `o.${f.name}`;
+		if (isBothStruct(f.desc))
+			return `${P}to_${f.desc.name}(${v}, ${f.desc.ptr ? "false" : "true"}, m)`;
+		return inExpr(f.desc, v);
+	});
+	const backLines = fields.map((f) => {
+		const got = `__w.__get_${name}_${f.name}(r)`;
+		if (isBothStruct(f.desc))
+			return `\t${P}back_${f.desc.name}(${got}, o.${f.name});`;
+		return `\to.${f.name} = ${outExpr(f.desc, got)};`;
+	});
+	const fromArgs = fields.map((f) =>
+		outExpr(f.desc, `__w.__get_${name}_${f.name}(r)`),
+	);
+	const viewProps = fields.map((f) => {
+		const got = `__w.__get_${name}_${f.name}(this.__ref)`;
+		return `"${f.name}": { "enumerable": true, "get"() { return ${viewExpr(f.desc, got)}; }, "set"(v) { __w.__set_${name}_${f.name}(this.__ref, ${inExpr(f.desc, "v")}); } }`;
+	});
+	out.push(`function ${P}to_${name}(o, isValue, m) {
+	if (o == null) return isValue ? __w.__zero_${name}() : null;
+	if (m) { const hit = m.get(o); if (hit) return hit; }
+	const r = __w.__new_${name}(${toArgs.join(", ")});
+	if (m) m.set(o, r);
+	return r;
+}
+function ${P}from_${name}(r) {
+	if (r == null) return null;
+	return new ${name}(${fromArgs.join(", ")});
+}
+// Live views share one prototype and are cached per wasm object so hot paths
+// (\`h.Pos.X = 1\` in a frame loop) do not allocate a wrapper per access.  The
+// prototype is built on first use: the facade may precede the \`both\`
+// package's own JS (and so the \`${name}\` class) in the bundle.
+let ${P}vp_${name} = null;
+const ${P}vc_${name} = new WeakMap();
+function ${P}view_${name}(r) {
+	if (r == null) return null;
+	let o = ${P}vc_${name}.get(r);
+	if (!o) {
+		if (${P}vp_${name} === null) ${P}vp_${name} = Object.create(${name}.prototype, { ${viewProps.join(", ")} });
+		o = Object.create(${P}vp_${name}); o.__ref = r; ${P}vc_${name}.set(r, o);
+	}
+	return o;
+}
+function ${P}back_${name}(r, o) {
+	if (r == null || o == null) return;
+${backLines.join("\n")}
+}`);
+}
+
+function genIfaceFacade(out, key, desc) {
+	const methods = desc.methods.map((m) => {
+		const { names, body } = genFuncBody(m.callName, m.params, m.returns, [
+			"this.__ref",
+		]);
+		return `\t${m.name}(${names.join(", ")}) {\n${indent(body, "\t")}\n\t}`;
+	});
+	const cases = desc.concrete.map((c, i) => {
+		const wrap = c.both ? `${P}view_${c.name}(r)` : `${c.name}.__wrap(r)`;
+		return `\t\tcase ${i + 1}: return ${P}ptag(${wrap});`;
+	});
+	const tag =
+		cases.length > 0
+			? `\tswitch (__w.__itag$${key}(r)) {\n${cases.join("\n")}\n\t}\n`
+			: "";
+	const msg = `GoFront: a JS-implemented value cannot cross into wasm as interface '${desc.name}'; implement it in a wasm package or pass a func callback`;
+	const implMsg = `GoFront: wasm value does not implement interface '${desc.name}'`;
+	out.push(`class ${P}I_${key} {
+	constructor(r) { this.__ref = r; }
+${methods.join("\n")}
+}
+const ${P}ic_${key} = new WeakMap();
+function ${P}ifout_${key}(r) {
+	if (r == null) return null;
+${tag}	let o = ${P}ic_${key}.get(r);
+	if (!o) { o = new ${P}I_${key}(r); ${P}ic_${key}.set(r, o); }
+	return o;
+}
+function ${P}ifin_${key}(v) {
+	if (v == null) return null;
+	if (v.__ref === undefined) throw new TypeError(${JSON.stringify(msg)});
+	if (!__w.__impl$${key}(v.__ref)) throw new TypeError(${JSON.stringify(implMsg)});
+	return v.__ref;
+}`);
+}
+
+function genHandleStruct(out, name, fields, methods) {
+	// `$`-suffixed params keep the mangler from renaming the matching getters.
+	const ctorParams = fields.map((f) => `${f.name}$ = ${zeroExpr(f.desc)}`);
+	const ctorArgs = fields.map((f) => inExpr(f.desc, `${f.name}$`));
+	const fromArgs = fields.map((f) => `o.${f.name}`);
+	const ptrMsg = `GoFront: expected a ${name} handle for a *${name} parameter (use ${name}.from(obj) to create one)`;
+	const lines = [
+		`const ${P}h_${name} = new WeakMap();
+function ${P}hval_${name}(h) {
+	if (h == null) return __w.__zero_${name}();
+	if (h.__ref !== undefined) return __w.__clone_${name}(h.__ref);
+	return ${name}.from(h).__ref;
+}
+function ${P}href_${name}(h) {
+	if (h == null) return null;
+	if (h.__ref !== undefined) return h.__ref;
+	throw new TypeError(${JSON.stringify(ptrMsg)});
+}
+class ${name} {
+	constructor(${ctorParams.join(", ")}) {
+		this.__ref = __w.__new_${name}(${ctorArgs.join(", ")});
+		${P}h_${name}.set(this.__ref, this);
+	}
+	static from(o) { return new ${name}(${fromArgs.join(", ")}); }
+	static __wrap(ref) {
+		if (ref == null) return null;
+		let h = ${P}h_${name}.get(ref);
+		if (!h) { h = Object.create(${name}.prototype); h.__ref = ref; ${P}h_${name}.set(ref, h); }
+		return h;
+	}
+	__clone() { return ${name}.__wrap(__w.__clone_${name}(this.__ref)); }`,
+	];
+	for (const f of fields) {
+		const got = `__w.__get_${name}_${f.name}(this.__ref)`;
+		lines.push(`\tget ${f.name}() { return ${viewExpr(f.desc, got)}; }`);
+		lines.push(
+			`\tset ${f.name}(v) { __w.__set_${name}_${f.name}(this.__ref, ${inExpr(f.desc, "v")}); }`,
+		);
+	}
+	for (const m of methods) {
+		const recv = m.ptrRecv ? "this.__ref" : `__w.__clone_${name}(this.__ref)`;
+		const { names, body } = genFuncBody(
+			m.callName ?? m.exportName,
+			m.params,
+			m.returns,
+			[recv],
+		);
+		lines.push(
+			`\t${m.name}(${names.join(", ")}) {\n${indent(body, "\t")}\n\t}`,
+		);
+	}
+	lines.push("}");
+	out.push(lines.join("\n"));
+}