gofront 1.5.1 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.5.1",
+	"version": "1.6.0",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {
@@ -11,12 +11,15 @@
 		"url": "https://github.com/seriva/gofront/issues"
 	},
 	"homepage": "https://github.com/seriva/gofront#readme",
-	"description": "A Go-inspired language that transpiles to JavaScript",
+	"description": "A Go-inspired language that compiles to JavaScript and WebAssembly",
 	"keywords": [
 		"go",
 		"compiler",
 		"transpiler",
 		"javascript",
+		"webassembly",
+		"wasm",
+		"wasmgc",
 		"frontend",
 		"type-safe"
 	],
@@ -31,31 +34,24 @@
 		"gofront": "./src/index.js"
 	},
 	"scripts": {
-		"build:simple": "node src/index.js example/simple/src -o example/simple/app.js",
-		"build:reactive": "node src/index.js example/reactive/src -o example/reactive/app.js",
-		"build:gom": "node src/index.js example/gom/src -o example/gom/app.js",
-		"build:templ": "node src/index.js example/templ/src -o example/templ/app.js",
-		"build:webgl": "node src/index.js example/webgl/src -o example/webgl/app.js",
-		"build:all": "npm run build:simple && npm run build:reactive && npm run build:gom && npm run build:templ && npm run build:webgl",
-		"test": "npm run test:unit",
-		"test:all": "npm run test:unit && npm run test:perf && npm run test:examples && npm run test:examples:dom && npm run test:e2e",
-		"test:unit": "node test/unit/run.js",
-		"test:perf": "node test/e2e/perf/zero-alloc.js",
-		"bench:raycast": "node --expose-gc test/e2e/perf/raycast-bench.js",
-		"test:examples": "node src/index.js test example/simple/src && node src/index.js test example/simple/src/utils && node src/index.js test example/reactive/src && node src/index.js test example/reactive/src/utils && node src/index.js test example/gom/src && node src/index.js test example/gom/src/utils && node src/index.js test example/templ/src && node src/index.js test example/templ/src/utils",
-		"test:examples:dom": "node src/index.js test --dom example/simple/src && node src/index.js test --dom example/gom/src && node src/index.js test --dom example/templ/src",
+		"build": "node src/index.js example/simple/src -o example/simple/app.js && node src/index.js example/reactive/src -o example/reactive/app.js && node src/index.js example/gom/src -o example/gom/app.js && node src/index.js example/templ/src -o example/templ/app.js && node src/index.js example/webgl/src -o example/webgl/app.js && node src/index.js example/hybrid/src -o example/hybrid/app.js",
+		"test": "node test/unit/run.js && node test/e2e/perf/zero-alloc.js && node src/index.js test --dom example/...",
+		"test:e2e": "playwright test",
 		"test:coverage": "c8 --include='src/**' --reporter=text --reporter=lcov node test/unit/run.js",
-		"test:e2e": "npm run build:all && playwright test",
+		"bench": "node --expose-gc test/e2e/perf/raycast-bench.js",
 		"format": "biome format --write .",
-		"check": "biome check . && sentrux check && sentrux gate && node src/index.js example/simple/src --check && node src/index.js example/reactive/src --check && node src/index.js example/gom/src --check && node src/index.js example/templ/src --check && node src/index.js example/webgl/src --check",
+		"check": "biome check . && sentrux check && sentrux gate && node src/index.js check example/...",
 		"prepare": "lefthook install"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.5.14",
+		"@biomejs/biome": "^2.5.15",
 		"@playwright/test": "^1.63.0",
 		"c8": "^12.0.0",
-		"jsdom": "^30.1.0",
-		"lefthook": "^2.1.14",
+		"jsdom": "^30.1.2",
+		"lefthook": "^2.1.17",
 		"serve": "^14.2.6"
+	},
+	"optionalDependencies": {
+		"binaryen": "^132.0.0"
 	}
 }

package/src/backend/js/expressions.js

@@ -14,7 +14,7 @@ import {
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
-export const STRICT_NUMERIC_TYPES = new Set([
+const STRICT_NUMERIC_TYPES = new Set([
 	"float32",
 	"int8",
 	"int16",
@@ -26,7 +26,7 @@ export const STRICT_NUMERIC_TYPES = new Set([
 	"uint32",
 ]);
 
-export const STRICT_OPS = new Set([
+const STRICT_OPS = new Set([
 	"+",
 	"-",
 	"*",
@@ -233,14 +233,19 @@ const BUILTIN_GEN = {
 		}
 		return `{ value: ${s.zeroValueForExpr(arg)} }`;
 	},
-	print: (s, e) => `console.log(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
+	// `print` writes without a trailing newline (Go semantics); the wasm glue
+	// buffers the same way, so output parity holds across backends.
+	print: (s, e) =>
+		`((__s) => (typeof process !== "undefined" && process?.stdout?.write ? process.stdout.write(__s) : console.log(__s)))([${e.args.map((a) => s.genExpr(a)).join(", ")}].map(String).join(" "))`,
 	println: (s, e) =>
 		`console.log(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
 	panic: (s, e) => `(() => { throw new Error(${s.genExpr(e.args[0])}); })()`,
-	recover: () =>
-		`(typeof __panic !== "undefined" && __panic !== null ? (() => { const __r = __panic.message ?? String(__panic); __panic = null; return __r; })() : null)`,
+	recover: (s) => {
+		s.useHelper("panicRt");
+		return `__recover(${s._recoverOkInScope ? "__recoverOk" : "false"})`;
+	},
 	error: (s, e) => {
-		s._usesError = true;
+		s.useHelper("error");
 		return `__error(${s.genExpr(e.args[0])})`;
 	},
 	min: (s, e) => `Math.min(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
@@ -272,7 +277,7 @@ export const expressionGenMethods = {
 		if (expr._ifaceBox && !expr._ifaceBoxing) {
 			expr._ifaceBoxing = true;
 			try {
-				this._usesIfaceBox = true;
+				this.useHelper("ifaceBox");
 				const fn = expr._ifaceBox === "ptr" ? "__ifp" : "__ifv";
 				return `${fn}(${this.genExpr(expr)})`;
 			} finally {
@@ -365,7 +370,7 @@ export const expressionGenMethods = {
 		if (base.kind === "struct") {
 			if (this._structClassName(t) || this._structClassName(base))
 				return `${js}.__clone()`;
-			this._usesSClone = true;
+			this.useHelper("sclone");
 			return `__sclone(${js})`;
 		}
 		const elemClone = this._cloneJs(base.elem, "__e");
@@ -613,7 +618,7 @@ export const expressionGenMethods = {
 		this._withFnCtx(expr.body, () =>
 			this.indented(() => {
 				this._emitParamCopies(expr.params);
-				this._genBody(expr.body);
+				this._genBody(expr.body, expr);
 			}),
 		);
 		const body = this.out.join("\n");
@@ -702,12 +707,20 @@ export const expressionGenMethods = {
 			return this._genTimeMethodCall(expr.func.field, expr);
 		if (recvName === "testing.T")
 			return this._genTestingMethodCall(expr.func.field, expr);
+		if (recvName?.startsWith("shared.") && expr.func.field === "Subarray") {
+			const args = expr.args.map((a) => this.genExpr(a)).join(", ");
+			return `${this.genExpr(expr.func.expr)}.subarray(${args})`;
+		}
 		return undefined;
 	},
 
 	_genSelectorCall(expr) {
-		if (this._isErrorMethodCall(expr))
-			return `${this.genExpr(expr.func.expr)}.Error()`;
+		if (this._isErrorMethodCall(expr)) {
+			const recv = this.genExpr(expr.func.expr);
+			if (!this.strict) return `${recv}.Error()`;
+			this.useHelper("nilCall");
+			return `__nilcall(${recv}).Error()`;
+		}
 		if (expr.func.expr.kind === "Ident") {
 			const ns = expr.func.expr.name;
 			const fn = expr.func.field;
@@ -716,7 +729,25 @@ export const expressionGenMethods = {
 		}
 		const recvType = expr.func.expr._type;
 		const recvName = this._resolveRecvName(recvType);
-		return this._genReceiverTypeCall(recvName, expr);
+		const typed = this._genReceiverTypeCall(recvName, expr);
+		if (typed !== undefined) return typed;
+		if (this.strict && this._isInterfaceType(recvType)) {
+			// Go panics with a nil-dereference runtime error; JS would throw a
+			// TypeError with a different message.
+			this.useHelper("nilCall");
+			const recv = this.genExpr(expr.func.expr);
+			const args = expr.args
+				.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
+				.join(", ");
+			return `__nilcall(${recv}).${expr.func.field}(${args})`;
+		}
+		return undefined;
+	},
+
+	_isInterfaceType(t) {
+		if (!t) return false;
+		if (t.kind === "interface") return true;
+		return t.kind === "named" && t.underlying?.kind === "interface";
 	},
 
 	_genBuiltinLen(expr) {
@@ -727,7 +758,7 @@ export const expressionGenMethods = {
 		if (wrapField) return `${this.genExpr(arg)}.${wrapField}.length`;
 		const js = this.genExpr(arg);
 		if (t?.kind === "map") return `Object.keys(${js}).length`;
-		this._usesLen = true;
+		this.useHelper("len");
 		return `__len(${js})`;
 	},
 
@@ -760,7 +791,7 @@ export const expressionGenMethods = {
 					a._spread ? `...${this.genExpr(a)}` : this.genValueExpr(a),
 				);
 			if (elems.length === 0) return this.genExpr(expr.args[0]);
-			this._usesAppend = true;
+			this.useHelper("append");
 			return `new ${retType.name}(__append(${sliceJS}, ${elems.join(", ")}))`;
 		}
 		const slice = this.genExpr(expr.args[0]);
@@ -768,7 +799,7 @@ export const expressionGenMethods = {
 			.slice(1)
 			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genValueExpr(a)));
 		if (elems.length === 0) return slice;
-		this._usesAppend = true;
+		this.useHelper("append");
 		const sliceType = expr._type ?? expr.args[0]._type;
 		const typedCtor = isTypedArraySlice(sliceType)
 			? typedArrayConstructorForElem(
@@ -1240,10 +1271,10 @@ export const expressionGenMethods = {
 			case "-":
 				return `{ re: ${l}.re - ${r}.re, im: ${l}.im - ${r}.im }`;
 			case "*":
-				this._usesCmul = true;
+				this.useHelper("cmul");
 				return `__cmul(${l}, ${r})`;
 			case "/":
-				this._usesCdiv = true;
+				this.useHelper("cdiv");
 				return `__cdiv(${l}, ${r})`;
 			case "==":
 				return `(${l}.re === ${r}.re && ${l}.im === ${r}.im)`;
@@ -1261,7 +1292,7 @@ export const expressionGenMethods = {
 			return this._genComplexBinary(expr);
 
 		if (this._isStructEquality(expr)) {
-			this._usesEqual = true;
+			this.useHelper("equal");
 			const cmp = `__equal(${this.genExpr(expr.left)}, ${this.genExpr(expr.right)})`;
 			return expr.op === "==" ? cmp : `!${cmp}`;
 		}
@@ -1346,7 +1377,7 @@ export const expressionGenMethods = {
 			return this._genSliceTypeConversion(expr, inner, t);
 		const target = t?.name;
 		if (target === "error") {
-			this._usesError = true;
+			this.useHelper("error");
 			return `__error(${inner})`;
 		}
 		if (target && this.namedWrapperNames.has(target))

package/src/backend/js/index.js

@@ -19,7 +19,9 @@
 
 import {
 	computeEmbeddedStubs,
+	hasDirectRecover,
 	isReferenceType,
+	normalizeDefers,
 	scanAddressTaken,
 } from "../../lower/index.js";
 import { isComplex, isNumeric } from "../../typechecker/types.js";
@@ -34,21 +36,24 @@ import {
 	HELPER_IFACE_BOX,
 	HELPER_INJECT_STYLES,
 	HELPER_LEN,
+	HELPER_NIL_CALL,
+	HELPER_PANIC,
 	HELPER_PATH_CLEAN,
 	HELPER_S,
 	HELPER_SCLONE,
 	HELPER_SORT_SLICE,
 	HELPER_SPRINTF,
+	HELPER_STRCONV,
 	HELPER_TESTING,
 	HELPER_TIME_FMT,
 	HELPER_TIME_PARSE,
 } from "./runtime.js";
-import { buildSourceMap } from "./source-map.js";
+import { buildSourceMap, buildWasmSourceMap } from "./source-map.js";
 import { statementGenMethods } from "./statements.js";
 import { stdlibGenMethods } from "./stdlib/index.js";
 import { templGenMethods } from "./templ.js";
 
-export { buildSourceMap };
+export { buildSourceMap, buildWasmSourceMap };
 
 // Valid Go identifiers that cannot be used as JS bindings; emitted with a `$` suffix.
 const JS_RESERVED = new Set([
@@ -90,6 +95,30 @@ const JS_RESERVED = new Set([
 const jsSafeName = (n) =>
 	typeof n === "string" && JS_RESERVED.has(n) ? `${n}$` : n;
 
+// Runtime helpers by registry name, in output order.  Mark one as needed with
+// `this.useHelper(name)`; `_prependHelpers` emits every marked entry.
+const HELPER_MAP = [
+	["len", HELPER_LEN],
+	["append", HELPER_APPEND],
+	["sliceGuard", HELPER_S],
+	["sclone", HELPER_SCLONE],
+	["ifaceBox", HELPER_IFACE_BOX],
+	["equal", HELPER_EQUAL],
+	["cmul", HELPER_CMUL],
+	["cdiv", HELPER_CDIV],
+	["panicRt", HELPER_PANIC],
+	["nilCall", HELPER_NIL_CALL],
+	["sprintf", HELPER_SPRINTF],
+	["error", HELPER_ERROR],
+	["errorIs", HELPER_ERROR_IS],
+	["strconv", HELPER_STRCONV],
+	["pathClean", HELPER_PATH_CLEAN],
+	["sortSlice", HELPER_SORT_SLICE],
+	["timeFmt", HELPER_TIME_FMT],
+	["timeParse", HELPER_TIME_PARSE],
+	["testing", HELPER_TESTING],
+];
+
 export class CodeGen {
 	// jsImports:       Map<importPath, string[]> — npm package imports to emit at top of file
 	// bundledPackages: Set<string>               — GoFront package names bundled inline;
@@ -116,22 +145,7 @@ export class CodeGen {
 		this._currentSrcFileIdx = 0; // updated as each top-level decl is generated
 		this._boxedVars = new Set(); // address-taken scalar variables that need boxing
 		// Runtime helper usage tracking — only emit helpers that are actually used
-		this._usesLen = false;
-		this._usesAppend = false;
-		this._usesSliceGuard = false;
-		this._usesSprintf = false;
-		this._usesEqual = false;
-		this._usesCmul = false;
-		this._usesCdiv = false;
-		this._usesError = false;
-		this._usesErrorIs = false;
-		this._usesPathClean = false;
-		this._usesSortSlice = false;
-		this._usesTimeFmt = false;
-		this._usesTimeParse = false;
-		this._usesTesting = false;
-		this._usesSClone = false;
-		this._usesIfaceBox = false;
+		this._helpers = new Set();
 		// Per-function context for Go value semantics (see _withFnCtx)
 		this._fnCtx = null;
 		// Iterator (range-over-func) context
@@ -217,6 +231,10 @@ export class CodeGen {
 
 	generate(program, options = {}) {
 		const isTest = options.isTest ?? false;
+		// Defer lowering (argument/receiver hoisting, recover-target marking) is
+		// idempotent and owned by the backends: the wasm path runs it via
+		// `lower()`, the JS path here.
+		normalizeDefers(program);
 		// Ensure _pkgName is set on all decls (generateAll sets it for
 		// multi-file; for single-file compiles we derive it from the AST).
 		const pkgName = program.pkg?.name;
@@ -407,28 +425,21 @@ export class CodeGen {
 		return methods;
 	}
 
+	/** Marks a runtime helper (key of HELPER_MAP) as needed by the output. */
+	useHelper(name) {
+		this._helpers.add(name);
+	}
+
 	_prependHelpers(isTest = false) {
-		const needsTesting = isTest || this._usesTesting;
-		const HELPER_MAP = [
-			[this.collectedCss.length > 0, HELPER_INJECT_STYLES],
-			[this._usesLen, HELPER_LEN],
-			[this._usesAppend, HELPER_APPEND],
-			[this._usesSliceGuard, HELPER_S],
-			[this._usesSClone, HELPER_SCLONE],
-			[this._usesIfaceBox, HELPER_IFACE_BOX],
-			[this._usesEqual, HELPER_EQUAL],
-			[this._usesCmul, HELPER_CMUL],
-			[this._usesCdiv, HELPER_CDIV],
-			[this._usesSprintf || needsTesting, HELPER_SPRINTF],
-			[this._usesError, HELPER_ERROR],
-			[this._usesErrorIs, HELPER_ERROR_IS],
-			[this._usesPathClean, HELPER_PATH_CLEAN],
-			[this._usesSortSlice, HELPER_SORT_SLICE],
-			[this._usesTimeFmt, HELPER_TIME_FMT],
-			[this._usesTimeParse, HELPER_TIME_PARSE],
-			[needsTesting, HELPER_TESTING],
-		];
-		const helpers = HELPER_MAP.filter(([flag]) => flag).map(([, h]) => h);
+		if (isTest || this._helpers.has("testing")) {
+			this.useHelper("sprintf");
+			this.useHelper("testing");
+		}
+		const helpers = [];
+		if (this.collectedCss.length > 0) helpers.push(HELPER_INJECT_STYLES);
+		for (const [name, src] of HELPER_MAP) {
+			if (this._helpers.has(name)) helpers.push(src);
+		}
 		if (helpers.length > 0) {
 			const helperLines = helpers.flatMap((h) => h.split("\n"));
 			helperLines.push("");
@@ -661,7 +672,7 @@ export class CodeGen {
 					}
 				}
 				this._emitParamCopies(decl.params);
-				this._withNamedReturns(decl, () => this._genBody(decl.body));
+				this._withNamedReturns(decl, () => this._genBody(decl.body, decl));
 			}),
 		);
 		this._unwrappedRecv = prevUnwrapped;
@@ -718,7 +729,7 @@ export class CodeGen {
 		this._withFnCtx(decl.body, () =>
 			this.indented(() => {
 				this._emitParamCopies(decl.params);
-				this._withNamedReturns(decl, () => this._genBody(decl.body));
+				this._withNamedReturns(decl, () => this._genBody(decl.body, decl));
 			}),
 		);
 		this._boxedVars = prevBoxed;
@@ -726,45 +737,74 @@ export class CodeGen {
 	}
 
 	_withNamedReturns(decl, fn) {
+		const prevDecl = this._currentDecl;
+		this._currentDecl = decl;
 		const named = decl.returnType?._namedReturns;
 		const prev = this.namedReturnVars;
 		if (named) {
 			// Emit zero-value declarations for named return vars
-			for (const { name, type } of named) {
-				if (name) {
-					this._markOwnership(name, true);
-					this.line(`let ${name} = ${this.zeroValueForTypeNode(type)};`);
-				}
+			for (let i = 0; i < named.length; i++) {
+				const { name, type } = named[i];
+				const varName = !name || name === "_" ? `__ret_blank$${i}` : name;
+				this._markOwnership(varName, true);
+				this.line(`let ${varName} = ${this.zeroValueForTypeNode(type)};`);
 			}
-			this.namedReturnVars = named.map((r) => r.name).filter(Boolean);
+			this.namedReturnVars = named.map((r, i) =>
+				!r.name || r.name === "_" ? `__ret_blank$${i}` : r.name,
+			);
 		} else {
 			this.namedReturnVars = null;
 		}
 		fn();
 		this.namedReturnVars = prev;
+		this._currentDecl = prevDecl;
 	}
 
 	// Emit a function body, wrapping in try/catch/finally for defer if needed.
-	_genBody(body) {
+	// `fnNode` is the enclosing FuncDecl/MethodDecl/FuncLit; it decides whether
+	// the recover-arming prologue is needed (see HELPER_PANIC).
+	_genBody(body, fnNode = null) {
+		const prevRecoverOk = this._recoverOkInScope;
+		this._recoverOkInScope = false;
+		const isTarget = Boolean(fnNode?._isDeferTarget);
+		const forwards = isTarget && Boolean(fnNode._deferForward);
+		if (!forwards && (isTarget || hasDirectRecover(body))) {
+			this.useHelper("panicRt");
+			this.line(
+				"const __recoverOk = __gopanic.armed; __gopanic.armed = false;",
+			);
+			this._recoverOkInScope = true;
+		}
 		if (!body._hasDefer) {
 			this.genBlock(body);
+			this._recoverOkInScope = prevRecoverOk;
 			return;
 		}
+		this.useHelper("panicRt");
 		this.line("const __defers = [];");
-		this.line("let __panic = null;");
+		this.line("const __frame = { pn: null };");
 		this.line("try {");
 		this.indented(() => this.genBlock(body));
 		this.line("} catch (__err) {");
-		this.indented(() => this.line("__panic = __err;"));
+		this.indented(() => {
+			this.line("__frame.pn = { err: __err, recovered: false };");
+			this.line("__gopanic.stack.push(__frame.pn);");
+		});
 		this.line("} finally {");
 		this.indented(() => {
-			this.line(
-				"for (let __i = __defers.length - 1; __i >= 0; __i--) __defers[__i]();",
-			);
-			this.line("if (__panic !== null) throw __panic;");
+			// Runs defers LIFO and rethrows an unrecovered panic.
+			this.line("__runDefers(__defers, __frame);");
+			if (this.namedReturnVars?.length > 0) {
+				const vars = this.namedReturnVars;
+				this.line(
+					vars.length === 1
+						? `return ${vars[0]};`
+						: `return [${vars.join(", ")}];`,
+				);
+			}
 		});
 		this.line("}");
-		// If a recover() cleared __panic, execution reaches here.
+		// If a recover() cleared the panic, execution reaches here.
 		// Return named return vars so deferred mutations are visible to the caller.
 		if (this.namedReturnVars?.length > 0) {
 			const vars = this.namedReturnVars;
@@ -773,7 +813,12 @@ export class CodeGen {
 					? `return ${vars[0]};`
 					: `return [${vars.join(", ")}];`,
 			);
+		} else if (this._currentDecl?.returnType) {
+			this.line(
+				`return ${this.zeroValueForTypeNode(this._currentDecl.returnType)};`,
+			);
 		}
+		this._recoverOkInScope = prevRecoverOk;
 	}
 
 	// Scan AST node for _addressTaken idents on scalars and populate _boxedVars.

package/src/backend/js/runtime.js

@@ -55,6 +55,13 @@ var __ifp = __ifp || function(x) {
   return x;
 };`;
 
+// Nil-interface method call guard (strict mode only): matches Go's panic
+// message instead of a JS TypeError.
+export const HELPER_NIL_CALL = `var __nilcall = __nilcall || function(x) {
+  if (x == null) throw new Error("runtime error: invalid memory address or nil pointer dereference");
+  return x;
+};`;
+
 export const HELPER_EQUAL = `var __equal = __equal || function __equal(a, b) {
   if (a === b) return true;
   if (a === null || b === null) return false;
@@ -86,6 +93,35 @@ export const HELPER_CDIV = `var __cdiv = __cdiv || function(a, b) {
   return { re: (a.re * b.re + a.im * b.im) / d, im: (a.im * b.re - a.re * b.im) / d };
 };`;
 
+// Panic/defer runtime.  \`stack\` holds the in-flight panic of every frame
+// currently running its defers; \`armed\` is set right before a deferred
+// function is invoked and consumed by that function's prologue, so recover()
+// only takes effect when called directly by the deferred function (Go spec).
+export const HELPER_PANIC = `var __gopanic = __gopanic || { stack: [], armed: false };
+var __runDefers = __runDefers || function(defers, frame) {
+  for (let i = defers.length - 1; i >= 0; i--) {
+    __gopanic.armed = true;
+    try { defers[i](); }
+    catch (e) {
+      if (frame.pn !== null) __gopanic.stack.pop();
+      frame.pn = { err: e, recovered: false };
+      __gopanic.stack.push(frame.pn);
+    } finally { __gopanic.armed = false; }
+  }
+  if (frame.pn !== null) {
+    __gopanic.stack.pop();
+    if (!frame.pn.recovered) throw frame.pn.err;
+  }
+};
+var __recover = __recover || function(ok) {
+  if (!ok) return null;
+  const s = __gopanic.stack;
+  const top = s.length > 0 ? s[s.length - 1] : null;
+  if (top === null || top.recovered) return null;
+  top.recovered = true;
+  return top.err?.message ?? String(top.err);
+};`;
+
 export const HELPER_SPRINTF = `var __sprintf = __sprintf || function(f, ...a) {
   let i = 0;
   return f.replace(/%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)[sdvftxXqobeEgGw%]/g, (m) => {
@@ -150,6 +186,72 @@ export const HELPER_ERROR_IS = `var __errorIs = __errorIs || function(err, targe
   return false;
 };`;
 
+// Go-semantics strconv parsers shared by the JS backend and the wasm runtime
+// imports (boundary.js), so both targets agree.  Each parser returns
+// [value, errorMessage | null]; integer values are BigInt (the wasm side
+// needs i64, the JS side converts with Number()).
+export const HELPER_STRCONV = `var __strconv_atoi = __strconv_atoi || function(s) {
+  if (!/^[+-]?[0-9]+$/.test(s)) return [0n, 'strconv.Atoi: parsing "' + s + '": invalid syntax'];
+  const v = BigInt(s);
+  if (v > 9223372036854775807n || v < -9223372036854775808n) {
+    return [v > 0n ? 9223372036854775807n : -9223372036854775808n, 'strconv.Atoi: parsing "' + s + '": value out of range'];
+  }
+  return [v, null];
+};
+var __strconv_parse_int = __strconv_parse_int || function(s, base, bits) {
+  let str = s, neg = false;
+  if (str[0] === "-" || str[0] === "+") { neg = str[0] === "-"; str = str.slice(1); }
+  if (base === 0) {
+    if (/^0[xX]/.test(str)) { base = 16; str = str.slice(2); }
+    else if (/^0[bB]/.test(str)) { base = 2; str = str.slice(2); }
+    else if (/^0[oO]/.test(str)) { base = 8; str = str.slice(2); }
+    else if (/^0[0-9]/.test(str)) { base = 8; str = str.slice(1); }
+    else base = 10;
+    str = str.replaceAll("_", "");
+  }
+  if (base < 2 || base > 36) return [0n, 'strconv.ParseInt: parsing "' + s + '": invalid base ' + base];
+  const digits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, base);
+  if (str === "" || [...str.toLowerCase()].some((c) => !digits.includes(c))) {
+    return [0n, 'strconv.ParseInt: parsing "' + s + '": invalid syntax'];
+  }
+  let v = 0n; const B = BigInt(base);
+  for (const c of str.toLowerCase()) v = v * B + BigInt(digits.indexOf(c));
+  if (neg) v = -v;
+  const w = bits === 0 ? 64 : bits;
+  const max = (1n << BigInt(w - 1)) - 1n, min = -(1n << BigInt(w - 1));
+  if (v > max || v < min) return [v > max ? max : min, 'strconv.ParseInt: parsing "' + s + '": value out of range'];
+  return [v, null];
+};
+var __strconv_parse_float = __strconv_parse_float || function(s) {
+  const str = s.replaceAll("_", "");
+  if (/^[+-]?(inf|infinity)$/i.test(str)) return [str[0] === "-" ? -Infinity : Infinity, null];
+  if (/^[+-]?nan$/i.test(str)) return [NaN, null];
+  if (str === "" || !/^[+-]?(\\d+\\.?\\d*|\\.\\d+)([eE][+-]?\\d+)?$|^[+-]?0[xX][0-9a-fA-F]+$/.test(str)) {
+    return [0, 'strconv.ParseFloat: parsing "' + s + '": invalid syntax'];
+  }
+  return [Number(str), null];
+};
+var __strconv_parse_bool = __strconv_parse_bool || function(s) {
+  if (["1", "t", "T", "TRUE", "true", "True"].includes(s)) return [true, null];
+  if (["0", "f", "F", "FALSE", "false", "False"].includes(s)) return [false, null];
+  return [false, 'strconv.ParseBool: parsing "' + s + '": invalid syntax'];
+};
+var __strconv_format_float = __strconv_format_float || function(f, fmtc, prec) {
+  const c = String.fromCharCode(fmtc);
+  if (!Number.isFinite(f)) return f !== f ? "NaN" : (f > 0 ? "+Inf" : "-Inf");
+  if (c === "f") return prec < 0 ? String(f) : f.toFixed(prec);
+  if (c === "e" || c === "E") {
+    const r = prec < 0 ? f.toExponential() : f.toExponential(prec);
+    const o = r.replace(/e([+-])(\\d)$/, "e$10$2");
+    return c === "E" ? o.toUpperCase() : o;
+  }
+  if (c === "g" || c === "G") {
+    const r = prec < 0 ? String(f) : f.toPrecision(prec);
+    return c === "G" ? r.toUpperCase() : r;
+  }
+  return String(f);
+};`;
+
 export const HELPER_PATH_CLEAN = `var __pathClean = __pathClean || function(p) {
   if (!p) return ".";
   const abs = p.startsWith("/");

package/src/backend/js/source-map.js

@@ -57,3 +57,35 @@ export function buildSourceMap(sources, mappings, sourcesContent) {
 	if (sourcesContent) map.sourcesContent = sourcesContent;
 	return JSON.stringify(map);
 }
+
+// WASM source maps use the convention "generated line 0, generated column =
+// byte offset into the module".  `mappings` is Array<{ offset, srcFileIdx,
+// srcLine }> (0-based line), one segment per function body (function-level
+// granularity); DevTools shows the Go file/line for each wasm function.
+export function buildWasmSourceMap(sources, mappings, sourcesContent) {
+	const sorted = [...mappings].sort((a, b) => a.offset - b.offset);
+	const segments = [];
+	let prevOffset = 0;
+	let prevSrcFile = 0;
+	let prevSrcLine = 0;
+	for (const m of sorted) {
+		const fileIdx = m.srcFileIdx ?? 0;
+		segments.push(
+			vlqEncode(m.offset - prevOffset) +
+				vlqEncode(fileIdx - prevSrcFile) +
+				vlqEncode(m.srcLine - prevSrcLine) +
+				vlqEncode(0),
+		);
+		prevOffset = m.offset;
+		prevSrcFile = fileIdx;
+		prevSrcLine = m.srcLine;
+	}
+	const map = {
+		version: 3,
+		sources: sources.map((s) => s.replace(/\\/g, "/")),
+		names: [],
+		mappings: segments.join(","),
+	};
+	if (sourcesContent) map.sourcesContent = sourcesContent;
+	return JSON.stringify(map);
+}