gofront 1.7.0 → 1.9.0

package/src/backend/wasm/boundary.js

@@ -2,7 +2,7 @@
 // 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):
+// Boundary v1 rules (plans/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,
@@ -31,24 +31,18 @@
 //     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 { BROWSER_GLOBALS } from "../../typechecker/types.js";
+import { FIXED_FLOAT_JS } from "../shared/fixed-float.js";
 import {
-	HELPER_BASE64,
-	HELPER_DURATION,
-	HELPER_ERROR,
-	HELPER_HEX,
-	HELPER_PATH_CLEAN,
-	HELPER_SHA256,
-	HELPER_SPRINTF,
-	HELPER_STRCONV,
-} from "../js/runtime.js";
+	unicodeIsJs,
+	unicodeToLowerJs,
+	unicodeToUpperJs,
+} from "../shared/host-unicode.js";
 import {
 	anonIfaceName,
 	getInterfaceMethodList,
 	getSharedInfo,
-	isTestingT,
 } from "./types.js";
 
 // ── Type classification ──────────────────────────────────────
@@ -85,8 +79,16 @@ function toRef(info) {
 	return { kind: "ref", nullable: true, typeIndex: info.typeIndex };
 }
 
+// The facade and its wasm export names build identifiers from a struct's name,
+// so the dot of a stdlib type (`strings.Builder`) becomes `$`.
 function structDesc(info, ptr) {
-	return { k: "struct", name: info.name, ptr, info, wType: toRef(info) };
+	return {
+		k: "struct",
+		name: info.name.replaceAll(".", "$"),
+		ptr,
+		info,
+		wType: toRef(info),
+	};
 }
 
 function funcSigFromAst(t) {
@@ -98,6 +100,10 @@ function funcSigFromAst(t) {
 				? t.returnType.types
 				: [t.returnType]
 			: [],
+		// `_variadic`: already desugared to a slice by variadic.js
+		variadic: Boolean(
+			t.params?.at(-1)?.variadic || t.params?.at(-1)?._variadic,
+		),
 	};
 }
 
@@ -105,17 +111,9 @@ function funcSigFromAst(t) {
 // 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") {
 		if (goType.name === "error") return { k: "error", wType: "anyref" };
-		if (goType.name === "time.Duration" || goType.name === "Duration")
-			return { k: "i64", unsigned: false, wType: "i64" };
-		if (goType.name === "time.Time" || goType.name === "Time") {
-			const info = mod.getStructType("time.Time");
-			if (info)
-				return { k: "time", name: "time.Time", info, wType: toRef(info) };
-		}
 		const info = mod.getStructType(goType.name);
 		if (info) return structDesc(info, false);
 		const resolved = mod.checker?.types?.get(goType.name);
@@ -148,10 +146,7 @@ function classifyType(goType, mod) {
 		case "interface":
 			return classifyInterface(t, mod);
 		case "simd":
-			return {
-				k: "unsupported",
-				what: "simd.F32x4 cannot cross the JS↔WASM boundary in 1.7.0 (use shared.Float32 instead)",
-			};
+			return classifySimd(t, mod);
 		default:
 			return {
 				k: "unsupported",
@@ -210,7 +205,12 @@ 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" };
+		return {
+			k: "i64",
+			unsigned: UNSIGNED.has(n),
+			is64: n === "int64" || n === "uint64",
+			wType: "i64",
+		};
 	const d = BASIC_DESCS[n];
 	return d ? { ...d } : { k: "unsupported", what: `type '${n}'` };
 }
@@ -219,26 +219,31 @@ function classifyNamed(t, mod) {
 	if (
 		t.name === "simd.F32x4" ||
 		t.name === "F32x4" ||
+		t.name === "simd.Mask32x4" ||
+		t.name === "Mask32x4" ||
 		t.underlying?.kind === "simd"
 	) {
-		return {
-			k: "unsupported",
-			what: "simd.F32x4 cannot cross the JS↔WASM boundary in 1.7.0 (use shared.Float32 instead)",
-		};
+		return classifySimd(t.underlying ?? t, mod, t.name);
 	}
 	if (t.name === "error") return { k: "error", wType: "anyref" };
-	if (t.name === "time.Duration")
-		return { k: "i64", unsigned: false, wType: "i64" };
-	if (t.name === "time.Time") {
-		const info = mod.getStructType("time.Time");
-		if (info) return { k: "time", name: "time.Time", info, wType: toRef(info) };
-	}
 	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}'` };
 }
 
+// F32x4 crosses as a copied 4-element Float32Array, Mask32x4 as a 4-element
+// boolean array.  Both travel through the wasm boundary as a GC array of the
+// four i32 lane words (`arr`), converted by __v128_from/__v128_to.
+function classifySimd(t, mod, name = "") {
+	const isMask = t.simd === "Mask32x4" || name.endsWith("Mask32x4");
+	const arr = classifyArray(
+		{ kind: "array", elem: { kind: "basic", name: "int32" }, size: 4 },
+		mod,
+	);
+	return { k: isMask ? "mask4" : "f32x4", wType: "v128", arr };
+}
+
 function classifyAnonStruct(t, mod) {
 	const rawFields = [];
 	if (t.fields instanceof Map) {
@@ -280,15 +285,23 @@ function classifyPointer(t, mod) {
 	if (base.k === "unsupported") return base;
 	if (base.k === "struct" && !base.ptr) return { ...base, ptr: true };
 	if (base.k === "anon_struct" && !base.ptr) return { ...base, ptr: true };
-	if (base.k === "time" && !base.ptr) return { ...base, ptr: true };
 	const boxInfo = mod.getBoxType(t.base);
-	const key = `${base.k}${base.unsigned ? "_u" : ""}_${boxInfo.typeIndex}`;
+	const ptrInfo = mod.getPtrType ? mod.getPtrType(t.base) : null;
+	const key = `${base.k}${base.unsigned ? "_u" : ""}${base.is64 ? "_64" : ""}_${boxInfo.typeIndex}`;
 	return {
 		k: "ptr_box",
 		base,
 		boxInfo,
+		ptrInfo,
 		key,
-		wType: { kind: "ref", nullable: true, typeIndex: boxInfo.typeIndex },
+		wType: ptrInfo
+			? {
+					kind: "ref",
+					nullable: true,
+					typeIndex: ptrInfo.typeIndex,
+					typeName: ptrInfo.name,
+				}
+			: { kind: "ref", nullable: true, typeIndex: boxInfo.typeIndex },
 	};
 }
 
@@ -352,7 +365,15 @@ function classifySlice(t, mod) {
 		k: "slice",
 		elem,
 		sliceInfo,
-		key: wTypeKey(sliceInfo.elemWType),
+		// []F32x4 and []Mask32x4 share a wasm slice type but cross differently,
+		// so they get separate helper keys.
+		key:
+			wTypeKey(sliceInfo.elemWType) +
+			(elem.k === "f32x4" || elem.k === "mask4"
+				? `_${elem.k}`
+				: elem.is64
+					? "_i64"
+					: ""),
 		wType: { kind: "ref", nullable: true, typeIndex: sliceInfo.typeIndex },
 	};
 }
@@ -372,7 +393,7 @@ function classifyArray(t, mod) {
 		elem,
 		size: arraySize(t),
 		arrInfo,
-		key: wTypeKey(arrInfo.elemWType),
+		key: wTypeKey(arrInfo.elemWType) + (elem.is64 ? "_i64" : ""),
 		wType: { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex },
 	};
 }
@@ -387,6 +408,9 @@ function classifySig(t, mod) {
 }
 
 function classifyFunc(t, mod) {
+	// A variadic func value is a slice-taking closure in wasm but a rest-param
+	// function in JS; no adapter yet, so it may not cross.
+	if (t.variadic) return { k: "unsupported", what: "variadic func value" };
 	const sig = classifySig(t, mod);
 	if (sig.k === "unsupported") return sig;
 	const closureInfo = mod.getClosureType(t);
@@ -451,7 +475,7 @@ function classifyNamedInterface(t, mod) {
 	const desc = {
 		k: "iface",
 		name: t.name,
-		key: t.name,
+		key: t.name.replaceAll(".", "_"),
 		wType: "anyref",
 		methods: [],
 		concrete: [],
@@ -544,19 +568,23 @@ export function collectBoundaryMeta(progs, funcDecls, mod) {
 	for (const p of progs) {
 		const pkgName = p.pkg?.name ?? "main";
 		const pkgTarget = p.target ?? "wasm";
+		// The tests of a package run inside the module: only the generated
+		// driver crosses the boundary.
+		if (isTestSource(p._path ?? p._filename)) continue;
 		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);
+				collectVarDecl(d, meta, mod);
 			}
 		}
 	}
 
 	for (const fn of funcDecls) {
 		if (fn._isClosure || fn._pkgTarget !== "wasm") continue;
+		if (isTestSource(fn._srcFile) && fn.name !== TEST_DRIVER) continue;
 		if (fn._isMethod) collectMethodMeta(fn, meta, errors, mod);
 		else collectFuncMeta(fn, meta, errors, mod);
 	}
@@ -565,12 +593,19 @@ export function collectBoundaryMeta(progs, funcDecls, mod) {
 	return meta;
 }
 
+// The driver function the test runner compiles in (src/cli/test-runner.js).
+const TEST_DRIVER = "GofrontRunTests";
+
+const isTestSource = (file) => Boolean(file?.endsWith("_test.go"));
+
 function collectStructDecl(d, pkgName, pkgTarget, meta, mod) {
-	if (!isExported(d.name) || meta.structByName.has(d.name)) return;
+	if (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);
+	// An unexported struct has no class of its own, but its exported methods
+	// reach JS through the exported structs that embed it.
+	if (isExported(d.name)) meta.structs.push(s);
 	meta.structByName.set(d.name, s);
 }
 
@@ -632,17 +667,24 @@ function checkDesc(desc, where, errors) {
 }
 
 // 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) {
+// TypedArray views (read once after instantiation; sizing is fixed).  Other
+// exported vars of a supported boundary type are read once when the module
+// loads, after package initialization (`var Limit = 40` is `Limit` in the
+// facade); a var of an unsupported type is left out.
+function collectVarDecl(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) });
+			const goType =
+				spec.type ?? mod.resolveGlobal(name)?.goType ?? values[i]?._type;
+			const shared = Boolean(getSharedInfo(goType, mod.checker));
+			const desc = classifyType(goType, mod);
+			if (!shared && (!desc || desc.k === "unsupported" || desc.k === "void"))
+				continue;
+			meta.vars.push({ name, desc, shared });
 		}
 	}
 }
@@ -657,6 +699,7 @@ function collectMethodMeta(fn, meta, errors, mod) {
 		exportName: fn._exportName,
 		fnName: fn.name,
 		ptrRecv: fn.params[0].type?.kind === "pointer",
+		variadic: Boolean(fn.params.at(-1)?._variadic),
 		params: fn.params
 			.slice(1)
 			.map((p) => checkDesc(classifyType(p.type, mod), where, errors)),
@@ -673,6 +716,7 @@ function collectFuncMeta(fn, meta, errors, mod) {
 		name: fn.name,
 		exportName: fn.name,
 		pkgName: fn._pkgName,
+		variadic: Boolean(fn.params?.at(-1)?._variadic),
 		params: (fn.params ?? []).map((p) =>
 			checkDesc(classifyType(p.type, mod), where, errors),
 		),
@@ -711,8 +755,10 @@ function visitNeed(desc, needs, errors, mod) {
 		case "error":
 			needs.error = true;
 			return;
-		case "time":
-			needs.time = true;
+		case "f32x4":
+		case "mask4":
+			needs.simd = desc.arr;
+			visitNeed(desc.arr, needs, errors, mod);
 			return;
 		case "slice":
 		case "array": {
@@ -790,7 +836,7 @@ function collectNeeds(meta) {
 		funcs: new Map(), // key -> desc
 		ifaces: new Map(), // interface name -> desc
 		error: false,
-		time: false,
+		simd: null, // array desc carrying vectors across the boundary
 		shared: false, // any shared buffer on the surface
 	};
 	const errors = [];
@@ -817,11 +863,20 @@ export function scanBoundaryImports(mod, meta) {
 	const needs = collectNeeds(meta);
 	meta._needs = needs;
 	for (const [key, desc] of needs.funcs) {
+		const paramDescs = desc.params ?? [];
+		const returnDescs = desc.returns ?? [];
 		mod.getOrAddFuncImport(
 			"env",
 			`__invoke$${key}`,
-			["externref", ...desc.closureInfo.paramWTypes.map(extType)],
-			desc.closureInfo.returnWTypes.map(extType),
+			[
+				"externref",
+				...desc.closureInfo.paramWTypes.map((w, i) =>
+					extType(w, paramDescs[i]?.is64),
+				),
+			],
+			desc.closureInfo.returnWTypes.map((w, i) =>
+				extType(w, returnDescs[i]?.is64),
+			),
 		);
 	}
 }
@@ -835,17 +890,25 @@ export function scanBoundaryImports(mod, meta) {
 function isGcRef(wType) {
 	return wType === "anyref" || (typeof wType === "object" && wType !== null);
 }
-function extType(wType) {
-	if (wType === "i64") return "f64";
+// A v128 crosses as an externref holding a GC array of its four i32 lanes;
+// the converting helpers are registered first thing in addBoundaryHelpers.
+const v128Conv = { from: null, to: null };
+
+function extType(wType, is64 = false) {
+	if (wType === "v128") return "externref";
+	if (wType === "i64") return is64 ? "i64" : "f64";
 	if (isGcRef(wType)) return "externref";
 	return wType;
 }
-function needsConv(wTypes) {
-	return wTypes.some((w) => w === "i64" || isGcRef(w));
+function needsConv(wTypes, descs = []) {
+	return wTypes.some(
+		(w, i) => (w === "i64" && !descs[i]?.is64) || w === "v128" || 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" }];
+function fromExt(wType, is64 = false) {
+	if (wType === "v128") return [{ op: "call", funcIndex: v128Conv.from }];
+	if (wType === "i64") return is64 ? [] : [{ op: "i64.trunc_sat_f64_s" }];
 	if (wType === "anyref") return [{ op: "any.convert_extern" }];
 	if (isGcRef(wType)) {
 		const out = [{ op: "any.convert_extern" }];
@@ -856,25 +919,31 @@ function fromExt(wType) {
 	return [];
 }
 // Instructions converting the value on the stack to its boundary form.
-function toExt(wType) {
-	if (wType === "i64") return [{ op: "f64.convert_i64_s" }];
+function toExt(wType, is64 = false) {
+	if (wType === "v128") return [{ op: "call", funcIndex: v128Conv.to }];
+	if (wType === "i64") return is64 ? [] : [{ 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]);
+function convertResults(wTypes, conv, localBase, descs = []) {
+	if (wTypes.length === 0 || !needsConv(wTypes, descs)) return [];
+	if (wTypes.length === 1) return conv(wTypes[0], descs[0]?.is64);
 	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]));
+		out.push(
+			{ op: "local.get", index: localBase + i },
+			...conv(wTypes[i], descs[i]?.is64),
+		);
 	return out;
 }
 
 function zeroInstr(wType) {
+	if (wType === "v128")
+		return { op: "v128.const", bytes: new Array(16).fill(0) };
 	if (wType === "i64") return { op: "i64.const", value: 0n };
 	if (wType === "f32" || wType === "f64")
 		return { op: `${wType}.const`, value: 0 };
@@ -926,20 +995,61 @@ export function addBoundaryHelpers(mod, meta) {
 		return idx;
 	};
 	const get = (i) => ({ op: "local.get", index: i });
+	if (needs.simd) {
+		const { arrInfo } = needs.simd;
+		const arrRef = needs.simd.wType;
+		v128Conv.to = addFunc(
+			"__v128_to",
+			["v128"],
+			["externref"],
+			[
+				...[0, 1, 2, 3].flatMap((lane) => [
+					get(0),
+					{ op: "i32x4.extract_lane", lane },
+				]),
+				{ op: "array.new_fixed", typeIndex: arrInfo.typeIndex, size: 4 },
+				{ op: "extern.convert_any" },
+			],
+			false,
+		);
+		v128Conv.from = addFunc(
+			"__v128_from",
+			["externref"],
+			["v128"],
+			[
+				get(0),
+				{ op: "any.convert_extern" },
+				{ op: "ref.cast_null", typeIndex: arrInfo.typeIndex },
+				{ op: "local.set", index: 1 },
+				get(1),
+				{ op: "i32.const", value: 0 },
+				{ op: "array.get", typeIndex: arrInfo.typeIndex },
+				{ op: "i32x4.splat" },
+				...[1, 2, 3].flatMap((lane) => [
+					get(1),
+					{ op: "i32.const", value: lane },
+					{ op: "array.get", typeIndex: arrInfo.typeIndex },
+					{ op: "i32x4.replace_lane", lane },
+				]),
+			],
+			false,
+			[arrRef],
+		);
+	}
 	// Parameter `i` converted from its boundary form.
-	const getIn = (i, wType) => [get(i), ...fromExt(wType)];
+	const getIn = (i, wType, is64 = false) => [get(i), ...fromExt(wType, is64)];
 	const EXT = "externref";
 
-	for (const [name, { info }] of needs.structs) {
+	for (const [name, { info, fields }] 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),
+			fieldWTypes.map((w, i) => extType(w, fields[i]?.desc?.is64)),
 			[EXT],
 			[
-				...fieldWTypes.flatMap((w, i) => getIn(i, w)),
+				...fieldWTypes.flatMap((w, i) => getIn(i, w, fields[i]?.desc?.is64)),
 				{ op: "struct.new", typeIndex: ti },
 				...toExt(ref),
 			],
@@ -969,23 +1079,24 @@ export function addBoundaryHelpers(mod, meta) {
 		);
 		for (let i = 0; i < info.fields.length; i++) {
 			const f = info.fields[i];
+			const is64 = Boolean(fields[i]?.desc?.is64);
 			addFunc(
 				`__get_${name}_${f.name}`,
 				[EXT],
-				[extType(f.wType)],
+				[extType(f.wType, is64)],
 				[
 					...getIn(0, ref),
 					{ op: "struct.get", typeIndex: ti, fieldIndex: i },
-					...toExt(f.wType),
+					...toExt(f.wType, is64),
 				],
 			);
 			addFunc(
 				`__set_${name}_${f.name}`,
-				[EXT, extType(f.wType)],
+				[EXT, extType(f.wType, is64)],
 				[],
 				[
 					...getIn(0, ref),
-					...getIn(1, f.wType),
+					...getIn(1, f.wType, is64),
 					{ op: "struct.set", typeIndex: ti, fieldIndex: i },
 				],
 			);
@@ -1011,25 +1122,26 @@ export function addBoundaryHelpers(mod, meta) {
 			["i32"],
 			[...getIn(0, ref), { op: "array.len" }],
 		);
+		const is64 = Boolean(desc.elem?.is64);
 		addFunc(
 			`__array_get_${key}`,
 			[EXT, "i32"],
-			[extType(arrInfo.elemWType)],
+			[extType(arrInfo.elemWType, is64)],
 			[
 				...getIn(0, ref),
 				get(1),
 				{ op: "array.get", typeIndex: arrInfo.typeIndex },
-				...toExt(arrInfo.elemWType),
+				...toExt(arrInfo.elemWType, is64),
 			],
 		);
 		addFunc(
 			`__array_set_${key}`,
-			[EXT, "i32", extType(arrInfo.elemWType)],
+			[EXT, "i32", extType(arrInfo.elemWType, is64)],
 			[],
 			[
 				...getIn(0, ref),
 				get(1),
-				...getIn(2, arrInfo.elemWType),
+				...getIn(2, arrInfo.elemWType, is64),
 				{ op: "array.set", typeIndex: arrInfo.typeIndex },
 			],
 		);
@@ -1040,6 +1152,7 @@ export function addBoundaryHelpers(mod, meta) {
 		const ref = desc.wType;
 		const arrTI = sliceInfo.arrInfo.typeIndex;
 		const sTI = sliceInfo.typeIndex;
+		const is64 = Boolean(desc.elem?.is64);
 		const elemAddr = [
 			...getIn(0, ref),
 			{ op: "struct.get", typeIndex: sTI, fieldIndex: 0 },
@@ -1071,11 +1184,11 @@ export function addBoundaryHelpers(mod, meta) {
 		addFunc(
 			`__slice_get_${key}`,
 			[EXT, "i32"],
-			[extType(sliceInfo.elemWType)],
+			[extType(sliceInfo.elemWType, is64)],
 			[
 				...elemAddr,
 				{ op: "array.get", typeIndex: arrTI },
-				...toExt(sliceInfo.elemWType),
+				...toExt(sliceInfo.elemWType, is64),
 			],
 		);
 		addFunc(
@@ -1096,11 +1209,11 @@ export function addBoundaryHelpers(mod, meta) {
 		);
 		addFunc(
 			`__slice_set_${key}`,
-			[EXT, "i32", extType(sliceInfo.elemWType)],
+			[EXT, "i32", extType(sliceInfo.elemWType, is64)],
 			[],
 			[
 				...elemAddr,
-				...getIn(2, sliceInfo.elemWType),
+				...getIn(2, sliceInfo.elemWType, is64),
 				{ op: "array.set", typeIndex: arrTI },
 			],
 		);
@@ -1110,6 +1223,8 @@ export function addBoundaryHelpers(mod, meta) {
 		const ci = desc.closureInfo;
 		const invokeIdx = mod.importCache.get(`env.__invoke$${key}`);
 		const nParams = ci.paramWTypes.length;
+		const paramDescs = desc.params ?? [];
+		const returnDescs = desc.returns ?? [];
 		// Thunk: wasm closure body calling the JS callback (boundary forms out, back in).
 		const thunkIdx = addFunc(
 			`__jsthunk$${key}`,
@@ -1118,12 +1233,17 @@ export function addBoundaryHelpers(mod, meta) {
 			[
 				get(0),
 				{ op: "extern.convert_any" },
-				...ci.paramWTypes.flatMap((w, i) => [get(i + 1), ...toExt(w)]),
+				...ci.paramWTypes.flatMap((w, i) => [
+					get(i + 1),
+					...toExt(w, paramDescs[i]?.is64),
+				]),
 				{ op: "call", funcIndex: invokeIdx },
-				...convertResults(ci.returnWTypes, fromExt, nParams + 1),
+				...convertResults(ci.returnWTypes, fromExt, nParams + 1, returnDescs),
 			],
 			false,
-			ci.returnWTypes.length > 1 ? ci.returnWTypes.map(extType) : [],
+			ci.returnWTypes.length > 1
+				? ci.returnWTypes.map((w, i) => extType(w, returnDescs[i]?.is64))
+				: [],
 		);
 		mod.addRefFuncElement(thunkIdx);
 		addFunc(
@@ -1141,16 +1261,18 @@ export function addBoundaryHelpers(mod, meta) {
 		// JS calling a wasm closure (boundary forms in, results out).
 		addFunc(
 			`__call_fn$${key}`,
-			[EXT, ...ci.paramWTypes.map(extType)],
-			ci.returnWTypes.map(extType),
+			[EXT, ...ci.paramWTypes.map((w, i) => extType(w, paramDescs[i]?.is64))],
+			ci.returnWTypes.map((w, i) => extType(w, returnDescs[i]?.is64)),
 			[
 				...getIn(0, desc.wType),
 				{ op: "struct.get", typeIndex: ci.typeIndex, fieldIndex: 1 },
-				...ci.paramWTypes.flatMap((w, i) => getIn(i + 1, w)),
+				...ci.paramWTypes.flatMap((w, i) =>
+					getIn(i + 1, w, paramDescs[i]?.is64),
+				),
 				...getIn(0, desc.wType),
 				{ op: "struct.get", typeIndex: ci.typeIndex, fieldIndex: 0 },
 				{ op: "call_ref", typeIndex: ci.funcTypeIndex },
-				...convertResults(ci.returnWTypes, toExt, nParams + 1),
+				...convertResults(ci.returnWTypes, toExt, nParams + 1, returnDescs),
 			],
 			true,
 			ci.returnWTypes.length > 1 ? ci.returnWTypes : [],
@@ -1168,16 +1290,20 @@ export function addBoundaryHelpers(mod, meta) {
 		if (sig?.form !== "func") return;
 		const paramW = sig.params;
 		const resultW = sig.results;
-		if (!needsConv(paramW) && !needsConv(resultW)) return;
-		entry.callName = `__x_${entry.exportName}`;
+		const paramDescs = entry.params ?? [];
+		const resultDescs = entry.returns ?? [];
+		if (!needsConv(paramW, paramDescs) && !needsConv(resultW, resultDescs))
+			return;
+		// Exported names become JS identifiers: no dot of a qualified type.
+		entry.callName = `__x_${entry.exportName}`.replaceAll(".", "_");
 		addFunc(
 			entry.callName,
-			paramW.map(extType),
-			resultW.map(extType),
+			paramW.map((w, i) => extType(w, paramDescs[i]?.is64)),
+			resultW.map((w, i) => extType(w, resultDescs[i]?.is64)),
 			[
-				...paramW.flatMap((w, i) => getIn(i, w)),
+				...paramW.flatMap((w, i) => getIn(i, w, paramDescs[i]?.is64)),
 				{ op: "call", funcIndex: fnIdx },
-				...convertResults(resultW, toExt, paramW.length),
+				...convertResults(resultW, toExt, paramW.length, resultDescs),
 			],
 			true,
 			resultW.length > 1 ? resultW : [],
@@ -1210,7 +1336,7 @@ export function addBoundaryHelpers(mod, meta) {
 			[get(0), get(1), { op: "struct.new", typeIndex }, ...toExt(wType)],
 		);
 		for (const v of meta.vars ?? []) {
-			const g = mod.resolveGlobal(v.name);
+			const g = v.shared ? mod.resolveGlobal(v.name) : null;
 			if (!g) continue;
 			addFunc(
 				`__var_${v.name}`,
@@ -1222,16 +1348,16 @@ export function addBoundaryHelpers(mod, meta) {
 	}
 
 	for (const [name, desc] of needs.anonStructs) {
-		const { info } = desc;
+		const { info, fields } = desc;
 		const ref = desc.wType;
 		const ti = info.typeIndex;
 		const fieldWTypes = info.fields.map((f) => f.wType);
 		addFunc(
 			`__new_${name}`,
-			fieldWTypes.map(extType),
+			fieldWTypes.map((w, i) => extType(w, fields[i]?.desc?.is64)),
 			[EXT],
 			[
-				...fieldWTypes.flatMap((w, i) => getIn(i, w)),
+				...fieldWTypes.flatMap((w, i) => getIn(i, w, fields[i]?.desc?.is64)),
 				{ op: "struct.new", typeIndex: ti },
 				...toExt(ref),
 			],
@@ -1248,23 +1374,24 @@ export function addBoundaryHelpers(mod, meta) {
 		);
 		for (let i = 0; i < info.fields.length; i++) {
 			const f = info.fields[i];
+			const is64 = Boolean(fields[i]?.desc?.is64);
 			addFunc(
 				`__get_${name}_${f.name}`,
 				[EXT],
-				[extType(f.wType)],
+				[extType(f.wType, is64)],
 				[
 					...getIn(0, ref),
 					{ op: "struct.get", typeIndex: ti, fieldIndex: i },
-					...toExt(f.wType),
+					...toExt(f.wType, is64),
 				],
 			);
 			addFunc(
 				`__set_${name}_${f.name}`,
-				[EXT, extType(f.wType)],
+				[EXT, extType(f.wType, is64)],
 				[],
 				[
 					...getIn(0, ref),
-					...getIn(1, f.wType),
+					...getIn(1, f.wType, is64),
 					{ op: "struct.set", typeIndex: ti, fieldIndex: i },
 				],
 			);
@@ -1272,40 +1399,52 @@ export function addBoundaryHelpers(mod, meta) {
 	}
 
 	for (const [key, desc] of needs.boxes) {
-		const { boxInfo } = desc;
+		const { boxInfo, base } = desc;
 		const ref = desc.wType;
 		const ti = boxInfo.typeIndex;
 		const w = boxInfo.wType;
+		const is64 = Boolean(base?.is64);
 		addFunc(
 			`__box_new_${key}`,
-			[extType(w)],
+			[extType(w, is64)],
 			[EXT],
-			[...getIn(0, w), { op: "struct.new", typeIndex: ti }, ...toExt(ref)],
+			[
+				...getIn(0, w, is64),
+				{ op: "struct.new", typeIndex: ti },
+				...toExt(ref),
+			],
 		);
+		const cast = {
+			op: "ref.cast",
+			typeIndex: boxInfo.typeIndex,
+			typeName: boxInfo.name,
+		};
 		addFunc(
 			`__box_get_${key}`,
 			[EXT],
-			[extType(w)],
+			[extType(w, is64)],
 			[
 				...getIn(0, ref),
+				cast,
 				{ op: "struct.get", typeIndex: ti, fieldIndex: 0 },
-				...toExt(w),
+				...toExt(w, is64),
 			],
 		);
 		addFunc(
 			`__box_set_${key}`,
-			[EXT, extType(w)],
+			[EXT, extType(w, is64)],
 			[],
 			[
 				...getIn(0, ref),
-				...getIn(1, w),
+				cast,
+				...getIn(1, w, is64),
 				{ op: "struct.set", typeIndex: ti, fieldIndex: 0 },
 			],
 		);
 	}
 
 	for (const [key, desc] of needs.maps) {
-		const { mapInfo, keySliceDesc, valSliceDesc } = desc;
+		const { mapInfo, keySliceDesc, valSliceDesc, keyDesc, valDesc } = desc;
 		const makeIdx = mod.resolveFuncIndex(mapInfo.makeFuncName);
 		addFunc(
 			`__map_new_${key}`,
@@ -1316,12 +1455,16 @@ export function addBoundaryHelpers(mod, meta) {
 		const setIdx = mod.resolveFuncIndex(mapInfo.setFuncName);
 		addFunc(
 			`__map_set_${key}`,
-			[EXT, extType(mapInfo.keyWType), extType(mapInfo.valWType)],
+			[
+				EXT,
+				extType(mapInfo.keyWType, keyDesc?.is64),
+				extType(mapInfo.valWType, valDesc?.is64),
+			],
 			[],
 			[
 				...getIn(0, desc.wType),
-				...getIn(1, mapInfo.keyWType),
-				...getIn(2, mapInfo.valWType),
+				...getIn(1, mapInfo.keyWType, keyDesc?.is64),
+				...getIn(2, mapInfo.valWType, valDesc?.is64),
 				{ op: "call", funcIndex: setIdx },
 			],
 		);
@@ -1380,69 +1523,27 @@ export function addBoundaryHelpers(mod, meta) {
 		);
 	}
 
-	if (needs.time) {
-		const timeInfo = mod.getStructType("time.Time");
-		if (timeInfo) {
-			const timeWType = toRef(timeInfo);
-			addFunc(
-				"__time_make",
-				["f64", "i32"],
-				[EXT],
-				[
-					get(0),
-					{ op: "f64.const", value: 1000000 },
-					{ op: "f64.mul" },
-					{ op: "i64.trunc_sat_f64_s" },
-					get(1),
-					{ op: "struct.new", typeIndex: timeInfo.typeIndex },
-					...toExt(timeWType),
-				],
-			);
-			addFunc(
-				"__time_unix_milli",
-				[EXT],
-				["f64"],
-				[
-					get(0),
-					{ op: "ref.is_null" },
-					{ op: "if", blockType: "f64" },
-					{ op: "f64.const", value: 0 },
-					{ op: "else" },
-					...getIn(0, timeWType),
-					{ op: "struct.get", typeIndex: timeInfo.typeIndex, fieldIndex: 0 },
-					{ op: "i64.const", value: 1000000n },
-					{ op: "i64.div_s" },
-					{ op: "f64.convert_i64_s" },
-					{ op: "end" },
-				],
-			);
-			addFunc(
-				"__time_offset",
-				[EXT],
-				["i32"],
-				[
-					get(0),
-					{ op: "ref.is_null" },
-					{ op: "if", blockType: "i32" },
-					{ op: "i32.const", value: 0 },
-					{ op: "else" },
-					...getIn(0, timeWType),
-					{ op: "struct.get", typeIndex: timeInfo.typeIndex, fieldIndex: 1 },
-					{ op: "end" },
-				],
-			);
-		}
-	}
-
 	for (const c of meta.consts ?? []) {
 		if (!c.dynamic) continue;
 		const g = mod.resolveGlobal(c.name);
 		if (!g) continue;
+		const is64 = Boolean(c.desc?.is64);
 		addFunc(
 			`__const_${c.name}`,
 			[],
-			[extType(c.desc.wType)],
-			[{ op: "global.get", index: g.index }, ...toExt(c.desc.wType)],
+			[extType(c.desc.wType, is64)],
+			[{ op: "global.get", index: g.index }, ...toExt(c.desc.wType, is64)],
+		);
+	}
+	for (const v of meta.vars ?? []) {
+		const g = v.shared ? null : mod.resolveGlobal(v.name);
+		if (!g) continue;
+		const is64 = Boolean(v.desc?.is64);
+		addFunc(
+			`__var_${v.name}`,
+			[],
+			[extType(v.desc.wType, is64)],
+			[{ op: "global.get", index: g.index }, ...toExt(v.desc.wType, is64)],
 		);
 	}
 }
@@ -1511,6 +1612,13 @@ function addIfaceHelpers(desc, mod, addFunc, addTrampoline) {
 
 const P = "__gfw_"; // facade helper prefix
 
+// Pieces of the strings host imports (written for use inside the templates
+// below, where a backslash escape must be doubled).
+const GO_SPACE =
+	"[ \\t\\n\\v\\f\\r\\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]";
+const BAD_RUNE = "r < 0 || r > 0x10FFFF || (r >= 0xD800 && r <= 0xDFFF)";
+const SURROGATE = "(v >= 0xD800 && v <= 0xDFFF)";
+
 // JS expression converting JS value `v` into the wasm representation.
 function inExpr(desc, v) {
 	switch (desc.k) {
@@ -1519,7 +1627,7 @@ function inExpr(desc, v) {
 		case "i32":
 			return `(${v} | 0)`;
 		case "i64":
-			return `${P}i64in(${v})`;
+			return desc.is64 ? `BigInt(${v})` : `${P}i64in(${v})`;
 		case "f32":
 		case "f64":
 			return `(+${v})`;
@@ -1529,8 +1637,10 @@ function inExpr(desc, v) {
 			return `(${v} === undefined ? null : ${v})`;
 		case "error":
 			return `${P}errin(${v})`;
-		case "time":
-			return desc.ptr ? `${P}timein_ptr(${v})` : `${P}timein(${v})`;
+		case "f32x4":
+			return `${P}f32x4in(${v})`;
+		case "mask4":
+			return `${P}mask4in(${v})`;
 		case "map":
 			return `${P}mapin_${desc.key}(${v})`;
 		case "ptr_box":
@@ -1568,13 +1678,19 @@ function outExpr(desc, v) {
 		case "i32":
 			return desc.unsigned ? `(${v} >>> 0)` : v;
 		case "i64":
+			if (desc.is64)
+				return desc.unsigned
+					? `BigInt.asUintN(64, ${v})`
+					: `BigInt.asIntN(64, ${v})`;
 			return desc.unsigned ? `${P}u64out(${v})` : `${P}i64out(${v})`;
 		case "string":
 			return `(${v} ?? "")`;
 		case "error":
 			return `${P}errout(${v})`;
-		case "time":
-			return desc.ptr ? `${P}timeout_ptr(${v})` : `${P}timeout(${v})`;
+		case "f32x4":
+			return `${P}f32x4out(${v})`;
+		case "mask4":
+			return `${P}mask4out(${v})`;
 		case "map":
 			return `${P}mapout_${desc.key}(${v})`;
 		case "ptr_box":
@@ -1607,14 +1723,18 @@ function zeroExpr(desc) {
 		case "bool":
 			return "false";
 		case "i32":
-		case "i64":
 		case "f32":
 		case "f64":
 			return "0";
+		case "i64":
+			return desc.is64 ? "0n" : "0";
 		case "string":
 			return '""';
+		case "f32x4":
+			return "new Float32Array(4)";
+		case "mask4":
+			return "[false, false, false, false]";
 		case "error":
-		case "time":
 		case "map":
 		case "ptr_box":
 			return "null";
@@ -1729,28 +1849,26 @@ function indent(text, prefix) {
 // 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) {
+function ${P}imports(stringTable, extraEnv, tag, write, toStderr) {
+	// Each instance numbers the references fmt_ptr_id is asked about from 1
+	// (the table the JS body of that intrinsic uses).
+	globalThis.__fmtptr = { m: new WeakMap(), n: 1 };
 	let lineBuf = "";
-	let targs = [];
-	let fmtStructMap = new WeakMap();
 	const late = { exports: null };
-	const flush = () => { write(lineBuf); lineBuf = ""; };
+	// Go separates operands with a space unconditionally, so track whether the
+	// current line already holds an operand (an empty string leaves lineBuf empty).
+	let started = false;
+	const flush = () => { write(lineBuf); lineBuf = ""; started = false; };
 	const print = (v) => {
-		const s = String(v);
-		if (lineBuf.length > 0 && !lineBuf.endsWith(" ") && !s.startsWith(" ")) {
-			lineBuf += " ";
-		}
+		const s = Object.is(v, -0) ? "-0" : String(v);
+		if (started) lineBuf += " ";
+		started = true;
 		lineBuf += s;
 	};
 	const println = (v) => {
-		const s = String(v);
-		if (lineBuf.length > 0 && !lineBuf.endsWith(" ") && !s.startsWith(" ")) {
-			lineBuf += " ";
-		}
-		lineBuf += s;
+		print(v);
 		flush();
 	};
-	const targ = (v) => { targs.push(v); };
 	let utf8Encoded = null;
 	let convBytes = null, convPos = 0;
 	const env = {
@@ -1762,7 +1880,9 @@ function ${P}imports(stringTable, extraEnv, tag, write) {
 			} catch {
 				str = "[panic object]";
 			}
-			throw new Error(str);
+			const err = new Error(str);
+			err.__gfp = true;
+			throw err;
 		},
 		"str": (i) => stringTable[i] ?? "",
 		"str_len": (s) => (s ? s.length : 0),
@@ -1775,7 +1895,7 @@ function ${P}imports(stringTable, extraEnv, tag, write) {
 		"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_from_code_point": (c) => String.fromCodePoint(c >= 0 && c <= 0x10ffff && !(c >= 0xd800 && c <= 0xdfff) ? c : 0xfffd),
 		"str_code_point_at": (s, i) => (s ? s.codePointAt(i) : 0),
 		"str_hash": (s) => {
 			if (!s) return 0;
@@ -1785,28 +1905,109 @@ function ${P}imports(stringTable, extraEnv, tag, write) {
 			}
 			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_to_upper": (s) => ${P}mapCase(s ?? "", "toUpperCase"),
+		"str_to_lower": (s) => ${P}mapCase(s ?? "", "toLowerCase"),
+		"str_trim_space": (s) => {
+			s = s ?? "";
+			const sp = /${GO_SPACE}/;
+			let i = 0, j = s.length;
+			while (i < j && sp.test(s[i])) i++;
+			while (j > i && sp.test(s[j - 1])) j--;
+			return s.slice(i, j);
+		},
+		"str_contains": (s, sub) => ((s ?? "").includes(sub ?? "") ? 1 : 0),
+		"str_has_prefix": (s, pre) => ((s ?? "").startsWith(pre ?? "") ? 1 : 0),
+		"str_has_suffix": (s, suf) => ((s ?? "").endsWith(suf ?? "") ? 1 : 0),
+		"os_write": (fd, s) => {
+			if (fd === 2 && toStderr && typeof process !== "undefined" && process.stderr?.write) { process.stderr.write(s ?? ""); return; }
+			lineBuf += s ?? "";
+			const nl = lineBuf.lastIndexOf("\\n");
+			if (nl >= 0) { write(lineBuf.slice(0, nl)); lineBuf = lineBuf.slice(nl + 1); }
+		},
+		"time_now_ms": () => (typeof globalThis.__GOFRONT_CLOCK === "function" ? globalThis.__GOFRONT_CLOCK() : Date.now()),
+		"time_timezone_offset": (ms) => (-new Date(ms).getTimezoneOffset() * 60) | 0,
+		"os_exit": (code) => {
+			if (lineBuf !== "") { write(lineBuf); lineBuf = ""; }
+			if (typeof process !== "undefined" && process.exit) process.exit(code);
+			throw new Error("os.Exit(" + code + ")");
+		},
+		"os_getenv": (k) => (typeof process !== "undefined" && process.env ? process.env : (globalThis.__os_env ??= {}))[k ?? ""] ?? "",
+		"os_setenv": (k, v) => { (typeof process !== "undefined" && process.env ? process.env : (globalThis.__os_env ??= {}))[k ?? ""] = v ?? ""; },
+		"unicode_is": (r, k) => { ${unicodeIsJs("r", "k")} },
+		"unicode_to_upper": (r) => { ${unicodeToUpperJs("r")} },
+		"unicode_to_lower": (r) => { ${unicodeToLowerJs("r")} },
+		"testing_nanotime": () => performance.now() * 1e6,
+		"testing_match": (p, s) => new RegExp(p ?? "").test(s ?? "") ? 1 : 0,
+		"fmt_ptr_id": (o) => {
+			if (o === null || o === undefined || (typeof o !== "object" && typeof o !== "function")) return 0;
+			const t = globalThis.__fmtptr;
+			let id = t.m.get(o);
+			if (!id) { id = t.n++; t.m.set(o, id); }
+			return id;
+		},
+		"crypto_rand_u32": () => {
+			const c = typeof crypto !== "undefined" ? crypto : globalThis.crypto;
+			return c?.getRandomValues ? c.getRandomValues(new Uint32Array(1))[0] | 0 : (Math.random() * 4294967296) | 0;
+		},
+		"strconv_shortest": (f) => f.toExponential(),
+		"strconv_fixed": ${FIXED_FLOAT_JS},
+		"strconv_parse_decimal": (s) => Number((s ?? "").replaceAll("_", "")),
+		"str_index": (s, sub) => (s ?? "").indexOf(sub ?? ""),
+		"str_last_index": (s, sub) => (s ?? "").lastIndexOf(sub ?? ""),
+		"str_index_byte": (s, b) => (s ?? "").indexOf(String.fromCharCode(b)),
+		"str_last_index_byte": (s, b) => (s ?? "").lastIndexOf(String.fromCharCode(b)),
+		"str_index_rune": (s, r) => (${BAD_RUNE} ? -1 : (s ?? "").indexOf(String.fromCodePoint(r))),
+		"str_contains_rune": (s, r) => (!(${BAD_RUNE}) && (s ?? "").includes(String.fromCodePoint(r)) ? 1 : 0),
+		"str_index_any": (s, cs) => {
+			s = s ?? "";
+			let m = -1;
+			for (const c of (cs ?? "")) {
+				const v = c.codePointAt(0);
+				if (${SURROGATE}) continue;
+				const i = s.indexOf(c);
+				if (i >= 0 && (m < 0 || i < m)) m = i;
+			}
+			return m;
+		},
+		"str_last_index_any": (s, cs) => {
+			s = s ?? "";
+			let m = -1;
+			for (const c of (cs ?? "")) {
+				const v = c.codePointAt(0);
+				if (${SURROGATE}) continue;
+				const i = s.lastIndexOf(c);
+				if (i > m) m = i;
+			}
+			return m;
+		},
+		"str_contains_any": (s, cs) => {
+			s = s ?? "";
+			for (const c of (cs ?? "")) {
+				const v = c.codePointAt(0);
+				if (!${SURROGATE} && s.includes(c)) return 1;
+			}
+			return 0;
 		},
+		"str_count": (s, t) => {
+			s = s ?? ""; t = t ?? "";
+			if (t === "") return [...s].length + 1;
+			let n = 0;
+			for (let i = s.indexOf(t); i !== -1; i = s.indexOf(t, i + t.length)) n++;
+			return n;
+		},
+		"str_replace": (s, o, w, n) => ${P}replace(s ?? "", o ?? "", w ?? "", n),
+		"str_replace_all": (s, o, w) => ${P}replace(s ?? "", o ?? "", w ?? "", -1),
+		"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 ?? "").startsWith(p ?? "") ? (s ?? "").slice((p ?? "").length) : (s ?? "")),
+		"str_trim_suffix": (s, p) => ((s ?? "").endsWith(p ?? "") ? (s ?? "").slice(0, (s ?? "").length - (p ?? "").length) : (s ?? "")),
 		"str_from_i64": (n) => String(n),
 		"str_from_i32": (n) => String(n),
-		"str_from_f64": (f) => String(f),
+		"str_from_f64": (f) => (Object.is(f, -0) ? "-0" : String(f)),
 		"is_string": (v) => (typeof v === "string" ? 1 : 0),
 		"str_to_bytes": (s) => {
-			utf8Encoded = new TextEncoder().encode(s ?? "");
+			utf8Encoded = ${P}u8enc(s ?? "");
 			return utf8Encoded.length;
 		},
 		"str_byte_at": (i) => (utf8Encoded ? (utf8Encoded[i] ?? 0) : 0),
@@ -1826,636 +2027,127 @@ function ${P}imports(stringTable, extraEnv, tag, write) {
 		},
 		"print_i32": print, "print_i64": print, "print_f32": print, "print_f64": print,
 		"print_str": print, "print_any": print,
+		"print_u64": (v) => print(BigInt.asUintN(64, v)),
+		"println_u64": (v) => println(BigInt.asUintN(64, v)),
+		"print_reset": () => { started = false; },
 		"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,
-		"fmt_new_array": () => [],
-		"fmt_array_push": (arr, v) => { arr.push(v); },
-		"fmt_new_map": () => new Map(),
-		"fmt_map_set": (m, k, v) => { m.set(k, v); },
-		"fmt_new_struct": (ref, isPtr) => {
-			if (ref !== null && ref !== undefined && typeof ref === "object" && fmtStructMap.has(ref)) {
-				return fmtStructMap.get(ref);
-			}
-			const o = {};
-			Object.defineProperty(o, "__struct", { value: true, configurable: true });
-			if (isPtr !== 0) Object.defineProperty(o, "__p", { value: true, configurable: true });
-			if (ref !== null && ref !== undefined && typeof ref === "object") fmtStructMap.set(ref, o);
-			return o;
-		},
-		"fmt_struct_set": (o, k, v) => { o[typeof k === "number" ? stringTable[k] : k] = v; },
-		"fmt_box_i32": (v) => v,
-		"fmt_box_i64": (v) => (v > ${P}MAX || v < -${P}MAX ? v : Number(v)),
-		"fmt_box_f64": (v) => v,
-		"fmt_box_bool": (v) => v !== 0,
-		"fmt_new_box": () => ({ value: null, __p: true, __box: true }),
-		"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 = []; fmtStructMap = new WeakMap(); 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 = []; fmtStructMap = new WeakMap(); 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);
+	// A host import that throws raises a Go panic: the module's panic stack
+	// gets the message (as env.panic does through __push_panic) before the
+	// error unwinds, so recover() in a calling frame sees it.  Errors already
+	// pushed (env.panic, nested calls into the module) are marked and pass
+	// through; traps and wasm exceptions are not host panics.
+	const hostPanic = (e) => {
+		if (e !== null && typeof e === "object") {
+			if (e.__gfp === true) return;
+			if (typeof WebAssembly !== "undefined" && (e instanceof WebAssembly.Exception || e instanceof WebAssembly.RuntimeError)) return;
+			try { e.__gfp = true; } catch {}
+		}
+		const push = late.exports && late.exports.__push_panic;
+		if (push) push(String(e !== null && typeof e === "object" && e.message !== undefined ? e.message : e));
+	};
+	for (const k of Object.keys(env)) {
+		const fn = env[k];
+		if (typeof fn !== "function" || k === "panic" || k === "panicTag") continue;
+		env[k] = function () {
+			try { return fn.apply(this, arguments); } catch (e) { hostPanic(e); throw e; }
+		};
+	}
 	const m = {};
-	for (const k of ["sin", "cos", "tan", "asin", "acos", "atan", "atan2", "pow", "exp", "log", "log2", "log10", "cbrt", "hypot", "random", "sinh", "cosh", "tanh"]) m[k] = Math[k];
+	for (const k of ["sin", "cos", "tan", "asin", "acos", "atan", "atan2", "pow", "exp", "log", "log2", "log10", "cbrt", "hypot", "random", "sinh", "cosh", "tanh", "log1p", "expm1"]) 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_ERROR}
-${HELPER_SPRINTF}
-${HELPER_STRCONV}
-${HELPER_PATH_CLEAN}
-${HELPER_DURATION}
-${HELPER_SHA256}
-${HELPER_HEX}
-${HELPER_BASE64}
-function ${P}stdlib(stringTable, io) {
-	let parts = [];
-	let cutBefore = "", cutAfter = "";
-	let strconvErr = null, strconvErrKind = 0;
-	let decodeSize = 0;
-	let replacerTarget = "", replacerPairs = [];
-	let splitDir = "", splitFile = "";
-	let joinParts = [];
-	let matchHasErr = 0;
-	let trimStart = 0, trimEnd = 0;
-	let sscanTokens = [];
-	let sscanHasErr = 0, sscanErrMsg = "";
-	let timeParseErr = null, timeParseOffset = 0;
-	let rawBytes = new Uint8Array(0);
-	let rawPos = 0;
-	let hexErr = null;
-	let base64Err = null;
-	let customBase64Encodings = [];
-	return {
-		"fmt_sscan_init": (s, mode) => {
-			sscanHasErr = 0;
-			sscanErrMsg = "";
-			const str = s ?? "";
-			sscanTokens = (mode === 1 ? str.split("\\n")[0] : str).trim().split(/\\s+/).filter(Boolean);
-			return sscanTokens.length;
-		},
-		"fmt_sscanf_init": (s, fmt) => {
-			sscanHasErr = 0;
-			sscanErrMsg = "";
-			const str = s ?? "";
-			const fmtStr = fmt ?? "";
-			let si = 0, fi = 0;
-			sscanTokens = [];
-			while (fi < fmtStr.length) {
-				if (/\\s/.test(fmtStr[fi])) {
-					while (fi < fmtStr.length && /\\s/.test(fmtStr[fi])) fi++;
-					while (si < str.length && /\\s/.test(str[si])) si++;
-					continue;
-				}
-				if (fmtStr[fi] === "%") {
-					if (fi + 1 < fmtStr.length && fmtStr[fi + 1] === "%") {
-						if (str[si] !== "%") {
-							sscanHasErr = 1;
-							sscanErrMsg = "input does not match format";
-							break;
-						}
-						si++;
-						fi += 2;
-						continue;
-					}
-					const vm = fmtStr.slice(fi).match(/^%[vdsfqtxXbcoeEfFgG]/);
-					if (vm) {
-						const verb = vm[0];
-						fi += verb.length;
-						if (verb !== "%c") {
-							while (si < str.length && /\\s/.test(str[si])) si++;
-						}
-						if (si >= str.length) break;
-						let tokRe = /^\\S+/;
-						if (verb === "%d" || verb === "%i") tokRe = /^[+-]?\\d+/;
-						else if (verb === "%f" || verb === "%F" || verb === "%e" || verb === "%E" || verb === "%g" || verb === "%G") tokRe = /^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?/;
-						else if (verb === "%t") tokRe = /^(?:true|false|1|0|t|f|T|F|TRUE|FALSE)/;
-						else if (verb === "%x" || verb === "%X") tokRe = /^[+-]?(?:0x)?[0-9a-fA-F]+/;
-						else if (verb === "%c") tokRe = /^[\\s\\S]/;
-						const m = str.slice(si).match(tokRe);
-						if (!m) {
-							sscanHasErr = 1;
-							sscanErrMsg = "input does not match format";
-							break;
-						}
-						sscanTokens.push(m[0]);
-						si += m[0].length;
-						continue;
-					}
-				}
-				if (si >= str.length) break;
-				if (str[si] !== fmtStr[fi]) {
-					sscanHasErr = 1;
-					sscanErrMsg = "input does not match format";
-					break;
-				}
-				si++;
-				fi++;
-			}
-			return sscanTokens.length;
-		},
-		"fmt_sscan_has_err": () => sscanHasErr,
-		"fmt_sscan_err_msg": () => sscanErrMsg || "syntax error",
-		"fmt_sscan_token_str": (i) => sscanTokens[i] ?? "",
-		"fmt_sscan_token_i64": (i) => {
-			if (i >= sscanTokens.length) { sscanHasErr = 1; sscanErrMsg = "unexpected EOF"; return 0n; }
-			const t = sscanTokens[i];
-			if (/^[+-]?(?:0[xX])?[0-9a-fA-F]+$/.test(t)) {
-				try {
-					if (/^[+-]?[0-9a-fA-F]+$/.test(t) && /[a-fA-F]/.test(t)) {
-						return BigInt("0x" + t);
-					}
-					return BigInt(t);
-				} catch {}
-			}
-			if (t.length === 1) {
-				return BigInt(t.charCodeAt(0));
-			}
-			sscanHasErr = 1;
-			sscanErrMsg = "expected integer";
-			return 0n;
-		},
-		"fmt_sscan_token_f64": (i) => {
-			if (i >= sscanTokens.length) { sscanHasErr = 1; sscanErrMsg = "unexpected EOF"; return 0; }
-			const t = sscanTokens[i];
-			const n = Number(t);
-			if (Number.isNaN(n) || !/^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?$/.test(t)) {
-				sscanHasErr = 1;
-				sscanErrMsg = "expected float";
-				return 0;
-			}
-			return n;
-		},
-		"fmt_sscan_token_bool": (i) => {
-			if (i >= sscanTokens.length) { sscanHasErr = 1; sscanErrMsg = "unexpected EOF"; return 0; }
-			const t = sscanTokens[i]?.toLowerCase();
-			if (t === "true" || t === "1" || t === "t") return 1;
-			if (t === "false" || t === "0" || t === "f") return 0;
-			sscanHasErr = 1;
-			sscanErrMsg = "expected boolean";
-			return 0;
-		},
-		"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())); },
-		"fmt_format_v": (v) => { const res = __sprintf("%v", v); io.take(); return res; },
-		"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_cut": (s, sep) => {
-			const i = (s ?? "").indexOf(sep ?? "");
-			if (i < 0) { cutBefore = s ?? ""; cutAfter = ""; return 0; }
-			cutBefore = (s ?? "").slice(0, i);
-			cutAfter = (s ?? "").slice(i + (sep ?? "").length);
-			return 1;
-		},
-		"str_cut_before": () => cutBefore,
-		"str_cut_after": () => cutAfter,
-		"str_cut_prefix": (s, p) => {
-			s = s ?? ""; p = p ?? "";
-			if (s.startsWith(p)) { cutAfter = s.slice(p.length); return 1; }
-			cutAfter = s; return 0;
-		},
-		"str_cut_suffix": (s, suf) => {
-			s = s ?? ""; suf = suf ?? "";
-			if (s.endsWith(suf)) { cutBefore = s.slice(0, s.length - suf.length); return 1; }
-			cutBefore = s; return 0;
-		},
-		"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_last_index_any": (s, cs) => {
-			s = s ?? ""; let best = -1;
-			for (const c of (cs ?? "")) {
-				const i = s.lastIndexOf(c);
-				if (i > best) best = i;
-			}
-			return best;
-		},
-		"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_split_n": (s, sep, n) => {
-			s = s ?? ""; sep = sep ?? "";
-			if (n === 0) return -1;
-			if (n < 0) { parts = sep === "" ? [...s] : s.split(sep); return parts.length; }
-			if (sep === "") {
-				const chars = [...s];
-				if (chars.length <= n) { parts = chars; return parts.length; }
-				const r = chars.slice(0, n - 1);
-				r.push(chars.slice(n - 1).join(""));
-				parts = r;
-				return parts.length;
-			}
-			const r = [];
-			let cur = s;
-			for (let i = 1; i < n && cur.length; i++) {
-				const j = cur.indexOf(sep);
-				if (j < 0) break;
-				r.push(cur.slice(0, j));
-				cur = cur.slice(j + sep.length);
-			}
-			r.push(cur);
-			parts = r;
-			return parts.length;
-		},
-		"str_split_after": (s, sep) => {
-			s = s ?? ""; sep = sep ?? "";
-			if (sep === "") { parts = [...s]; return parts.length; }
-			const r = [];
-			let cur = s;
-			while (true) {
-				const j = cur.indexOf(sep);
-				if (j < 0) { r.push(cur); break; }
-				r.push(cur.slice(0, j + sep.length));
-				cur = cur.slice(j + sep.length);
-			}
-			parts = r;
-			return parts.length;
-		},
-		"str_split_after_n": (s, sep, n) => {
-			s = s ?? ""; sep = sep ?? "";
-			if (n === 0) return -1;
-			if (sep === "") {
-				const chars = [...s];
-				if (n < 0 || chars.length <= n) parts = chars;
-				else {
-					const r = chars.slice(0, n - 1);
-					r.push(chars.slice(n - 1).join(""));
-					parts = r;
-				}
-				return parts.length;
-			}
-			const r = [];
-			let cur = s;
-			for (let i = 1; (n < 0 || i < n) && cur.length; i++) {
-				const j = cur.indexOf(sep);
-				if (j < 0) break;
-				r.push(cur.slice(0, j + sep.length));
-				cur = cur.slice(j + sep.length);
-			}
-			r.push(cur);
-			parts = r;
-			return parts.length;
-		},
-		"str_fields": (s) => { parts = (s ?? "").split(/\\s+/).filter((p) => p !== ""); return parts.length; },
-		"str_part": (i) => parts[i] ?? "",
-		"str_replacer_init": (s) => {
-			replacerTarget = s ?? "";
-			replacerPairs = [];
-		},
-		"str_replacer_add": (o, n) => {
-			replacerPairs.push([o ?? "", n ?? ""]);
-		},
-		"str_replacer_run": () => {
-			let s = replacerTarget;
-			if (!replacerPairs.length || s === "") return s;
-			let out = "";
-			let i = 0;
-			while (i < s.length) {
-				let matched = false;
-				for (let k = 0; k < replacerPairs.length; k++) {
-					const [oldStr, newStr] = replacerPairs[k];
-					if (oldStr.length > 0 && s.startsWith(oldStr, i)) {
-						out += newStr;
-						i += oldStr.length;
-						matched = true;
-						break;
-					}
-				}
-				if (!matched) {
-					out += s[i];
-					i++;
-				}
-			}
-			return out;
-		},
-		"strconv_atoi": (s) => {
-			const r = __strconv_atoi(s ?? "");
-			strconvErr = r[1];
-			strconvErrKind = r[1] ? (r[1].includes("invalid syntax") ? 1 : r[1].includes("value out of range") ? 2 : 0) : 0;
-			return r[0];
-		},
-		"strconv_parse_int": (s, base, bits) => {
-			const r = __strconv_parse_int(s ?? "", base, bits);
-			strconvErr = r[1];
-			strconvErrKind = r[1] ? (r[1].includes("invalid syntax") ? 1 : r[1].includes("value out of range") ? 2 : 0) : 0;
-			return r[0];
-		},
-		"strconv_parse_float": (s) => {
-			const r = __strconv_parse_float(s ?? "");
-			strconvErr = r[1];
-			strconvErrKind = r[1] ? (r[1].includes("invalid syntax") ? 1 : r[1].includes("value out of range") ? 2 : 0) : 0;
-			return r[0];
-		},
-		"strconv_parse_bool": (s) => {
-			const r = __strconv_parse_bool(s ?? "");
-			strconvErr = r[1];
-			strconvErrKind = r[1] ? (r[1].includes("invalid syntax") ? 1 : r[1].includes("value out of range") ? 2 : 0) : 0;
-			return r[0] ? 1 : 0;
-		},
-		"strconv_err": () => strconvErr,
-		"strconv_err_kind": () => strconvErrKind,
-		"strconv_format_float": (f, fmtc, prec, _bits) => __strconv_format_float(f, fmtc, prec),
-		"strconv_format_int": (n, base) => n.toString(base),
-		"strconv_format_uint": (n, base) => BigInt.asUintN(64, BigInt(n)).toString(base),
-		"strconv_parse_uint": (s, base, bits) => {
-			const r = __strconv_parse_uint(s ?? "", base, bits);
-			strconvErr = r[1];
-			strconvErrKind = r[1] ? (r[1].includes("invalid syntax") ? 1 : r[1].includes("value out of range") ? 2 : 0) : 0;
-			return r[0];
-		},
-		"strconv_quote": (s) => JSON.stringify(s ?? ""),
-		"strconv_unquote": (s) => {
-			s = s ?? "";
-			if (s.startsWith("\`") && s.endsWith("\`") && s.length >= 2) {
-				if (s.slice(1, -1).includes("\`")) {
-					strconvErr = "invalid syntax";
-					strconvErrKind = 1;
-					return "";
-				}
-				strconvErr = null;
-				strconvErrKind = 0;
-				return s.slice(1, -1);
-			}
-			try {
-				const v = JSON.parse(s);
-				if (typeof v !== "string") {
-					strconvErr = "invalid syntax";
-					strconvErrKind = 1;
-					return "";
-				}
-				strconvErr = null;
-				strconvErrKind = 0;
-				return v;
-			} catch (e) {
-				strconvErr = "invalid syntax";
-				strconvErrKind = 1;
-				return "";
-			}
-		},
-		"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; },
-		// unicode
-		"unicode_is_letter": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return (c && /\\p{L}/u.test(c)) ? 1 : 0; },
-		"unicode_is_digit": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return (c && /\\p{Nd}/u.test(c)) ? 1 : 0; },
-		"unicode_is_space": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return (c && /\\s/u.test(c)) ? 1 : 0; },
-		"unicode_is_upper": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return (c && /\\p{Lu}/u.test(c)) ? 1 : 0; },
-		"unicode_is_lower": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return (c && /\\p{Ll}/u.test(c)) ? 1 : 0; },
-		"unicode_is_punct": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return (c && /\\p{P}/u.test(c)) ? 1 : 0; },
-		"unicode_is_control": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return (c && /\\p{Cc}/u.test(c)) ? 1 : 0; },
-		"unicode_is_print": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return (c && !/\\p{Cc}/u.test(c)) ? 1 : 0; },
-		"unicode_is_graphic": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return (c && !/\\p{Cc}/u.test(c)) ? 1 : 0; },
-		"unicode_to_upper": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return c ? (c.toUpperCase().codePointAt(0) ?? r) : r; },
-		"unicode_to_lower": (r) => { const c = (r >= 0 && r <= 0x10ffff) ? String.fromCodePoint(r) : null; return c ? (c.toLowerCase().codePointAt(0) ?? r) : r; },
-		// html
-		"html_escape": (s) => (s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&#34;").replace(/'/g, "&#39;"),
-		"html_unescape": (s) => (s ?? "").replace(/&(?:quot|apos|#39|#34|gt|lt|amp|#(?:[0-9]+|[xX][0-9a-fA-F]+));/g, (m) => {
-			switch (m) {
-				case "&quot;": case "&#34;": return '"';
-				case "&apos;": case "&#39;": return "'";
-				case "&gt;": return ">";
-				case "&lt;": return "<";
-				case "&amp;": return "&";
-				default: {
-					if (m.startsWith("&#")) {
-						const raw = m.slice(2, -1);
-						const cp = (raw.startsWith("x") || raw.startsWith("X")) ? parseInt(raw.slice(1), 16) : parseInt(raw, 10);
-						return (cp >= 0 && cp <= 0x10FFFF && !(cp >= 0xD800 && cp <= 0xDFFF)) ? String.fromCodePoint(cp) : "\\uFFFD";
-					}
-					return m;
-				}
-			}
-		}),
-		// path
-		"path_base": (p) => { if (!p) return "."; const stripped = p.replace(/\\/+$/, ""); if (!stripped) return "/"; const i = stripped.lastIndexOf("/"); return i < 0 ? stripped : stripped.slice(i + 1) || "/"; },
-		"path_dir": (p) => { const s = p ?? ""; const i = s.lastIndexOf("/"); if (i < 0) return "."; const res = s.slice(0, i); return res === "" ? "/" : __pathClean(res); },
-		"path_ext": (p) => { const s = p ?? ""; const b = s.slice(s.lastIndexOf("/") + 1); const i = b.lastIndexOf("."); return i <= 0 ? "" : b.slice(i); },
-		"path_is_abs": (p) => (p ?? "").startsWith("/") ? 1 : 0,
-		"path_clean": (p) => __pathClean(p ?? ""),
-		"path_split": (p) => {
-			const s = p ?? "";
-			const i = s.lastIndexOf("/");
-			if (i < 0) { splitDir = ""; splitFile = s; }
-			else { splitDir = s.slice(0, i + 1); splitFile = s.slice(i + 1); }
-		},
-		"path_split_dir": () => splitDir,
-		"path_split_file": () => splitFile,
-		"path_join_init": () => { joinParts = []; },
-		"path_join_push": (s) => { if (s) joinParts.push(s); },
-		"path_join_run": () => {
-			if (joinParts.length === 0) return "";
-			const res = __pathClean(joinParts.join("/"));
-			joinParts = [];
-			return res;
-		},
-		"path_match": (pat, name) => {
-			const r = __pathMatch(pat ?? "", name ?? "");
-			matchHasErr = r[1] ? 1 : 0;
-			return r[0] ? 1 : 0;
-		},
-		"path_match_has_err": () => matchHasErr,
-		// bytes trim
-		"bytes_trim": (s, cutset, left, right) => {
-			const cs = new Set(Array.from(cutset ?? ""));
-			const chars = Array.from(s ?? "");
-			let a = 0, b = chars.length;
-			if (left) while (a < b && cs.has(chars[a])) a++;
-			if (right) while (b > a && cs.has(chars[b - 1])) b--;
-			const enc = new TextEncoder();
-			trimStart = a === 0 ? 0 : enc.encode(chars.slice(0, a).join("")).length;
-			trimEnd = b === chars.length ? enc.encode(s ?? "").length : enc.encode(chars.slice(0, b).join("")).length;
-		},
-		"bytes_trim_start": () => trimStart,
-		"bytes_trim_end": () => trimEnd,
-		// time
-		"time_now_ms": () => (typeof globalThis.__GOFRONT_CLOCK === "function" ? globalThis.__GOFRONT_CLOCK() : Date.now()),
-		"time_timezone_offset": (ms) => -new Date(ms).getTimezoneOffset() * 60,
-		"time_duration_string": (d) => __durationString(d),
-		"time_parse": (layout, val) => {
-			try {
-				const d = new Date(val ?? "");
-				if (isNaN(d.getTime())) throw 0;
-				timeParseErr = null;
-				timeParseOffset = -d.getTimezoneOffset() * 60;
-				return d.getTime();
-			} catch {
-				timeParseErr = "parsing time: cannot parse";
-				timeParseOffset = 0;
-				return 0;
-			}
-		},
-		"time_parse_err": () => timeParseErr,
-		"time_parse_offset": () => timeParseOffset,
-		"time_format": (y, m, d, hr, min, sec, wd, ms, offsetSec, layout) => {
-			const DAYS = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
-			const MONTHS = ["January","February","March","April","May","June","July","August","September","October","November","December"];
-			const pad = (n, w = 2) => String(n).padStart(w, "0");
-			return (layout ?? "").replace(/2006|06|Monday|Mon|January|Jan|01|02|15|PM|pm|03|04|05|Z07:00|\\.(?:0+|9+)|1|2|3|4|5/g, t => {
-				if (t.startsWith(".")) {
-					const isZeroPad = t.includes("0");
-					const maxLen = t.length - 1;
-					let frac = pad(ms % 1000, 3);
-					if (maxLen > 3) frac = frac.padEnd(maxLen, "0");
-					else frac = frac.slice(0, maxLen);
-					if (!isZeroPad) {
-						frac = frac.replace(/0+$/, "");
-						return frac.length > 0 ? "." + frac : "";
-					}
-					return "." + frac;
-				}
-				switch (t) {
-					case "2006": return String(y);
-					case "06":   return String(y).slice(-2);
-					case "Monday": return DAYS[wd];
-					case "Mon":    return DAYS[wd].slice(0, 3);
-					case "January": return MONTHS[m - 1];
-					case "Jan":     return MONTHS[m - 1].slice(0, 3);
-					case "01": return pad(m);
-					case "1":  return String(m);
-					case "02": return pad(d);
-					case "2":  return String(d);
-					case "15": return pad(hr);
-					case "PM": return hr < 12 ? "AM" : "PM";
-					case "pm": return hr < 12 ? "am" : "pm";
-					case "03": return pad(hr % 12 || 12);
-					case "3":  return String(hr % 12 || 12);
-					case "04": return pad(min);
-					case "4":  return String(min);
-					case "05": return pad(sec);
-					case "5":  return String(sec);
-					case "Z07:00": {
-						const o = Math.floor(offsetSec / 60);
-						return o === 0 ? "Z" : (o > 0 ? "+" : "-") + pad(Math.floor(Math.abs(o) / 60)) + ":" + pad(Math.abs(o) % 60);
-					}
-					default: return t;
-				}
-			});
-		},
-		"raw_bytes_init": (len) => {
-			rawBytes = new Uint8Array(len);
-			rawPos = 0;
-		},
-		"raw_bytes_push": (b) => {
-			if (rawPos < rawBytes.length) {
-				rawBytes[rawPos++] = b & 0xff;
-			}
-		},
-		"raw_bytes_len": () => rawBytes.length,
-		"raw_bytes_get": (i) => rawBytes[i] ?? 0,
-		"crypto_rand_fill": (len) => {
-			rawBytes = new Uint8Array(len);
-			if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-				const CHUNK = 65536;
-				for (let offset = 0; offset < len; offset += CHUNK) {
-					crypto.getRandomValues(rawBytes.subarray(offset, Math.min(offset + CHUNK, len)));
-				}
-			} else {
-				for (let i = 0; i < len; i++) rawBytes[i] = Math.floor(Math.random() * 256);
-			}
-			return len;
-		},
-		"crypto_sha256_sum": () => {
-			const d = __sha256.Sum256(rawBytes);
-			rawBytes = new Uint8Array(d);
-			return 32;
-		},
-		"hex_encode_to_string": () => {
-			return __hex_encode_to_string(rawBytes);
-		},
-		"hex_decode_string": (s) => {
-			const [res, err] = __hex_decode_string(s ?? "");
-			hexErr = err ? (err.message ?? String(err)) : null;
-			rawBytes = new Uint8Array(res);
-			return rawBytes.length;
-		},
-		"hex_get_err": () => hexErr,
-		"base64_new_encoding": (alphabet) => {
-			const id = customBase64Encodings.length + 4;
-			customBase64Encodings.push(__base64_make(alphabet ?? "", "="));
-			return id;
-		},
-		"base64_encode_to_string": (mode) => {
-			const enc = mode === 1 ? __base64_url : mode === 2 ? __base64_raw_std : mode === 3 ? __base64_raw_url : mode >= 4 ? customBase64Encodings[mode - 4] : __base64_std;
-			return (enc ?? __base64_std).EncodeToString(rawBytes);
-		},
-		"base64_decode_string": (mode, s) => {
-			const enc = mode === 1 ? __base64_url : mode === 2 ? __base64_raw_std : mode === 3 ? __base64_raw_url : mode >= 4 ? customBase64Encodings[mode - 4] : __base64_std;
-			const [res, err] = (enc ?? __base64_std).DecodeString(s ?? "");
-			base64Err = err ? (err.message ?? String(err)) : null;
-			rawBytes = new Uint8Array(res);
-			return rawBytes.length;
-		},
-		"base64_get_err": () => base64Err,
+	// A partial last line (print / fmt.Print without a newline) is written when
+	// the program ends; Node gets it without the newline console.log adds.
+	const flushPartial = () => {
+		if (lineBuf === "") return;
+		const s = lineBuf;
+		lineBuf = "";
+		started = false;
+		if (typeof process !== "undefined" && process?.stdout?.write) process.stdout.write(s);
+		else write(s);
 	};
+	return { "env": env, "Math": m, "__bind": (ex) => { late.exports = ex; }, "__flush": flushPartial };
 }
+// string -> bytes: UTF-8, except that a lone surrogate U+DC80-U+DCFF (a raw
+// byte from a \\xNN escape in the source) encodes as that single byte.
+function ${P}u8enc(s) {
+	const e = new TextEncoder();
+	if (s.isWellFormed()) return e.encode(s);
+	const out = [];
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (c >= 0xdc80 && c <= 0xdcff && !(i > 0 && (s.charCodeAt(i - 1) & 0xfc00) === 0xd800)) { out.push(c - 0xdc00); continue; }
+		const cp = s.codePointAt(i);
+		if (cp > 0xffff) i++;
+		for (const b of e.encode(String.fromCodePoint(cp))) out.push(b);
+	}
+	return Uint8Array.from(out);
+}
+// strings.ToUpper/ToLower: letter by letter through the first code point of
+// the host's mapping, as unicode.ToUpper/ToLower do; ASCII text maps whole.
+function ${P}mapCase(s, method) {
+	if (/^[\\x00-\\x7f]*$/.test(s)) return s[method]();
+	return Array.from(s, (c) => {
+		const m = c[method]();
+		const r = String.fromCodePoint(m.codePointAt(0));
+		// A letter whose upper case spans several code points (ß) stays as is.
+		return method === "toUpperCase" && m.length > r.length ? c : r;
+	}).join("");
+}
+// Code-point-aware Trim/TrimLeft/TrimRight of strings.
 function ${P}trim(s, cutset, left, right) {
-	const cs = new Set(Array.from(cutset));
-	const chars = Array.from(s);
-	let a = 0, b = chars.length;
-	if (left) while (a < b && cs.has(chars[a])) a++;
-	if (right) while (b > a && cs.has(chars[b - 1])) b--;
-	return chars.slice(a, b).join("");
+	if (s === "" || cutset === "") return s;
+	const set = new Set(cutset);
+	let i = 0, j = s.length;
+	if (left) while (i < j) {
+		const c = s.codePointAt(i);
+		if (!set.has(String.fromCodePoint(c))) break;
+		i += c > 0xFFFF ? 2 : 1;
+	}
+	if (right) while (j > i) {
+		let k = j - 1;
+		const lo = s.charCodeAt(k);
+		if (lo >= 0xDC00 && lo <= 0xDFFF && k > i) {
+			const hi = s.charCodeAt(k - 1);
+			if (hi >= 0xD800 && hi <= 0xDBFF) k--;
+		}
+		if (!set.has(s.slice(k, j))) break;
+		j = k;
+	}
+	return s.slice(i, j);
+}
+// strings.Replace: an empty old string matches before every code point and at
+// the end; the replacement is literal.
+function ${P}replace(s, o, w, n) {
+	if (o === w || n === 0) return s;
+	if (o !== "") {
+		if (n < 0) return s.replaceAll(o, () => w);
+		let r = "", i = 0;
+		for (let k = n; k > 0; k--) {
+			const j = s.indexOf(o, i);
+			if (j < 0) break;
+			r += s.slice(i, j) + w;
+			i = j + o.length;
+		}
+		return r + s.slice(i);
+	}
+	const cs = [...s];
+	const m = n < 0 || n > cs.length + 1 ? cs.length + 1 : n;
+	let r = "";
+	for (let k = 0; k < m; k++) r += (k > 0 ? cs[k - 1] : "") + w;
+	return r + cs.slice(m - 1).join("");
 }`;
 
 // Runtime loader emitted at the top of the facade.
-const wasmLoaderJs = (stdlibEnv) => `${WASM_IMPORTS_JS}
-${stdlibEnv ? WASM_STDLIB_JS : ""}
+const wasmLoaderJs = `${WASM_IMPORTS_JS}
 async function ${P}fetch(url) {
 	const res = await fetch(url);
 	if (!res.ok) throw new Error("GoFront: failed to fetch " + url + " (" + res.status + ")");
@@ -2472,17 +2164,19 @@ async function ${P}instantiate(imports) {
 	}
 	return WebAssembly.instantiate(await ${P}fetch(url), imports);
 }
+let ${P}flushOut = () => {};
 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));
+	const imports = ${P}imports(stringTable, extraEnv, tag, (s) => console.log(s), true);
 	// 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);
+	${P}flushOut = imports.__flush;
 	return result.instance.exports;
 }
 // Go int/int64 cross the boundary as f64 (exact within the safe-integer range).
@@ -2536,32 +2230,63 @@ function ${P}idxview(n, getAt, setAt) {
 }`;
 
 // Generates the JS facade for the linked wasm module.
+// A facade binding for a Go name that shadows a browser global carries the
+// same `$` suffix as JS output uses (see jsBindingName in backend/js), so the
+// flat bundle keeps reaching the real global.
+function facadeName(name) {
+	return BROWSER_GLOBALS.has(name) ? `${name}$` : name;
+}
+
 export function generateFacade(
 	meta,
-	{ stringTable = [], callMain = false, stdlibEnv = true } = {},
+	{ stringTable = [], callMain = false } = {},
 ) {
 	const needs = meta._needs ?? collectNeeds(meta);
-	const out = [wasmLoaderJs(stdlibEnv)];
+	const out = [wasmLoaderJs];
 
 	// 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(", ")})`;
+		const hasPtrBox = desc.params.some((d) => d.k === "ptr_box");
 		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(", ")}];`;
+		if (hasPtrBox) {
+			const argVars = desc.params.map((_, i) => `__arg${i}`);
+			const decls = desc.params.map(
+				(d, i) =>
+					`const __arg${i} = ${isPtrBoth(d) ? `${P}view_${d.name}(${names[i]})` : outExpr(d, names[i])};`,
+			);
+			const call = `fn(${argVars.join(", ")})`;
+			const writebacks = desc.params
+				.map((d, i) =>
+					d.k === "ptr_box"
+						? `if (__arg${i} && __arg${i}.value !== undefined) __w.__box_set_${d.key}(${names[i]}, ${inExpr(d.base, `__arg${i}.value`)});`
+						: "",
+				)
+				.filter(Boolean);
+			if (desc.returns.length === 0) {
+				body = `${decls.join(" ")} ${call}; ${writebacks.join(" ")}`;
+			} else if (desc.returns.length === 1) {
+				body = `${decls.join(" ")} const __r = ${call}; ${writebacks.join(" ")} return ${inExpr(desc.returns[0], "__r")};`;
+			} else {
+				body = `${decls.join(" ")} const __r = ${call}; ${writebacks.join(" ")} return [${desc.returns.map((d, i) => inExpr(d, `__r[${i}]`)).join(", ")}];`;
+			}
+		} else {
+			const args = desc.params.map((d, i) =>
+				isPtrBoth(d) ? `${P}view_${d.name}(${names[i]})` : outExpr(d, names[i]),
+			);
+			const call = `fn(${args.join(", ")})`;
+			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; } };`,
+			`${P}env["__invoke$${key}"] = (${sig}) => { try { ${body} } catch (__e) { if (__w && __w.__push_panic && !(__e && __e.__gfp === true)) { __w.__push_panic(__e.message ?? String(__e)); try { __e.__gfp = true; } catch {} } throw __e; } };`,
 		);
 	}
 	out.push(
@@ -2572,9 +2297,11 @@ export function generateFacade(
 		if (info.pkgTarget === "both") genBothStruct(out, name, fields);
 		else {
 			const methods = meta.structByName.get(name)?.methods ?? [];
-			genHandleStruct(out, name, fields, methods);
+			const promoted = promotedMethods(info, fields, methods, meta);
+			genHandleStruct(out, name, fields, methods, promoted);
 		}
 	}
+	genGenericClasses(out, needs, meta._mod);
 
 	for (const [name, desc] of needs.anonStructs) {
 		out.push(`function ${P}to_${name}(o) {
@@ -2596,12 +2323,17 @@ ${desc.fields.map((f) => `\to.${f.name} = ${outExpr(f.desc, `__w.__get_${name}_$
 	for (const [key, desc] of needs.boxes) {
 		out.push(`function ${P}boxin_${key}(b) {
 	if (b == null) return null;
+	if (b.__ref) return b.__ref;
 	const v = b.value !== undefined ? b.value : ${zeroExpr(desc.base)};
 	return __w.__box_new_${key}(${inExpr(desc.base, "v")});
 }
 function ${P}boxout_${key}(r) {
 	if (r == null) return null;
-	return { "value": ${outExpr(desc.base, `__w.__box_get_${key}(r)`)} };
+	return {
+		__ref: r,
+		get value() { return ${outExpr(desc.base, `__w.__box_get_${key}(r)`)}; },
+		set value(v) { __w.__box_set_${key}(r, ${inExpr(desc.base, "v")}); }
+	};
 }
 function ${P}boxback_${key}(r, b) {
 	if (r == null || b == null) return;
@@ -2610,6 +2342,27 @@ function ${P}boxback_${key}(r, b) {
 	}
 
 	for (const [key, desc] of needs.slices) {
+		if (desc.elem.k === "f32x4") {
+			// []F32x4 travels as one Float32Array of 4n lanes.
+			out.push(`function ${P}slin_${key}(arr) {
+	if (arr == null) return __w.__slice_nil_${key}();
+	const n = arr.length >> 2;
+	const s = __w.__slice_new_${key}(n);
+	for (let i = 0; i < n; i++) __w.__slice_set_${key}(s, i, ${P}f32x4in(arr.subarray ? arr.subarray(4 * i, 4 * i + 4) : arr.slice(4 * i, 4 * i + 4)));
+	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 Float32Array(4 * n);
+	for (let i = 0; i < n; i++) out.set(${P}f32x4out(__w.__slice_get_${key}(s, i)), 4 * i);
+	return out;
+}
+function ${P}slview_${key}(s) {
+	return ${P}slout_${key}(s);
+}`);
+			continue;
+		}
 		out.push(`function ${P}slin_${key}(arr) {
 	if (arr == null) return __w.__slice_nil_${key}();
 	const n = arr.length;
@@ -2630,6 +2383,15 @@ function ${P}slview_${key}(s) {
 } `);
 	}
 
+	if (needs.maps.size > 0) {
+		// GoFront JS code reads a map as a plain object (`m["a"]`, `len(m)`), so
+		// each entry is also an own property of the returned Map unless that name
+		// is one the Map already has.
+		out.push(`function ${P}mapprop(m, k, v) {
+	const p = String(k);
+	if (!(p in m)) m[p] = v;
+}`);
+	}
 	for (const [key, desc] of needs.maps) {
 		out.push(`function ${P}mapin_${key}(m) {
 	if (m == null) return null;
@@ -2649,12 +2411,41 @@ function ${P}mapout_${key}(m) {
 	if (ks) {
 		for (let i = 0; i < ks.length; i++) {
 			out.set(ks[i], vs[i]);
+			${P}mapprop(out, ks[i], vs[i]);
 		}
 	}
 	return out;
 }`);
 	}
 
+	if (needs.simd) {
+		const k = needs.simd.key;
+		out.push(`function ${P}v4in(words) {
+	const a = __w.__array_new_${k}(4);
+	for (let i = 0; i < 4; i++) __w.__array_set_${k}(a, i, words[i]);
+	return a;
+}
+function ${P}v4out(a) {
+	const words = new Int32Array(4);
+	for (let i = 0; i < 4; i++) words[i] = __w.__array_get_${k}(a, i);
+	return words;
+}
+function ${P}f32x4in(v) {
+	return ${P}v4in(new Int32Array(new Float32Array(v ?? 4).buffer));
+}
+function ${P}f32x4out(a) {
+	return new Float32Array(${P}v4out(a).buffer);
+}
+function ${P}mask4in(v) {
+	const w = new Int32Array(4);
+	if (v) for (let i = 0; i < 4; i++) w[i] = v[i] ? -1 : 0;
+	return ${P}v4in(w);
+}
+function ${P}mask4out(a) {
+	return Array.from(${P}v4out(a), (w) => w !== 0);
+}`);
+	}
+
 	for (const [key, desc] of needs.arrays) {
 		out.push(`function ${P}arrzero_${key}(n) {
 	const out = new Array(n);
@@ -2748,28 +2539,6 @@ function ${P}errin(e) {
 }`);
 	}
 
-	if (needs.time) {
-		out.push(`function ${P}timeout(r) {
-	if (r == null) return null;
-	const ms = __w.__time_unix_milli ? __w.__time_unix_milli(r) : 0;
-	const off = __w.__time_offset ? __w.__time_offset(r) : 0;
-	return { _d: new Date(ms), _offset: off };
-}
-function ${P}timeout_ptr(r) {
-	return ${P}timeout(r);
-}
-function ${P}timein(v) {
-	if (v == null) return null;
-	const d = v._d ? v._d : (v instanceof Date ? v : new Date(v));
-	const ms = d.getTime();
-	const off = typeof v?._offset === "number" ? v._offset : -d.getTimezoneOffset() * 60;
-	return __w.__time_make ? __w.__time_make(ms, off) : null;
-}
-function ${P}timein_ptr(v) {
-	return ${P}timein(v);
-}`);
-	}
-
 	if (needs.shared) {
 		// Zero-copy TypedArray views over the exported memory.  Memory never
 		// grows after the start function (allocation is startup-only), but the
@@ -2794,15 +2563,17 @@ function ${P}shin(v, Ctor) {
 	for (const c of meta.consts) {
 		if (c.dynamic) {
 			out.push(
-				`const ${c.name} = ${outExpr(c.desc, `__w.__const_${c.name}()`)};`,
+				`const ${facadeName(c.name)} = ${outExpr(c.desc, `__w.__const_${c.name}()`)};`,
 			);
 		} else {
-			out.push(`const ${c.name} = ${c.value};`);
+			out.push(`const ${facadeName(c.name)} = ${c.value};`);
 		}
 	}
 	for (const v of meta.vars ?? [])
 		out.push(
-			`const ${v.name} = ${P}shout(__w.__var_${v.name}(), ${v.desc.ctor});`,
+			v.shared
+				? `const ${facadeName(v.name)} = ${P}shout(__w.__var_${v.name}(), ${v.desc.ctor});`
+				: `const ${facadeName(v.name)} = ${outExpr(v.desc, `__w.__var_${v.name}()`)};`,
 		);
 
 	for (const f of meta.funcs) {
@@ -2811,13 +2582,22 @@ function ${P}shin(v, Ctor) {
 			f.params,
 			f.returns,
 		);
-		out.push(`function ${f.name}(${names.join(", ")}) {\n${body}\n}`);
+		out.push(
+			`function ${facadeName(f.name)}(${restParams(names, f.variadic)}) {\n${body}\n}`,
+		);
 	}
 
-	if (callMain) out.push("__w.main();");
+	if (callMain) out.push(`try { __w.main(); } finally { ${P}flushOut(); }`);
 	return bindExports(out.join("\n"));
 }
 
+// A variadic Go function is a slice parameter in wasm; JS callers pass the
+// trailing arguments spread, so the facade collects them with a rest param.
+function restParams(names, variadic) {
+	if (!variadic || names.length === 0) return names.join(", ");
+	return [...names.slice(0, -1), `...${names.at(-1)}`].join(", ");
+}
+
 // 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
@@ -2858,8 +2638,26 @@ function genBothStruct(out, name, fields) {
 		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")}); } }`;
 	});
+	// The one conversion `time.Time` has beyond the ordinary struct rules: JS
+	// code may pass a Date (or an object holding one in `_d`), and a Time
+	// handed to JS also reads as a Date through `_d`.
+	const isTime = name === "Time$$time";
+	if (isTime)
+		out.push(`function ${P}time_in(o) {
+	const d = o instanceof Date ? o : o?._d instanceof Date ? o._d : null;
+	if (d === null) return o;
+	const ms = d.getTime();
+	const off = typeof o._offset === "number" ? o._offset : -d.getTimezoneOffset() * 60;
+	const sec = Math.floor(ms / 1000);
+	return new Time$$time(BigInt(sec) + 62135596800n, (ms - sec * 1000) * 1000000, new Location$$time("", off, 0));
+}
+function ${P}time_out(t) {
+	Object.defineProperty(t, "_d", { configurable: true, get() { return new Date(Number(this.sec - 62135596800n) * 1000 + Math.floor(this.nsec / 1000000)); } });
+	Object.defineProperty(t, "_offset", { configurable: true, get() { return this.loc ? this.loc.offset : 0; } });
+	return t;
+}`);
 	out.push(`function ${P}to_${name}(o, isValue, m) {
-	if (o == null) return isValue ? __w.__zero_${name}() : null;
+${isTime ? `\to = ${P}time_in(o);\n` : ""}	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);
@@ -2867,7 +2665,7 @@ function genBothStruct(out, name, fields) {
 }
 function ${P}from_${name}(r) {
 	if (r == null) return null;
-	return new ${name}(${fromArgs.join(", ")});
+	return ${isTime ? `${P}time_out(new ${name}(${fromArgs.join(", ")}))` : `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
@@ -2926,7 +2724,84 @@ function ${P}ifin_${key}(v) {
 }`);
 }
 
-function genHandleStruct(out, name, fields, methods) {
+// Methods a struct gets from its embedded structs, shallowest first (a name
+// found twice at one depth is ambiguous and left out).  Each is forwarded
+// through the embedded field's getter: `{ name, via, params, variadic }`.
+function promotedMethods(info, fields, methods, meta) {
+	const taken = new Set([
+		...methods.map((m) => m.name),
+		...fields.map((f) => f.name),
+	]);
+	const promoted = [];
+	const seen = new Set([info]);
+	let level = [{ info, via: "" }];
+	while (level.length > 0) {
+		const next = [];
+		const found = new Map();
+		for (const { info: owner, via } of level) {
+			for (const e of owner.embeds ?? []) {
+				const typeName = e.typeName ?? e.name;
+				const path = `${via}.${e.name}`;
+				const inner = meta._mod.getStructType(typeName);
+				const innerMethods =
+					meta.structByName.get(typeName.replaceAll(".", "$"))?.methods ?? [];
+				for (const m of innerMethods) {
+					if (!found.has(m.name)) found.set(m.name, []);
+					found.get(m.name).push({
+						name: m.name,
+						via: path,
+						params: m.params,
+						variadic: m.variadic,
+					});
+				}
+				if (inner && !seen.has(inner)) {
+					seen.add(inner);
+					next.push({ info: inner, via: path });
+				}
+			}
+		}
+		for (const [n, c] of found) {
+			if (!taken.has(n) && c.length === 1) promoted.push(c[0]);
+			taken.add(n);
+		}
+		level = next;
+	}
+	return promoted;
+}
+
+// A generic struct is built in a js main as `new Box(V, [...zeroFactories,
+// "int"])`; the facade only has the instances (`Box$int`).  `Box` picks the
+// instance named by the last type-argument entry (the printed type arguments).
+function genGenericClasses(out, needs, mod) {
+	const groups = new Map();
+	for (const [name, { info }] of needs.structs) {
+		if (info.pkgTarget === "both") continue;
+		const goName = mod?.checker?.types?.get(info.name)?._goName;
+		const m = goName ? /^([^[]+)\[(.*)\]$/s.exec(goName) : null;
+		if (!m) continue;
+		if (!groups.has(m[1])) groups.set(m[1], new Map());
+		// The js caller keys instances by the unqualified printed arguments.
+		groups
+			.get(m[1])
+			.set(m[2].replaceAll(" ", "").replace(/(?<![\w.])main\./g, ""), name);
+	}
+	for (const [base, instances] of groups) {
+		const table = [...instances]
+			.map(([id, cls]) => `${JSON.stringify(id)}: ${cls}`)
+			.join(", ");
+		out.push(`class ${facadeName(base)} {
+	constructor(...a) {
+		const tz = a.at(-1);
+		const id = Array.isArray(tz) && typeof tz.at(-1) === "string" ? tz.at(-1).replaceAll(" ", "") : undefined;
+		const C = id === undefined ? ${instances.size === 1 ? `${[...instances.values()][0]}` : "undefined"} : { ${table} }[id];
+		if (!C) throw new TypeError("GoFront: no ${base} instance for the type arguments " + id + " in the wasm package");
+		return new C(...(Array.isArray(tz) ? a.slice(0, -1) : a));
+	}
+}`);
+	}
+}
+
+function genHandleStruct(out, name, fields, methods, promoted = []) {
 	// `$`-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}$`));
@@ -2974,7 +2849,13 @@ class ${name} {
 			[recv],
 		);
 		lines.push(
-			`\t${m.name}(${names.join(", ")}) {\n${indent(body, "\t")}\n\t}`,
+			`\t${m.name}(${restParams(names, m.variadic)}) {\n${indent(body, "\t")}\n\t}`,
+		);
+	}
+	for (const m of promoted) {
+		const names = m.params.map((_, i) => `a${i}`);
+		lines.push(
+			`\t${m.name}(${restParams(names, m.variadic)}) { return this${m.via}.${m.name}(${restParams(names, m.variadic)}); }`,
 		);
 	}
 	lines.push("}");