gofront 1.5.1 → 1.6.1

package/src/backend/wasm/encode.js

@@ -52,24 +52,36 @@ export function encodeI64LEB(val) {
 	return bytes;
 }
 
+const _f32Arr = new Float32Array(1);
+const _f32Bytes = new Uint8Array(_f32Arr.buffer);
 export function encodeF32(val) {
-	const buf = new ArrayBuffer(4);
-	new DataView(buf).setFloat32(0, Number(val), true); // little-endian
-	return Array.from(new Uint8Array(buf));
+	_f32Arr[0] = Number(val);
+	return [_f32Bytes[0], _f32Bytes[1], _f32Bytes[2], _f32Bytes[3]];
 }
 
+const _f64Arr = new Float64Array(1);
+const _f64Bytes = new Uint8Array(_f64Arr.buffer);
 export function encodeF64(val) {
-	const buf = new ArrayBuffer(8);
-	new DataView(buf).setFloat64(0, Number(val), true); // little-endian
-	return Array.from(new Uint8Array(buf));
+	_f64Arr[0] = Number(val);
+	return [
+		_f64Bytes[0],
+		_f64Bytes[1],
+		_f64Bytes[2],
+		_f64Bytes[3],
+		_f64Bytes[4],
+		_f64Bytes[5],
+		_f64Bytes[6],
+		_f64Bytes[7],
+	];
 }
 
-export function encodeString(str) {
-	const utf8 = new TextEncoder().encode(str);
+const _textEncoder = new TextEncoder();
+function encodeString(str) {
+	const utf8 = _textEncoder.encode(str);
 	return [...encodeU32LEB(utf8.length), ...utf8];
 }
 
-export function encodeVector(items, encodeItem) {
+function encodeVector(items, encodeItem) {
 	const count = encodeU32LEB(items.length);
 	const bytes = [];
 	for (const item of items) {
@@ -83,7 +95,7 @@ export function encodeVector(items, encodeItem) {
 
 // ── Value Types & Heap Types ─────────────────────────────────
 
-export const ValType = {
+const ValType = {
 	i32: 0x7f,
 	i64: 0x7e,
 	f32: 0x7d,
@@ -101,9 +113,11 @@ export const ValType = {
 	nullref: 0x71,
 	nullfuncref: 0x73,
 	nullexternref: 0x72,
+	exnref: 0x69,
+	nullexnref: 0x75,
 };
 
-export function encodeValType(type) {
+function encodeValType(type) {
 	if (typeof type === "number") {
 		return [type];
 	}
@@ -129,7 +143,7 @@ export function encodeValType(type) {
 	throw new Error(`Invalid valtype specification: ${JSON.stringify(type)}`);
 }
 
-export function encodeBlockType(blockType) {
+function encodeBlockType(blockType) {
 	if (!blockType || blockType === "void") {
 		return [0x40];
 	}
@@ -153,6 +167,7 @@ const OPCODES = {
 	if: 0x04,
 	else: 0x05,
 	throw: 0x08,
+	throw_ref: 0x0a,
 	end: 0x0b,
 	br: 0x0c,
 	br_if: 0x0d,
@@ -164,6 +179,7 @@ const OPCODES = {
 	return_call_indirect: 0x13,
 	call_ref: 0x14,
 	return_call_ref: 0x15,
+	try_table: 0x1f,
 	drop: 0x1a,
 	select: 0x1b,
 
@@ -173,6 +189,23 @@ const OPCODES = {
 	"global.get": 0x23,
 	"global.set": 0x24,
 
+	"i32.load": 0x28,
+	"i64.load": 0x29,
+	"f32.load": 0x2a,
+	"f64.load": 0x2b,
+	"i32.load8_s": 0x2c,
+	"i32.load8_u": 0x2d,
+	"i32.load16_s": 0x2e,
+	"i32.load16_u": 0x2f,
+	"i32.store": 0x36,
+	"i64.store": 0x37,
+	"f32.store": 0x38,
+	"f64.store": 0x39,
+	"i32.store8": 0x3a,
+	"i32.store16": 0x3b,
+	"memory.size": 0x3f,
+	"memory.grow": 0x40,
+
 	"i32.const": 0x41,
 	"i64.const": 0x42,
 	"f32.const": 0x43,
@@ -360,12 +393,41 @@ const GC_OPCODES = {
 	"extern.convert_any": 0x1b,
 };
 
-export function encodeInstruction(inst) {
+// Natural alignment (log2) per load/store opcode; memarg = align, offset.
+const MEM_ALIGN = {
+	"i32.load": 2,
+	"i64.load": 3,
+	"f32.load": 2,
+	"f64.load": 3,
+	"i32.load8_s": 0,
+	"i32.load8_u": 0,
+	"i32.load16_s": 1,
+	"i32.load16_u": 1,
+	"i32.store": 2,
+	"i64.store": 3,
+	"f32.store": 2,
+	"f64.store": 3,
+	"i32.store8": 0,
+	"i32.store16": 1,
+};
+
+function encodeInstruction(inst) {
 	if (typeof inst === "string") {
 		inst = { op: inst };
 	}
 	const { op } = inst;
 
+	if (MEM_ALIGN[op] !== undefined) {
+		return [
+			OPCODES[op],
+			...encodeU32LEB(inst.align ?? MEM_ALIGN[op]),
+			...encodeU32LEB(inst.offset ?? 0),
+		];
+	}
+	if (op === "memory.size" || op === "memory.grow") {
+		return [OPCODES[op], 0x00];
+	}
+
 	// 1. Check saturating truncations (0xFC prefix)
 	if (SAT_TRUNC_OPCODES[op] !== undefined) {
 		return [0xfc, ...encodeU32LEB(SAT_TRUNC_OPCODES[op])];
@@ -392,6 +454,26 @@ export function encodeInstruction(inst) {
 		) {
 			return bytes;
 		}
+		if (
+			op === "ref.cast" ||
+			op === "ref.cast_null" ||
+			op === "ref.test" ||
+			op === "ref.test_null"
+		) {
+			const ht =
+				inst.heapType !== undefined
+					? inst.heapType
+					: inst.typeIndex !== undefined
+						? inst.typeIndex
+						: "any";
+			if (typeof ht === "number") {
+				bytes.push(...encodeI32LEB(ht));
+			} else {
+				const code = ValType[ht] ?? ValType[`${ht}ref`] ?? 0x6e;
+				bytes.push(code);
+			}
+			return bytes;
+		}
 		if (inst.typeIndex !== undefined) {
 			bytes.push(...encodeU32LEB(inst.typeIndex));
 		}
@@ -425,6 +507,40 @@ export function encodeInstruction(inst) {
 			case "throw":
 				return [byte, ...encodeU32LEB(inst.tagIndex ?? inst.index ?? 0)];
 
+			case "throw_ref":
+				return [byte];
+
+			case "try_table": {
+				const blockTypeBytes = encodeBlockType(
+					inst.blockType ?? inst.resultType,
+				);
+				const catches = inst.catches ?? [];
+				const catchBytes = encodeVector(catches, (c) => {
+					const kind = c.kind ?? c.op;
+					switch (kind) {
+						case "catch":
+							return [
+								0x00,
+								...encodeU32LEB(c.tagIndex ?? c.tag ?? 0),
+								...encodeU32LEB(c.label ?? c.depth ?? 0),
+							];
+						case "catch_ref":
+							return [
+								0x01,
+								...encodeU32LEB(c.tagIndex ?? c.tag ?? 0),
+								...encodeU32LEB(c.label ?? c.depth ?? 0),
+							];
+						case "catch_all":
+							return [0x02, ...encodeU32LEB(c.label ?? c.depth ?? 0)];
+						case "catch_all_ref":
+							return [0x03, ...encodeU32LEB(c.label ?? c.depth ?? 0)];
+						default:
+							throw new Error(`Unknown catch kind: ${kind}`);
+					}
+				});
+				return [byte, ...blockTypeBytes, ...catchBytes];
+			}
+
 			case "call":
 			case "return_call":
 				return [byte, ...encodeU32LEB(inst.funcIndex ?? inst.index ?? 0)];
@@ -494,7 +610,7 @@ function encodeSection(id, payload) {
 	return [id, ...encodeU32LEB(payload.length), ...payload];
 }
 
-export function encodeTypeEntry(t) {
+function encodeTypeEntry(t) {
 	if (t.form === "rec") {
 		// Recursive type group: 0x4E, count, types
 		const count = encodeU32LEB(t.types.length);
@@ -533,12 +649,12 @@ export function encodeTypeEntry(t) {
 	];
 }
 
-export function encodeTypeSection(types) {
+function encodeTypeSection(types) {
 	if (!types || types.length === 0) return [];
 	return encodeSection(1, encodeVector(types, encodeTypeEntry));
 }
 
-export function encodeImportSection(imports) {
+function encodeImportSection(imports) {
 	if (!imports || imports.length === 0) return [];
 	return encodeSection(
 		2,
@@ -581,7 +697,7 @@ export function encodeImportSection(imports) {
 	);
 }
 
-export function encodeFunctionSection(funcs) {
+function encodeFunctionSection(funcs) {
 	if (!funcs || funcs.length === 0) return [];
 	return encodeSection(
 		3,
@@ -589,7 +705,7 @@ export function encodeFunctionSection(funcs) {
 	);
 }
 
-export function encodeTagSection(tags) {
+function encodeTagSection(tags) {
 	if (!tags || tags.length === 0) return [];
 	return encodeSection(
 		13,
@@ -597,7 +713,22 @@ export function encodeTagSection(tags) {
 	);
 }
 
-export function encodeGlobalSection(globals) {
+// Single linear memory: `{ min, max }` in 64 KiB pages.  `max` is optional;
+// the shared-buffer runtime only grows the memory inside the start function,
+// before any JS TypedArray view exists.
+function encodeMemorySection(memory) {
+	if (!memory) return [];
+	const limits =
+		memory.max != null
+			? [0x01, ...encodeU32LEB(memory.min), ...encodeU32LEB(memory.max)]
+			: [0x00, ...encodeU32LEB(memory.min)];
+	return encodeSection(
+		5,
+		encodeVector([limits], (b) => b),
+	);
+}
+
+function encodeGlobalSection(globals) {
 	if (!globals || globals.length === 0) return [];
 	return encodeSection(
 		6,
@@ -621,7 +752,7 @@ export function encodeGlobalSection(globals) {
 	);
 }
 
-export function encodeExportSection(exports) {
+function encodeExportSection(exports) {
 	if (!exports || exports.length === 0) return [];
 	return encodeSection(
 		7,
@@ -670,7 +801,7 @@ function sameValType(a, b) {
 	return false;
 }
 
-export function encodeElementSection(elements) {
+function encodeElementSection(elements) {
 	if (!elements || elements.length === 0) return [];
 	const segment = [0x03, 0x00, ...encodeVector(elements, encodeU32LEB)];
 	return encodeSection(
@@ -679,64 +810,76 @@ export function encodeElementSection(elements) {
 	);
 }
 
-export function encodeCodeSection(funcs) {
+// Encodes the code section.  `bodyOffsets` (when given) receives, per
+// function, the offset of the body's first instruction relative to the start
+// of the section bytes returned.
+function encodeCodeSection(funcs, bodyOffsets = null) {
 	if (!funcs || funcs.length === 0) return [];
-	return encodeSection(
-		10,
-		encodeVector(funcs, (fn) => {
-			// Compress locals: [type1, type1, type2] -> [{ count: 2, type: type1 }, { count: 1, type: type2 }]
-			const rawLocals = fn.locals ?? [];
-			const compressedLocals = [];
-			for (const loc of rawLocals) {
-				const locType =
-					typeof loc === "string"
-						? loc
-						: loc.type !== undefined
-							? loc.type
-							: loc;
-				if (
-					compressedLocals.length > 0 &&
-					sameValType(
-						compressedLocals[compressedLocals.length - 1].type,
-						locType,
-					)
-				) {
-					compressedLocals[compressedLocals.length - 1].count++;
-				} else {
-					compressedLocals.push({ count: 1, type: locType });
-				}
-			}
-
-			const localsBytes = encodeVector(compressedLocals, (group) => [
-				...encodeU32LEB(group.count),
-				...encodeValType(group.type),
-			]);
-
-			const bodyInsts = fn.body ?? [];
-			const bodyBytes = [];
-			for (const inst of bodyInsts) {
-				const chunk = encodeInstruction(inst);
-				for (let i = 0; i < chunk.length; i++) bodyBytes.push(chunk[i]);
-			}
-			// Ensure terminating end opcode (0x0B)
+	const relOffsets = [];
+	const payload = encodeVector(funcs, (fn) => {
+		// Compress locals: [type1, type1, type2] -> [{ count: 2, type: type1 }, { count: 1, type: type2 }]
+		const rawLocals = fn.locals ?? [];
+		const compressedLocals = [];
+		for (const loc of rawLocals) {
+			const locType =
+				typeof loc === "string" ? loc : loc.type !== undefined ? loc.type : loc;
 			if (
-				bodyInsts.length === 0 ||
-				bodyInsts[bodyInsts.length - 1].op !== "end"
+				compressedLocals.length > 0 &&
+				sameValType(compressedLocals[compressedLocals.length - 1].type, locType)
 			) {
-				bodyBytes.push(0x0b);
+				compressedLocals[compressedLocals.length - 1].count++;
+			} else {
+				compressedLocals.push({ count: 1, type: locType });
 			}
+		}
 
-			const fullBody = [...localsBytes, ...bodyBytes];
-			return [...encodeU32LEB(fullBody.length), ...fullBody];
-		}),
-	);
+		const localsBytes = encodeVector(compressedLocals, (group) => [
+			...encodeU32LEB(group.count),
+			...encodeValType(group.type),
+		]);
+
+		const bodyInsts = fn.body ?? [];
+		const bodyBytes = [];
+		for (const inst of bodyInsts) {
+			const chunk = encodeInstruction(inst);
+			for (let i = 0; i < chunk.length; i++) bodyBytes.push(chunk[i]);
+		}
+		// Ensure terminating end opcode (0x0B)
+		if (
+			bodyInsts.length === 0 ||
+			bodyInsts[bodyInsts.length - 1].op !== "end"
+		) {
+			bodyBytes.push(0x0b);
+		}
+
+		const fullBody = [...localsBytes, ...bodyBytes];
+		const sizeBytes = encodeU32LEB(fullBody.length);
+		// Offset of the first instruction within this entry + entry length.
+		relOffsets.push([
+			sizeBytes.length + localsBytes.length,
+			sizeBytes.length + fullBody.length,
+		]);
+		return [...sizeBytes, ...fullBody];
+	});
+	if (bodyOffsets) {
+		// Section-relative: id + size LEB + count LEB + preceding entries.
+		let cursor =
+			1 +
+			encodeU32LEB(payload.length).length +
+			encodeU32LEB(funcs.length).length;
+		for (const [first, len] of relOffsets) {
+			bodyOffsets.push(cursor + first);
+			cursor += len;
+		}
+	}
+	return encodeSection(10, payload);
 }
 
 // ── Top-level Module Encoder ─────────────────────────────────
 
 // Custom section placed right after the header; `isGoFrontWasm` keys off it.
-export const GOFRONT_SECTION_NAME = "gofront";
-const GOFRONT_SECTION_BYTES = [
+const GOFRONT_SECTION_NAME = "gofront";
+export const GOFRONT_SECTION_BYTES = [
 	0x00,
 	...encodeU32LEB(1 + GOFRONT_SECTION_NAME.length),
 	...encodeString(GOFRONT_SECTION_NAME),
@@ -753,6 +896,10 @@ export function isGoFrontWasm(bytes) {
 	return true;
 }
 
+// Encodes the module.  When `mod.sourceMappingURL` is set a trailing
+// `sourceMappingURL` custom section is appended, and `mod.codeOffsets` is
+// filled with the absolute byte offset of every function body (aligned with
+// `mod.funcs`) so a function-level source map can be built.
 export function encodeModule(mod) {
 	const magic = [0x00, 0x61, 0x73, 0x6d]; // \0asm
 	const version = [0x01, 0x00, 0x00, 0x00]; // version 1
@@ -760,6 +907,7 @@ export function encodeModule(mod) {
 	const typeSec = encodeTypeSection(mod.types);
 	const importSec = encodeImportSection(mod.imports);
 	const funcSec = encodeFunctionSection(mod.funcs);
+	const memorySec = encodeMemorySection(mod.memory);
 	const tagSec = encodeTagSection(mod.tags);
 	const globalSec = encodeGlobalSection(mod.globals);
 	const exportSec = encodeExportSection(mod.exports);
@@ -768,22 +916,48 @@ export function encodeModule(mod) {
 			? encodeSection(8, encodeU32LEB(mod.start))
 			: [];
 	const elemSec = encodeElementSection(mod.elements);
-	const codeSec = encodeCodeSection(mod.funcs);
-
-	const allBytes = [
-		...magic,
-		...version,
-		...GOFRONT_SECTION_BYTES,
-		...typeSec,
-		...importSec,
-		...funcSec,
-		...tagSec,
-		...globalSec,
-		...exportSec,
-		...startSec,
-		...elemSec,
-		...codeSec,
+	const sectionOffsets = [];
+	const codeSec = encodeCodeSection(mod.funcs, sectionOffsets);
+
+	const sections = [
+		magic,
+		version,
+		GOFRONT_SECTION_BYTES,
+		typeSec,
+		importSec,
+		funcSec,
+		memorySec,
+		tagSec,
+		globalSec,
+		exportSec,
+		startSec,
+		elemSec,
 	];
+	let totalLen = 0;
+	for (const s of sections) totalLen += s.length;
+	const codeStart = totalLen;
+	mod.codeOffsets = sectionOffsets.map((o) => codeStart + o);
+	totalLen += codeSec.length;
+	let smSec = null;
+	if (mod.sourceMappingURL) {
+		smSec = encodeSection(0, [
+			...encodeString("sourceMappingURL"),
+			...encodeString(mod.sourceMappingURL),
+		]);
+		totalLen += smSec.length;
+	}
+
+	const out = new Uint8Array(totalLen);
+	let offset = 0;
+	for (const s of sections) {
+		out.set(s, offset);
+		offset += s.length;
+	}
+	out.set(codeSec, offset);
+	offset += codeSec.length;
+	if (smSec) {
+		out.set(smSec, offset);
+	}
 
-	return new Uint8Array(allBytes);
+	return out;
 }

package/src/backend/wasm/glue.js

@@ -1,14 +1,16 @@
 // src/backend/wasm/glue.js
 // Runtime imports and JS glue for executing GoFront WASM modules.
 
-import { WASM_IMPORTS_JS } from "./boundary.js";
+import { WASM_IMPORTS_JS, WASM_STDLIB_JS } from "./boundary.js";
 
 // The import table is authored once as source text (it is spliced into the
 // production bundle by the facade); evaluate that same text here so tests
 // exercise exactly what ships.  The text is a compile-time constant.
-const makeImports = new Function(`${WASM_IMPORTS_JS}\nreturn __gfw_imports;`)();
+const makeImports = new Function(
+	`${WASM_IMPORTS_JS}\n${WASM_STDLIB_JS}\nreturn __gfw_imports;`,
+)();
 
-export function createWasmImports({
+function createWasmImports({
 	stringTable = [],
 	panicTag = null,
 	stdout = null,
@@ -30,6 +32,14 @@ const NIL_DEREF_PATTERNS = [
 	"null dereference", // JavaScriptCore
 ];
 
+function safeString(v) {
+	try {
+		return String(v);
+	} catch {
+		return "[panic object]";
+	}
+}
+
 function isNilDerefTrap(e) {
 	if (
 		typeof WebAssembly !== "undefined" &&
@@ -53,6 +63,7 @@ export function instantiateWasm(
 
 	const module = new WebAssembly.Module(wasmBytes);
 	const instance = new WebAssembly.Instance(module, imports);
+	imports.__bind?.(instance.exports);
 
 	// The module exports its panic tag if defined internally, or uses the imported one
 	const tag = instance.exports.panicTag ?? defaultPanicTag;
@@ -67,9 +78,12 @@ export function instantiateWasm(
 					try {
 						return val(...cur);
 					} catch (e) {
+						if (instance.exports.__panic) {
+							instance.exports.__panic.value = null;
+						}
 						if (tag && e instanceof WebAssembly.Exception && e.is(tag)) {
 							const msg = e.getArg(tag, 0);
-							throw new Error(String(msg));
+							throw new Error(safeString(msg));
 						}
 						if (isNilDerefTrap(e)) {
 							throw new Error(
@@ -91,7 +105,7 @@ export function instantiateWasm(
 											inner.is(tag)
 										) {
 											const msg = inner.getArg(tag, 0);
-											throw new Error(String(msg));
+											throw new Error(safeString(msg));
 										}
 										if (isNilDerefTrap(inner)) {
 											throw new Error(