@jax-js/jax 0.1.13 → 0.1.14

package/dist/{backend-DMyuoWi2.cjs → backend-VlXzdQvR.cjs}

@@ -2328,6 +2328,25 @@ var TuneDims = class {
 			this.upcast++;
 		}
 	}
+	applyGroup(axis, amount) {
+		if (axis < this.reduce || axis >= this.unroll) throw new Error("Can only group reduction axes");
+		const length = this.st.shape[axis];
+		if (length % amount !== 0) throw new Error(`Group by ${amount} on axis length ${length}`);
+		this.st = this.st.reshape([
+			...this.st.shape.slice(0, axis),
+			length / amount,
+			amount,
+			...this.st.shape.slice(axis + 1)
+		]).permute([
+			...range(this.reduce),
+			axis + 1,
+			...range(this.reduce, axis + 1),
+			...range(axis + 2, this.st.shape.length + 1)
+		]);
+		this.reduce++;
+		this.unroll++;
+		this.upcast++;
+	}
 };
 /** Tuning step that does not apply any optimization. */
 function tuneNullopt(kernel) {
@@ -2399,6 +2418,17 @@ function tuneWebgpu(kernel) {
 			upcastedAxis.add(choices[0][2]);
 		} else break;
 	}
+	const groupCandidateSts = sts.map((st) => st.compose(dim.st));
+	const groupCandidateHasContiguousInputs = groupCandidateSts.every((st) => {
+		const hasOutputStride = st.lastStrides.slice(0, dim.groups).some((stride) => stride !== 0);
+		return !hasOutputStride || Math.abs(st.lastStrides[dim.reduce]) <= 1;
+	});
+	if (reduction.op === AluOp.Add && reduction.dtype === DType.Float32 && groupCandidateHasContiguousInputs && prod(dim.st.shape.slice(0, dim.groups)) < 4096 && prod(dim.st.shape.slice(dim.reduce, dim.unroll)) >= 512) {
+		const axis = dim.reduce;
+		let amount = 16;
+		while (amount > 1 && dim.st.shape[axis] % amount !== 0) amount /= 2;
+		if (amount > 1) dim.applyGroup(axis, amount);
+	}
 	if (!/Mobi|Android/i.test(navigator.userAgent) && dim.reduce < dim.unroll && (prod(dim.st.shape.slice(dim.unroll)) <= 4 || dim.unroll === dim.upcast && prod(dim.st.shape.slice(dim.upcast)) < 64)) {
 		const s = dim.st.shape[dim.unroll - 1];
 		if (0 < s && s <= 32) dim.applyUnroll(dim.reduce, s);
@@ -3219,6 +3249,30 @@ function wasm_threefry2x32(cg) {
 	});
 }
 
+//#endregion
+//#region src/backend/wasm/featureProbe.ts
+const featureProbes = { "relaxed-madd": "0061736d0100000001080160037b7b7b017b030201000a0d010b00200020012002fd85020b" };
+const featureSupportCache = /* @__PURE__ */ new Map();
+/** Detects whether this environment supports a probed Wasm CPU feature. */
+function hasWasmFeature(feature) {
+	const cached = featureSupportCache.get(feature);
+	if (cached !== void 0) return cached;
+	const testHex = featureProbes[feature];
+	let supported = false;
+	try {
+		supported = typeof WebAssembly !== "undefined" && WebAssembly.validate(decodeHex(testHex));
+	} catch {
+		supported = false;
+	}
+	featureSupportCache.set(feature, supported);
+	return supported;
+}
+function decodeHex(hex) {
+	const bytes = new Uint8Array(/* @__PURE__ */ new ArrayBuffer(hex.length / 2));
+	for (let i = 0; i < bytes.length; i++) bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+
 //#endregion
 //#region src/backend/wasm/parallel.ts
 /** Check if SharedArrayBuffer is available. */
@@ -3309,10 +3363,10 @@ var WasmWorkerPool = class {
 	* Returns an epoch that can be used to wait for the ongoing work to complete,
 	* which is guaranteed to be monotonically increasing.
 	*/
-	dispatch(module$1, ptrs, size) {
+	dispatch(module$1, ptrs, size, chunkAlignment = 16, minWorkPerWorker = MIN_ELEMS_PER_THREAD) {
 		this.#ensureInit();
 		this.#epochEnd++;
-		const result = this.#queue.then(() => this.#dispatchNow(module$1, ptrs, size));
+		const result = this.#queue.then(() => this.#dispatchNow(module$1, ptrs, size, chunkAlignment, minWorkPerWorker));
 		this.#queue = result.then(() => {}, () => {}).then(() => {
 			this.#epoch++;
 			const hooks = this.#hooks.get(this.#epoch);
@@ -3323,10 +3377,10 @@ var WasmWorkerPool = class {
 		});
 		return this.#epochEnd;
 	}
-	async #dispatchNow(module$1, ptrs, size) {
+	async #dispatchNow(module$1, ptrs, size, chunkAlignment, minWorkPerWorker) {
 		if (size === 0) return;
-		const n = Math.min(this.#workers.length, Math.ceil(size / MIN_ELEMS_PER_THREAD));
-		const chunkSize = Math.ceil(size / n / 16) * 16;
+		const n = Math.min(this.#workers.length, Math.ceil(size / minWorkPerWorker));
+		const chunkSize = Math.ceil(size / n / chunkAlignment) * chunkAlignment;
 		const promises = [];
 		for (let i = 0; i < n; i++) {
 			const begin = i * chunkSize;
@@ -3361,1421 +3415,1529 @@ function createWorkerPool(memory) {
 }
 
 //#endregion
-//#region src/backend/wasm/wasmblr.ts
-/**
-* @file Minimalist WebAssembly assembler. This allows you to emit WebAssembly
-* bytecode directly from the browser.
-*
-* Self-contained port of https://github.com/bwasti/wasmblr to TypeScript.
-* Some operation names in this module are written in `snake_case` to match
-* their names in the Wasm specification.
-*
-* Reference: https://pengowray.github.io/wasm-ops/.
-*/
-const magicModuleHeader = [
-	0,
-	97,
-	115,
-	109
-];
-const moduleVersion = [
-	1,
-	0,
-	0,
-	0
-];
-function assert(condition, message) {
-	if (!condition) throw new Error(message || "Assertion failed");
+//#region src/backend/wasm/tilePlan.ts
+const simdLanes = 4;
+const TILED_SIMD_ROWS = 128;
+const TILED_SIMD_COLUMNS = 128;
+const TILED_SIMD_K = 64;
+const TILED_SIMD_MICRO_ROWS = 4;
+const TILED_SIMD_MICRO_VECTORS = 4;
+const K_SIMD_MICRO_ROWS = 4;
+const K_SIMD_MICRO_COLS = 4;
+const K_SIMD_UNROLL = 4;
+const TILE_AXIS_PARTS = 8;
+function isSymbol(exp, name) {
+	return exp.op === AluOp.Variable && exp.arg === name || exp.op === AluOp.Special && exp.arg[0] === name;
 }
-function encodeSigned(n) {
-	const out = [];
-	let more = true;
-	while (more) {
-		let byte = n & 127;
-		n >>= 7;
-		if (n === 0 && (byte & 64) === 0 || n === -1 && (byte & 64) !== 0) more = false;
-		else byte |= 128;
-		out.push(byte);
+function referencesSymbol(exp, name) {
+	return isSymbol(exp, name) || exp.src.some((src) => referencesSymbol(src, name));
+}
+function referencesGidx(exp) {
+	return referencesSymbol(exp, "gidx");
+}
+function hasFragmentRisk(tileSize, N) {
+	return isFinite(tileSize) && tileSize > N && tileSize % N !== 0;
+}
+function constInt(exp) {
+	if (exp.op !== AluOp.Const) return null;
+	const value = exp.arg;
+	return Number.isInteger(value) ? value : null;
+}
+function coefficientOfSymbol(exp, name) {
+	if (!referencesSymbol(exp, name)) return 0;
+	if (isSymbol(exp, name)) return 1;
+	if (exp.op === AluOp.Add || exp.op === AluOp.Sub) {
+		const a = coefficientOfSymbol(exp.src[0], name);
+		const b = coefficientOfSymbol(exp.src[1], name);
+		if (a === null || b === null) return null;
+		return exp.op === AluOp.Add ? a + b : a - b;
 	}
-	return out;
+	if (exp.op === AluOp.Mul) {
+		const lhs = constInt(exp.src[0]);
+		if (lhs !== null) {
+			const rhsCoeff = coefficientOfSymbol(exp.src[1], name);
+			return rhsCoeff === null ? null : lhs * rhsCoeff;
+		}
+		const rhs = constInt(exp.src[1]);
+		if (rhs !== null) {
+			const lhsCoeff = coefficientOfSymbol(exp.src[0], name);
+			return lhsCoeff === null ? null : rhs * lhsCoeff;
+		}
+	}
+	return null;
 }
-function encodeUnsigned(n) {
-	const out = [];
-	do {
-		let byte = n & 127;
-		n = n >>> 7;
-		if (n !== 0) byte |= 128;
-		out.push(byte);
-	} while (n !== 0);
-	return out;
+function rewriteSymbol(exp, name, rewrite) {
+	return exp.rewrite((node) => isSymbol(node, name) ? rewrite(node) : void 0).simplify();
 }
-function encodeString(s) {
-	const bytes = new TextEncoder().encode(s);
-	return [bytes.length, ...bytes];
+function repeatsAcrossGidxTile(exp, tileSize) {
+	if (!isFinite(tileSize)) return false;
+	const shifted = rewriteSymbol(exp, "gidx", (node) => AluExp.add(node, AluExp.i32(tileSize)));
+	return shifted.getHash() === exp.getHash();
 }
-function encodeBlocktype(type) {
-	assert(type.length > 0, "blocktype must have at least one type");
-	if (type.length === 1) return [type[0].typeId];
-	return [
-		96,
-		...encodeUnsigned(0),
-		...encodeUnsigned(type.length),
-		...type.map((t) => t.typeId)
-	];
+function divisorAtMost(value, limit) {
+	for (let i = Math.min(value, limit); i > 1; i--) if (value % i === 0) return i;
+	return 1;
 }
-function encodeOpcode(opcode) {
-	if (typeof opcode === "number") return [opcode];
-	return [opcode[0], ...encodeUnsigned(opcode[1])];
+function tileAxisLimit(axisSize, maxTileSize) {
+	return Math.min(maxTileSize, Math.max(1, Math.floor(axisSize / TILE_AXIS_PARTS)));
 }
-function concat(out, inp) {
-	out.push(...inp);
+function commonTileSize(kernelSize, strideMap, minTileSize, unconstrainedTileSize = null) {
+	const tileSizes = [];
+	for (const stride of strideMap.values()) if (stride.kind !== "gather" && isFinite(stride.tileSize)) tileSizes.push(stride.tileSize);
+	if (tileSizes.length === 0) return unconstrainedTileSize;
+	const tileSize = Math.min(...tileSizes);
+	if (tileSize < minTileSize || kernelSize % tileSize !== 0 || tileSizes.some((size) => size % tileSize !== 0)) return null;
+	return tileSize;
 }
-var Function_ = class {
-	inputTypes;
-	outputTypes;
-	body;
-	locals = [];
-	constructor(inputTypes, outputTypes, body) {
-		this.inputTypes = inputTypes;
-		this.outputTypes = outputTypes;
-		this.body = body || (() => {});
-	}
-	emit() {
-		this.locals = [];
-		this.body();
-	}
-};
-var Memory = class {
-	min = 0;
-	max = 0;
-	isShared = false;
-	aString = "";
-	bString = "";
-	constructor(cg) {
-		this.cg = cg;
-	}
-	/** Declare the size of the memory. Each page is 64 KiB. */
-	pages(min, max = 0) {
-		assert(this.min === 0 && this.max === 0);
-		this.min = min;
-		this.max = max;
-		return this;
-	}
-	export(a) {
-		assert(!this.isImport && !this.isExport, "already set");
-		this.aString = a;
-		return this;
-	}
-	shared(isShared) {
-		this.isShared = isShared;
-		return this;
-	}
-	import(a, b) {
-		assert(!this.isImport && !this.isExport, "already set");
-		this.aString = a;
-		this.bString = b;
-		return this;
-	}
-	size() {
-		this.cg._emit(63);
-		this.cg._emit(0);
-	}
-	grow() {
-		this.cg._emit(64);
-		this.cg._emit(0);
-	}
-	get isImport() {
-		return this.aString.length > 0 && this.bString.length > 0;
-	}
-	get isExport() {
-		return this.aString.length > 0 && this.bString.length === 0;
-	}
-};
-/** Public API of WebAssembly assembler. */
-var CodeGenerator = class {
-	local;
-	i32;
-	f32;
-	f64;
-	v128;
-	i32x4;
-	f32x4;
-	memory;
-	void = {
-		typeId: 64,
-		name: "void"
+function tiledRows(kernelSize, tileSize) {
+	const rowCount = kernelSize / tileSize;
+	return divisorAtMost(rowCount, tileAxisLimit(rowCount, TILED_SIMD_ROWS));
+}
+function tiledColumns(tileSize, laneWidth = 1) {
+	return divisorAtMost(tileSize / laneWidth, Math.max(1, Math.floor(tileAxisLimit(tileSize, TILED_SIMD_COLUMNS) / laneWidth)));
+}
+function periodicStride(exp, kind) {
+	if (exp.src[1].op !== AluOp.Const) return null;
+	const N = exp.src[1].arg;
+	const inner = analyzeStride(exp.src[0]);
+	if (inner.kind === "broadcast") return inner;
+	if (inner.kind !== "contiguous" || hasFragmentRisk(inner.tileSize, N)) return { kind: "gather" };
+	return {
+		kind,
+		tileSize: Math.min(inner.tileSize, N)
 	};
-	#functions = [];
-	#importedFunctions = [];
-	#exportedFunctions = /* @__PURE__ */ new Map();
-	#curFunction = null;
-	#curBytes = [];
-	#typeStack = [];
-	#blockFrames = [];
-	constructor() {
-		this.local = new Local(this);
-		this.i32 = new I32(this);
-		this.f32 = new F32(this);
-		this.f64 = new F64(this);
-		this.v128 = new V128(this);
-		this.i32x4 = new I32x4(this);
-		this.f32x4 = new F32x4(this);
-		this.memory = new Memory(this);
-	}
-	unreachable() {
-		this._emit(0);
-	}
-	nop() {
-		this._emit(1);
-	}
-	block(...type) {
-		this.#blockFrames.push({
-			idx: this.#typeStack.length,
-			ty: type
-		});
-		this._emit(2);
-		this._emit(encodeBlocktype(type));
+}
+function addStrides(lhs, rhs) {
+	if (lhs.kind === "gather" || rhs.kind === "gather") return { kind: "gather" };
+	const tileSize = Math.min(lhs.tileSize, rhs.tileSize);
+	if (lhs.kind === "broadcast") return {
+		kind: rhs.kind,
+		tileSize
+	};
+	if (rhs.kind === "broadcast") return {
+		kind: lhs.kind,
+		tileSize
+	};
+	return { kind: "gather" };
+}
+function analyzeStride(exp) {
+	if (!referencesGidx(exp)) return {
+		kind: "broadcast",
+		tileSize: Infinity
+	};
+	if (exp.op === AluOp.Special && exp.arg[0] === "gidx") return {
+		kind: "contiguous",
+		tileSize: Infinity
+	};
+	if (exp.op === AluOp.Idiv || exp.op === AluOp.Mod) {
+		const stride = periodicStride(exp, exp.op === AluOp.Idiv ? "broadcast" : "contiguous");
+		if (stride) return stride;
 	}
-	loop(...type) {
-		this.#blockFrames.push({
-			idx: this.#typeStack.length,
-			ty: type
-		});
-		this._emit(3);
-		this._emit(encodeBlocktype(type));
+	if (exp.op === AluOp.Mul) {
+		for (let i = 0; i < 2; i++) if (exp.src[i].op === AluOp.Const) {
+			const inner = analyzeStride(exp.src[1 - i]);
+			if (inner.kind === "broadcast") return inner;
+			return { kind: "gather" };
+		}
 	}
-	if(...type) {
-		assert(this._pop().typeId === this.i32.typeId, "if_: expected i32");
-		this.#blockFrames.push({
-			idx: this.#typeStack.length,
-			ty: type
+	if (exp.op === AluOp.Add) return addStrides(analyzeStride(exp.src[0]), analyzeStride(exp.src[1]));
+	return { kind: "gather" };
+}
+function simdStrideResult(globalIndex) {
+	const index = globalIndex.src[0];
+	const result = analyzeStride(index);
+	const [_, len] = globalIndex.arg;
+	if (result.kind !== "gather" && (result.tileSize < simdLanes || isFinite(result.tileSize) && result.tileSize % simdLanes !== 0)) return { kind: "gather" };
+	if (result.kind === "contiguous" && (index.min < 0 || index.max >= len)) return { kind: "gather" };
+	return result;
+}
+function collectSimdStrides(exp) {
+	return new Map((exp?.collect((node) => node.op === AluOp.GlobalIndex) ?? []).map((gi) => [gi, simdStrideResult(gi)]));
+}
+function reductionPointerCandidates(exp, strideMap) {
+	const candidates = [];
+	for (const gi of exp.collect((node) => node.op === AluOp.GlobalIndex)) {
+		const stride = strideMap?.get(gi) ?? {
+			kind: "broadcast",
+			tileSize: Infinity
+		};
+		if (strideMap && stride.kind === "gather") continue;
+		const [gid, len] = gi.arg;
+		const index = gi.src[0];
+		const strideElems = coefficientOfSymbol(index, "ridx");
+		if (strideElems === null || !Number.isInteger(strideElems)) continue;
+		if (index.min < 0 || index.max >= len) continue;
+		candidates.push({
+			exp: gi,
+			gid,
+			dtype: gi.dtype,
+			stride,
+			baseIndex: rewriteSymbol(index, "ridx", () => AluExp.i32(0)),
+			strideBytes: strideElems * byteWidth(gi.dtype)
 		});
-		this._emit(4);
-		this._emit(encodeBlocktype(type));
-	}
-	else() {
-		assert(this.#blockFrames.length > 0, "else: no block to else");
-		const frame = this.#blockFrames[this.#blockFrames.length - 1];
-		this.#typeStack = this.#typeStack.slice(0, frame.idx);
-		this._emit(5);
 	}
-	/** End a block (`block`, `if`/`else`, `loop`, or function). */
-	end() {
-		const frame = this.#blockFrames.pop();
-		assert(frame !== void 0, "end: no block to end");
-		this.#typeStack = this.#typeStack.slice(0, frame.idx);
-		for (const ty of frame.ty) if (ty.typeId !== this.void.typeId) this._push(ty);
-		this._emit(11);
-	}
-	/** Branch to a block a certain depth outward on the stack. */
-	br(depth) {
-		this._emit(12);
-		this._emit(encodeUnsigned(depth));
-	}
-	/** Conditional branch to a block a certain depth outward on the stack. */
-	br_if(depth) {
-		assert(this._pop().typeId === this.i32.typeId, "br_if: expected i32");
-		this._emit(13);
-		this._emit(encodeUnsigned(depth));
-	}
-	/** Jump table that indexes into a label vector (like switch). */
-	br_table(...depths) {
-		assert(this._pop().typeId === this.i32.typeId, "br_table: expected i32");
-		assert(depths.length > 0, "br_table: expected at least one default depth");
-		this._emit(14);
-		this._emit(encodeUnsigned(depths.length - 1));
-		for (const d of depths) this._emit(encodeUnsigned(d));
-	}
-	/** Return from a function, branching out of the outermost block. */
-	return() {
-		this._emit(15);
-	}
-	/** Call a function with the given ID. */
-	call(fn) {
-		const totalFunctions = this.#importedFunctions.length + this.#functions.length;
-		assert(fn < totalFunctions, "function index does not exist");
-		const func = fn < this.#importedFunctions.length ? this.#importedFunctions[fn] : this.#functions[fn - this.#importedFunctions.length];
-		for (let i = func.inputTypes.length - 1; i >= 0; i--) {
-			const argType = this._pop();
-			assert(argType.typeId === func.inputTypes[i].typeId, `call: argument ${i} type mismatch, expected ${func.inputTypes[i].name} got ${argType.name}`);
+	return candidates;
+}
+function reductionTilePlan(kernel, strideMap) {
+	if (!kernel.reduction) return null;
+	const tileSize = commonTileSize(kernel.size, strideMap, simdLanes);
+	if (tileSize === null) return null;
+	const tileRows = tiledRows(kernel.size, tileSize);
+	const tileVectors = tiledColumns(tileSize, simdLanes);
+	return {
+		tileSize,
+		tileRows,
+		tileVectors,
+		tileK: divisorAtMost(kernel.reduction.size, TILED_SIMD_K),
+		microRows: divisorAtMost(tileRows, TILED_SIMD_MICRO_ROWS),
+		microVectors: divisorAtMost(tileVectors, TILED_SIMD_MICRO_VECTORS)
+	};
+}
+function reductionKTilePlan(kernel, strideMap) {
+	if (!kernel.reduction) return null;
+	if (kernel.reduction.size % (simdLanes * K_SIMD_UNROLL) !== 0) return null;
+	const tileSize = commonTileSize(kernel.size, strideMap, 1, 1);
+	if (tileSize === null) return null;
+	const tileRows = tiledRows(kernel.size, tileSize);
+	const tileCols = tiledColumns(tileSize);
+	return {
+		tileSize,
+		tileRows,
+		tileCols,
+		microRows: divisorAtMost(tileRows, K_SIMD_MICRO_ROWS),
+		microCols: divisorAtMost(tileCols, K_SIMD_MICRO_COLS),
+		kUnroll: K_SIMD_UNROLL
+	};
+}
+function pointerShareKey(candidate, row, vector, groupIndex) {
+	const hash = candidate.exp.getHash().toString();
+	const { stride } = candidate;
+	if (stride.kind === "broadcast") return isFinite(stride.tileSize) ? `${hash}:row${row}` : `${hash}:all`;
+	if (stride.kind === "contiguous" && isFinite(stride.tileSize)) return repeatsAcrossGidxTile(candidate.baseIndex, stride.tileSize) ? `${hash}:vec${vector}` : `${hash}:row${row}:vec${vector}`;
+	return `${hash}:g${groupIndex}`;
+}
+function kReductionPointerShareKey(candidate, outputStride, tileSize, row, col, groupIndex) {
+	const hash = candidate.exp.getHash().toString();
+	if (outputStride.kind === "broadcast" && isFinite(outputStride.tileSize)) return `${hash}:row${row}`;
+	if (repeatsAcrossGidxTile(candidate.baseIndex, tileSize)) return `${hash}:col${col}`;
+	return `${hash}:g${groupIndex}`;
+}
+
+//#endregion
+//#region src/backend/wasm/translation.ts
+function translateExp(cg, funcs, exp, ctx, pointerMap = /* @__PURE__ */ new Map()) {
+	const references = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const countReferences = (exp$1) => {
+		references.set(exp$1, (references.get(exp$1) ?? 0) + 1);
+		if (!seen.has(exp$1)) {
+			seen.add(exp$1);
+			for (const src of exp$1.src) countReferences(src);
 		}
-		for (const outputType of func.outputTypes) this._push(outputType);
-		this._emit(16);
-		this._emit(encodeUnsigned(fn));
-	}
-	/** Throw away an operand on the stack. */
-	drop() {
-		this._pop();
-		this._emit(26);
-	}
-	/** Select one of the first two operands (T, F) based on the third operand (i32)'s value. */
-	select() {
-		assert(this._pop().typeId === this.i32.typeId, "select: expected i32 condition");
-		const [b, a] = [this._pop(), this._pop()];
-		assert(a.typeId === b.typeId, "select: expected same type for both operands");
-		this._push(a);
-		this._emit(27);
-	}
-	/** Import a JavaScript function; returns its index. */
-	importFunction(module$1, name, inputTypes, outputTypes) {
-		if (this.#functions.length > 0) throw new Error("function imports must precede defining functions");
-		const idx = this.#importedFunctions.length;
-		this.#importedFunctions.push({
-			module: module$1,
-			name,
-			inputTypes,
-			outputTypes
-		});
-		return idx;
-	}
-	/** Export a function. */
-	export(fn, name) {
-		this.#exportedFunctions.set(fn, name);
-	}
-	/** Declare a new function; returns its index. */
-	function(inputTypes, outputTypes, body) {
-		const idx = this.#importedFunctions.length + this.#functions.length;
-		this.#functions.push(new Function_(inputTypes, outputTypes, body));
-		return idx;
-	}
-	_declareLocal(type) {
-		assert(this.#curFunction !== null, "No current function");
-		const idx = this.#curFunction.locals.length + this.#curFunction.inputTypes.length;
-		this.#curFunction.locals.push(type);
-		return idx;
-	}
-	_inputTypes() {
-		assert(this.#curFunction !== null, "No current function");
-		return this.#curFunction.inputTypes;
-	}
-	_locals() {
-		assert(this.#curFunction !== null, "No current function");
-		return this.#curFunction.locals;
+	};
+	const expContext = /* @__PURE__ */ new Map();
+	const gen = (exp$1) => {
+		if (expContext.has(exp$1)) return cg.local.get(expContext.get(exp$1));
+		const { op, src, dtype, arg } = exp$1;
+		if (AluGroup.Binary.has(op) || AluGroup.Compare.has(op)) {
+			gen(src[0]), gen(src[1]);
+			if (op === AluOp.Add) if (dtype === DType.Bool) cg.i32.or();
+			else dty(cg, op, dtype).add();
+			else if (op === AluOp.Sub) dty(cg, op, dtype).sub();
+			else if (op === AluOp.Mul) if (dtype === DType.Bool) cg.i32.and();
+			else dty(cg, op, dtype).mul();
+			else if (op === AluOp.Idiv) if (isFloatDtype(dtype)) {
+				dtyF(cg, op, dtype).div();
+				dtyF(cg, op, dtype).trunc();
+			} else if (dtype === DType.Uint32) cg.i32.div_u();
+			else if (dtype === DType.Int32) cg.i32.div_s();
+			else throw new UnsupportedOpError(op, dtype, "wasm");
+			else if (op === AluOp.Mod) if (isFloatDtype(dtype)) {
+				const dt = dtyF(cg, op, dtype);
+				const a = cg.local.declare(dt);
+				const b = cg.local.declare(dt);
+				cg.local.set(b);
+				cg.local.tee(a);
+				cg.local.get(a);
+				cg.local.get(b);
+				dt.div();
+				dt.trunc();
+				cg.local.get(b);
+				dt.mul();
+				dt.sub();
+			} else if (dtype === DType.Uint32) cg.i32.rem_u();
+			else if (dtype === DType.Int32) cg.i32.rem_s();
+			else throw new UnsupportedOpError(op, dtype, "wasm");
+			else if (op === AluOp.Min || op === AluOp.Max) if (isFloatDtype(dtype)) if (op === AluOp.Min) dtyF(cg, op, dtype).min();
+			else dtyF(cg, op, dtype).max();
+			else if (dtype === DType.Int32 || dtype === DType.Uint32 || dtype === DType.Bool) {
+				const a = cg.local.declare(cg.i32);
+				const b = cg.local.declare(cg.i32);
+				cg.local.set(b);
+				cg.local.tee(a);
+				cg.local.get(b);
+				cg.local.get(a);
+				cg.local.get(b);
+				if (dtype === DType.Int32) if (op === AluOp.Min) cg.i32.lt_s();
+				else cg.i32.gt_s();
+				else if (op === AluOp.Min) cg.i32.lt_u();
+				else cg.i32.gt_u();
+				cg.select();
+			} else throw new UnsupportedOpError(op, dtype, "wasm");
+			else if (op === AluOp.BitCombine) if (arg === "and") cg.i32.and();
+			else if (arg === "or") cg.i32.or();
+			else cg.i32.xor();
+			else if (op === AluOp.BitShift) if (arg === "shl") cg.i32.shl();
+			else cg.i32.shr_u();
+			else if (op === AluOp.Cmplt) {
+				const srcDtype = src[0].dtype;
+				if (isFloatDtype(srcDtype)) dtyF(cg, op, srcDtype).lt();
+				else if (srcDtype === DType.Int32) cg.i32.lt_s();
+				else if (srcDtype === DType.Uint32) cg.i32.lt_u();
+				else throw new UnsupportedOpError(op, dtype, "wasm");
+			} else if (op === AluOp.Cmpne) dty(cg, op, src[0].dtype).ne();
+			else throw new UnsupportedOpError(op, dtype, "wasm");
+		} else if (AluGroup.Unary.has(op)) {
+			const callFuncF32 = (func) => {
+				if (dtype !== DType.Float32) if (dtype === DType.Float64) cg.f32.demote_f64();
+				else throw new UnsupportedOpError(op, dtype, "wasm");
+				cg.call(func);
+				if (dtype === DType.Float64) cg.f64.promote_f32();
+			};
+			if (op === AluOp.Sin) gen(src[0]), callFuncF32(funcs.sin);
+			else if (op === AluOp.Cos) gen(src[0]), callFuncF32(funcs.cos);
+			else if (op === AluOp.Asin) gen(src[0]), callFuncF32(funcs.asin);
+			else if (op === AluOp.Atan) gen(src[0]), callFuncF32(funcs.atan);
+			else if (op === AluOp.Exp) gen(src[0]), callFuncF32(funcs.exp);
+			else if (op === AluOp.Log) gen(src[0]), callFuncF32(funcs.log);
+			else if (op === AluOp.Erf) gen(src[0]), callFuncF32(funcs.erf);
+			else if (op === AluOp.Erfc) gen(src[0]), callFuncF32(funcs.erfc);
+			else if (op === AluOp.Sqrt) gen(src[0]), dtyF(cg, op, dtype).sqrt();
+			else if (op === AluOp.Reciprocal) {
+				const dt = dtyF(cg, op, dtype);
+				dt.const(1), gen(src[0]), dt.div();
+			} else if (op === AluOp.Floor) gen(src[0]), dtyF(cg, op, dtype).floor();
+			else if (op === AluOp.Ceil) gen(src[0]), dtyF(cg, op, dtype).ceil();
+			else if (op === AluOp.Cast) {
+				gen(src[0]);
+				const dtype0 = src[0].dtype;
+				const i32repr = dtype0 === DType.Int32 || dtype0 === DType.Uint32 || dtype0 === DType.Bool;
+				if (dtype === DType.Int32) if (dtype0 === DType.Float32) cg.i32.trunc_sat_f32_s();
+				else if (dtype0 === DType.Float64) cg.i32.trunc_sat_f64_s();
+				else if (i32repr);
+				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
+				else if (dtype === DType.Uint32) if (dtype0 === DType.Float32) cg.i32.trunc_sat_f32_u();
+				else if (dtype0 === DType.Float64) cg.i32.trunc_sat_f64_u();
+				else if (i32repr);
+				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
+				else if (dtype === DType.Float32) if (dtype0 === DType.Float32);
+				else if (dtype0 === DType.Float64) cg.f32.demote_f64();
+				else if (dtype0 === DType.Int32 || dtype0 === DType.Bool) cg.f32.convert_i32_s();
+				else if (dtype0 === DType.Uint32) cg.f32.convert_i32_u();
+				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
+				else if (dtype === DType.Float64) if (dtype0 === DType.Float32) cg.f64.promote_f32();
+				else if (dtype0 === DType.Float64);
+				else if (dtype0 === DType.Int32 || dtype0 === DType.Bool) cg.f64.convert_i32_s();
+				else if (dtype0 === DType.Uint32) cg.f64.convert_i32_u();
+				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
+				else if (dtype === DType.Bool) if (dtype0 === DType.Bool);
+				else if (i32repr) cg.i32.const(0), cg.i32.ne();
+				else if (dtype0 === DType.Float32) cg.f32.const(0), cg.f32.ne();
+				else if (dtype0 === DType.Float64) cg.f64.const(0), cg.f64.ne();
+				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
+				else throw new UnsupportedOpError(op, dtype, "wasm");
+			} else if (op === AluOp.Bitcast) {
+				gen(src[0]);
+				const dtype0 = src[0].dtype;
+				if (dtype !== dtype0) {
+					const i32repr = dtype0 === DType.Int32 || dtype0 === DType.Uint32;
+					if (dtype === DType.Int32 || dtype === DType.Uint32) if (dtype0 === DType.Float32) cg.i32.reinterpret_f32();
+					else if (i32repr);
+					else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
+					else if (dtype === DType.Float32) if (i32repr) cg.f32.reinterpret_i32();
+					else if (dtype0 === DType.Float32);
+					else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
+					else throw new UnsupportedOpError(op, dtype, "wasm");
+				}
+			} else throw new UnsupportedOpError(op, dtype, "wasm");
+		} else if (op === AluOp.Where) {
+			gen(src[1]);
+			gen(src[2]);
+			gen(src[0]);
+			cg.select();
+		} else if (op === AluOp.Threefry2x32) {
+			for (let i = 0; i < 4; i++) gen(src[i]);
+			cg.call(funcs.threefry2x32);
+			if (arg === "xor") cg.i32.xor();
+			else if (arg === 0) cg.drop();
+			else if (arg === 1) {
+				const local = cg.local.declare(cg.i32);
+				cg.local.set(local);
+				cg.drop();
+				cg.local.get(local);
+			} else throw new UnsupportedOpError(op, dtype, "wasm", arg);
+		} else if (op === AluOp.Const) return dty(cg, op, dtype).const(arg);
+		else if (op === AluOp.Special) return cg.local.get(ctx[arg[0]]);
+		else if (op === AluOp.Variable) return cg.local.get(ctx[arg]);
+		else if (op === AluOp.GlobalIndex) {
+			const [gid, len] = arg;
+			const pointer = pointerMap.get(exp$1);
+			if (pointer) cg.local.get(pointer.ptr);
+			else {
+				gen(src[0]);
+				const local = cg.local.declare(cg.i32);
+				cg.local.tee(local);
+				cg.i32.const(0);
+				cg.local.get(local), cg.i32.const(len), cg.i32.lt_u();
+				cg.select();
+				cg.i32.const(byteWidth(dtype));
+				cg.i32.mul();
+				cg.local.get(gid);
+				cg.i32.add();
+			}
+			dty(cg, op, dtype).load(Math.log2(byteWidth(dtype)));
+		} else throw new UnsupportedOpError(op, dtype, "wasm");
+		if ((references.get(exp$1) ?? 0) > 1) {
+			const local = cg.local.declare(dty(cg, op, dtype));
+			cg.local.tee(local);
+			expContext.set(exp$1, local);
+		}
+	};
+	countReferences(exp);
+	gen(exp);
+}
+/**
+* SIMD version of translateExp. Emits one v128 value for `exp`, interpreting
+* the current `gidx` local as the first lane and the following lanes as
+* `gidx + 1`, `gidx + 2`, etc.
+*
+* GlobalIndex loads are the only places where per-lane address behavior
+* matters:
+* - `strideMap` classifies each GlobalIndex as contiguous, broadcast, or
+*   gather. Contiguous loads become one v128.load, broadcast loads become a
+*   scalar load plus splat, and gather loads fall back to four scalar loads.
+* - `pointerMap` optionally supplies precomputed reduction pointers for
+*   GlobalIndex nodes whose address can be advanced by the surrounding
+*   reduction loop. This avoids re-emitting scalar index math in the hot path.
+* - `pointerValueCache` lets pointer plans with the same `valueKey` share a
+*   single loaded vector within one emitted reduction step.
+*/
+function translateExpSimd(cg, funcs, exp, ctx, strideMap, pointerMap = /* @__PURE__ */ new Map(), pointerValueCache = /* @__PURE__ */ new Map()) {
+	const references = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const countReferences = (exp$1) => {
+		references.set(exp$1, (references.get(exp$1) ?? 0) + 1);
+		if (!seen.has(exp$1)) {
+			seen.add(exp$1);
+			for (const src of exp$1.src) countReferences(src);
+		}
+	};
+	const expContext = /* @__PURE__ */ new Map();
+	const gen = (exp$1) => {
+		if (expContext.has(exp$1)) return cg.local.get(expContext.get(exp$1));
+		const { op, src, arg, dtype } = exp$1;
+		const isInt = dtype === DType.Int32 || dtype === DType.Uint32 || dtype === DType.Bool;
+		const isSigned = dtype === DType.Int32;
+		if (op === AluOp.Add) {
+			gen(src[0]), gen(src[1]);
+			if (dtype === DType.Bool) cg.v128.or();
+			else if (isInt) cg.i32x4.add();
+			else cg.f32x4.add();
+		} else if (op === AluOp.Sub) {
+			gen(src[0]), gen(src[1]);
+			if (isInt) cg.i32x4.sub();
+			else cg.f32x4.sub();
+		} else if (op === AluOp.Mul) {
+			gen(src[0]), gen(src[1]);
+			if (dtype === DType.Bool) cg.v128.and();
+			else if (isInt) cg.i32x4.mul();
+			else cg.f32x4.mul();
+		} else if (op === AluOp.Min) {
+			gen(src[0]), gen(src[1]);
+			if (isInt) if (isSigned) cg.i32x4.min_s();
+			else cg.i32x4.min_u();
+			else cg.f32x4.min();
+		} else if (op === AluOp.Max) {
+			gen(src[0]), gen(src[1]);
+			if (isInt) if (isSigned) cg.i32x4.max_s();
+			else cg.i32x4.max_u();
+			else cg.f32x4.max();
+		} else if (op === AluOp.Sqrt) {
+			gen(src[0]);
+			cg.f32x4.sqrt();
+		} else if (op === AluOp.Floor) {
+			gen(src[0]);
+			cg.f32x4.floor();
+		} else if (op === AluOp.Ceil) {
+			gen(src[0]);
+			cg.f32x4.ceil();
+		} else if (op === AluOp.Const) if (isInt) {
+			cg.i32.const(arg);
+			cg.i32x4.splat();
+		} else {
+			cg.f32.const(arg);
+			cg.f32x4.splat();
+		}
+		else if (op === AluOp.Cast) {
+			gen(src[0]);
+			const dtype0 = src[0].dtype;
+			const src0IsInt = dtype0 === DType.Int32 || dtype0 === DType.Uint32 || dtype0 === DType.Bool;
+			if (isInt && !src0IsInt) if (isSigned) cg.i32x4.trunc_sat_f32x4_s();
+			else cg.i32x4.trunc_sat_f32x4_u();
+			else if (!isInt && src0IsInt) if (dtype0 === DType.Int32 || dtype0 === DType.Bool) cg.f32x4.convert_i32x4_s();
+			else cg.f32x4.convert_i32x4_u();
+		} else if (op === AluOp.Cmplt) {
+			gen(src[0]), gen(src[1]);
+			const srcDtype = src[0].dtype;
+			if (srcDtype === DType.Float32) cg.f32x4.lt();
+			else if (srcDtype === DType.Int32) cg.i32x4.lt_s();
+			else if (srcDtype === DType.Uint32) cg.i32x4.lt_u();
+			else throw new UnsupportedOpError(op, dtype, "wasm");
+			cg.i32.const(1);
+			cg.i32x4.splat();
+			cg.v128.and();
+		} else if (op === AluOp.Cmpne) {
+			gen(src[0]), gen(src[1]);
+			const srcDtype = src[0].dtype;
+			if (srcDtype === DType.Float32) cg.f32x4.ne();
+			else cg.i32x4.ne();
+			cg.i32.const(1);
+			cg.i32x4.splat();
+			cg.v128.and();
+		} else if (op === AluOp.Where) {
+			gen(src[1]);
+			gen(src[2]);
+			gen(src[0]);
+			cg.i32.const(0);
+			cg.i32x4.splat();
+			cg.i32x4.ne();
+			cg.v128.bitselect();
+		} else if (op === AluOp.Variable || op === AluOp.Special) throw new Error(`translateExpSimd: unexpected ${op}(${arg})`);
+		else if (op === AluOp.GlobalIndex) {
+			const [gid, len] = arg;
+			const indexSubtree = src[0];
+			const pointer = pointerMap.get(exp$1);
+			const stride = pointer?.stride ?? strideMap.get(exp$1) ?? { kind: "gather" };
+			if (pointer) {
+				const cached = pointer.valueKey ? pointerValueCache.get(pointer.valueKey) : void 0;
+				if (cached !== void 0) cg.local.get(cached);
+				else {
+					cg.local.get(pointer.ptr);
+					if (stride.kind === "contiguous") if (isInt) cg.i32x4.load(4);
+					else cg.f32x4.load(4);
+					else if (stride.kind === "broadcast") if (isInt) {
+						cg.i32.load(2);
+						cg.i32x4.splat();
+					} else {
+						cg.f32.load(2);
+						cg.f32x4.splat();
+					}
+					else throw new Error("reduction pointer plan cannot use gather loads");
+					if (pointer.valueKey) {
+						const local = cg.local.declare(isInt ? cg.i32x4 : cg.f32x4);
+						cg.local.tee(local);
+						pointerValueCache.set(pointer.valueKey, local);
+					}
+				}
+			} else if (stride.kind === "contiguous") {
+				translateExp(cg, funcs, indexSubtree, ctx);
+				{
+					const maxIdx = Math.max(len - simdLanes, 0);
+					const wideIdx = cg.local.declare(cg.i32);
+					cg.local.set(wideIdx);
+					cg.local.get(wideIdx);
+					cg.i32.const(maxIdx);
+					cg.local.get(wideIdx);
+					cg.i32.const(maxIdx);
+					cg.i32.lt_u();
+					cg.select();
+				}
+				cg.i32.const(byteWidth(dtype));
+				cg.i32.mul();
+				cg.local.get(gid);
+				cg.i32.add();
+				if (isInt) cg.i32x4.load(4);
+				else cg.f32x4.load(4);
+			} else if (stride.kind === "broadcast") {
+				translateExp(cg, funcs, indexSubtree, ctx);
+				const local = cg.local.declare(cg.i32);
+				cg.local.tee(local);
+				cg.i32.const(0);
+				cg.local.get(local), cg.i32.const(len), cg.i32.lt_u();
+				cg.select();
+				cg.i32.const(byteWidth(dtype));
+				cg.i32.mul();
+				cg.local.get(gid);
+				cg.i32.add();
+				if (isInt) {
+					cg.i32.load(2);
+					cg.i32x4.splat();
+				} else {
+					cg.f32.load(2);
+					cg.f32x4.splat();
+				}
+			} else {
+				const steppingLocal = ctx["gidx"];
+				const origValue = cg.local.declare(cg.i32);
+				cg.local.get(steppingLocal);
+				cg.local.set(origValue);
+				if (isInt) {
+					cg.i32.const(0);
+					cg.i32x4.splat();
+				} else {
+					cg.f32.const(0);
+					cg.f32x4.splat();
+				}
+				const vec = cg.local.declare(isInt ? cg.i32x4 : cg.f32x4);
+				cg.local.set(vec);
+				const idx = cg.local.declare(cg.i32);
+				const scalarVal = cg.local.declare(isInt ? cg.i32 : cg.f32);
+				for (let lane = 0; lane < simdLanes; lane++) {
+					cg.local.get(origValue);
+					if (lane > 0) {
+						cg.i32.const(lane);
+						cg.i32.add();
+					}
+					cg.local.set(steppingLocal);
+					translateExp(cg, funcs, indexSubtree, ctx);
+					cg.local.tee(idx);
+					cg.i32.const(0);
+					cg.local.get(idx), cg.i32.const(len), cg.i32.lt_u();
+					cg.select();
+					cg.i32.const(byteWidth(dtype));
+					cg.i32.mul();
+					cg.local.get(gid);
+					cg.i32.add();
+					if (isInt) cg.i32.load(2);
+					else cg.f32.load(2);
+					cg.local.set(scalarVal);
+					cg.local.get(vec);
+					cg.local.get(scalarVal);
+					if (isInt) cg.i32x4.replace_lane(lane);
+					else cg.f32x4.replace_lane(lane);
+					cg.local.set(vec);
+				}
+				cg.local.get(origValue);
+				cg.local.set(steppingLocal);
+				cg.local.get(vec);
+			}
+		} else throw new Error(`translateExpSimd: unsupported op ${op}`);
+		if ((references.get(exp$1) ?? 0) > 1) {
+			const local = cg.local.declare(isInt ? cg.i32x4 : cg.f32x4);
+			cg.local.tee(local);
+			expContext.set(exp$1, local);
+		}
+	};
+	countReferences(exp);
+	gen(exp);
+}
+function dty(cg, op, dtype) {
+	switch (dtype) {
+		case DType.Float32: return cg.f32;
+		case DType.Float64: return cg.f64;
+		case DType.Int32:
+		case DType.Uint32:
+		case DType.Bool: return cg.i32;
+		default: throw new UnsupportedOpError(op, dtype, "wasm");
 	}
-	_push(type) {
-		if (!type) throw new Error(`pushing type ${type}`);
-		this.#typeStack.push(type);
+}
+function dtyF(cg, op, dtype) {
+	switch (dtype) {
+		case DType.Float32: return cg.f32;
+		case DType.Float64: return cg.f64;
+		default: throw new UnsupportedOpError(op, dtype, "wasm");
 	}
-	_pop() {
-		assert(this.#typeStack.length > 0, "popping empty stack");
-		return this.#typeStack.pop();
+}
+/** Subset of operations supported in SIMD compilation mode. */
+const simdSupportedOps = /* @__PURE__ */ new Map();
+simdSupportedOps.set(DType.Float32, new Set([
+	AluOp.Add,
+	AluOp.Sub,
+	AluOp.Mul,
+	AluOp.Floor,
+	AluOp.Ceil,
+	AluOp.Min,
+	AluOp.Max,
+	AluOp.Sqrt,
+	AluOp.Cast,
+	AluOp.Where,
+	AluOp.Const,
+	AluOp.GlobalIndex
+]));
+simdSupportedOps.set(DType.Int32, new Set([
+	AluOp.Add,
+	AluOp.Sub,
+	AluOp.Mul,
+	AluOp.Min,
+	AluOp.Max,
+	AluOp.Cast,
+	AluOp.Where,
+	AluOp.Const,
+	AluOp.GlobalIndex
+]));
+simdSupportedOps.set(DType.Uint32, simdSupportedOps.get(DType.Int32));
+simdSupportedOps.set(DType.Bool, new Set([
+	AluOp.Add,
+	AluOp.Mul,
+	AluOp.Min,
+	AluOp.Max,
+	AluOp.Cmplt,
+	AluOp.Cmpne,
+	AluOp.Const,
+	AluOp.GlobalIndex
+]));
+
+//#endregion
+//#region src/backend/wasm/wasmblr.ts
+/**
+* @file Minimalist WebAssembly assembler. This allows you to emit WebAssembly
+* bytecode directly from the browser.
+*
+* Self-contained port of https://github.com/bwasti/wasmblr to TypeScript.
+* Some operation names in this module are written in `snake_case` to match
+* their names in the Wasm specification.
+*
+* Reference: https://pengowray.github.io/wasm-ops/.
+*/
+const magicModuleHeader = [
+	0,
+	97,
+	115,
+	109
+];
+const moduleVersion = [
+	1,
+	0,
+	0,
+	0
+];
+function assert(condition, message) {
+	if (!condition) throw new Error(message || "Assertion failed");
+}
+function encodeSigned(n) {
+	const out = [];
+	let more = true;
+	while (more) {
+		let byte = n & 127;
+		n >>= 7;
+		if (n === 0 && (byte & 64) === 0 || n === -1 && (byte & 64) !== 0) more = false;
+		else byte |= 128;
+		out.push(byte);
 	}
-	_emit(bytes) {
-		if (typeof bytes === "number") this.#curBytes.push(bytes);
-		else this.#curBytes.push(...bytes);
+	return out;
+}
+function encodeUnsigned(n) {
+	const out = [];
+	do {
+		let byte = n & 127;
+		n = n >>> 7;
+		if (n !== 0) byte |= 128;
+		out.push(byte);
+	} while (n !== 0);
+	return out;
+}
+function encodeString(s) {
+	const bytes = new TextEncoder().encode(s);
+	return [bytes.length, ...bytes];
+}
+function encodeBlocktype(type) {
+	assert(type.length > 0, "blocktype must have at least one type");
+	if (type.length === 1) return [type[0].typeId];
+	return [
+		96,
+		...encodeUnsigned(0),
+		...encodeUnsigned(type.length),
+		...type.map((t) => t.typeId)
+	];
+}
+function encodeOpcode(opcode) {
+	if (typeof opcode === "number") return [opcode];
+	return [opcode[0], ...encodeUnsigned(opcode[1])];
+}
+function appendLengthEncodedBlock(out, inp) {
+	out.push(...encodeUnsigned(inp.length));
+	for (const b of inp) out.push(b);
+}
+var Function_ = class {
+	inputTypes;
+	outputTypes;
+	body;
+	locals = [];
+	constructor(inputTypes, outputTypes, body) {
+		this.inputTypes = inputTypes;
+		this.outputTypes = outputTypes;
+		this.body = body || (() => {});
 	}
-	finish() {
-		this.#curBytes = [];
-		const emittedBytes = [];
-		concat(emittedBytes, magicModuleHeader);
-		concat(emittedBytes, moduleVersion);
-		const typeSectionBytes = [];
-		const totalFunctionTypes = this.#importedFunctions.length + this.#functions.length;
-		concat(typeSectionBytes, encodeUnsigned(totalFunctionTypes));
-		for (const f of [...this.#importedFunctions, ...this.#functions]) {
-			typeSectionBytes.push(96);
-			concat(typeSectionBytes, encodeUnsigned(f.inputTypes.length));
-			for (const t of f.inputTypes) typeSectionBytes.push(t.typeId);
-			concat(typeSectionBytes, encodeUnsigned(f.outputTypes.length));
-			for (const t of f.outputTypes) typeSectionBytes.push(t.typeId);
-		}
-		emittedBytes.push(1);
-		concat(emittedBytes, encodeUnsigned(typeSectionBytes.length));
-		concat(emittedBytes, typeSectionBytes);
-		const importSectionBytes = [];
-		const numImports = this.#importedFunctions.length + (this.memory.isImport ? 1 : 0);
-		if (numImports > 0) {
-			concat(importSectionBytes, encodeUnsigned(numImports));
-			for (let i = 0; i < this.#importedFunctions.length; i++) {
-				const f = this.#importedFunctions[i];
-				concat(importSectionBytes, encodeString(f.module));
-				concat(importSectionBytes, encodeString(f.name));
-				importSectionBytes.push(0);
-				concat(importSectionBytes, encodeUnsigned(i));
-			}
-			if (this.memory.isImport) {
-				concat(importSectionBytes, encodeString(this.memory.aString));
-				concat(importSectionBytes, encodeString(this.memory.bString));
-				importSectionBytes.push(2);
-				if (this.memory.max) {
-					if (this.memory.isShared) importSectionBytes.push(3);
-					else importSectionBytes.push(1);
-					concat(importSectionBytes, encodeUnsigned(this.memory.min));
-					concat(importSectionBytes, encodeUnsigned(this.memory.max));
-				} else {
-					assert(!this.memory.isShared, "shared memory must have a max size");
-					importSectionBytes.push(0);
-					concat(importSectionBytes, encodeUnsigned(this.memory.min));
-				}
-			}
-			emittedBytes.push(2);
-			concat(emittedBytes, encodeUnsigned(importSectionBytes.length));
-			concat(emittedBytes, importSectionBytes);
-		}
-		const functionSectionBytes = [];
-		concat(functionSectionBytes, encodeUnsigned(this.#functions.length));
-		for (let i = 0; i < this.#functions.length; i++) {
-			const typeIndex = this.#importedFunctions.length + i;
-			concat(functionSectionBytes, encodeUnsigned(typeIndex));
-		}
-		emittedBytes.push(3);
-		concat(emittedBytes, encodeUnsigned(functionSectionBytes.length));
-		concat(emittedBytes, functionSectionBytes);
-		const memorySectionBytes = [];
-		if (!this.memory.isImport && (this.memory.min || this.memory.max)) {
-			memorySectionBytes.push(1);
-			if (this.memory.min && this.memory.max) {
-				if (this.memory.isShared) memorySectionBytes.push(3);
-				else memorySectionBytes.push(1);
-				concat(memorySectionBytes, encodeUnsigned(this.memory.min));
-				concat(memorySectionBytes, encodeUnsigned(this.memory.max));
-			} else {
-				assert(!this.memory.isShared, "shared memory must have a max size");
-				memorySectionBytes.push(0);
-				concat(memorySectionBytes, encodeUnsigned(this.memory.min));
-			}
-			emittedBytes.push(5);
-			concat(emittedBytes, encodeUnsigned(memorySectionBytes.length));
-			concat(emittedBytes, memorySectionBytes);
-		}
-		const exportSectionBytes = [];
-		const numExports = this.#exportedFunctions.size + (this.memory.isExport ? 1 : 0);
-		concat(exportSectionBytes, encodeUnsigned(numExports));
-		if (this.memory.isExport) {
-			concat(exportSectionBytes, encodeString(this.memory.aString));
-			exportSectionBytes.push(2);
-			exportSectionBytes.push(0);
-		}
-		for (const [key, name] of this.#exportedFunctions.entries()) {
-			concat(exportSectionBytes, encodeString(name));
-			exportSectionBytes.push(0);
-			concat(exportSectionBytes, encodeUnsigned(key));
-		}
-		emittedBytes.push(7);
-		concat(emittedBytes, encodeUnsigned(exportSectionBytes.length));
-		concat(emittedBytes, exportSectionBytes);
-		const codeSectionBytes = [];
-		concat(codeSectionBytes, encodeUnsigned(this.#functions.length));
-		for (const f of this.#functions) {
-			this.#typeStack = [];
-			this.#blockFrames = [{
-				idx: 0,
-				ty: f.outputTypes
-			}];
-			this.#curFunction = f;
-			this.#curBytes = [];
-			f.emit();
-			this.end();
-			const bodyBytes = [...this.#curBytes];
-			this.#curBytes = [];
-			concat(this.#curBytes, encodeUnsigned(f.locals.length));
-			for (const l of f.locals) {
-				this._emit(1);
-				this._emit(l.typeId);
-			}
-			const headerBytes = [...this.#curBytes];
-			const fnSize = headerBytes.length + bodyBytes.length;
-			concat(codeSectionBytes, encodeUnsigned(fnSize));
-			concat(codeSectionBytes, headerBytes);
-			concat(codeSectionBytes, bodyBytes);
-		}
-		this.#curFunction = null;
-		emittedBytes.push(10);
-		concat(emittedBytes, encodeUnsigned(codeSectionBytes.length));
-		concat(emittedBytes, codeSectionBytes);
-		return new Uint8Array(emittedBytes);
+	emit() {
+		this.locals = [];
+		this.body();
 	}
 };
-var Local = class {
+var Memory = class {
+	min = 0;
+	max = 0;
+	isShared = false;
+	aString = "";
+	bString = "";
 	constructor(cg) {
 		this.cg = cg;
 	}
-	declare(type) {
-		return this.cg._declareLocal(type);
+	/** Declare the size of the memory. Each page is 64 KiB. */
+	pages(min, max = 0) {
+		assert(this.min === 0 && this.max === 0);
+		this.min = min;
+		this.max = max;
+		return this;
 	}
-	get(idx) {
-		assert(Number.isInteger(idx), "getting non-integer local");
-		const inputTypes = this.cg._inputTypes();
-		if (idx < inputTypes.length) this.cg._push(inputTypes[idx]);
-		else this.cg._push(this.cg._locals()[idx - inputTypes.length]);
-		this.cg._emit(32);
-		this.cg._emit(encodeUnsigned(idx));
+	export(a) {
+		assert(!this.isImport && !this.isExport, "already set");
+		this.aString = a;
+		return this;
 	}
-	set(idx) {
-		const t = this.cg._pop();
-		const inputTypes = this.cg._inputTypes();
-		const expectedType = idx < inputTypes.length ? inputTypes[idx] : this.cg._locals()[idx - inputTypes.length];
-		assert(expectedType.typeId === t.typeId, "can't set local to this value (wrong type)");
-		this.cg._emit(33);
-		this.cg._emit(encodeUnsigned(idx));
+	shared(isShared) {
+		this.isShared = isShared;
+		return this;
+	}
+	import(a, b) {
+		assert(!this.isImport && !this.isExport, "already set");
+		this.aString = a;
+		this.bString = b;
+		return this;
+	}
+	size() {
+		this.cg._emit(63);
+		this.cg._emit(0);
+	}
+	grow() {
+		this.cg._emit(64);
+		this.cg._emit(0);
+	}
+	get isImport() {
+		return this.aString.length > 0 && this.bString.length > 0;
 	}
-	tee(idx) {
-		const t = this.cg._pop();
-		const inputTypes = this.cg._inputTypes();
-		const expectedType = idx < inputTypes.length ? inputTypes[idx] : this.cg._locals()[idx - inputTypes.length];
-		assert(expectedType.typeId === t.typeId, "can't tee local to this value (wrong type)");
-		this.cg._emit(34);
-		this.cg._emit(encodeUnsigned(idx));
-		this.cg._push(expectedType);
+	get isExport() {
+		return this.aString.length > 0 && this.bString.length === 0;
 	}
 };
-function UNARY_OP(op, opcode, inType, outType) {
-	return function() {
-		const t = this.cg._pop();
-		assert(t.typeId === this.cg[inType].typeId, `invalid type for ${op} (${inType} -> ${outType})`);
-		this.cg._emit(encodeOpcode(opcode));
-		this.cg._push(this.cg[outType]);
-	};
-}
-function BINARY_OP(op, opcode, typeA, typeB, outType) {
-	return function() {
-		const b = this.cg._pop();
-		const a = this.cg._pop();
-		assert(a.typeId === this.cg[typeA].typeId && b.typeId === this.cg[typeB].typeId, `invalid type for ${op} (${typeA}, ${typeB} -> ${outType})`);
-		this.cg._emit(encodeOpcode(opcode));
-		this.cg._push(this.cg[outType]);
-	};
-}
-function LOAD_OP(op, opcode, outType) {
-	return function(align = 0, offset = 0) {
-		const idxType = this.cg._pop();
-		assert(idxType.typeId === this.cg.i32.typeId, `invalid type for ${op}`);
-		this.cg._emit(encodeOpcode(opcode));
-		this.cg._emit(encodeUnsigned(align));
-		this.cg._emit(encodeUnsigned(offset));
-		this.cg._push(this.cg[outType]);
-	};
-}
-function STORE_OP(op, opcode, inType) {
-	return function(align = 0, offset = 0) {
-		const valType = this.cg._pop();
-		const idxType = this.cg._pop();
-		assert(valType.typeId === this.cg[inType].typeId, `invalid value type for ${op} (${inType})`);
-		assert(idxType.typeId === this.cg.i32.typeId, `invalid type for ${op}`);
-		this.cg._emit(encodeOpcode(opcode));
-		this.cg._emit(encodeUnsigned(align));
-		this.cg._emit(encodeUnsigned(offset));
+/** Public API of WebAssembly assembler. */
+var CodeGenerator = class {
+	local;
+	i32;
+	f32;
+	f64;
+	v128;
+	i32x4;
+	f32x4;
+	memory;
+	void = {
+		typeId: 64,
+		name: "void"
 	};
-}
-var I32 = class {
-	constructor(cg) {
-		this.cg = cg;
+	#functions = [];
+	#importedFunctions = [];
+	#exportedFunctions = /* @__PURE__ */ new Map();
+	#curFunction = null;
+	#curBytes = [];
+	#typeStack = [];
+	#blockFrames = [];
+	constructor() {
+		this.local = new Local(this);
+		this.i32 = new I32(this);
+		this.f32 = new F32(this);
+		this.f64 = new F64(this);
+		this.v128 = new V128(this);
+		this.i32x4 = new I32x4(this);
+		this.f32x4 = new F32x4(this);
+		this.memory = new Memory(this);
 	}
-	get typeId() {
-		return 127;
+	unreachable() {
+		this._emit(0);
 	}
-	get name() {
-		return "i32";
+	nop() {
+		this._emit(1);
 	}
-	const(i) {
-		this.cg._emit(65);
-		this.cg._emit(encodeSigned(i));
-		this.cg._push(this);
+	block(...type) {
+		this.#blockFrames.push({
+			idx: this.#typeStack.length,
+			ty: type
+		});
+		this._emit(2);
+		this._emit(encodeBlocktype(type));
 	}
-	clz = UNARY_OP("clz", 103, "i32", "i32");
-	ctz = UNARY_OP("ctz", 104, "i32", "i32");
-	popcnt = UNARY_OP("popcnt", 105, "i32", "i32");
-	lt_s = BINARY_OP("lt_s", 72, "i32", "i32", "i32");
-	lt_u = BINARY_OP("lt_u", 73, "i32", "i32", "i32");
-	gt_s = BINARY_OP("gt_s", 74, "i32", "i32", "i32");
-	gt_u = BINARY_OP("gt_u", 75, "i32", "i32", "i32");
-	le_s = BINARY_OP("le_s", 76, "i32", "i32", "i32");
-	le_u = BINARY_OP("le_u", 77, "i32", "i32", "i32");
-	ge_s = BINARY_OP("ge_s", 78, "i32", "i32", "i32");
-	ge_u = BINARY_OP("ge_u", 79, "i32", "i32", "i32");
-	add = BINARY_OP("add", 106, "i32", "i32", "i32");
-	sub = BINARY_OP("sub", 107, "i32", "i32", "i32");
-	mul = BINARY_OP("mul", 108, "i32", "i32", "i32");
-	div_s = BINARY_OP("div_s", 109, "i32", "i32", "i32");
-	div_u = BINARY_OP("div_u", 110, "i32", "i32", "i32");
-	rem_s = BINARY_OP("rem_s", 111, "i32", "i32", "i32");
-	rem_u = BINARY_OP("rem_u", 112, "i32", "i32", "i32");
-	and = BINARY_OP("and", 113, "i32", "i32", "i32");
-	or = BINARY_OP("or", 114, "i32", "i32", "i32");
-	xor = BINARY_OP("xor", 115, "i32", "i32", "i32");
-	shl = BINARY_OP("shl", 116, "i32", "i32", "i32");
-	shr_s = BINARY_OP("shr_s", 117, "i32", "i32", "i32");
-	shr_u = BINARY_OP("shr_u", 118, "i32", "i32", "i32");
-	rotl = BINARY_OP("rotl", 119, "i32", "i32", "i32");
-	rotr = BINARY_OP("rotr", 120, "i32", "i32", "i32");
-	eqz = UNARY_OP("eqz", 69, "i32", "i32");
-	eq = BINARY_OP("eq", 70, "i32", "i32", "i32");
-	ne = BINARY_OP("ne", 71, "i32", "i32", "i32");
-	trunc_f32_s = UNARY_OP("trunc_f32_s", 168, "f32", "i32");
-	trunc_f32_u = UNARY_OP("trunc_f32_u", 169, "f32", "i32");
-	trunc_f64_s = UNARY_OP("trunc_f64_s", 170, "f64", "i32");
-	trunc_f64_u = UNARY_OP("trunc_f64_u", 171, "f64", "i32");
-	load = LOAD_OP("load", 40, "i32");
-	load8_s = LOAD_OP("load8_s", 44, "i32");
-	load8_u = LOAD_OP("load8_u", 45, "i32");
-	load16_s = LOAD_OP("load16_s", 46, "i32");
-	load16_u = LOAD_OP("load16_u", 47, "i32");
-	store = STORE_OP("store", 54, "i32");
-	store8 = STORE_OP("store8", 58, "i32");
-	store16 = STORE_OP("store16", 59, "i32");
-	reinterpret_f32 = UNARY_OP("reinterpret_f32", 188, "f32", "i32");
-	trunc_sat_f32_s = UNARY_OP("trunc_sat_f32_s", [252, 0], "f32", "i32");
-	trunc_sat_f32_u = UNARY_OP("trunc_sat_f32_u", [252, 1], "f32", "i32");
-	trunc_sat_f64_s = UNARY_OP("trunc_sat_f64_s", [252, 2], "f64", "i32");
-	trunc_sat_f64_u = UNARY_OP("trunc_sat_f64_u", [252, 3], "f64", "i32");
-};
-var F32 = class {
-	constructor(cg) {
-		this.cg = cg;
+	loop(...type) {
+		this.#blockFrames.push({
+			idx: this.#typeStack.length,
+			ty: type
+		});
+		this._emit(3);
+		this._emit(encodeBlocktype(type));
 	}
-	get typeId() {
-		return 125;
+	if(...type) {
+		assert(this._pop().typeId === this.i32.typeId, "if_: expected i32");
+		this.#blockFrames.push({
+			idx: this.#typeStack.length,
+			ty: type
+		});
+		this._emit(4);
+		this._emit(encodeBlocktype(type));
 	}
-	get name() {
-		return "f32";
+	else() {
+		assert(this.#blockFrames.length > 0, "else: no block to else");
+		const frame = this.#blockFrames[this.#blockFrames.length - 1];
+		this.#typeStack = this.#typeStack.slice(0, frame.idx);
+		this._emit(5);
 	}
-	const(f) {
-		this.cg._emit(67);
-		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
-		new DataView(buffer).setFloat32(0, f, true);
-		const bytes = new Uint8Array(buffer);
-		for (let i = 0; i < 4; i++) this.cg._emit(bytes[i]);
-		this.cg._push(this);
+	/** End a block (`block`, `if`/`else`, `loop`, or function). */
+	end() {
+		const frame = this.#blockFrames.pop();
+		assert(frame !== void 0, "end: no block to end");
+		this.#typeStack = this.#typeStack.slice(0, frame.idx);
+		for (const ty of frame.ty) if (ty.typeId !== this.void.typeId) this._push(ty);
+		this._emit(11);
 	}
-	load = LOAD_OP("load", 42, "f32");
-	store = STORE_OP("store", 56, "f32");
-	eq = BINARY_OP("eq", 91, "f32", "f32", "i32");
-	ne = BINARY_OP("ne", 92, "f32", "f32", "i32");
-	lt = BINARY_OP("lt", 93, "f32", "f32", "i32");
-	gt = BINARY_OP("gt", 94, "f32", "f32", "i32");
-	le = BINARY_OP("le", 95, "f32", "f32", "i32");
-	ge = BINARY_OP("ge", 96, "f32", "f32", "i32");
-	abs = UNARY_OP("abs", 139, "f32", "f32");
-	neg = UNARY_OP("neg", 140, "f32", "f32");
-	ceil = UNARY_OP("ceil", 141, "f32", "f32");
-	floor = UNARY_OP("floor", 142, "f32", "f32");
-	trunc = UNARY_OP("trunc", 143, "f32", "f32");
-	nearest = UNARY_OP("nearest", 144, "f32", "f32");
-	sqrt = UNARY_OP("sqrt", 145, "f32", "f32");
-	add = BINARY_OP("add", 146, "f32", "f32", "f32");
-	sub = BINARY_OP("sub", 147, "f32", "f32", "f32");
-	mul = BINARY_OP("mul", 148, "f32", "f32", "f32");
-	div = BINARY_OP("div", 149, "f32", "f32", "f32");
-	min = BINARY_OP("min", 150, "f32", "f32", "f32");
-	max = BINARY_OP("max", 151, "f32", "f32", "f32");
-	copysign = BINARY_OP("copysign", 152, "f32", "f32", "f32");
-	convert_i32_s = UNARY_OP("convert_i32_s", 178, "i32", "f32");
-	convert_i32_u = UNARY_OP("convert_i32_u", 179, "i32", "f32");
-	demote_f64 = UNARY_OP("demote_f64", 182, "f64", "f32");
-	reinterpret_i32 = UNARY_OP("reinterpret_i32", 190, "i32", "f32");
-};
-var F64 = class {
-	constructor(cg) {
-		this.cg = cg;
+	/** Branch to a block a certain depth outward on the stack. */
+	br(depth) {
+		this._emit(12);
+		this._emit(encodeUnsigned(depth));
 	}
-	get typeId() {
-		return 124;
+	/** Conditional branch to a block a certain depth outward on the stack. */
+	br_if(depth) {
+		assert(this._pop().typeId === this.i32.typeId, "br_if: expected i32");
+		this._emit(13);
+		this._emit(encodeUnsigned(depth));
+	}
+	/** Jump table that indexes into a label vector (like switch). */
+	br_table(...depths) {
+		assert(this._pop().typeId === this.i32.typeId, "br_table: expected i32");
+		assert(depths.length > 0, "br_table: expected at least one default depth");
+		this._emit(14);
+		this._emit(encodeUnsigned(depths.length - 1));
+		for (const d of depths) this._emit(encodeUnsigned(d));
+	}
+	/** Return from a function, branching out of the outermost block. */
+	return() {
+		this._emit(15);
+	}
+	/** Call a function with the given ID. */
+	call(fn) {
+		const totalFunctions = this.#importedFunctions.length + this.#functions.length;
+		assert(fn < totalFunctions, "function index does not exist");
+		const func = fn < this.#importedFunctions.length ? this.#importedFunctions[fn] : this.#functions[fn - this.#importedFunctions.length];
+		for (let i = func.inputTypes.length - 1; i >= 0; i--) {
+			const argType = this._pop();
+			assert(argType.typeId === func.inputTypes[i].typeId, `call: argument ${i} type mismatch, expected ${func.inputTypes[i].name} got ${argType.name}`);
+		}
+		for (const outputType of func.outputTypes) this._push(outputType);
+		this._emit(16);
+		this._emit(encodeUnsigned(fn));
+	}
+	/** Throw away an operand on the stack. */
+	drop() {
+		this._pop();
+		this._emit(26);
 	}
-	get name() {
-		return "f64";
+	/** Select one of the first two operands (T, F) based on the third operand (i32)'s value. */
+	select() {
+		assert(this._pop().typeId === this.i32.typeId, "select: expected i32 condition");
+		const [b, a] = [this._pop(), this._pop()];
+		assert(a.typeId === b.typeId, "select: expected same type for both operands");
+		this._push(a);
+		this._emit(27);
 	}
-	const(f) {
-		this.cg._emit(68);
-		const buffer = /* @__PURE__ */ new ArrayBuffer(8);
-		new DataView(buffer).setFloat64(0, f, true);
-		const bytes = new Uint8Array(buffer);
-		for (let i = 0; i < 8; i++) this.cg._emit(bytes[i]);
-		this.cg._push(this);
+	/** Import a JavaScript function; returns its index. */
+	importFunction(module$1, name, inputTypes, outputTypes) {
+		if (this.#functions.length > 0) throw new Error("function imports must precede defining functions");
+		const idx = this.#importedFunctions.length;
+		this.#importedFunctions.push({
+			module: module$1,
+			name,
+			inputTypes,
+			outputTypes
+		});
+		return idx;
 	}
-	load = LOAD_OP("load", 43, "f64");
-	store = STORE_OP("store", 57, "f64");
-	eq = BINARY_OP("eq", 97, "f64", "f64", "i32");
-	ne = BINARY_OP("ne", 98, "f64", "f64", "i32");
-	lt = BINARY_OP("lt", 99, "f64", "f64", "i32");
-	gt = BINARY_OP("gt", 100, "f64", "f64", "i32");
-	le = BINARY_OP("le", 101, "f64", "f64", "i32");
-	ge = BINARY_OP("ge", 102, "f64", "f64", "i32");
-	abs = UNARY_OP("abs", 153, "f64", "f64");
-	neg = UNARY_OP("neg", 154, "f64", "f64");
-	ceil = UNARY_OP("ceil", 155, "f64", "f64");
-	floor = UNARY_OP("floor", 156, "f64", "f64");
-	trunc = UNARY_OP("trunc", 157, "f64", "f64");
-	nearest = UNARY_OP("nearest", 158, "f64", "f64");
-	sqrt = UNARY_OP("sqrt", 159, "f64", "f64");
-	add = BINARY_OP("add", 160, "f64", "f64", "f64");
-	sub = BINARY_OP("sub", 161, "f64", "f64", "f64");
-	mul = BINARY_OP("mul", 162, "f64", "f64", "f64");
-	div = BINARY_OP("div", 163, "f64", "f64", "f64");
-	min = BINARY_OP("min", 164, "f64", "f64", "f64");
-	max = BINARY_OP("max", 165, "f64", "f64", "f64");
-	copysign = BINARY_OP("copysign", 166, "f64", "f64", "f64");
-	convert_i32_s = UNARY_OP("convert_i32_s", 183, "i32", "f64");
-	convert_i32_u = UNARY_OP("convert_i32_u", 184, "i32", "f64");
-	promote_f32 = UNARY_OP("promote_f32", 187, "f32", "f64");
-};
-function VECTOR_OP(op, vopcode, inTypes, outType) {
-	return function() {
-		for (const inType of inTypes.toReversed()) {
-			const actualType = this.cg._pop();
-			assert(actualType.typeId === this.cg[inType].typeId, `invalid type for ${op} (${inTypes.join(", ")} -> ${outType})`);
-		}
-		this.cg._emit(encodeOpcode([253, vopcode]));
-		this.cg._push(this.cg[outType]);
-	};
-}
-function VECTOR_OPL(op, vopcode, inTypes, outType) {
-	return function(lane) {
-		for (const inType of inTypes.toReversed()) {
-			const actualType = this.cg._pop();
-			assert(actualType.typeId === this.cg[inType].typeId, `invalid type for ${op} (${inTypes} -> ${outType})`);
-		}
-		this.cg._emit(encodeOpcode([253, vopcode]));
-		this.cg._emit(lane);
-		this.cg._push(this.cg[outType]);
-	};
-}
-function VECTOR_LOAD_OP(op, vopcode) {
-	return function(align = 0, offset = 0) {
-		const idxType = this.cg._pop();
-		assert(idxType.typeId === this.cg.i32.typeId, `invalid type for ${op}`);
-		this.cg._emit(encodeOpcode([253, vopcode]));
-		this.cg._emit(encodeUnsigned(align));
-		this.cg._emit(encodeUnsigned(offset));
-		this.cg._push(this.cg.v128);
-	};
-}
-var V128 = class {
-	constructor(cg) {
-		this.cg = cg;
+	/** Export a function. */
+	export(fn, name) {
+		this.#exportedFunctions.set(fn, name);
 	}
-	get typeId() {
-		return 123;
+	/** Declare a new function; returns its index. */
+	function(inputTypes, outputTypes, body) {
+		const idx = this.#importedFunctions.length + this.#functions.length;
+		this.#functions.push(new Function_(inputTypes, outputTypes, body));
+		return idx;
 	}
-	get name() {
-		return "v128";
+	_declareLocal(type) {
+		assert(this.#curFunction !== null, "No current function");
+		const idx = this.#curFunction.locals.length + this.#curFunction.inputTypes.length;
+		this.#curFunction.locals.push(type);
+		return idx;
 	}
-	load = VECTOR_LOAD_OP("load", 0);
-	load32x2_s = VECTOR_LOAD_OP("load32x2_s", 5);
-	load32x2_u = VECTOR_LOAD_OP("load32x2_u", 6);
-	load32_splat = VECTOR_LOAD_OP("load32_splat", 9);
-	load32_zero = VECTOR_LOAD_OP("load32_zero", 92);
-	store(align = 0, offset = 0) {
-		const valType = this.cg._pop();
-		assert(valType.typeId === this.cg.v128.typeId, `invalid type for store`);
-		const idxType = this.cg._pop();
-		assert(idxType.typeId === this.cg.i32.typeId, `invalid type for store`);
-		this.cg._emit(253);
-		this.cg._emit(encodeUnsigned(11));
-		this.cg._emit(encodeUnsigned(align));
-		this.cg._emit(encodeUnsigned(offset));
+	_inputTypes() {
+		assert(this.#curFunction !== null, "No current function");
+		return this.#curFunction.inputTypes;
 	}
-	not = VECTOR_OP("not", 77, ["v128"], "v128");
-	and = VECTOR_OP("and", 78, ["v128", "v128"], "v128");
-	andnot = VECTOR_OP("andnot", 79, ["v128", "v128"], "v128");
-	or = VECTOR_OP("or", 80, ["v128", "v128"], "v128");
-	xor = VECTOR_OP("xor", 81, ["v128", "v128"], "v128");
-	bitselect = VECTOR_OP("bitselect", 82, [
-		"v128",
-		"v128",
-		"v128"
-	], "v128");
-	any_true = VECTOR_OP("any_true", 83, ["v128"], "i32");
-};
-var I32x4 = class extends V128 {
-	splat = VECTOR_OP("splat", 17, ["i32"], "v128");
-	extract_lane = VECTOR_OPL("extract_lane", 27, ["v128"], "i32");
-	replace_lane = VECTOR_OPL("replace_lane", 28, ["v128", "i32"], "v128");
-	eq = VECTOR_OP("eq", 55, ["v128", "v128"], "v128");
-	ne = VECTOR_OP("ne", 56, ["v128", "v128"], "v128");
-	lt_s = VECTOR_OP("lt_s", 57, ["v128", "v128"], "v128");
-	lt_u = VECTOR_OP("lt_u", 58, ["v128", "v128"], "v128");
-	gt_s = VECTOR_OP("gt_s", 59, ["v128", "v128"], "v128");
-	gt_u = VECTOR_OP("gt_u", 60, ["v128", "v128"], "v128");
-	le_s = VECTOR_OP("le_s", 61, ["v128", "v128"], "v128");
-	le_u = VECTOR_OP("le_u", 62, ["v128", "v128"], "v128");
-	ge_s = VECTOR_OP("ge_s", 63, ["v128", "v128"], "v128");
-	ge_u = VECTOR_OP("ge_u", 64, ["v128", "v128"], "v128");
-	abs = VECTOR_OP("abs", 160, ["v128"], "v128");
-	neg = VECTOR_OP("neg", 161, ["v128"], "v128");
-	all_true = VECTOR_OP("all_true", 163, ["v128"], "i32");
-	bitmask = VECTOR_OP("bitmask", 164, ["v128"], "i32");
-	shl = VECTOR_OP("shl", 171, ["v128", "i32"], "v128");
-	shr_s = VECTOR_OP("shr_s", 172, ["v128", "i32"], "v128");
-	shr_u = VECTOR_OP("shr_u", 173, ["v128", "i32"], "v128");
-	add = VECTOR_OP("add", 174, ["v128", "v128"], "v128");
-	sub = VECTOR_OP("sub", 177, ["v128", "v128"], "v128");
-	mul = VECTOR_OP("mul", 181, ["v128", "v128"], "v128");
-	min_s = VECTOR_OP("min_s", 182, ["v128", "v128"], "v128");
-	min_u = VECTOR_OP("min_u", 183, ["v128", "v128"], "v128");
-	max_s = VECTOR_OP("max_s", 184, ["v128", "v128"], "v128");
-	max_u = VECTOR_OP("max_u", 185, ["v128", "v128"], "v128");
-	trunc_sat_f32x4_s = VECTOR_OP("trunc_sat_f32x4_s", 248, ["v128"], "v128");
-	trunc_sat_f32x4_u = VECTOR_OP("trunc_sat_f32x4_u", 249, ["v128"], "v128");
-};
-var F32x4 = class extends V128 {
-	splat = VECTOR_OP("splat", 19, ["f32"], "v128");
-	extract_lane = VECTOR_OPL("extract_lane", 31, ["v128"], "f32");
-	replace_lane = VECTOR_OPL("replace_lane", 32, ["v128", "f32"], "v128");
-	eq = VECTOR_OP("eq", 65, ["v128", "v128"], "v128");
-	ne = VECTOR_OP("ne", 66, ["v128", "v128"], "v128");
-	lt = VECTOR_OP("lt", 67, ["v128", "v128"], "v128");
-	gt = VECTOR_OP("gt", 68, ["v128", "v128"], "v128");
-	le = VECTOR_OP("le", 69, ["v128", "v128"], "v128");
-	ge = VECTOR_OP("ge", 70, ["v128", "v128"], "v128");
-	ceil = VECTOR_OP("ceil", 103, ["v128"], "v128");
-	floor = VECTOR_OP("floor", 104, ["v128"], "v128");
-	trunc = VECTOR_OP("trunc", 105, ["v128"], "v128");
-	nearest = VECTOR_OP("nearest", 106, ["v128"], "v128");
-	abs = VECTOR_OP("abs", 224, ["v128"], "v128");
-	neg = VECTOR_OP("neg", 225, ["v128"], "v128");
-	sqrt = VECTOR_OP("sqrt", 227, ["v128"], "v128");
-	add = VECTOR_OP("add", 228, ["v128", "v128"], "v128");
-	sub = VECTOR_OP("sub", 229, ["v128", "v128"], "v128");
-	mul = VECTOR_OP("mul", 230, ["v128", "v128"], "v128");
-	div = VECTOR_OP("div", 231, ["v128", "v128"], "v128");
-	min = VECTOR_OP("min", 232, ["v128", "v128"], "v128");
-	max = VECTOR_OP("max", 233, ["v128", "v128"], "v128");
-	pmin = VECTOR_OP("pmin", 234, ["v128", "v128"], "v128");
-	pmax = VECTOR_OP("pmax", 235, ["v128", "v128"], "v128");
-	convert_i32x4_s = VECTOR_OP("convert_i32x4_s", 250, ["v128"], "v128");
-	convert_i32x4_u = VECTOR_OP("convert_i32x4_u", 251, ["v128"], "v128");
-};
-
-//#endregion
-//#region src/backend/wasm.ts
-/**
-* SIMD version of translateExp: emits v128 (f32x4 or i32x4) instructions instead of scalar.
-* gidx always steps by 4. strideMap classifies each GlobalIndex as broadcast/contiguous/gather.
-*/
-function translateExpSimd(cg, funcs, exp, ctx, strideMap) {
-	const references = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const countReferences = (exp$1) => {
-		references.set(exp$1, (references.get(exp$1) ?? 0) + 1);
-		if (!seen.has(exp$1)) {
-			seen.add(exp$1);
-			for (const src of exp$1.src) countReferences(src);
-		}
-	};
-	const expContext = /* @__PURE__ */ new Map();
-	const gen = (exp$1) => {
-		if (expContext.has(exp$1)) return cg.local.get(expContext.get(exp$1));
-		const { op, src, arg, dtype } = exp$1;
-		const isInt = dtype === DType.Int32 || dtype === DType.Uint32 || dtype === DType.Bool;
-		const isSigned = dtype === DType.Int32;
-		if (op === AluOp.Add) {
-			gen(src[0]);
-			gen(src[1]);
-			if (isInt) cg.i32x4.add();
-			else cg.f32x4.add();
-		} else if (op === AluOp.Sub) {
-			gen(src[0]);
-			gen(src[1]);
-			if (isInt) cg.i32x4.sub();
-			else cg.f32x4.sub();
-		} else if (op === AluOp.Mul) {
-			gen(src[0]);
-			gen(src[1]);
-			if (isInt) cg.i32x4.mul();
-			else cg.f32x4.mul();
-		} else if (op === AluOp.Min) {
-			gen(src[0]);
-			gen(src[1]);
-			if (isInt) if (isSigned) cg.i32x4.min_s();
-			else cg.i32x4.min_u();
-			else cg.f32x4.min();
-		} else if (op === AluOp.Max) {
-			gen(src[0]);
-			gen(src[1]);
-			if (isInt) if (isSigned) cg.i32x4.max_s();
-			else cg.i32x4.max_u();
-			else cg.f32x4.max();
-		} else if (op === AluOp.Sqrt) {
-			gen(src[0]);
-			cg.f32x4.sqrt();
-		} else if (op === AluOp.Floor) {
-			gen(src[0]);
-			cg.f32x4.floor();
-		} else if (op === AluOp.Ceil) {
-			gen(src[0]);
-			cg.f32x4.ceil();
-		} else if (op === AluOp.Const) if (isInt) {
-			cg.i32.const(arg);
-			cg.i32x4.splat();
-		} else {
-			cg.f32.const(arg);
-			cg.f32x4.splat();
+	_locals() {
+		assert(this.#curFunction !== null, "No current function");
+		return this.#curFunction.locals;
+	}
+	_push(type) {
+		if (!type) throw new Error(`pushing type ${type}`);
+		this.#typeStack.push(type);
+	}
+	_pop() {
+		assert(this.#typeStack.length > 0, "popping empty stack");
+		return this.#typeStack.pop();
+	}
+	_emit(bytes) {
+		if (typeof bytes === "number") this.#curBytes.push(bytes);
+		else this.#curBytes.push(...bytes);
+	}
+	finish() {
+		this.#curBytes = [];
+		const emittedBytes = [];
+		emittedBytes.push(...magicModuleHeader);
+		emittedBytes.push(...moduleVersion);
+		const typeSectionBytes = [];
+		const totalFunctionTypes = this.#importedFunctions.length + this.#functions.length;
+		typeSectionBytes.push(...encodeUnsigned(totalFunctionTypes));
+		for (const f of [...this.#importedFunctions, ...this.#functions]) {
+			typeSectionBytes.push(96);
+			typeSectionBytes.push(...encodeUnsigned(f.inputTypes.length));
+			for (const t of f.inputTypes) typeSectionBytes.push(t.typeId);
+			typeSectionBytes.push(...encodeUnsigned(f.outputTypes.length));
+			for (const t of f.outputTypes) typeSectionBytes.push(t.typeId);
 		}
-		else if (op === AluOp.Cast) {
-			gen(src[0]);
-			const dtype0 = src[0].dtype;
-			const src0IsInt = dtype0 === DType.Int32 || dtype0 === DType.Uint32 || dtype0 === DType.Bool;
-			if (isInt && !src0IsInt) if (isSigned) cg.i32x4.trunc_sat_f32x4_s();
-			else cg.i32x4.trunc_sat_f32x4_u();
-			else if (!isInt && src0IsInt) if (dtype0 === DType.Int32 || dtype0 === DType.Bool) cg.f32x4.convert_i32x4_s();
-			else cg.f32x4.convert_i32x4_u();
-		} else if (op === AluOp.Cmplt) {
-			gen(src[0]);
-			gen(src[1]);
-			const srcDtype = src[0].dtype;
-			if (srcDtype === DType.Float32) cg.f32x4.lt();
-			else if (srcDtype === DType.Int32) cg.i32x4.lt_s();
-			else if (srcDtype === DType.Uint32) cg.i32x4.lt_u();
-			else throw new UnsupportedOpError(op, dtype, "wasm");
-			cg.i32.const(1);
-			cg.i32x4.splat();
-			cg.v128.and();
-		} else if (op === AluOp.Cmpne) {
-			gen(src[0]);
-			gen(src[1]);
-			const srcDtype = src[0].dtype;
-			if (srcDtype === DType.Float32) cg.f32x4.ne();
-			else cg.i32x4.ne();
-			cg.i32.const(1);
-			cg.i32x4.splat();
-			cg.v128.and();
-		} else if (op === AluOp.Where) {
-			gen(src[1]);
-			gen(src[2]);
-			gen(src[0]);
-			cg.i32.const(0);
-			cg.i32x4.splat();
-			cg.i32x4.ne();
-			cg.v128.bitselect();
-		} else if (op === AluOp.Variable || op === AluOp.Special) throw new Error(`translateExpSimd: unexpected ${op}(${arg})`);
-		else if (op === AluOp.GlobalIndex) {
-			const [gid, len] = arg;
-			const indexSubtree = src[0];
-			const stride = strideMap.get(exp$1) ?? GATHER;
-			if (stride.kind === "contiguous") {
-				translateExp(cg, funcs, indexSubtree, ctx);
-				{
-					const maxIdx = Math.max(len - SIMD_LANES, 0);
-					const wideIdx = cg.local.declare(cg.i32);
-					cg.local.set(wideIdx);
-					cg.local.get(wideIdx);
-					cg.i32.const(maxIdx);
-					cg.local.get(wideIdx);
-					cg.i32.const(maxIdx);
-					cg.i32.lt_u();
-					cg.select();
-				}
-				cg.i32.const(byteWidth(dtype));
-				cg.i32.mul();
-				cg.local.get(gid);
-				cg.i32.add();
-				if (isInt) cg.i32x4.load(4);
-				else cg.f32x4.load(4);
-			} else if (stride.kind === "broadcast") {
-				translateExp(cg, funcs, indexSubtree, ctx);
-				const local = cg.local.declare(cg.i32);
-				cg.local.tee(local);
-				cg.i32.const(0);
-				cg.local.get(local), cg.i32.const(len), cg.i32.lt_u();
-				cg.select();
-				cg.i32.const(byteWidth(dtype));
-				cg.i32.mul();
-				cg.local.get(gid);
-				cg.i32.add();
-				if (isInt) {
-					cg.i32.load(2);
-					cg.i32x4.splat();
+		emittedBytes.push(1);
+		appendLengthEncodedBlock(emittedBytes, typeSectionBytes);
+		const importSectionBytes = [];
+		const numImports = this.#importedFunctions.length + (this.memory.isImport ? 1 : 0);
+		if (numImports > 0) {
+			importSectionBytes.push(...encodeUnsigned(numImports));
+			for (let i = 0; i < this.#importedFunctions.length; i++) {
+				const f = this.#importedFunctions[i];
+				importSectionBytes.push(...encodeString(f.module));
+				importSectionBytes.push(...encodeString(f.name));
+				importSectionBytes.push(0);
+				importSectionBytes.push(...encodeUnsigned(i));
+			}
+			if (this.memory.isImport) {
+				importSectionBytes.push(...encodeString(this.memory.aString));
+				importSectionBytes.push(...encodeString(this.memory.bString));
+				importSectionBytes.push(2);
+				if (this.memory.max) {
+					if (this.memory.isShared) importSectionBytes.push(3);
+					else importSectionBytes.push(1);
+					importSectionBytes.push(...encodeUnsigned(this.memory.min));
+					importSectionBytes.push(...encodeUnsigned(this.memory.max));
 				} else {
-					cg.f32.load(2);
-					cg.f32x4.splat();
+					assert(!this.memory.isShared, "shared memory must have a max size");
+					importSectionBytes.push(0);
+					importSectionBytes.push(...encodeUnsigned(this.memory.min));
 				}
+			}
+			emittedBytes.push(2);
+			appendLengthEncodedBlock(emittedBytes, importSectionBytes);
+		}
+		const functionSectionBytes = [];
+		functionSectionBytes.push(...encodeUnsigned(this.#functions.length));
+		for (let i = 0; i < this.#functions.length; i++) {
+			const typeIndex = this.#importedFunctions.length + i;
+			functionSectionBytes.push(...encodeUnsigned(typeIndex));
+		}
+		emittedBytes.push(3);
+		appendLengthEncodedBlock(emittedBytes, functionSectionBytes);
+		const memorySectionBytes = [];
+		if (!this.memory.isImport && (this.memory.min || this.memory.max)) {
+			memorySectionBytes.push(1);
+			if (this.memory.min && this.memory.max) {
+				if (this.memory.isShared) memorySectionBytes.push(3);
+				else memorySectionBytes.push(1);
+				memorySectionBytes.push(...encodeUnsigned(this.memory.min));
+				memorySectionBytes.push(...encodeUnsigned(this.memory.max));
 			} else {
-				const steppingLocal = ctx["gidx"];
-				const origValue = cg.local.declare(cg.i32);
-				cg.local.get(steppingLocal);
-				cg.local.set(origValue);
-				if (isInt) {
-					cg.i32.const(0);
-					cg.i32x4.splat();
-				} else {
-					cg.f32.const(0);
-					cg.f32x4.splat();
-				}
-				const vec = cg.local.declare(isInt ? cg.i32x4 : cg.f32x4);
-				cg.local.set(vec);
-				const idx = cg.local.declare(cg.i32);
-				const scalarVal = cg.local.declare(isInt ? cg.i32 : cg.f32);
-				for (let lane = 0; lane < SIMD_LANES; lane++) {
-					cg.local.get(origValue);
-					if (lane > 0) {
-						cg.i32.const(lane);
-						cg.i32.add();
-					}
-					cg.local.set(steppingLocal);
-					translateExp(cg, funcs, indexSubtree, ctx);
-					cg.local.tee(idx);
-					cg.i32.const(0);
-					cg.local.get(idx), cg.i32.const(len), cg.i32.lt_u();
-					cg.select();
-					cg.i32.const(byteWidth(dtype));
-					cg.i32.mul();
-					cg.local.get(gid);
-					cg.i32.add();
-					if (isInt) cg.i32.load(2);
-					else cg.f32.load(2);
-					cg.local.set(scalarVal);
-					cg.local.get(vec);
-					cg.local.get(scalarVal);
-					if (isInt) cg.i32x4.replace_lane(lane);
-					else cg.f32x4.replace_lane(lane);
-					cg.local.set(vec);
-				}
-				cg.local.get(origValue);
-				cg.local.set(steppingLocal);
-				cg.local.get(vec);
+				assert(!this.memory.isShared, "shared memory must have a max size");
+				memorySectionBytes.push(0);
+				memorySectionBytes.push(...encodeUnsigned(this.memory.min));
 			}
-		} else throw new Error(`translateExpSimd: unsupported op ${op}`);
-		if ((references.get(exp$1) ?? 0) > 1) {
-			const local = cg.local.declare(isInt ? cg.i32x4 : cg.f32x4);
-			cg.local.tee(local);
-			expContext.set(exp$1, local);
+			emittedBytes.push(5);
+			appendLengthEncodedBlock(emittedBytes, memorySectionBytes);
 		}
-	};
-	countReferences(exp);
-	gen(exp);
-}
-/** Number of SIMD lanes (f32x4 / i32x4 = 4 lanes). */
-const SIMD_LANES = 4;
-function referencesGidx(exp) {
-	if (exp.op === AluOp.Special && exp.arg[0] === "gidx") return true;
-	return exp.src.some(referencesGidx);
-}
-/** When tileSize > N but doesn't divide evenly, the last group before the
-*  inner reset is shorter than N — a SIMD group could straddle it. */
-function hasFragmentRisk(tileSize, N) {
-	return isFinite(tileSize) && tileSize > N && tileSize % N !== 0;
-}
-const GATHER = { kind: "gather" };
-/**
-* Classify how a GlobalIndex's index expression behaves as gidx increments.
-*/
-function analyzeStride(exp) {
-	if (!referencesGidx(exp)) return {
-		kind: "broadcast",
-		tileSize: Infinity
-	};
-	if (exp.op === AluOp.Special && exp.arg[0] === "gidx") return {
-		kind: "contiguous",
-		tileSize: Infinity
-	};
-	if (exp.op === AluOp.Idiv && exp.src[1].op === AluOp.Const) {
-		const N = exp.src[1].arg;
-		const inner = analyzeStride(exp.src[0]);
-		if (inner.kind === "broadcast") return inner;
-		if (inner.kind !== "contiguous") return GATHER;
-		if (hasFragmentRisk(inner.tileSize, N)) return GATHER;
-		return {
-			kind: "broadcast",
-			tileSize: Math.min(inner.tileSize, N)
-		};
+		const exportSectionBytes = [];
+		const numExports = this.#exportedFunctions.size + (this.memory.isExport ? 1 : 0);
+		exportSectionBytes.push(...encodeUnsigned(numExports));
+		if (this.memory.isExport) {
+			exportSectionBytes.push(...encodeString(this.memory.aString));
+			exportSectionBytes.push(2);
+			exportSectionBytes.push(0);
+		}
+		for (const [key, name] of this.#exportedFunctions.entries()) {
+			exportSectionBytes.push(...encodeString(name));
+			exportSectionBytes.push(0);
+			exportSectionBytes.push(...encodeUnsigned(key));
+		}
+		emittedBytes.push(7);
+		appendLengthEncodedBlock(emittedBytes, exportSectionBytes);
+		const codeSectionBytes = [];
+		codeSectionBytes.push(...encodeUnsigned(this.#functions.length));
+		for (const f of this.#functions) {
+			this.#typeStack = [];
+			this.#blockFrames = [{
+				idx: 0,
+				ty: f.outputTypes
+			}];
+			this.#curFunction = f;
+			this.#curBytes = [];
+			f.emit();
+			this.end();
+			const bodyBytes = this.#curBytes;
+			this.#curBytes = [];
+			this.#curBytes.push(...encodeUnsigned(f.locals.length));
+			for (const l of f.locals) {
+				this._emit(1);
+				this._emit(l.typeId);
+			}
+			const fnBytes = this.#curBytes.concat(bodyBytes);
+			appendLengthEncodedBlock(codeSectionBytes, fnBytes);
+		}
+		this.#curFunction = null;
+		emittedBytes.push(10);
+		appendLengthEncodedBlock(emittedBytes, codeSectionBytes);
+		return new Uint8Array(emittedBytes);
 	}
-	if (exp.op === AluOp.Mod && exp.src[1].op === AluOp.Const) {
-		const N = exp.src[1].arg;
-		const inner = analyzeStride(exp.src[0]);
-		if (inner.kind === "broadcast") return inner;
-		if (inner.kind !== "contiguous") return GATHER;
-		if (hasFragmentRisk(inner.tileSize, N)) return GATHER;
-		return {
-			kind: "contiguous",
-			tileSize: Math.min(inner.tileSize, N)
-		};
+};
+var Local = class {
+	constructor(cg) {
+		this.cg = cg;
 	}
-	if (exp.op === AluOp.Mul) {
-		for (let i = 0; i < 2; i++) if (exp.src[i].op === AluOp.Const) {
-			const inner = analyzeStride(exp.src[1 - i]);
-			if (inner.kind === "broadcast") return inner;
-			return GATHER;
-		}
+	declare(type) {
+		return this.cg._declareLocal(type);
+	}
+	get(idx) {
+		assert(Number.isInteger(idx), "getting non-integer local");
+		const inputTypes = this.cg._inputTypes();
+		if (idx < inputTypes.length) this.cg._push(inputTypes[idx]);
+		else this.cg._push(this.cg._locals()[idx - inputTypes.length]);
+		this.cg._emit(32);
+		this.cg._emit(encodeUnsigned(idx));
+	}
+	set(idx) {
+		const t = this.cg._pop();
+		const inputTypes = this.cg._inputTypes();
+		const expectedType = idx < inputTypes.length ? inputTypes[idx] : this.cg._locals()[idx - inputTypes.length];
+		assert(expectedType.typeId === t.typeId, "can't set local to this value (wrong type)");
+		this.cg._emit(33);
+		this.cg._emit(encodeUnsigned(idx));
 	}
-	if (exp.op === AluOp.Add) {
-		const lhsHasGidx = referencesGidx(exp.src[0]);
-		const rhsHasGidx = referencesGidx(exp.src[1]);
-		if (lhsHasGidx && !rhsHasGidx) return analyzeStride(exp.src[0]);
-		if (!lhsHasGidx && rhsHasGidx) return analyzeStride(exp.src[1]);
+	tee(idx) {
+		const t = this.cg._pop();
+		const inputTypes = this.cg._inputTypes();
+		const expectedType = idx < inputTypes.length ? inputTypes[idx] : this.cg._locals()[idx - inputTypes.length];
+		assert(expectedType.typeId === t.typeId, "can't tee local to this value (wrong type)");
+		this.cg._emit(34);
+		this.cg._emit(encodeUnsigned(idx));
+		this.cg._push(expectedType);
 	}
-	return GATHER;
+};
+function UNARY_OP(op, opcode, inType, outType) {
+	return function() {
+		const t = this.cg._pop();
+		assert(t.typeId === this.cg[inType].typeId, `invalid type for ${op} (${inType} -> ${outType})`);
+		this.cg._emit(encodeOpcode(opcode));
+		this.cg._push(this.cg[outType]);
+	};
 }
-/** Ops that have direct SIMD (f32x4) instruction variants. */
-const simdF32Ops = new Set([
-	AluOp.Add,
-	AluOp.Sub,
-	AluOp.Mul,
-	AluOp.Floor,
-	AluOp.Ceil,
-	AluOp.Min,
-	AluOp.Max,
-	AluOp.Sqrt,
-	AluOp.Cast,
-	AluOp.Where,
-	AluOp.Const,
-	AluOp.GlobalIndex
-]);
-/** Ops that have direct SIMD (i32x4) instruction variants. */
-const simdI32Ops = new Set([
-	AluOp.Add,
-	AluOp.Sub,
-	AluOp.Mul,
-	AluOp.Min,
-	AluOp.Max,
-	AluOp.Cast,
-	AluOp.Where,
-	AluOp.Const,
-	AluOp.GlobalIndex
-]);
-/** Ops that produce Bool (i32x4 bitmask) in SIMD. */
-const simdBoolOps = new Set([
-	AluOp.Cmplt,
-	AluOp.Cmpne,
-	AluOp.Const,
-	AluOp.GlobalIndex
-]);
-/**
-* Check if a kernel is eligible for SIMD codegen.
-*
-* A kernel qualifies when:
-* - size >= 4 (need at least 4 elements for a SIMD group)
-* - For reductions: the reduction op has a SIMD variant for its dtype
-* - All nodes have a supported dtype (f32, i32, u32, bool) with SIMD variants
-*/
-function isSimdEligible(tunedExp, kernel) {
-	if (kernel.size < SIMD_LANES) return false;
-	if (kernel.reduction) {
-		if (!simdSupportedOpsForDtype(kernel.reduction.dtype)?.has(kernel.reduction.op)) return false;
-	}
-	const check = (exp, visited) => {
-		if (visited.has(exp)) return true;
-		visited.add(exp);
-		const supportedOps = simdSupportedOpsForDtype(exp.dtype);
-		if (!supportedOps || !supportedOps.has(exp.op)) return false;
-		if (exp.op === AluOp.GlobalIndex) return true;
-		for (const child of exp.src) if (!check(child, visited)) return false;
-		return true;
+function BINARY_OP(op, opcode, typeA, typeB, outType) {
+	return function() {
+		const b = this.cg._pop();
+		const a = this.cg._pop();
+		assert(a.typeId === this.cg[typeA].typeId && b.typeId === this.cg[typeB].typeId, `invalid type for ${op} (${typeA}, ${typeB} -> ${outType})`);
+		this.cg._emit(encodeOpcode(opcode));
+		this.cg._push(this.cg[outType]);
 	};
-	return check(tunedExp, /* @__PURE__ */ new Set());
 }
-function simdSupportedOpsForDtype(dtype) {
-	if (dtype === DType.Float32) return simdF32Ops;
-	if (dtype === DType.Int32 || dtype === DType.Uint32) return simdI32Ops;
-	if (dtype === DType.Bool) return simdBoolOps;
-	return null;
+function LOAD_OP(op, opcode, outType) {
+	return function(align = 0, offset = 0) {
+		const idxType = this.cg._pop();
+		assert(idxType.typeId === this.cg.i32.typeId, `invalid type for ${op}`);
+		this.cg._emit(encodeOpcode(opcode));
+		this.cg._emit(encodeUnsigned(align));
+		this.cg._emit(encodeUnsigned(offset));
+		this.cg._push(this.cg[outType]);
+	};
 }
-const moduleCache = /* @__PURE__ */ new Map();
-/** Backend that compiles into WebAssembly bytecode for immediate execution. */
-var WasmBackend = class {
-	type = "wasm";
-	maxArgs = 64;
-	#memory;
-	#nextSlot;
-	#allocator;
-	#buffers;
-	#workerPool;
-	#pendingWork = /* @__PURE__ */ new Map();
-	constructor() {
-		this.#memory = hasSharedArrayBuffer() ? new WebAssembly.Memory({
-			initial: 0,
-			maximum: 65536,
-			shared: true
-		}) : new WebAssembly.Memory({ initial: 0 });
-		this.#allocator = new WasmAllocator(this.#memory);
-		this.#nextSlot = 1;
-		this.#buffers = /* @__PURE__ */ new Map();
-		this.#workerPool = createWorkerPool(this.#memory);
+function STORE_OP(op, opcode, inType) {
+	return function(align = 0, offset = 0) {
+		const valType = this.cg._pop();
+		const idxType = this.cg._pop();
+		assert(valType.typeId === this.cg[inType].typeId, `invalid value type for ${op} (${inType})`);
+		assert(idxType.typeId === this.cg.i32.typeId, `invalid type for ${op}`);
+		this.cg._emit(encodeOpcode(opcode));
+		this.cg._emit(encodeUnsigned(align));
+		this.cg._emit(encodeUnsigned(offset));
+	};
+}
+var I32 = class {
+	constructor(cg) {
+		this.cg = cg;
 	}
-	malloc(size, initialData) {
-		const ptr = this.#allocator.malloc(size);
-		if (initialData) {
-			if (initialData.byteLength !== size) throw new Error("initialData size does not match buffer size");
-			new Uint8Array(this.#memory.buffer, ptr, size).set(initialData);
-		}
-		const slot = this.#nextSlot++;
-		this.#buffers.set(slot, {
-			ptr,
-			size,
-			ref: 1
-		});
-		return slot;
+	get typeId() {
+		return 127;
 	}
-	incRef(slot) {
-		const buffer = this.#buffers.get(slot);
-		if (!buffer) throw new SlotError(slot);
-		buffer.ref++;
+	get name() {
+		return "i32";
 	}
-	decRef(slot) {
-		const buffer = this.#buffers.get(slot);
-		if (!buffer) throw new SlotError(slot);
-		buffer.ref--;
-		if (buffer.ref === 0) {
-			this.#allocator.free(buffer.ptr);
-			this.#buffers.delete(slot);
-		}
+	const(i) {
+		this.cg._emit(65);
+		this.cg._emit(encodeSigned(i));
+		this.cg._push(this);
 	}
-	async read(slot, start, count) {
-		const epoch = this.#pendingWork.get(slot);
-		if (epoch) await this.#workerPool.waitForEpoch(epoch);
-		return this.#readData(slot, start, count);
+	clz = UNARY_OP("clz", 103, "i32", "i32");
+	ctz = UNARY_OP("ctz", 104, "i32", "i32");
+	popcnt = UNARY_OP("popcnt", 105, "i32", "i32");
+	lt_s = BINARY_OP("lt_s", 72, "i32", "i32", "i32");
+	lt_u = BINARY_OP("lt_u", 73, "i32", "i32", "i32");
+	gt_s = BINARY_OP("gt_s", 74, "i32", "i32", "i32");
+	gt_u = BINARY_OP("gt_u", 75, "i32", "i32", "i32");
+	le_s = BINARY_OP("le_s", 76, "i32", "i32", "i32");
+	le_u = BINARY_OP("le_u", 77, "i32", "i32", "i32");
+	ge_s = BINARY_OP("ge_s", 78, "i32", "i32", "i32");
+	ge_u = BINARY_OP("ge_u", 79, "i32", "i32", "i32");
+	add = BINARY_OP("add", 106, "i32", "i32", "i32");
+	sub = BINARY_OP("sub", 107, "i32", "i32", "i32");
+	mul = BINARY_OP("mul", 108, "i32", "i32", "i32");
+	div_s = BINARY_OP("div_s", 109, "i32", "i32", "i32");
+	div_u = BINARY_OP("div_u", 110, "i32", "i32", "i32");
+	rem_s = BINARY_OP("rem_s", 111, "i32", "i32", "i32");
+	rem_u = BINARY_OP("rem_u", 112, "i32", "i32", "i32");
+	and = BINARY_OP("and", 113, "i32", "i32", "i32");
+	or = BINARY_OP("or", 114, "i32", "i32", "i32");
+	xor = BINARY_OP("xor", 115, "i32", "i32", "i32");
+	shl = BINARY_OP("shl", 116, "i32", "i32", "i32");
+	shr_s = BINARY_OP("shr_s", 117, "i32", "i32", "i32");
+	shr_u = BINARY_OP("shr_u", 118, "i32", "i32", "i32");
+	rotl = BINARY_OP("rotl", 119, "i32", "i32", "i32");
+	rotr = BINARY_OP("rotr", 120, "i32", "i32", "i32");
+	eqz = UNARY_OP("eqz", 69, "i32", "i32");
+	eq = BINARY_OP("eq", 70, "i32", "i32", "i32");
+	ne = BINARY_OP("ne", 71, "i32", "i32", "i32");
+	trunc_f32_s = UNARY_OP("trunc_f32_s", 168, "f32", "i32");
+	trunc_f32_u = UNARY_OP("trunc_f32_u", 169, "f32", "i32");
+	trunc_f64_s = UNARY_OP("trunc_f64_s", 170, "f64", "i32");
+	trunc_f64_u = UNARY_OP("trunc_f64_u", 171, "f64", "i32");
+	load = LOAD_OP("load", 40, "i32");
+	load8_s = LOAD_OP("load8_s", 44, "i32");
+	load8_u = LOAD_OP("load8_u", 45, "i32");
+	load16_s = LOAD_OP("load16_s", 46, "i32");
+	load16_u = LOAD_OP("load16_u", 47, "i32");
+	store = STORE_OP("store", 54, "i32");
+	store8 = STORE_OP("store8", 58, "i32");
+	store16 = STORE_OP("store16", 59, "i32");
+	reinterpret_f32 = UNARY_OP("reinterpret_f32", 188, "f32", "i32");
+	trunc_sat_f32_s = UNARY_OP("trunc_sat_f32_s", [252, 0], "f32", "i32");
+	trunc_sat_f32_u = UNARY_OP("trunc_sat_f32_u", [252, 1], "f32", "i32");
+	trunc_sat_f64_s = UNARY_OP("trunc_sat_f64_s", [252, 2], "f64", "i32");
+	trunc_sat_f64_u = UNARY_OP("trunc_sat_f64_u", [252, 3], "f64", "i32");
+};
+var F32 = class {
+	constructor(cg) {
+		this.cg = cg;
 	}
-	readSync(slot, start, count) {
-		const epoch = this.#pendingWork.get(slot);
-		if (epoch && this.#workerPool.epoch < epoch) throw new Error("cannot read synchronously from a slot with async work");
-		return this.#readData(slot, start, count);
+	get typeId() {
+		return 125;
 	}
-	#readData(slot, start, count) {
-		const buffer = this.#getBuffer(slot);
-		if (start === void 0) start = 0;
-		if (count === void 0) count = buffer.byteLength - start;
-		if (hasSharedArrayBuffer() && buffer.buffer instanceof SharedArrayBuffer) return new Uint8Array(buffer.slice(start, start + count));
-		else return buffer.slice(start, start + count);
+	get name() {
+		return "f32";
 	}
-	async prepareKernel(kernel) {
-		const kernelHash = FpHash.hash(kernel);
-		const module$1 = await runWithCacheAsync(moduleCache, kernelHash.toString(), () => WebAssembly.compile(codegenWasm(kernel)));
-		return new Executable(kernel, {
-			module: module$1,
-			parallel: this.#workerPool !== null
-		});
+	const(f) {
+		this.cg._emit(67);
+		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
+		new DataView(buffer).setFloat32(0, f, true);
+		const bytes = new Uint8Array(buffer);
+		for (let i = 0; i < 4; i++) this.cg._emit(bytes[i]);
+		this.cg._push(this);
+	}
+	load = LOAD_OP("load", 42, "f32");
+	store = STORE_OP("store", 56, "f32");
+	eq = BINARY_OP("eq", 91, "f32", "f32", "i32");
+	ne = BINARY_OP("ne", 92, "f32", "f32", "i32");
+	lt = BINARY_OP("lt", 93, "f32", "f32", "i32");
+	gt = BINARY_OP("gt", 94, "f32", "f32", "i32");
+	le = BINARY_OP("le", 95, "f32", "f32", "i32");
+	ge = BINARY_OP("ge", 96, "f32", "f32", "i32");
+	abs = UNARY_OP("abs", 139, "f32", "f32");
+	neg = UNARY_OP("neg", 140, "f32", "f32");
+	ceil = UNARY_OP("ceil", 141, "f32", "f32");
+	floor = UNARY_OP("floor", 142, "f32", "f32");
+	trunc = UNARY_OP("trunc", 143, "f32", "f32");
+	nearest = UNARY_OP("nearest", 144, "f32", "f32");
+	sqrt = UNARY_OP("sqrt", 145, "f32", "f32");
+	add = BINARY_OP("add", 146, "f32", "f32", "f32");
+	sub = BINARY_OP("sub", 147, "f32", "f32", "f32");
+	mul = BINARY_OP("mul", 148, "f32", "f32", "f32");
+	div = BINARY_OP("div", 149, "f32", "f32", "f32");
+	min = BINARY_OP("min", 150, "f32", "f32", "f32");
+	max = BINARY_OP("max", 151, "f32", "f32", "f32");
+	copysign = BINARY_OP("copysign", 152, "f32", "f32", "f32");
+	convert_i32_s = UNARY_OP("convert_i32_s", 178, "i32", "f32");
+	convert_i32_u = UNARY_OP("convert_i32_u", 179, "i32", "f32");
+	demote_f64 = UNARY_OP("demote_f64", 182, "f64", "f32");
+	reinterpret_i32 = UNARY_OP("reinterpret_i32", 190, "i32", "f32");
+};
+var F64 = class {
+	constructor(cg) {
+		this.cg = cg;
 	}
-	prepareKernelSync(kernel) {
-		const kernelHash = FpHash.hash(kernel);
-		const module$1 = runWithCache(moduleCache, kernelHash.toString(), () => new WebAssembly.Module(codegenWasm(kernel)));
-		return new Executable(kernel, {
-			module: module$1,
-			parallel: false
-		});
+	get typeId() {
+		return 124;
 	}
-	async prepareRoutine(routine) {
-		return this.prepareRoutineSync(routine);
+	get name() {
+		return "f64";
 	}
-	prepareRoutineSync(routine) {
-		return new Executable(routine, {
-			module: void 0,
-			parallel: false
-		});
+	const(f) {
+		this.cg._emit(68);
+		const buffer = /* @__PURE__ */ new ArrayBuffer(8);
+		new DataView(buffer).setFloat64(0, f, true);
+		const bytes = new Uint8Array(buffer);
+		for (let i = 0; i < 8; i++) this.cg._emit(bytes[i]);
+		this.cg._push(this);
 	}
-	dispatch(exe, inputs, outputs) {
-		const tracing = isTracing();
-		const start = tracing ? performance.now() : 0;
-		if (exe.source instanceof Routine) runCpuRoutine(exe.source, inputs.map((slot) => this.#getBuffer(slot)), outputs.map((slot) => this.#getBuffer(slot)));
-		else {
-			const ptrs = [...inputs, ...outputs].map((slot) => this.#buffers.get(slot).ptr);
-			if (exe.data.parallel && this.#workerPool) {
-				const epoch = this.#workerPool.dispatch(exe.data.module, ptrs, exe.source.size);
-				for (const slot of outputs) this.#pendingWork.set(slot, epoch);
-			} else {
-				if (inputs.some((slot) => {
-					const epoch = this.#pendingWork.get(slot);
-					return epoch && this.#workerPool.epoch < epoch;
-				})) throw new Error("cannot dispatch synchronously with pending async work");
-				const instance = new WebAssembly.Instance(exe.data.module, { env: { memory: this.#memory } });
-				const func = instance.exports.kernel;
-				func(...ptrs, 0, exe.source.size);
-			}
+	load = LOAD_OP("load", 43, "f64");
+	store = STORE_OP("store", 57, "f64");
+	eq = BINARY_OP("eq", 97, "f64", "f64", "i32");
+	ne = BINARY_OP("ne", 98, "f64", "f64", "i32");
+	lt = BINARY_OP("lt", 99, "f64", "f64", "i32");
+	gt = BINARY_OP("gt", 100, "f64", "f64", "i32");
+	le = BINARY_OP("le", 101, "f64", "f64", "i32");
+	ge = BINARY_OP("ge", 102, "f64", "f64", "i32");
+	abs = UNARY_OP("abs", 153, "f64", "f64");
+	neg = UNARY_OP("neg", 154, "f64", "f64");
+	ceil = UNARY_OP("ceil", 155, "f64", "f64");
+	floor = UNARY_OP("floor", 156, "f64", "f64");
+	trunc = UNARY_OP("trunc", 157, "f64", "f64");
+	nearest = UNARY_OP("nearest", 158, "f64", "f64");
+	sqrt = UNARY_OP("sqrt", 159, "f64", "f64");
+	add = BINARY_OP("add", 160, "f64", "f64", "f64");
+	sub = BINARY_OP("sub", 161, "f64", "f64", "f64");
+	mul = BINARY_OP("mul", 162, "f64", "f64", "f64");
+	div = BINARY_OP("div", 163, "f64", "f64", "f64");
+	min = BINARY_OP("min", 164, "f64", "f64", "f64");
+	max = BINARY_OP("max", 165, "f64", "f64", "f64");
+	copysign = BINARY_OP("copysign", 166, "f64", "f64", "f64");
+	convert_i32_s = UNARY_OP("convert_i32_s", 183, "i32", "f64");
+	convert_i32_u = UNARY_OP("convert_i32_u", 184, "i32", "f64");
+	promote_f32 = UNARY_OP("promote_f32", 187, "f32", "f64");
+};
+function VECTOR_OP(op, vopcode, inTypes, outType) {
+	return function() {
+		for (const inType of inTypes.toReversed()) {
+			const actualType = this.cg._pop();
+			assert(actualType.typeId === this.cg[inType].typeId, `invalid type for ${op} (${inTypes.join(", ")} -> ${outType})`);
 		}
-		if (tracing) {
-			const info = traceSourceInfo(exe.source);
-			emitTrace("wasm", info, start, performance.now());
+		this.cg._emit(encodeOpcode([253, vopcode]));
+		this.cg._push(this.cg[outType]);
+	};
+}
+function VECTOR_OPL(op, vopcode, inTypes, outType) {
+	return function(lane) {
+		for (const inType of inTypes.toReversed()) {
+			const actualType = this.cg._pop();
+			assert(actualType.typeId === this.cg[inType].typeId, `invalid type for ${op} (${inTypes} -> ${outType})`);
 		}
+		this.cg._emit(encodeOpcode([253, vopcode]));
+		this.cg._emit(lane);
+		this.cg._push(this.cg[outType]);
+	};
+}
+function VECTOR_LOAD_OP(op, vopcode) {
+	return function(align = 0, offset = 0) {
+		const idxType = this.cg._pop();
+		assert(idxType.typeId === this.cg.i32.typeId, `invalid type for ${op}`);
+		this.cg._emit(encodeOpcode([253, vopcode]));
+		this.cg._emit(encodeUnsigned(align));
+		this.cg._emit(encodeUnsigned(offset));
+		this.cg._push(this.cg.v128);
+	};
+}
+var V128 = class {
+	constructor(cg) {
+		this.cg = cg;
 	}
-	#getBuffer(slot) {
-		const buffer = this.#buffers.get(slot);
-		if (!buffer) throw new SlotError(slot);
-		return new Uint8Array(this.#memory.buffer, buffer.ptr, buffer.size);
+	get typeId() {
+		return 123;
+	}
+	get name() {
+		return "v128";
+	}
+	load = VECTOR_LOAD_OP("load", 0);
+	load32x2_s = VECTOR_LOAD_OP("load32x2_s", 5);
+	load32x2_u = VECTOR_LOAD_OP("load32x2_u", 6);
+	load32_splat = VECTOR_LOAD_OP("load32_splat", 9);
+	load32_zero = VECTOR_LOAD_OP("load32_zero", 92);
+	store(align = 0, offset = 0) {
+		const valType = this.cg._pop();
+		assert(valType.typeId === this.cg.v128.typeId, `invalid type for store`);
+		const idxType = this.cg._pop();
+		assert(idxType.typeId === this.cg.i32.typeId, `invalid type for store`);
+		this.cg._emit(253);
+		this.cg._emit(encodeUnsigned(11));
+		this.cg._emit(encodeUnsigned(align));
+		this.cg._emit(encodeUnsigned(offset));
 	}
+	not = VECTOR_OP("not", 77, ["v128"], "v128");
+	and = VECTOR_OP("and", 78, ["v128", "v128"], "v128");
+	andnot = VECTOR_OP("andnot", 79, ["v128", "v128"], "v128");
+	or = VECTOR_OP("or", 80, ["v128", "v128"], "v128");
+	xor = VECTOR_OP("xor", 81, ["v128", "v128"], "v128");
+	bitselect = VECTOR_OP("bitselect", 82, [
+		"v128",
+		"v128",
+		"v128"
+	], "v128");
+	any_true = VECTOR_OP("any_true", 83, ["v128"], "i32");
 };
-/** Emit a runtime guard: enter the if-block only when [begin, end) is SIMD-aligned. */
-function emitAlignmentGuard(cg, paramBegin, paramEnd) {
-	const mask = SIMD_LANES - 1;
-	cg.local.get(paramEnd);
-	cg.local.get(paramBegin);
-	cg.i32.sub();
-	cg.i32.const(mask);
-	cg.i32.and();
-	cg.i32.eqz();
-	cg.local.get(paramBegin);
-	cg.i32.const(mask);
-	cg.i32.and();
-	cg.i32.eqz();
-	cg.i32.and();
-	cg.if(cg.void);
-}
-function codegenWasm(kernel) {
-	const tune = tuneNullopt(kernel);
-	const re = kernel.reduction;
-	if (DEBUG >= 3) console.info(`kernel.exp: ${kernel.exp}\ntune.exp: ${tune.exp}`);
-	const useSimd = isSimdEligible(tune.exp, kernel);
-	const bufferStrides = /* @__PURE__ */ new Map();
-	if (useSimd) tune.exp.collect((e) => e.op === AluOp.GlobalIndex).forEach((gi) => {
-		const result = analyzeStride(gi.src[0]);
-		if (result.kind !== "gather" && (result.tileSize < SIMD_LANES || isFinite(result.tileSize) && result.tileSize % SIMD_LANES !== 0)) bufferStrides.set(gi, GATHER);
-		else bufferStrides.set(gi, result);
-	});
-	const cg = new CodeGenerator();
-	cg.memory.import("env", "memory");
-	if (hasSharedArrayBuffer()) cg.memory.pages(0, 65536).shared(true);
-	const distinctOps = mapSetUnion(tune.exp.distinctOps(), tune.epilogue?.distinctOps());
-	const funcs = {};
-	if (distinctOps.has(AluOp.Sin)) funcs.sin = wasm_sin(cg);
-	if (distinctOps.has(AluOp.Cos)) funcs.cos = wasm_cos(cg);
-	if (distinctOps.has(AluOp.Asin)) funcs.asin = wasm_asin(cg);
-	if (distinctOps.has(AluOp.Atan)) funcs.atan = wasm_atan(cg);
-	if (distinctOps.has(AluOp.Exp) || distinctOps.has(AluOp.Erf) || distinctOps.has(AluOp.Erfc)) funcs.exp = wasm_exp(cg);
-	if (distinctOps.has(AluOp.Log)) funcs.log = wasm_log(cg);
-	if (distinctOps.has(AluOp.Erf)) funcs.erf = wasm_erf(cg, funcs.exp);
-	if (distinctOps.has(AluOp.Erfc)) funcs.erfc = wasm_erfc(cg, funcs.exp);
-	if (distinctOps.has(AluOp.Threefry2x32)) funcs.threefry2x32 = wasm_threefry2x32(cg);
-	const paramBegin = kernel.nargs + 1;
-	const paramEnd = kernel.nargs + 2;
-	const kernelFunc = cg.function(rep(kernel.nargs + 3, cg.i32), [], () => {
-		const gidx = cg.local.declare(cg.i32);
-		cg.local.get(paramBegin);
-		cg.local.set(gidx);
-		if (useSimd) {
-			emitAlignmentGuard(cg, paramBegin, paramEnd);
-			cg.loop(cg.void);
-			if (!re) {
-				cg.block(cg.void);
-				cg.local.get(gidx);
-				cg.local.get(paramEnd);
-				cg.i32.ge_u();
-				cg.br_if(0);
-				cg.local.get(kernel.nargs);
-				cg.local.get(gidx);
-				cg.i32.const(byteWidth(kernel.dtype));
-				cg.i32.mul();
-				cg.i32.add();
-				translateExpSimd(cg, funcs, tune.exp, { gidx }, bufferStrides);
-				cg.v128.store(4);
-				cg.local.get(gidx);
-				cg.i32.const(SIMD_LANES);
-				cg.i32.add();
-				cg.local.set(gidx);
-				cg.br(1);
-				cg.end();
-			} else {
-				const reIsInt = kernel.exp.dtype === DType.Int32 || kernel.exp.dtype === DType.Uint32;
-				cg.block(cg.void);
-				cg.local.get(gidx);
-				cg.local.get(paramEnd);
-				cg.i32.ge_u();
-				cg.br_if(0);
-				const vecAcc = cg.local.declare(reIsInt ? cg.i32x4 : cg.f32x4);
-				if (reIsInt) {
-					cg.i32.const(re.identity);
-					cg.i32x4.splat();
-				} else {
-					cg.f32.const(re.identity);
-					cg.f32x4.splat();
-				}
-				cg.local.set(vecAcc);
-				const ridx = cg.local.declare(cg.i32);
-				cg.i32.const(0);
-				cg.local.set(ridx);
-				cg.loop(cg.void);
-				cg.block(cg.void);
-				cg.local.get(ridx);
-				cg.i32.const(re.size);
-				cg.i32.ge_u();
-				cg.br_if(0);
-				translateExpSimd(cg, funcs, tune.exp, {
-					gidx,
-					ridx
-				}, bufferStrides);
-				cg.local.get(vecAcc);
-				if (reIsInt) if (re.op === AluOp.Add) cg.i32x4.add();
-				else if (re.op === AluOp.Mul) cg.i32x4.mul();
-				else if (re.op === AluOp.Min) if (re.dtype === DType.Int32) cg.i32x4.min_s();
-				else cg.i32x4.min_u();
-				else if (re.op === AluOp.Max) if (re.dtype === DType.Int32) cg.i32x4.max_s();
-				else cg.i32x4.max_u();
-				else throw new Error(`invalid SIMD reduction op: ${re.op}`);
-				else if (re.op === AluOp.Add) cg.f32x4.add();
-				else if (re.op === AluOp.Mul) cg.f32x4.mul();
-				else if (re.op === AluOp.Min) cg.f32x4.min();
-				else if (re.op === AluOp.Max) cg.f32x4.max();
-				else throw new Error(`invalid SIMD reduction op: ${re.op}`);
-				cg.local.set(vecAcc);
-				cg.local.get(ridx);
-				cg.i32.const(1);
-				cg.i32.add();
-				cg.local.set(ridx);
-				cg.br(1);
-				cg.end();
-				cg.end();
-				for (let lane = 0; lane < SIMD_LANES; lane++) {
-					cg.local.get(kernel.nargs);
-					cg.local.get(gidx);
-					if (lane > 0) {
-						cg.i32.const(lane);
-						cg.i32.add();
-					}
-					cg.i32.const(byteWidth(kernel.dtype));
-					cg.i32.mul();
-					cg.i32.add();
-					const acc = cg.local.declare(reIsInt ? cg.i32 : cg.f32);
-					cg.local.get(vecAcc);
-					if (reIsInt) cg.i32x4.extract_lane(lane);
-					else cg.f32x4.extract_lane(lane);
-					cg.local.set(acc);
-					const laneGidx = cg.local.declare(cg.i32);
-					cg.local.get(gidx);
-					if (lane > 0) {
-						cg.i32.const(lane);
-						cg.i32.add();
-					}
-					cg.local.set(laneGidx);
-					translateExp(cg, funcs, tune.epilogue, {
-						acc,
-						gidx: laneGidx
-					});
-					dty(cg, null, kernel.dtype).store(Math.log2(byteWidth(kernel.dtype)));
-				}
-				cg.local.get(gidx);
-				cg.i32.const(SIMD_LANES);
-				cg.i32.add();
-				cg.local.set(gidx);
-				cg.br(1);
-				cg.end();
-			}
-			cg.end();
-			cg.return();
-			cg.end();
-		}
-		cg.loop(cg.void);
-		cg.block(cg.void);
-		cg.local.get(gidx);
-		cg.local.get(paramEnd);
-		cg.i32.ge_u();
-		cg.br_if(0);
-		cg.local.get(kernel.nargs);
-		cg.local.get(gidx);
-		cg.i32.const(byteWidth(kernel.dtype));
+var I32x4 = class extends V128 {
+	splat = VECTOR_OP("splat", 17, ["i32"], "v128");
+	extract_lane = VECTOR_OPL("extract_lane", 27, ["v128"], "i32");
+	replace_lane = VECTOR_OPL("replace_lane", 28, ["v128", "i32"], "v128");
+	eq = VECTOR_OP("eq", 55, ["v128", "v128"], "v128");
+	ne = VECTOR_OP("ne", 56, ["v128", "v128"], "v128");
+	lt_s = VECTOR_OP("lt_s", 57, ["v128", "v128"], "v128");
+	lt_u = VECTOR_OP("lt_u", 58, ["v128", "v128"], "v128");
+	gt_s = VECTOR_OP("gt_s", 59, ["v128", "v128"], "v128");
+	gt_u = VECTOR_OP("gt_u", 60, ["v128", "v128"], "v128");
+	le_s = VECTOR_OP("le_s", 61, ["v128", "v128"], "v128");
+	le_u = VECTOR_OP("le_u", 62, ["v128", "v128"], "v128");
+	ge_s = VECTOR_OP("ge_s", 63, ["v128", "v128"], "v128");
+	ge_u = VECTOR_OP("ge_u", 64, ["v128", "v128"], "v128");
+	abs = VECTOR_OP("abs", 160, ["v128"], "v128");
+	neg = VECTOR_OP("neg", 161, ["v128"], "v128");
+	all_true = VECTOR_OP("all_true", 163, ["v128"], "i32");
+	bitmask = VECTOR_OP("bitmask", 164, ["v128"], "i32");
+	shl = VECTOR_OP("shl", 171, ["v128", "i32"], "v128");
+	shr_s = VECTOR_OP("shr_s", 172, ["v128", "i32"], "v128");
+	shr_u = VECTOR_OP("shr_u", 173, ["v128", "i32"], "v128");
+	add = VECTOR_OP("add", 174, ["v128", "v128"], "v128");
+	sub = VECTOR_OP("sub", 177, ["v128", "v128"], "v128");
+	mul = VECTOR_OP("mul", 181, ["v128", "v128"], "v128");
+	min_s = VECTOR_OP("min_s", 182, ["v128", "v128"], "v128");
+	min_u = VECTOR_OP("min_u", 183, ["v128", "v128"], "v128");
+	max_s = VECTOR_OP("max_s", 184, ["v128", "v128"], "v128");
+	max_u = VECTOR_OP("max_u", 185, ["v128", "v128"], "v128");
+	trunc_sat_f32x4_s = VECTOR_OP("trunc_sat_f32x4_s", 248, ["v128"], "v128");
+	trunc_sat_f32x4_u = VECTOR_OP("trunc_sat_f32x4_u", 249, ["v128"], "v128");
+};
+var F32x4 = class extends V128 {
+	splat = VECTOR_OP("splat", 19, ["f32"], "v128");
+	extract_lane = VECTOR_OPL("extract_lane", 31, ["v128"], "f32");
+	replace_lane = VECTOR_OPL("replace_lane", 32, ["v128", "f32"], "v128");
+	eq = VECTOR_OP("eq", 65, ["v128", "v128"], "v128");
+	ne = VECTOR_OP("ne", 66, ["v128", "v128"], "v128");
+	lt = VECTOR_OP("lt", 67, ["v128", "v128"], "v128");
+	gt = VECTOR_OP("gt", 68, ["v128", "v128"], "v128");
+	le = VECTOR_OP("le", 69, ["v128", "v128"], "v128");
+	ge = VECTOR_OP("ge", 70, ["v128", "v128"], "v128");
+	ceil = VECTOR_OP("ceil", 103, ["v128"], "v128");
+	floor = VECTOR_OP("floor", 104, ["v128"], "v128");
+	trunc = VECTOR_OP("trunc", 105, ["v128"], "v128");
+	nearest = VECTOR_OP("nearest", 106, ["v128"], "v128");
+	abs = VECTOR_OP("abs", 224, ["v128"], "v128");
+	neg = VECTOR_OP("neg", 225, ["v128"], "v128");
+	sqrt = VECTOR_OP("sqrt", 227, ["v128"], "v128");
+	add = VECTOR_OP("add", 228, ["v128", "v128"], "v128");
+	sub = VECTOR_OP("sub", 229, ["v128", "v128"], "v128");
+	mul = VECTOR_OP("mul", 230, ["v128", "v128"], "v128");
+	div = VECTOR_OP("div", 231, ["v128", "v128"], "v128");
+	min = VECTOR_OP("min", 232, ["v128", "v128"], "v128");
+	max = VECTOR_OP("max", 233, ["v128", "v128"], "v128");
+	pmin = VECTOR_OP("pmin", 234, ["v128", "v128"], "v128");
+	pmax = VECTOR_OP("pmax", 235, ["v128", "v128"], "v128");
+	convert_i32x4_s = VECTOR_OP("convert_i32x4_s", 250, ["v128"], "v128");
+	convert_i32x4_u = VECTOR_OP("convert_i32x4_u", 251, ["v128"], "v128");
+	relaxed_madd = VECTOR_OP("relaxed_madd", 261, [
+		"v128",
+		"v128",
+		"v128"
+	], "v128");
+	relaxed_nmadd = VECTOR_OP("relaxed_nmadd", 262, [
+		"v128",
+		"v128",
+		"v128"
+	], "v128");
+};
+
+//#endregion
+//#region src/backend/wasm/codegen.ts
+function isIdentityEpilogue(exp) {
+	return exp?.op === AluOp.Variable && exp.arg === "acc";
+}
+function initializeReductionPointer(cg, funcs, candidate, ctx, valueKey, ridxOffset) {
+	const ptr = cg.local.declare(cg.i32);
+	translateExp(cg, funcs, candidate.baseIndex, ctx);
+	cg.i32.const(byteWidth(candidate.dtype));
+	cg.i32.mul();
+	cg.local.get(candidate.gid);
+	cg.i32.add();
+	if (ridxOffset !== void 0 && candidate.strideBytes !== 0) {
+		cg.local.get(ridxOffset);
+		cg.i32.const(candidate.strideBytes);
 		cg.i32.mul();
 		cg.i32.add();
-		if (re) {
-			const acc = cg.local.declare(dty(cg, null, kernel.exp.dtype));
-			dty(cg, null, kernel.exp.dtype).const(re.identity);
-			cg.local.set(acc);
-			const ridx = cg.local.declare(cg.i32);
-			cg.i32.const(0);
-			cg.local.set(ridx);
-			cg.loop(cg.void);
-			cg.block(cg.void);
-			cg.local.get(ridx);
-			cg.i32.const(re.size);
-			cg.i32.ge_u();
-			cg.br_if(0);
-			translateExp(cg, funcs, tune.exp, {
-				gidx,
-				ridx
-			});
-			if (re.op === AluOp.Add) {
-				cg.local.get(acc);
-				if (re.dtype === DType.Bool) cg.i32.or();
-				else dty(cg, re.op, re.dtype).add();
-			} else if (re.op === AluOp.Mul) {
-				cg.local.get(acc);
-				if (re.dtype === DType.Bool) cg.i32.and();
-				else dty(cg, re.op, re.dtype).mul();
-			} else if (re.op === AluOp.Min || re.op === AluOp.Max) if (isFloatDtype(re.dtype)) {
+	}
+	cg.local.set(ptr);
+	return {
+		...candidate,
+		ptr,
+		valueKey
+	};
+}
+function incrementReductionPointers(cg, pointers, multiplier = 1) {
+	for (const pointer of pointers) {
+		if (pointer.strideBytes === 0) continue;
+		cg.local.get(pointer.ptr);
+		cg.i32.const(pointer.strideBytes * multiplier);
+		cg.i32.add();
+		cg.local.set(pointer.ptr);
+	}
+}
+function emitSimdReductionOp(cg, re, reIsInt, valueAlreadyAccumulated) {
+	if (!reIsInt && valueAlreadyAccumulated) return;
+	switch (re.op) {
+		case AluOp.Add:
+			if (reIsInt) cg.i32x4.add();
+			else cg.f32x4.add();
+			return;
+		case AluOp.Mul:
+			if (reIsInt) cg.i32x4.mul();
+			else cg.f32x4.mul();
+			return;
+		case AluOp.Min:
+			if (reIsInt) if (re.dtype === DType.Int32) cg.i32x4.min_s();
+			else cg.i32x4.min_u();
+			else cg.f32x4.min();
+			return;
+		case AluOp.Max:
+			if (reIsInt) if (re.dtype === DType.Int32) cg.i32x4.max_s();
+			else cg.i32x4.max_u();
+			else cg.f32x4.max();
+			return;
+		default: throw new Error(`invalid SIMD reduction op: ${re.op}`);
+	}
+}
+function emitScalarReductionOp(cg, re, acc) {
+	switch (re.op) {
+		case AluOp.Add:
+			cg.local.get(acc);
+			if (re.dtype === DType.Bool) cg.i32.or();
+			else dty(cg, re.op, re.dtype).add();
+			return;
+		case AluOp.Mul:
+			cg.local.get(acc);
+			if (re.dtype === DType.Bool) cg.i32.and();
+			else dty(cg, re.op, re.dtype).mul();
+			return;
+		case AluOp.Min:
+		case AluOp.Max:
+			if (isFloatDtype(re.dtype)) {
 				cg.local.get(acc);
 				if (re.op === AluOp.Min) dtyF(cg, re.op, re.dtype).min();
 				else dtyF(cg, re.op, re.dtype).max();
@@ -4795,227 +4957,619 @@ function codegenWasm(kernel) {
 				else cg.i32.gt_u();
 				cg.select();
 			} else throw new Error(`invalid reduction min/max over ${re.dtype}`);
-			else throw new Error(`invalid wasm reduction op: ${re.op}`);
-			cg.local.set(acc);
-			cg.local.get(ridx);
-			cg.i32.const(1);
-			cg.i32.add();
-			cg.local.set(ridx);
-			cg.br(1);
-			cg.end();
-			cg.end();
-			translateExp(cg, funcs, tune.epilogue, {
-				acc,
-				gidx
-			});
-		} else translateExp(cg, funcs, tune.exp, { gidx });
-		dty(cg, null, kernel.dtype).store(Math.log2(byteWidth(kernel.dtype)));
-		cg.local.get(gidx);
-		cg.i32.const(1);
-		cg.i32.add();
-		cg.local.set(gidx);
-		cg.br(1);
-		cg.end();
-		cg.end();
-	});
-	cg.export(kernelFunc, "kernel");
-	return cg.finish();
+			return;
+		default: throw new Error(`invalid wasm reduction op: ${re.op}`);
+	}
 }
-function translateExp(cg, funcs, exp, ctx) {
-	const references = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const countReferences = (exp$1) => {
-		references.set(exp$1, (references.get(exp$1) ?? 0) + 1);
-		if (!seen.has(exp$1)) {
-			seen.add(exp$1);
-			for (const src of exp$1.src) countReferences(src);
-		}
+/**
+* Check if a kernel is eligible for SIMD codegen.
+*
+* A kernel qualifies when:
+* - size >= 4 (need at least 4 elements for a SIMD group)
+* - For reductions: the reduction op has a SIMD variant for its dtype
+* - All nodes have a supported dtype (f32, i32, u32, bool) with SIMD variants
+*/
+function isSimdEligible(tunedExp, kernel) {
+	if (kernel.size < simdLanes) return false;
+	if (kernel.reduction) {
+		if (!simdSupportedOps.get(kernel.reduction.dtype)?.has(kernel.reduction.op)) return false;
+	}
+	const check = (exp, visited) => {
+		if (visited.has(exp)) return true;
+		visited.add(exp);
+		if (!simdSupportedOps.get(exp.dtype)?.has(exp.op)) return false;
+		if (exp.op === AluOp.GlobalIndex) return true;
+		for (const child of exp.src) if (!check(child, visited)) return false;
+		return true;
 	};
-	const expContext = /* @__PURE__ */ new Map();
-	const gen = (exp$1) => {
-		if (expContext.has(exp$1)) return cg.local.get(expContext.get(exp$1));
-		const { op, src, dtype, arg } = exp$1;
-		if (AluGroup.Binary.has(op) || AluGroup.Compare.has(op)) {
-			gen(src[0]);
-			gen(src[1]);
-			if (op === AluOp.Add) if (dtype === DType.Bool) cg.i32.or();
-			else dty(cg, op, dtype).add();
-			else if (op === AluOp.Sub) dty(cg, op, dtype).sub();
-			else if (op === AluOp.Mul) if (dtype === DType.Bool) cg.i32.and();
-			else dty(cg, op, dtype).mul();
-			else if (op === AluOp.Idiv) if (isFloatDtype(dtype)) {
-				dtyF(cg, op, dtype).div();
-				dtyF(cg, op, dtype).trunc();
-			} else if (dtype === DType.Uint32) cg.i32.div_u();
-			else if (dtype === DType.Int32) cg.i32.div_s();
-			else throw new UnsupportedOpError(op, dtype, "wasm");
-			else if (op === AluOp.Mod) if (isFloatDtype(dtype)) {
-				const dt = dtyF(cg, op, dtype);
-				const a = cg.local.declare(dt);
-				const b = cg.local.declare(dt);
-				cg.local.set(b);
-				cg.local.tee(a);
-				cg.local.get(a);
-				cg.local.get(b);
-				dt.div();
-				dt.trunc();
-				cg.local.get(b);
-				dt.mul();
-				dt.sub();
-			} else if (dtype === DType.Uint32) cg.i32.rem_u();
-			else if (dtype === DType.Int32) cg.i32.rem_s();
-			else throw new UnsupportedOpError(op, dtype, "wasm");
-			else if (op === AluOp.Min || op === AluOp.Max) if (isFloatDtype(dtype)) if (op === AluOp.Min) dtyF(cg, op, dtype).min();
-			else dtyF(cg, op, dtype).max();
-			else if (dtype === DType.Int32 || dtype === DType.Uint32 || dtype === DType.Bool) {
-				const a = cg.local.declare(cg.i32);
-				const b = cg.local.declare(cg.i32);
-				cg.local.set(b);
-				cg.local.tee(a);
-				cg.local.get(b);
-				cg.local.get(a);
-				cg.local.get(b);
-				if (dtype === DType.Int32) if (op === AluOp.Min) cg.i32.lt_s();
-				else cg.i32.gt_s();
-				else if (op === AluOp.Min) cg.i32.lt_u();
-				else cg.i32.gt_u();
-				cg.select();
-			} else throw new UnsupportedOpError(op, dtype, "wasm");
-			else if (op === AluOp.BitCombine) if (arg === "and") cg.i32.and();
-			else if (arg === "or") cg.i32.or();
-			else cg.i32.xor();
-			else if (op === AluOp.BitShift) if (arg === "shl") cg.i32.shl();
-			else cg.i32.shr_u();
-			else if (op === AluOp.Cmplt) {
-				const srcDtype = src[0].dtype;
-				if (isFloatDtype(srcDtype)) dtyF(cg, op, srcDtype).lt();
-				else if (srcDtype === DType.Int32) cg.i32.lt_s();
-				else if (srcDtype === DType.Uint32) cg.i32.lt_u();
-				else throw new UnsupportedOpError(op, dtype, "wasm");
-			} else if (op === AluOp.Cmpne) dty(cg, op, src[0].dtype).ne();
-			else throw new UnsupportedOpError(op, dtype, "wasm");
-		} else if (AluGroup.Unary.has(op)) {
-			const callFuncF32 = (func) => {
-				if (dtype !== DType.Float32) if (dtype === DType.Float64) cg.f32.demote_f64();
-				else throw new UnsupportedOpError(op, dtype, "wasm");
-				cg.call(func);
-				if (dtype === DType.Float64) cg.f64.promote_f32();
-			};
-			if (op === AluOp.Sin) gen(src[0]), callFuncF32(funcs.sin);
-			else if (op === AluOp.Cos) gen(src[0]), callFuncF32(funcs.cos);
-			else if (op === AluOp.Asin) gen(src[0]), callFuncF32(funcs.asin);
-			else if (op === AluOp.Atan) gen(src[0]), callFuncF32(funcs.atan);
-			else if (op === AluOp.Exp) gen(src[0]), callFuncF32(funcs.exp);
-			else if (op === AluOp.Log) gen(src[0]), callFuncF32(funcs.log);
-			else if (op === AluOp.Erf) gen(src[0]), callFuncF32(funcs.erf);
-			else if (op === AluOp.Erfc) gen(src[0]), callFuncF32(funcs.erfc);
-			else if (op === AluOp.Sqrt) gen(src[0]), dtyF(cg, op, dtype).sqrt();
-			else if (op === AluOp.Reciprocal) {
-				const dt = dtyF(cg, op, dtype);
-				dt.const(1), gen(src[0]), dt.div();
-			} else if (op === AluOp.Floor) gen(src[0]), dtyF(cg, op, dtype).floor();
-			else if (op === AluOp.Ceil) gen(src[0]), dtyF(cg, op, dtype).ceil();
-			else if (op === AluOp.Cast) {
-				gen(src[0]);
-				const dtype0 = src[0].dtype;
-				const i32repr = dtype0 === DType.Int32 || dtype0 === DType.Uint32 || dtype0 === DType.Bool;
-				if (dtype === DType.Int32) if (dtype0 === DType.Float32) cg.i32.trunc_sat_f32_s();
-				else if (dtype0 === DType.Float64) cg.i32.trunc_sat_f64_s();
-				else if (i32repr);
-				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
-				else if (dtype === DType.Uint32) if (dtype0 === DType.Float32) cg.i32.trunc_sat_f32_u();
-				else if (dtype0 === DType.Float64) cg.i32.trunc_sat_f64_u();
-				else if (i32repr);
-				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
-				else if (dtype === DType.Float32) if (dtype0 === DType.Float32);
-				else if (dtype0 === DType.Float64) cg.f32.demote_f64();
-				else if (dtype0 === DType.Int32 || dtype0 === DType.Bool) cg.f32.convert_i32_s();
-				else if (dtype0 === DType.Uint32) cg.f32.convert_i32_u();
-				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
-				else if (dtype === DType.Float64) if (dtype0 === DType.Float32) cg.f64.promote_f32();
-				else if (dtype0 === DType.Float64);
-				else if (dtype0 === DType.Int32 || dtype0 === DType.Bool) cg.f64.convert_i32_s();
-				else if (dtype0 === DType.Uint32) cg.f64.convert_i32_u();
-				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
-				else if (dtype === DType.Bool) if (dtype0 === DType.Bool);
-				else if (i32repr) cg.i32.const(0), cg.i32.ne();
-				else if (dtype0 === DType.Float32) cg.f32.const(0), cg.f32.ne();
-				else if (dtype0 === DType.Float64) cg.f64.const(0), cg.f64.ne();
-				else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
-				else throw new UnsupportedOpError(op, dtype, "wasm");
-			} else if (op === AluOp.Bitcast) {
-				gen(src[0]);
-				const dtype0 = src[0].dtype;
-				if (dtype !== dtype0) {
-					const i32repr = dtype0 === DType.Int32 || dtype0 === DType.Uint32;
-					if (dtype === DType.Int32 || dtype === DType.Uint32) if (dtype0 === DType.Float32) cg.i32.reinterpret_f32();
-					else if (i32repr);
-					else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
-					else if (dtype === DType.Float32) if (i32repr) cg.f32.reinterpret_i32();
-					else if (dtype0 === DType.Float32);
-					else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
-					else throw new UnsupportedOpError(op, dtype, "wasm");
-				}
-			} else throw new UnsupportedOpError(op, dtype, "wasm");
-		} else if (op === AluOp.Where) {
-			gen(src[1]);
-			gen(src[2]);
-			gen(src[0]);
-			cg.select();
-		} else if (op === AluOp.Threefry2x32) {
-			for (let i = 0; i < 4; i++) gen(src[i]);
-			cg.call(funcs.threefry2x32);
-			if (arg === "xor") cg.i32.xor();
-			else if (arg === 0) cg.drop();
-			else if (arg === 1) {
-				const local = cg.local.declare(cg.i32);
-				cg.local.set(local);
-				cg.drop();
-				cg.local.get(local);
-			} else throw new UnsupportedOpError(op, dtype, "wasm", arg);
-		} else if (op === AluOp.Const) return dty(cg, op, dtype).const(arg);
-		else if (op === AluOp.Special) return cg.local.get(ctx[arg[0]]);
-		else if (op === AluOp.Variable) return cg.local.get(ctx[arg]);
-		else if (op === AluOp.GlobalIndex) {
-			const [gid, len] = arg;
-			gen(src[0]);
-			const local = cg.local.declare(cg.i32);
-			cg.local.tee(local);
-			cg.i32.const(0);
-			cg.local.get(local), cg.i32.const(len), cg.i32.lt_u();
-			cg.select();
-			cg.i32.const(byteWidth(dtype));
+	return check(tunedExp, /* @__PURE__ */ new Set());
+}
+/** Checks if SIMD over the reduced-k dimension is workable. */
+function canUseKSimdReduction(exp, re, pointers) {
+	if (re.op !== AluOp.Add) return false;
+	const globalIndexCount = exp.collect((node) => node.op === AluOp.GlobalIndex).length;
+	return globalIndexCount === pointers.length && pointers.every((candidate) => candidate.dtype === DType.Float32 && (candidate.strideBytes === 0 || candidate.strideBytes === byteWidth(candidate.dtype)));
+}
+/** Emit a runtime guard: enter the if-block only when [begin, end) is SIMD-aligned. */
+function emitAlignmentGuard(cg, paramBegin, paramEnd, alignment = simdLanes) {
+	cg.local.get(paramEnd);
+	cg.local.get(paramBegin);
+	cg.i32.sub();
+	cg.i32.const(alignment);
+	cg.i32.rem_u();
+	cg.i32.eqz();
+	cg.local.get(paramBegin);
+	cg.i32.const(alignment);
+	cg.i32.rem_u();
+	cg.i32.eqz();
+	cg.i32.and();
+	cg.if(cg.void);
+}
+function codegenWasm(kernel) {
+	const tune = tuneNullopt(kernel);
+	const re = kernel.reduction;
+	if (DEBUG >= 3) console.info(`kernel.exp: ${kernel.exp}\ntune.exp: ${tune.exp}`);
+	const simdEligible = isSimdEligible(tune.exp, kernel);
+	const hasIdentityEpilogue = isIdentityEpilogue(tune.epilogue);
+	const expStrides = simdEligible ? collectSimdStrides(tune.exp) : /* @__PURE__ */ new Map();
+	const reductionHasLaneGather = re && [...expStrides.values()].some((stride) => stride.kind === "gather");
+	const useSimd = simdEligible && !reductionHasLaneGather;
+	const simdReductionPointerCandidates = useSimd && re ? reductionPointerCandidates(tune.exp, expStrides) : [];
+	const reductionPointers = re ? reductionPointerCandidates(tune.exp) : [];
+	const useKSimdReduction = simdEligible && re && canUseKSimdReduction(tune.exp, re, reductionPointers);
+	const kSimdReductionPointerCandidates = useKSimdReduction && re ? reductionPointers.map((candidate) => ({
+		...candidate,
+		stride: candidate.strideBytes === 0 ? {
+			kind: "broadcast",
+			tileSize: Infinity
+		} : {
+			kind: "contiguous",
+			tileSize: Infinity
+		}
+	})) : [];
+	const simdTilePlan = useSimd && re && hasIdentityEpilogue ? reductionTilePlan(kernel, expStrides) : null;
+	const kSimdTilePlan = reductionHasLaneGather && useKSimdReduction ? reductionKTilePlan(kernel, expStrides) : null;
+	const useRelaxedMadd = hasWasmFeature("relaxed-madd") && re?.op === AluOp.Add && tune.exp.dtype === DType.Float32 && tune.exp.op === AluOp.Mul;
+	const cg = new CodeGenerator();
+	cg.memory.import("env", "memory");
+	if (hasSharedArrayBuffer()) cg.memory.pages(0, 65536).shared(true);
+	const distinctOps = mapSetUnion(tune.exp.distinctOps(), tune.epilogue?.distinctOps());
+	const funcs = {};
+	if (distinctOps.has(AluOp.Sin)) funcs.sin = wasm_sin(cg);
+	if (distinctOps.has(AluOp.Cos)) funcs.cos = wasm_cos(cg);
+	if (distinctOps.has(AluOp.Asin)) funcs.asin = wasm_asin(cg);
+	if (distinctOps.has(AluOp.Atan)) funcs.atan = wasm_atan(cg);
+	if (distinctOps.has(AluOp.Exp) || distinctOps.has(AluOp.Erf) || distinctOps.has(AluOp.Erfc)) funcs.exp = wasm_exp(cg);
+	if (distinctOps.has(AluOp.Log)) funcs.log = wasm_log(cg);
+	if (distinctOps.has(AluOp.Erf)) funcs.erf = wasm_erf(cg, funcs.exp);
+	if (distinctOps.has(AluOp.Erfc)) funcs.erfc = wasm_erfc(cg, funcs.exp);
+	if (distinctOps.has(AluOp.Threefry2x32)) funcs.threefry2x32 = wasm_threefry2x32(cg);
+	const paramBegin = kernel.nargs + 1;
+	const paramEnd = kernel.nargs + 2;
+	const kernelFunc = cg.function(rep(kernel.nargs + 3, cg.i32), [], () => {
+		const gidx = cg.local.declare(cg.i32);
+		cg.local.get(paramBegin);
+		cg.local.set(gidx);
+		const emitLocalPlusConst = (local, amount) => {
+			cg.local.get(local);
+			cg.i32.const(amount);
+			cg.i32.add();
+		};
+		const bumpLocal = (local, amount) => {
+			emitLocalPlusConst(local, amount);
+			cg.local.set(local);
+		};
+		const setLocalConst = (local, value) => {
+			cg.i32.const(value);
+			cg.local.set(local);
+		};
+		const copyLocal = (target, source) => {
+			cg.local.get(source);
+			cg.local.set(target);
+		};
+		const setRowBase = (target, rowTileBase, rowOffset, tileSize) => {
+			cg.local.get(rowTileBase);
+			cg.local.get(rowOffset);
+			cg.i32.const(tileSize);
 			cg.i32.mul();
-			cg.local.get(gid);
 			cg.i32.add();
-			dty(cg, op, dtype).load(Math.log2(byteWidth(dtype)));
-		} else throw new UnsupportedOpError(op, dtype, "wasm");
-		if ((references.get(exp$1) ?? 0) > 1) {
-			const local = cg.local.declare(dty(cg, op, dtype));
-			cg.local.tee(local);
-			expContext.set(exp$1, local);
+			cg.local.set(target);
+		};
+		const emitOutputAddress = (index) => {
+			cg.local.get(kernel.nargs);
+			cg.local.get(index);
+			cg.i32.const(byteWidth(kernel.dtype));
+			cg.i32.mul();
+			cg.i32.add();
+		};
+		const declareTileGidx = (rowBase, col, rowOffset, colOffset) => {
+			const local = cg.local.declare(cg.i32);
+			cg.local.get(rowBase);
+			if (rowOffset !== 0) {
+				cg.i32.const(rowOffset);
+				cg.i32.add();
+			}
+			cg.local.get(col);
+			cg.i32.add();
+			if (colOffset !== 0) {
+				cg.i32.const(colOffset);
+				cg.i32.add();
+			}
+			cg.local.set(local);
+			return local;
+		};
+		const emitLoopWhileLt = (index, emitBound, emitBody) => {
+			cg.loop(cg.void);
+			cg.block(cg.void);
+			cg.local.get(index);
+			emitBound();
+			cg.i32.ge_u();
+			cg.br_if(0);
+			emitBody();
+			cg.br(1);
+			cg.end();
+			cg.end();
+		};
+		const emitLoopWhileLocalLt = (index, bound, emitBody) => emitLoopWhileLt(index, () => cg.local.get(bound), emitBody);
+		const emitLoopWhileConstLt = (index, bound, emitBody) => emitLoopWhileLt(index, () => cg.i32.const(bound), emitBody);
+		const emitSimdExpWithAccumulator = (ctx, pointerMap, pointerValueCache, acc) => {
+			if (useRelaxedMadd) {
+				translateExpSimd(cg, funcs, tune.exp.src[0], ctx, expStrides, pointerMap, pointerValueCache);
+				translateExpSimd(cg, funcs, tune.exp.src[1], ctx, expStrides, pointerMap, pointerValueCache);
+				cg.local.get(acc);
+				cg.f32x4.relaxed_madd();
+				return true;
+			}
+			translateExpSimd(cg, funcs, tune.exp, ctx, expStrides, pointerMap, pointerValueCache);
+			cg.local.get(acc);
+			return false;
+		};
+		const emitSimdReductionForGidxs = (gidxs, pointerMaps, uniquePointers, ridxStart, ridxEnd) => {
+			if (!re) throw new Error("internal: missing reduction");
+			const reIsInt = kernel.exp.dtype === DType.Int32 || kernel.exp.dtype === DType.Uint32;
+			const vecAccs = gidxs.map(() => cg.local.declare(reIsInt ? cg.i32x4 : cg.f32x4));
+			const initializeIdentityAccumulators = () => {
+				for (const acc of vecAccs) {
+					if (reIsInt) {
+						cg.i32.const(re.identity);
+						cg.i32x4.splat();
+					} else {
+						cg.f32.const(re.identity);
+						cg.f32x4.splat();
+					}
+					cg.local.set(acc);
+				}
+			};
+			const loadPartialAccumulators = () => {
+				for (let i = 0; i < gidxs.length; i++) {
+					emitOutputAddress(gidxs[i]);
+					if (reIsInt) cg.i32x4.load(4);
+					else cg.f32x4.load(4);
+					cg.local.set(vecAccs[i]);
+				}
+			};
+			if (ridxStart === void 0) initializeIdentityAccumulators();
+			else {
+				cg.local.get(ridxStart);
+				cg.i32.eqz();
+				cg.if(cg.void);
+				initializeIdentityAccumulators();
+				cg.else();
+				loadPartialAccumulators();
+				cg.end();
+			}
+			const ridx = cg.local.declare(cg.i32);
+			const emitReductionStep = () => {
+				const pointerValueCache = /* @__PURE__ */ new Map();
+				for (let i = 0; i < gidxs.length; i++) {
+					const valueAlreadyAccumulated = emitSimdExpWithAccumulator({
+						gidx: gidxs[i],
+						ridx
+					}, pointerMaps[i], pointerValueCache, vecAccs[i]);
+					emitSimdReductionOp(cg, re, reIsInt, valueAlreadyAccumulated);
+					cg.local.set(vecAccs[i]);
+				}
+				incrementReductionPointers(cg, uniquePointers);
+			};
+			if (ridxStart === void 0) setLocalConst(ridx, 0);
+			else copyLocal(ridx, ridxStart);
+			const emitReductionLoopBody = () => {
+				emitReductionStep();
+				bumpLocal(ridx, 1);
+			};
+			if (ridxEnd === void 0) emitLoopWhileConstLt(ridx, re.size, emitReductionLoopBody);
+			else emitLoopWhileLocalLt(ridx, ridxEnd, emitReductionLoopBody);
+			if (hasIdentityEpilogue) {
+				for (let i = 0; i < gidxs.length; i++) {
+					emitOutputAddress(gidxs[i]);
+					cg.local.get(vecAccs[i]);
+					cg.v128.store(4);
+				}
+				return;
+			}
+			const laneGidx = cg.local.declare(cg.i32);
+			const laneAcc = cg.local.declare(reIsInt ? cg.i32 : cg.f32);
+			for (let i = 0; i < gidxs.length; i++) for (let lane = 0; lane < simdLanes; lane++) {
+				cg.local.get(kernel.nargs);
+				cg.local.get(gidxs[i]);
+				if (lane > 0) {
+					cg.i32.const(lane);
+					cg.i32.add();
+				}
+				cg.local.tee(laneGidx);
+				cg.i32.const(byteWidth(kernel.dtype));
+				cg.i32.mul();
+				cg.i32.add();
+				cg.local.get(vecAccs[i]);
+				if (reIsInt) cg.i32x4.extract_lane(lane);
+				else cg.f32x4.extract_lane(lane);
+				cg.local.set(laneAcc);
+				translateExp(cg, funcs, tune.epilogue, {
+					acc: laneAcc,
+					gidx: laneGidx
+				});
+				dty(cg, null, kernel.dtype).store(Math.log2(byteWidth(kernel.dtype)));
+			}
+		};
+		const initializePointerMaps = (groups, candidates, keyFor, ctxFor, ridxOffset) => {
+			const pointerMaps = groups.map(() => /* @__PURE__ */ new Map());
+			const sharedPointers = /* @__PURE__ */ new Map();
+			const uniquePointers = [];
+			for (let i = 0; i < groups.length; i++) {
+				const group = groups[i];
+				for (const candidate of candidates) {
+					const key = keyFor(candidate, group, i);
+					let plan = sharedPointers.get(key);
+					if (!plan) {
+						plan = initializeReductionPointer(cg, funcs, candidate, ctxFor(group), key, ridxOffset);
+						sharedPointers.set(key, plan);
+						uniquePointers.push(plan);
+					}
+					pointerMaps[i].set(candidate.exp, plan);
+				}
+			}
+			return {
+				pointerMaps,
+				uniquePointers
+			};
+		};
+		const emitSimdReductionStep = () => {
+			const groups = [{
+				gidx,
+				row: 0,
+				vector: 0
+			}];
+			const { pointerMaps, uniquePointers } = initializePointerMaps(groups, simdReductionPointerCandidates, (candidate, group, i) => pointerShareKey(candidate, group.row, group.vector, i), (group) => ({ gidx: group.gidx }));
+			emitSimdReductionForGidxs([gidx], pointerMaps, uniquePointers);
+			bumpLocal(gidx, simdLanes);
+		};
+		const emitElementwiseSimdStep = () => {
+			emitOutputAddress(gidx);
+			translateExpSimd(cg, funcs, tune.exp, { gidx }, expStrides);
+			cg.v128.store(4);
+			bumpLocal(gidx, simdLanes);
+		};
+		const emitKSimdReductionForGroups = (groups, pointerMaps, uniquePointers) => {
+			if (!re) throw new Error("internal: missing reduction");
+			if (!kSimdTilePlan) throw new Error("internal: missing K SIMD plan");
+			const vecAccs = groups.map(() => cg.local.declare(cg.f32x4));
+			for (const acc of vecAccs) {
+				cg.f32.const(re.identity);
+				cg.f32x4.splat();
+				cg.local.set(acc);
+			}
+			const ridx = cg.local.declare(cg.i32);
+			setLocalConst(ridx, 0);
+			emitLoopWhileConstLt(ridx, re.size, () => {
+				for (let u = 0; u < kSimdTilePlan.kUnroll; u++) {
+					const pointerValueCache = /* @__PURE__ */ new Map();
+					for (let i = 0; i < groups.length; i++) {
+						const valueAlreadyAccumulated = emitSimdExpWithAccumulator({
+							gidx: groups[i].gidx,
+							ridx
+						}, pointerMaps[i], pointerValueCache, vecAccs[i]);
+						if (!valueAlreadyAccumulated) cg.f32x4.add();
+						cg.local.set(vecAccs[i]);
+					}
+					incrementReductionPointers(cg, uniquePointers, simdLanes);
+				}
+				bumpLocal(ridx, simdLanes * kSimdTilePlan.kUnroll);
+			});
+			for (let i = 0; i < groups.length; i++) {
+				const acc = cg.local.declare(cg.f32);
+				for (let lane = 0; lane < simdLanes; lane++) {
+					cg.local.get(vecAccs[i]);
+					cg.f32x4.extract_lane(lane);
+					if (lane > 0) cg.f32.add();
+				}
+				cg.local.set(acc);
+				emitOutputAddress(groups[i].gidx);
+				translateExp(cg, funcs, tune.epilogue, {
+					acc,
+					gidx: groups[i].gidx
+				});
+				dty(cg, null, kernel.dtype).store(Math.log2(byteWidth(kernel.dtype)));
+			}
+		};
+		const emitKSimdReductionLoop = (plan) => {
+			const colTile = cg.local.declare(cg.i32);
+			const col = cg.local.declare(cg.i32);
+			const rowTileBase = cg.local.declare(cg.i32);
+			const rowOffset = cg.local.declare(cg.i32);
+			const rowBase = cg.local.declare(cg.i32);
+			const emitBlock = () => {
+				const groups = [];
+				for (let row = 0; row < plan.microRows; row++) for (let colOffset = 0; colOffset < plan.microCols; colOffset++) groups.push({
+					gidx: declareTileGidx(rowBase, col, row * plan.tileSize, colOffset),
+					row,
+					col: colOffset
+				});
+				if (!kSimdTilePlan) throw new Error("internal: missing K SIMD plan");
+				const { pointerMaps, uniquePointers } = initializePointerMaps(groups, kSimdReductionPointerCandidates, (candidate, group, i) => kReductionPointerShareKey(candidate, expStrides.get(candidate.exp) ?? { kind: "gather" }, kSimdTilePlan.tileSize, group.row, group.col, i), (group) => ({ gidx: group.gidx }));
+				emitKSimdReductionForGroups(groups, pointerMaps, uniquePointers);
+			};
+			emitLoopWhileLocalLt(gidx, paramEnd, () => {
+				copyLocal(rowTileBase, gidx);
+				setLocalConst(colTile, 0);
+				emitLoopWhileConstLt(colTile, plan.tileSize, () => {
+					setLocalConst(rowOffset, 0);
+					emitLoopWhileConstLt(rowOffset, plan.tileRows, () => {
+						copyLocal(col, colTile);
+						emitLoopWhileLt(col, () => emitLocalPlusConst(colTile, plan.tileCols), () => {
+							setRowBase(rowBase, rowTileBase, rowOffset, plan.tileSize);
+							emitBlock();
+							bumpLocal(col, plan.microCols);
+						});
+						bumpLocal(rowOffset, plan.microRows);
+					});
+					bumpLocal(colTile, plan.tileCols);
+				});
+				bumpLocal(gidx, plan.tileRows * plan.tileSize);
+			});
+		};
+		const emitTiledSimdReductionLoop = (plan) => {
+			const colTile = cg.local.declare(cg.i32);
+			const col = cg.local.declare(cg.i32);
+			const kTile = cg.local.declare(cg.i32);
+			const tileEnd = cg.local.declare(cg.i32);
+			const rowTileBase = cg.local.declare(cg.i32);
+			const rowOffset = cg.local.declare(cg.i32);
+			const rowBase = cg.local.declare(cg.i32);
+			const emitRowBlock = () => {
+				const groups = [];
+				for (let row = 0; row < plan.microRows; row++) for (let vector = 0; vector < plan.microVectors; vector++) groups.push({
+					gidx: declareTileGidx(rowBase, col, row * plan.tileSize, vector * simdLanes),
+					row,
+					vector
+				});
+				const { pointerMaps, uniquePointers } = initializePointerMaps(groups, simdReductionPointerCandidates, (candidate, group, i) => pointerShareKey(candidate, group.row, group.vector, i), (group) => ({ gidx: group.gidx }), kTile);
+				emitSimdReductionForGidxs(groups.map((group) => group.gidx), pointerMaps, uniquePointers, kTile, tileEnd);
+			};
+			emitLoopWhileLocalLt(gidx, paramEnd, () => {
+				copyLocal(rowTileBase, gidx);
+				setLocalConst(colTile, 0);
+				emitLoopWhileConstLt(colTile, plan.tileSize, () => {
+					setLocalConst(kTile, 0);
+					emitLoopWhileConstLt(kTile, re.size, () => {
+						emitLocalPlusConst(kTile, plan.tileK);
+						cg.local.set(tileEnd);
+						setLocalConst(rowOffset, 0);
+						emitLoopWhileConstLt(rowOffset, plan.tileRows, () => {
+							copyLocal(col, colTile);
+							emitLoopWhileLt(col, () => emitLocalPlusConst(colTile, plan.tileVectors * simdLanes), () => {
+								setRowBase(rowBase, rowTileBase, rowOffset, plan.tileSize);
+								emitRowBlock();
+								bumpLocal(col, plan.microVectors * simdLanes);
+							});
+							bumpLocal(rowOffset, plan.microRows);
+						});
+						bumpLocal(kTile, plan.tileK);
+					});
+					bumpLocal(colTile, plan.tileVectors * simdLanes);
+				});
+				bumpLocal(gidx, plan.tileRows * plan.tileSize);
+			});
+		};
+		const emitGuardedFastPath = (alignment, emit) => {
+			emitAlignmentGuard(cg, paramBegin, paramEnd, alignment);
+			emit();
+			cg.return();
+			cg.end();
+		};
+		if (kSimdTilePlan) emitGuardedFastPath(kSimdTilePlan.tileRows * kSimdTilePlan.tileSize, () => emitKSimdReductionLoop(kSimdTilePlan));
+		if (useSimd) {
+			if (simdTilePlan) emitGuardedFastPath(simdTilePlan.tileRows * simdTilePlan.tileSize, () => emitTiledSimdReductionLoop(simdTilePlan));
+			emitGuardedFastPath(simdLanes, () => {
+				emitLoopWhileLocalLt(gidx, paramEnd, re ? emitSimdReductionStep : emitElementwiseSimdStep);
+			});
 		}
+		emitLoopWhileLocalLt(gidx, paramEnd, () => {
+			emitOutputAddress(gidx);
+			if (re) {
+				const acc = cg.local.declare(dty(cg, null, kernel.exp.dtype));
+				dty(cg, null, kernel.exp.dtype).const(re.identity);
+				cg.local.set(acc);
+				const ridx = cg.local.declare(cg.i32);
+				const emitReductionStep = () => {
+					translateExp(cg, funcs, tune.exp, {
+						gidx,
+						ridx
+					});
+					emitScalarReductionOp(cg, re, acc);
+					cg.local.set(acc);
+				};
+				setLocalConst(ridx, 0);
+				emitLoopWhileConstLt(ridx, re.size, () => {
+					emitReductionStep();
+					bumpLocal(ridx, 1);
+				});
+				translateExp(cg, funcs, tune.epilogue, {
+					acc,
+					gidx
+				});
+			} else translateExp(cg, funcs, tune.exp, { gidx });
+			dty(cg, null, kernel.dtype).store(Math.log2(byteWidth(kernel.dtype)));
+			bumpLocal(gidx, 1);
+		});
+	});
+	cg.export(kernelFunc, "kernel");
+	const tiledPlan = simdTilePlan ?? kSimdTilePlan;
+	return {
+		bytes: cg.finish(),
+		workSize: kernel.size,
+		chunkAlignment: tiledPlan ? tiledPlan.tileRows * tiledPlan.tileSize : 16,
+		minWorkPerWorker: tiledPlan && kernel.size / tiledPlan.tileSize >= 1024 ? tiledPlan.tileSize * 32 : 256
 	};
-	countReferences(exp);
-	gen(exp);
 }
-function dty(cg, op, dtype) {
-	switch (dtype) {
-		case DType.Float32: return cg.f32;
-		case DType.Float64: return cg.f64;
-		case DType.Int32:
-		case DType.Uint32:
-		case DType.Bool: return cg.i32;
-		default: throw new UnsupportedOpError(op, dtype, "wasm");
+
+//#endregion
+//#region src/backend/wasm.ts
+const compiledProgramCache = /* @__PURE__ */ new Map();
+/** Backend that compiles into WebAssembly bytecode for immediate execution. */
+var WasmBackend = class {
+	type = "wasm";
+	maxArgs = 64;
+	#memory;
+	#nextSlot;
+	#allocator;
+	#buffers;
+	#workerPool;
+	#pendingWork = /* @__PURE__ */ new Map();
+	constructor() {
+		this.#memory = hasSharedArrayBuffer() ? new WebAssembly.Memory({
+			initial: 0,
+			maximum: 65536,
+			shared: true
+		}) : new WebAssembly.Memory({ initial: 0 });
+		this.#allocator = new WasmAllocator(this.#memory);
+		this.#nextSlot = 1;
+		this.#buffers = /* @__PURE__ */ new Map();
+		this.#workerPool = createWorkerPool(this.#memory);
 	}
-}
-function dtyF(cg, op, dtype) {
-	switch (dtype) {
-		case DType.Float32: return cg.f32;
-		case DType.Float64: return cg.f64;
-		default: throw new UnsupportedOpError(op, dtype, "wasm");
+	malloc(size, initialData) {
+		const ptr = this.#allocator.malloc(size);
+		if (initialData) {
+			if (initialData.byteLength !== size) throw new Error("initialData size does not match buffer size");
+			new Uint8Array(this.#memory.buffer, ptr, size).set(initialData);
+		}
+		const slot = this.#nextSlot++;
+		this.#buffers.set(slot, {
+			ptr,
+			size,
+			ref: 1
+		});
+		return slot;
 	}
-}
+	incRef(slot) {
+		const buffer = this.#buffers.get(slot);
+		if (!buffer) throw new SlotError(slot);
+		buffer.ref++;
+	}
+	decRef(slot) {
+		const buffer = this.#buffers.get(slot);
+		if (!buffer) throw new SlotError(slot);
+		buffer.ref--;
+		if (buffer.ref === 0) {
+			this.#allocator.free(buffer.ptr);
+			this.#buffers.delete(slot);
+			this.#pendingWork.delete(slot);
+		}
+	}
+	async read(slot, start, count) {
+		const epoch = this.#pendingWork.get(slot);
+		if (epoch) await this.#workerPool.waitForEpoch(epoch);
+		return this.#readData(slot, start, count);
+	}
+	readSync(slot, start, count) {
+		const epoch = this.#pendingWork.get(slot);
+		if (epoch && this.#workerPool.epoch < epoch) throw new Error("cannot read synchronously from a slot with async work");
+		return this.#readData(slot, start, count);
+	}
+	#readData(slot, start, count) {
+		const buffer = this.#getBuffer(slot);
+		if (start === void 0) start = 0;
+		if (count === void 0) count = buffer.byteLength - start;
+		if (hasSharedArrayBuffer() && buffer.buffer instanceof SharedArrayBuffer) return new Uint8Array(buffer.slice(start, start + count));
+		else return buffer.slice(start, start + count);
+	}
+	async prepareKernel(kernel) {
+		const kernelHash = FpHash.hash(kernel);
+		const hashKey = kernelHash.toString();
+		const program = await runWithCacheAsync(compiledProgramCache, hashKey, async () => {
+			const { bytes,...metadata } = codegenWasm(kernel);
+			const module$1 = await WebAssembly.compile(bytes);
+			return {
+				module: module$1,
+				...metadata
+			};
+		});
+		return new Executable(kernel, {
+			program,
+			sync: false
+		});
+	}
+	prepareKernelSync(kernel) {
+		const kernelHash = FpHash.hash(kernel);
+		const hashKey = kernelHash.toString();
+		const compiled = runWithCache(compiledProgramCache, hashKey, () => {
+			const { bytes,...metadata } = codegenWasm(kernel);
+			const module$1 = new WebAssembly.Module(bytes);
+			return {
+				module: module$1,
+				...metadata
+			};
+		});
+		return new Executable(kernel, {
+			program: compiled,
+			sync: true
+		});
+	}
+	async prepareRoutine(routine) {
+		return this.prepareRoutineSync(routine);
+	}
+	prepareRoutineSync(routine) {
+		return new Executable(routine, {
+			program: void 0,
+			sync: true
+		});
+	}
+	dispatch(exe, inputs, outputs) {
+		const tracing = isTracing();
+		const start = tracing ? performance.now() : 0;
+		if (exe.source instanceof Routine) runCpuRoutine(exe.source, inputs.map((slot) => this.#getBuffer(slot)), outputs.map((slot) => this.#getBuffer(slot)));
+		else {
+			const { program, sync } = exe.data;
+			const ptrs = [...inputs, ...outputs].map((slot) => this.#buffers.get(slot).ptr);
+			if (this.#workerPool && !sync) {
+				const retainedSlots = [...inputs, ...outputs];
+				for (const slot of retainedSlots) this.incRef(slot);
+				const epoch = this.#workerPool.dispatch(program.module, ptrs, program.workSize, program.chunkAlignment, program.minWorkPerWorker);
+				for (const slot of outputs) this.#pendingWork.set(slot, epoch);
+				this.#workerPool.waitForEpoch(epoch).then(() => {
+					for (const slot of outputs) if (this.#pendingWork.get(slot) === epoch) this.#pendingWork.delete(slot);
+					for (const slot of retainedSlots) this.decRef(slot);
+				});
+			} else {
+				if (inputs.some((slot) => {
+					const epoch = this.#pendingWork.get(slot);
+					return epoch && this.#workerPool.epoch < epoch;
+				})) throw new Error("cannot dispatch synchronously with pending async work");
+				const instance = new WebAssembly.Instance(program.module, { env: { memory: this.#memory } });
+				const func = instance.exports.kernel;
+				func(...ptrs, 0, program.workSize);
+			}
+		}
+		if (tracing) {
+			const info = traceSourceInfo(exe.source);
+			emitTrace("wasm", info, start, performance.now());
+		}
+	}
+	#getBuffer(slot) {
+		const buffer = this.#buffers.get(slot);
+		if (!buffer) throw new SlotError(slot);
+		return new Uint8Array(this.#memory.buffer, buffer.ptr, buffer.size);
+	}
+};
 
 //#endregion
 //#region src/backend.ts
@@ -5062,7 +5616,7 @@ async function createBackend(device) {
 		if (!navigator.gpu) return null;
 		const adapter = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
 		if (!adapter) return null;
-		const { WebGPUBackend } = await Promise.resolve().then(() => require("./webgpu-DDGCYtHa.cjs"));
+		const { WebGPUBackend } = await Promise.resolve().then(() => require("./webgpu-pWnE96Xc.cjs"));
 		const importantLimits = [
 			"maxBufferSize",
 			"maxComputeInvocationsPerWorkgroup",
@@ -5100,7 +5654,7 @@ async function createBackend(device) {
 		});
 		if (!gl) return null;
 		if (!gl.getExtension("EXT_color_buffer_float")) return null;
-		const { WebGLBackend } = await Promise.resolve().then(() => require("./webgl-pbfUGDA6.cjs"));
+		const { WebGLBackend } = await Promise.resolve().then(() => require("./webgl-C6rCbloA.cjs"));
 		return new WebGLBackend(gl);
 	} else throw new Error(`Backend not found: ${device}`);
 }