@jax-js/jax 0.0.2 → 0.0.4

package/dist/{backend-BK21PBVP.cjs → backend-Ss1Mev_-.cjs}

@@ -36,7 +36,22 @@ var PPrint = class PPrint {
 //#endregion
 //#region src/utils.ts
 /** @file Generic programming utilities with no dependencies on library code. */
-const DEBUG = 3;
+let DEBUG = 0;
+/**
+* Set the debug level for verbose logging.
+*
+* 1. JIT compile logs
+* 2. Shader code
+* 3. Expressions and metadata
+* 4. JIT programs, tuning details
+* 5. Most verbose operation traces
+*
+* This is an experimental API and may change in behavior. Do not rely on this
+* in production.
+*/
+function setDebug(level) {
+	DEBUG = level;
+}
 function unzip2(pairs) {
 	const lst1 = [];
 	const lst2 = [];
@@ -49,6 +64,10 @@ function unzip2(pairs) {
 function zip(xs, ys) {
 	return xs.map((x, i) => [x, ys[i]]);
 }
+function zipn(...arrays) {
+	const minLength = Math.min(...arrays.map((x) => x.length));
+	return Array.from({ length: minLength }, (_, i) => arrays.map((arr) => arr[i]));
+}
 function rep(length, value) {
 	if (value instanceof Function) return new Array(length).fill(0).map((_, i) => value(i));
 	return new Array(length).fill(value);
@@ -56,6 +75,11 @@ function rep(length, value) {
 function prod(arr) {
 	return arr.reduce((acc, x) => acc * x, 1);
 }
+function gcd(...values) {
+	let a = 0;
+	for (let b of values) while (b !== 0) [a, b] = [b, a % b];
+	return Math.abs(a);
+}
 /** Shorthand for integer division, like in Python. */
 function intdiv(a, b) {
 	return Math.floor(a / b);
@@ -73,6 +97,11 @@ function deepEqual(a, b) {
 	for (const key of Object.keys(a)) if (!deepEqual(a[key], b[key])) return false;
 	return true;
 }
+function union(...sets) {
+	const result = /* @__PURE__ */ new Set();
+	for (const s of sets) if (s) for (const x of s) result.add(x);
+	return result;
+}
 /** Splits the list based on a condition, `false` first then `true`. */
 function partitionList(which, array) {
 	const falseList = [];
@@ -96,9 +125,23 @@ function isNumberPair(x) {
 }
 /** Check an axis against number of dimensions, and resolve negative axes. */
 function checkAxis(axis, ndim) {
-	if (axis < -ndim || axis >= ndim) throw new Error(`Invalid axis ${axis} for array of ${ndim} dimensions`);
+	if (axis < -ndim || axis >= ndim) throw new Error(`Axis ${axis} out of bounds for array of dimension ${ndim}`);
 	return axis < 0 ? axis + ndim : axis;
 }
+/** Normalize common axis argument for functions, defaulting to all axes. */
+function normalizeAxis(axis, ndim) {
+	if (axis === null) return range(ndim);
+	else if (typeof axis === "number") return [checkAxis(axis, ndim)];
+	else {
+		const seen = /* @__PURE__ */ new Set();
+		for (const a of axis) {
+			const ca = checkAxis(a, ndim);
+			if (seen.has(ca)) throw new Error(`Duplicate axis ${ca} passed to function`);
+			seen.add(ca);
+		}
+		return [...seen].sort();
+	}
+}
 function range(start, stop, step = 1) {
 	if (stop === void 0) {
 		stop = start;
@@ -173,6 +216,7 @@ function strip1(str) {
 	if (str[0] === "(" && str[str.length - 1] === ")") return str.slice(1, -1);
 	return str;
 }
+const _stagingbuf = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
 /**
 * Polynomial hashes modulo p are good at avoiding collisions in expectation.
 * Probability-wise, it's good enough to be used for something like
@@ -187,22 +231,26 @@ var FpHash = class FpHash {
 		const modulus = 3189051996290219n;
 		this.value = (this.value * base + x) % modulus;
 	}
-	update(...values) {
-		for (const x of values) if (typeof x === "string") for (const c of x) this.#update(BigInt(199 + c.charCodeAt(0)));
-		else if (typeof x === "number") if (Number.isInteger(x)) this.#update(68265653n ^ BigInt(x));
+	update(x) {
+		if (typeof x === "string") {
+			this.#update(BigInt(x.length));
+			for (let i = 0; i < x.length; i++) this.#update(BigInt(199 + x.charCodeAt(i)));
+		} else if (typeof x === "number") if (Number.isInteger(x)) this.#update(68265653n ^ BigInt(x));
 		else {
-			const ar = new Float64Array([x]);
-			this.#update(new DataView(ar.buffer).getBigUint64(0, true));
+			_stagingbuf.setFloat64(0, x, true);
+			this.#update(_stagingbuf.getBigUint64(0, true));
 		}
 		else if (typeof x === "boolean") this.#update(x ? 69069841n : 63640693n);
 		else if (typeof x === "bigint") this.#update(x ^ 71657401n);
 		else if (x === null) this.#update(37832657n);
 		else if (x === void 0) this.#update(18145117n);
-		else if (typeof x === "object" && "hash" in x) x.hash(this);
+		else x.hash(this);
 		return this;
 	}
 	static hash(...values) {
-		return new FpHash().update(...values).value;
+		const h = new FpHash();
+		for (const x of values) h.update(x);
+		return h.value;
 	}
 };
 /** Run a function while caching it inline inside a `Map`. */
@@ -217,12 +265,13 @@ function runWithCache(cache, key, thunk) {
 
 //#endregion
 //#region src/alu.ts
+/** A numerical data type for array contents. */
 let DType = /* @__PURE__ */ function(DType$1) {
 	DType$1["Float32"] = "float32";
 	DType$1["Int32"] = "int32";
 	DType$1["Uint32"] = "uint32";
 	DType$1["Bool"] = "bool";
-	DType$1["Complex64"] = "complex64";
+	DType$1["Float16"] = "float16";
 	return DType$1;
 }({});
 const byteWidth = (dtype) => {
@@ -231,17 +280,65 @@ const byteWidth = (dtype) => {
 		case DType.Int32:
 		case DType.Uint32:
 		case DType.Bool: return 4;
-		case DType.Complex64: return 8;
+		case DType.Float16: return 2;
 		default: throw new TypeError(`Unknown dtype: ${dtype}`);
 	}
 };
-const isFloatDtype = (dtype) => dtype === DType.Float32 || dtype === DType.Complex64;
+const isFloatDtype = (dtype) => dtype === DType.Float32 || dtype === DType.Float16;
+/**
+* Promote two dtypes to their join according to the type lattice.
+*
+* When performing operations between arrays of different types, we need to
+* promote both operands to a common type that can represent values from both
+* input types. This follows JAX's type promotion rules.
+*
+* **Type lattice:**
+* ```text
+* bool -> uint32 -> int32 -> float16 -> float32
+*  weak f* --^
+* ```
+*
+* The asterisk f* is a weak type used for JS number constants. When creating
+* arrays, JS numbers default to float32 but "weak" so they cast to the dtype of
+* any array they are first combined with.
+*
+* **Examples:**
+* - `promoteTypes(bool, int32) → int32`
+* - `promoteTypes(uint32, int32) → int32`
+* - `promoteTypes(int32, float16) → float16`
+* - `promoteTypes(float16, float32) → float32`
+* - `promoteTypes(uint32, float32) → float32`
+*/
+function promoteTypes(dtype1, dtype2) {
+	if (dtype1 === dtype2) return dtype1;
+	const rank = {
+		[DType.Bool]: 0,
+		[DType.Uint32]: 1,
+		[DType.Int32]: 2,
+		[DType.Float16]: 3,
+		[DType.Float32]: 4
+	};
+	return rank[dtype1] > rank[dtype2] ? dtype1 : dtype2;
+}
 function dtypedArray(dtype, data) {
+	const { buffer, byteLength, byteOffset } = data;
+	const length = byteLength / byteWidth(dtype);
+	switch (dtype) {
+		case DType.Float32: return new Float32Array(buffer, byteOffset, length);
+		case DType.Int32:
+		case DType.Bool: return new Int32Array(buffer, byteOffset, length);
+		case DType.Uint32: return new Uint32Array(buffer, byteOffset, length);
+		case DType.Float16: return new Float16Array(buffer, byteOffset, length);
+		default: throw new Error(`Unimplemented dtype: ${dtype}`);
+	}
+}
+function dtypedJsArray(dtype, data) {
 	switch (dtype) {
 		case DType.Float32: return new Float32Array(data);
-		case DType.Int32: return new Int32Array(data);
-		case DType.Uint32: return new Uint32Array(data);
+		case DType.Int32:
 		case DType.Bool: return new Int32Array(data);
+		case DType.Uint32: return new Uint32Array(data);
+		case DType.Float16: return new Float16Array(data);
 		default: throw new Error(`Unimplemented dtype: ${dtype}`);
 	}
 }
@@ -292,12 +389,21 @@ var AluExp = class AluExp {
 	static cos(a) {
 		return new AluExp(AluOp.Cos, a.dtype, [a]);
 	}
+	static asin(a) {
+		return new AluExp(AluOp.Asin, a.dtype, [a]);
+	}
+	static atan(a) {
+		return new AluExp(AluOp.Atan, a.dtype, [a]);
+	}
 	static exp(a) {
 		return new AluExp(AluOp.Exp, a.dtype, [a]);
 	}
 	static log(a) {
 		return new AluExp(AluOp.Log, a.dtype, [a]);
 	}
+	static sqrt(a) {
+		return new AluExp(AluOp.Sqrt, a.dtype, [a]);
+	}
 	static reciprocal(a) {
 		return new AluExp(AluOp.Reciprocal, a.dtype, [a]);
 	}
@@ -343,24 +449,27 @@ var AluExp = class AluExp {
 	static variable(dtype, name) {
 		return new AluExp(AluOp.Variable, dtype, [], name);
 	}
-	static globalIndex(dtype, gid, bufidx) {
-		return new AluExp(AluOp.GlobalIndex, dtype, [bufidx], gid);
+	static globalIndex(dtype, gid, len, bufidx) {
+		return new AluExp(AluOp.GlobalIndex, dtype, [bufidx], [gid, len]);
 	}
 	static globalView(dtype, gid, st, indices) {
 		return new AluExp(AluOp.GlobalView, dtype, indices, [gid, st]);
 	}
+	static f32(value) {
+		return AluExp.const(DType.Float32, value);
+	}
 	static i32(value) {
 		return AluExp.const(DType.Int32, value);
 	}
 	static u32(value) {
 		return AluExp.const(DType.Uint32, value);
 	}
-	static f32(value) {
-		return AluExp.const(DType.Float32, value);
-	}
 	static bool(value) {
 		return AluExp.const(DType.Bool, Number(value));
 	}
+	static f16(value) {
+		return AluExp.const(DType.Float16, value);
+	}
 	not() {
 		if (this.dtype !== DType.Bool) throw new Error("not() can only be called on boolean expressions");
 		return AluExp.cmpne(this, AluExp.const(DType.Bool, true));
@@ -369,8 +478,11 @@ var AluExp = class AluExp {
 	getHash() {
 		if (this.#hash !== void 0) return this.#hash;
 		const hasher = new FpHash();
-		hasher.update(this.op, this.dtype, JSON.stringify(this.arg));
-		hasher.update(this.src.length, ...this.src);
+		hasher.update(this.op);
+		hasher.update(this.dtype);
+		hasher.update(JSON.stringify(this.arg));
+		hasher.update(this.src.length);
+		for (const s of this.src) hasher.update(s);
 		this.#hash = hasher.value;
 		return this.#hash;
 	}
@@ -390,9 +502,9 @@ var AluExp = class AluExp {
 	reindexGids(gidMap) {
 		return this.rewrite((exp) => {
 			if (exp.op === AluOp.GlobalIndex) {
-				const gid = exp.arg;
+				const [gid, len] = exp.arg;
 				const newGid = gidMap.get(gid);
-				if (newGid !== void 0 && newGid !== gid) return AluExp.globalIndex(exp.dtype, newGid, exp.src[0]);
+				if (newGid !== void 0 && newGid !== gid) return AluExp.globalIndex(exp.dtype, newGid, len, exp.src[0]);
 			} else if (exp.op === AluOp.GlobalView) {
 				const gid = exp.arg[0];
 				const newGid = gidMap.get(gid);
@@ -421,17 +533,16 @@ var AluExp = class AluExp {
 			case AluOp.Sub:
 				ret = [src[0].min - src[1].max, src[0].max - src[1].min];
 				break;
-			case AluOp.Mul: {
+			case AluOp.Mul:
 				ret = minMax4((a, b) => a * b);
 				break;
-			}
-			case AluOp.Idiv: {
-				ret = minMax4((a, b) => Math.floor(a / b));
+			case AluOp.Idiv:
+				ret = minMax4((a, b) => Math.trunc(a / b));
 				break;
-			}
 			case AluOp.Mod: {
 				let divisorRange = src[1].#computeRange();
 				if (divisorRange[0] <= 0 && divisorRange[1] >= 0) divisorRange = [0, Math.max(-divisorRange[0], divisorRange[1])];
+				if (divisorRange[1] < 0) divisorRange = [-divisorRange[1], -divisorRange[0]];
 				const maxDivisor = isFloatDtype(this.dtype) ? divisorRange[1] : divisorRange[1] - 1;
 				ret = [clamp(src[0].min, -maxDivisor, 0), clamp(src[0].max, 0, maxDivisor)];
 				break;
@@ -443,10 +554,16 @@ var AluExp = class AluExp {
 				ret = [Math.max(src[0].min, src[1].min), Math.max(src[0].max, src[1].max)];
 				break;
 			case AluOp.Sin:
-				ret = [Math.sin(src[0].min), Math.sin(src[0].max)];
+				ret = [-1, 1];
 				break;
 			case AluOp.Cos:
-				ret = [Math.cos(src[0].min), Math.cos(src[0].max)];
+				ret = [-1, 1];
+				break;
+			case AluOp.Asin:
+				ret = [-Math.PI / 2, Math.PI / 2];
+				break;
+			case AluOp.Atan:
+				ret = [-Math.PI / 2, Math.PI / 2];
 				break;
 			case AluOp.Exp:
 				ret = [Math.exp(src[0].min), Math.exp(src[0].max)];
@@ -454,23 +571,31 @@ var AluExp = class AluExp {
 			case AluOp.Log:
 				ret = [Math.log(src[0].min), Math.log(src[0].max)];
 				break;
+			case AluOp.Sqrt:
+				ret = [Math.sqrt(src[0].min), Math.sqrt(src[0].max)];
+				break;
 			case AluOp.Reciprocal:
 				if (src[0].min <= 0 && src[0].max >= 0) return [-Infinity, Infinity];
 				ret = [1 / src[0].max, 1 / src[0].min];
 				break;
-			case AluOp.Cast:
+			case AluOp.Cast: {
+				const wasFloat = isFloatDtype(src[0].dtype);
+				const bounded = Number.isFinite(src[0].min) && Number.isFinite(src[0].max);
 				if (this.dtype === DType.Bool) {
 					const canBeZero = src[0].min <= 0 && src[0].max >= 0;
 					const mustBeZero = src[0].min === 0 && src[0].max === 0;
 					ret = mustBeZero ? [0, 0] : canBeZero ? [0, 1] : [1, 1];
-				} else if (this.dtype === DType.Int32) ret = [Math.trunc(src[0].min), Math.trunc(src[0].max)];
-				else if (this.dtype === DType.Uint32) {
-					const a = Math.trunc(src[0].min);
-					const b = Math.trunc(src[0].max);
-					if (Math.floor(a / 2 ** 32) !== Math.floor(b / 2 ** 32)) ret = [0, -1 >>> 0];
-					else ret = [a % 2 ** 32, b % 2 ** 32];
+				} else if (this.dtype === DType.Int32) {
+					const a = wasFloat ? clamp(src[0].min, -2147483648, 2147483647) | 0 : src[0].min | 0;
+					const b = wasFloat ? clamp(src[0].max, -2147483648, 2147483647) | 0 : src[0].max | 0;
+					ret = bounded && a <= b ? [a, b] : [-Infinity, Infinity];
+				} else if (this.dtype === DType.Uint32) {
+					const a = wasFloat ? clamp(src[0].min, 0, 4294967295) >>> 0 : src[0].min >>> 0;
+					const b = wasFloat ? clamp(src[0].max, 0, 4294967295) >>> 0 : src[0].max >>> 0;
+					ret = bounded && a <= b ? [a, b] : [0, Infinity];
 				} else ret = [src[0].min, src[0].max];
 				break;
+			}
 			case AluOp.Cmplt:
 				ret = [0, 1];
 				break;
@@ -493,6 +618,7 @@ var AluExp = class AluExp {
 			ret[0] = clamp(ret[0], 0, 1);
 			ret[1] = clamp(ret[1], 0, 1);
 		}
+		if (this.dtype === DType.Uint32) ret[0] = Math.max(0, ret[0]);
 		this.#range = ret;
 		return ret;
 	}
@@ -502,21 +628,63 @@ var AluExp = class AluExp {
 	get max() {
 		return this.#computeRange()[1];
 	}
+	/** Largest known integer that divides self. */
+	constFactor() {
+		if (this.op === AluOp.Const) return Math.abs(this.arg);
+		if (this.op === AluOp.Add) return gcd(this.src[0].constFactor(), this.src[1].constFactor());
+		if (this.op === AluOp.Mul) {
+			if (this.src[0].op === AluOp.Const) return Math.abs(this.src[0].arg);
+			if (this.src[1].op === AluOp.Const) return Math.abs(this.src[1].arg);
+		}
+		return 1;
+	}
+	/**
+	* Checks if divisible by an integer v and returns the quotient if it is, or
+	* `null` if it's not divisible.
+	*/
+	divides(v) {
+		if (v === 1) return this;
+		if (this.op === AluOp.Const && this.arg % v === 0) return AluExp.const(this.dtype, this.arg / v);
+		if (this.op === AluOp.Add) {
+			const a = this.src[0].divides(v);
+			if (a !== null) {
+				const b = this.src[1].divides(v);
+				if (b !== null) return AluExp.add(a, b);
+			}
+		}
+		if (this.op === AluOp.Mul) {
+			const a = this.src[0].divides(v);
+			if (a !== null) return AluExp.mul(a, this.src[1]);
+			const b = this.src[1].divides(v);
+			if (b !== null) return AluExp.mul(this.src[0], b);
+		}
+		return null;
+	}
 	#isConstInt() {
 		return this.op === AluOp.Const && (this.dtype === DType.Int32 || this.dtype === DType.Uint32);
 	}
 	/**
+	* Get all expressions by deeply matching an operation.
+	*
+	* For example: `((2+(3*5))+4).splitOp(+) -> [2,(3*5),4]`.
+	*/
+	*splitOp(sep) {
+		if (this.op === sep) for (const src of this.src) yield* src.splitOp(sep);
+		else yield this;
+	}
+	/**
 	* Simplify the expression by replacing any known patterns and deduping
 	* identical subexpressions.
 	*/
 	simplify(cache = /* @__PURE__ */ new Map()) {
 		if (this.#simplified !== void 0) return this.#simplified;
 		const hash = this.getHash();
-		if (cache.has(hash)) return this.#simplified = cache.get(hash);
+		const prevCachedValue = cache.get(hash);
+		if (prevCachedValue !== void 0) return this.#simplified = prevCachedValue;
 		const simplified = this.#simplifyInner(cache);
 		const simplifiedHash = simplified.getHash();
-		if (cache.has(simplifiedHash)) {
-			const prevSimplified = cache.get(simplifiedHash);
+		const prevSimplified = cache.get(simplifiedHash);
+		if (prevSimplified !== void 0) {
 			cache.set(hash, prevSimplified);
 			this.#simplified = prevSimplified;
 			return prevSimplified;
@@ -550,7 +718,24 @@ var AluExp = class AluExp {
 			if (a.op === AluOp.Const && a.arg === -1) return new AluExp(opNeg, this.dtype, [src[0], b]);
 			else if (b.op === AluOp.Const && b.arg === -1) return new AluExp(opNeg, this.dtype, [src[0], a]);
 		}
+		if (op === AluOp.Where && src.slice(1).every((s, i) => s.op === AluOp.Const && s.arg === 1 - i)) return AluExp.cast(this.dtype, src[0]);
+		if (op === AluOp.Cmplt) {
+			if (src[0].min >= src[1].max) return AluExp.const(DType.Bool, false);
+			if (src[0].max < src[1].min) return AluExp.const(DType.Bool, true);
+		}
+		if (op === AluOp.Cmpne) {
+			if (src[0].max < src[1].min || src[0].min > src[1].max) return AluExp.const(DType.Bool, true);
+		}
+		if (op === AluOp.Where) {
+			if (src[0].max === 0) return src[2];
+			if (src[0].min === 1) return src[1];
+		}
 		if (op === AluOp.Mod && src[1].op === AluOp.Const && src[0].min >= 0 && src[0].max < src[1].arg) return src[0];
+		if (op === AluOp.Mod && src[0].op === AluOp.Mod && src[1].#isConstInt() && src[0].src[1].#isConstInt()) {
+			const A = src[0].src[1].arg;
+			const B = src[1].arg;
+			if (A > 0 && B > 0 && (A % B === 0 || B % A === 0)) return AluExp.mod(src[0].src[0], AluExp.const(this.dtype, Math.min(A, B))).simplify();
+		}
 		if (op === AluOp.Add && src[0].op === AluOp.Mul && src[0].src[1].#isConstInt() && src[1].op === AluOp.Mod && src[1].src[1].#isConstInt() && src[0].src[1].arg === src[1].src[1].arg) {
 			const [mul, mod] = src;
 			const check = (exp) => {
@@ -570,7 +755,7 @@ var AluExp = class AluExp {
 					const A = numer.src[i].arg;
 					if (A % B === 0) {
 						let ret = numer.src[1 - i];
-						if (A / B !== 1) ret = AluExp.mul(ret, AluExp.i32(A / B));
+						if (A / B !== 1) ret = AluExp.mul(ret, AluExp.const(ret.dtype, A / B));
 						return ret.simplify(cache);
 					}
 				}
@@ -578,8 +763,8 @@ var AluExp = class AluExp {
 					const A = numer.src[j].src[i].arg;
 					if (A % B === 0) {
 						let ret = numer.src[j].src[1 - i];
-						if (A / B !== 1) ret = AluExp.mul(ret, AluExp.i32(A / B));
-						ret = AluExp.add(ret, AluExp.idiv(numer.src[1 - j], B));
+						if (A / B !== 1) ret = AluExp.mul(ret, AluExp.const(ret.dtype, A / B));
+						ret = AluExp.add(ret, AluExp.idiv(numer.src[1 - j], AluExp.const(ret.dtype, B)));
 						return ret.simplify(cache);
 					}
 				}
@@ -588,23 +773,81 @@ var AluExp = class AluExp {
 		if (op === AluOp.Mod && src[1].#isConstInt() && src[1].arg > 0 && src[0].min >= 0) {
 			const [numer, denom] = src;
 			const B = denom.arg;
-			for (let i = 0; i < 2; i++) if (numer.op === AluOp.Add && numer.src[i].#isConstInt()) {
-				const A = numer.src[i].arg;
-				let ret = numer.src[1 - i];
-				if (A % B !== 0) ret = AluExp.add(ret, AluExp.i32(A % B));
-				return ret.simplify(cache);
+			for (let i = 0; i < 2; i++) if (numer.op === AluOp.Add) {
+				if (numer.src[i].#isConstInt()) {
+					const A = numer.src[i].arg;
+					const x = numer.src[1 - i];
+					if (A % B === 0 && x.min >= 0) return AluExp.mod(x, denom).simplify(cache);
+				}
+				for (let j = 0; j < 2; j++) if (numer.src[i].op === AluOp.Mul && numer.src[i].src[j].#isConstInt()) {
+					const A = numer.src[i].src[j].arg;
+					const x = numer.src[1 - i];
+					if (A % B === 0 && x.min >= 0) return AluExp.mod(x, denom).simplify(cache);
+				}
+			} else if (numer.op === AluOp.Mul) {
+				if (numer.src[i].#isConstInt()) {
+					const A = numer.src[i].arg;
+					if (A % B === 0) return AluExp.const(this.dtype, 0);
+					if (A % B === 1) return AluExp.mod(numer.src[1 - i], denom).simplify(cache);
+				}
 			}
 		}
-		if (op === AluOp.Cmplt) {
-			if (src[0].min >= src[1].max) return AluExp.const(DType.Bool, false);
-			if (src[0].max < src[1].min) return AluExp.const(DType.Bool, true);
-		}
-		if (op === AluOp.Cmpne) {
-			if (src[0].max < src[1].min || src[0].min > src[1].max) return AluExp.const(DType.Bool, true);
+		const commOps = [
+			AluOp.Add,
+			AluOp.Mul,
+			AluOp.Max,
+			AluOp.Min
+		];
+		if (commOps.includes(op)) {
+			const p = (a, b) => new AluExp(op, this.dtype, [a, b]);
+			if (src[0].op === AluOp.Const) return p(src[1], src[0]).simplify(cache);
+			if (src[0].op === op && src[0].src[1].op === AluOp.Const) if (src[1].op === AluOp.Const) return p(src[0].src[0], p(src[0].src[1], src[1])).simplify(cache);
+			else return p(p(src[0].src[0], src[1]), src[0].src[1]).simplify(cache);
+			if (src[1].op === op && src[1].src[1].op === AluOp.Const) return p(p(src[0], src[1].src[0]), src[1].src[1]).simplify(cache);
 		}
-		if (op === AluOp.Where) {
-			if (src[0].max === 0) return src[2];
-			if (src[0].min === 1) return src[1];
+		if (op === AluOp.Mod || op === AluOp.Idiv && src[1].#isConstInt()) {
+			const [x, y] = src;
+			{
+				const factors = [];
+				const terms = [];
+				for (const u of x.splitOp(AluOp.Add)) {
+					const factor = u.constFactor();
+					factors.push(factor);
+					terms.push(u.divides(factor));
+				}
+				const g = gcd(y.arg, ...factors);
+				if (g !== 1) {
+					let ret = new AluExp(op, this.dtype, [factors.map((f, i) => AluExp.mul(AluExp.const(terms[i].dtype, f / g), terms[i])).reduceRight((a, x$1) => AluExp.add(x$1, a)), AluExp.const(y.dtype, y.arg / g)]);
+					if (op === AluOp.Mod) ret = AluExp.mul(ret, AluExp.const(this.dtype, g));
+					return ret.simplify(cache);
+				}
+			}
+			if (y.arg > 0) {
+				let [xNoConst, constVal] = [x, 0];
+				if (x.op === AluOp.Add && x.src[1].op === AluOp.Const) [xNoConst, constVal] = [x.src[0], x.src[1].arg];
+				const terms = [];
+				const factors = [];
+				for (const u of xNoConst.splitOp(AluOp.Add)) {
+					const f = u.constFactor();
+					const divided = u.divides(f);
+					terms.push(divided ?? u);
+					factors.push(divided ? f : 1);
+				}
+				const quotients = factors.map((f) => Math.floor(f / y.arg));
+				const remainders = factors.map((f) => f % y.arg);
+				const gcdVal = remainders.reduce((g, r) => gcd(g, r), y.arg);
+				if (constVal % y.arg !== constVal || gcdVal !== 1 || remainders.some((r, i) => r === 0 || r !== factors[i] && op === AluOp.Mod)) {
+					let quo = AluExp.const(x.dtype, Math.floor(constVal / y.arg));
+					let rem = AluExp.const(x.dtype, Math.floor(constVal % y.arg / gcdVal));
+					for (let i = 0; i < terms.length; i++) if (op === AluOp.Idiv && remainders[i] !== 0) rem = AluExp.add(rem, AluExp.mul(AluExp.const(x.dtype, Math.floor(factors[i] / gcdVal)), terms[i]));
+					else {
+						rem = AluExp.add(rem, AluExp.mul(AluExp.const(x.dtype, Math.floor(remainders[i] / gcdVal)), terms[i]));
+						quo = AluExp.add(quo, AluExp.mul(AluExp.const(x.dtype, quotients[i]), terms[i]));
+					}
+					if (!((x.min < 0 || rem.min < 0) && remainders.some((r) => r !== 0))) if (op === AluOp.Mod) return AluExp.add(AluExp.mul(AluExp.const(x.dtype, gcdVal), AluExp.mod(rem, AluExp.const(x.dtype, Math.floor(y.arg / gcdVal)))), AluExp.const(x.dtype, constVal % gcdVal)).simplify(cache);
+					else return AluExp.add(AluExp.idiv(rem, AluExp.const(x.dtype, Math.floor(y.arg / gcdVal))), quo).simplify(cache);
+				}
+			}
 		}
 		const newExp = src.every((s, i) => s === this.src[i]) ? this : new AluExp(op, this.dtype, src, this.arg);
 		return newExp;
@@ -645,14 +888,20 @@ var AluExp = class AluExp {
 			switch (this.op) {
 				case AluOp.Sin: return Math.sin(x);
 				case AluOp.Cos: return Math.cos(x);
+				case AluOp.Asin: return Math.asin(x);
+				case AluOp.Atan: return Math.atan(x);
 				case AluOp.Exp: return Math.exp(x);
 				case AluOp.Log: return Math.log(x);
+				case AluOp.Sqrt: return Math.sqrt(x);
 				case AluOp.Reciprocal: return 1 / x;
-				case AluOp.Cast: if (this.dtype === DType.Int32) return Math.trunc(x) | 0;
-				else if (this.dtype === DType.Uint32) return Math.trunc(x) >>> 0;
-				else if (this.dtype === DType.Float32) return x;
-				else if (this.dtype === DType.Bool) return Number(Boolean(x));
-				else throw new Error(`Unsupported cast to ${this.dtype}`);
+				case AluOp.Cast: {
+					const wasFloat = isFloatDtype(this.src[0].dtype);
+					if (this.dtype === DType.Int32) return (wasFloat ? clamp(x, -2147483648, 2147483647) : x) | 0;
+					else if (this.dtype === DType.Uint32) return (wasFloat ? clamp(x, 0, 4294967295) : x) >>> 0;
+					else if (isFloatDtype(this.dtype)) return x;
+					else if (this.dtype === DType.Bool) return Number(Boolean(x));
+					else throw new Error(`Unsupported cast to ${this.dtype}`);
+				}
 				case AluOp.Bitcast: {
 					const buf = new ArrayBuffer(byteWidth(this.dtype));
 					const view = new DataView(buf);
@@ -660,10 +909,12 @@ var AluExp = class AluExp {
 					if (fromType === DType.Float32) view.setFloat32(0, x, true);
 					else if (fromType === DType.Int32) view.setInt32(0, x, true);
 					else if (fromType === DType.Uint32) view.setUint32(0, x, true);
+					else if (fromType === DType.Float16) view.setFloat16(0, x, true);
 					else throw new Error(`Unsupported bitcast from ${fromType}`);
 					if (this.dtype === DType.Float32) return view.getFloat32(0, true);
 					else if (this.dtype === DType.Int32) return view.getInt32(0, true);
 					else if (this.dtype === DType.Uint32) return view.getUint32(0, true);
+					else if (this.dtype === DType.Float16) return view.getFloat16(0, true);
 					else throw new Error(`Unsupported bitcast to ${this.dtype}`);
 				}
 				default: throw new Error(`Missing implemementation for ${this.op}`);
@@ -692,7 +943,7 @@ var AluExp = class AluExp {
 			}
 			case AluOp.GlobalIndex: {
 				if (!globals) throw new Error("Missing globals function");
-				const gid = this.arg;
+				const gid = this.arg[0];
 				const bufidx = this.src[0].evaluate(context, globals);
 				return globals(gid, bufidx);
 			}
@@ -722,13 +973,7 @@ var AluExp = class AluExp {
 			[AluOp.Cmplt]: "<",
 			[AluOp.Cmpne]: "!="
 		};
-		const UNARY_SYM = {
-			[AluOp.Sin]: "sin",
-			[AluOp.Cos]: "cos",
-			[AluOp.Exp]: "exp",
-			[AluOp.Log]: "log",
-			[AluOp.Reciprocal]: "1/"
-		};
+		const UNARY_SYM = { [AluOp.Reciprocal]: "1/" };
 		return this.fold((node, parts) => {
 			switch (node.op) {
 				case AluOp.Const: return "" + (node.dtype === DType.Bool ? Boolean(node.arg) : node.arg);
@@ -737,7 +982,7 @@ var AluExp = class AluExp {
 					const [name, n] = node.arg;
 					return `#${name}{${n}}`;
 				}
-				case AluOp.GlobalIndex: return `G_${node.arg}<${node.dtype}>[${strip1(parts[0])}]`;
+				case AluOp.GlobalIndex: return `G_${node.arg[0]}<${node.dtype}>[${strip1(parts[0])}]`;
 				case AluOp.GlobalView: {
 					const [gid, st] = node.arg;
 					const shape = st.shape.join(",");
@@ -766,6 +1011,17 @@ var AluExp = class AluExp {
 		};
 		return recurse(this);
 	}
+	/** Check if any expression in the tree satisfies a predicate. */
+	some(predicate) {
+		const visited = /* @__PURE__ */ new Set();
+		const recurse = (exp) => {
+			if (visited.has(exp)) return false;
+			if (predicate(exp)) return true;
+			visited.add(exp);
+			return exp.src.some(recurse);
+		};
+		return recurse(this);
+	}
 	/** Rewrite the expression recursively using a visitor. */
 	rewrite(visitor) {
 		return this.fold((exp, newSrc) => {
@@ -784,6 +1040,23 @@ var AluExp = class AluExp {
 		});
 		return result;
 	}
+	/** Produce a list of all distinct AluOp in this expression. */
+	distinctOps() {
+		const ops = /* @__PURE__ */ new Set();
+		this.fold((exp) => {
+			ops.add(exp.op);
+		});
+		return ops;
+	}
+	/** Rewrite GlobalView operations to GlobalIndex operations. */
+	rewriteGlobalViews() {
+		return this.rewrite((exp) => {
+			if (exp.op === AluOp.GlobalView) {
+				const [gid, st] = exp.arg;
+				return accessorGlobal(exp.dtype, gid, st, exp.src);
+			}
+		});
+	}
 };
 /** Symbolic form for each mathematical operation. */
 let AluOp = /* @__PURE__ */ function(AluOp$1) {
@@ -796,8 +1069,11 @@ let AluOp = /* @__PURE__ */ function(AluOp$1) {
 	AluOp$1["Max"] = "Max";
 	AluOp$1["Sin"] = "Sin";
 	AluOp$1["Cos"] = "Cos";
+	AluOp$1["Asin"] = "Asin";
+	AluOp$1["Atan"] = "Atan";
 	AluOp$1["Exp"] = "Exp";
 	AluOp$1["Log"] = "Log";
+	AluOp$1["Sqrt"] = "Sqrt";
 	AluOp$1["Reciprocal"] = "Reciprocal";
 	AluOp$1["Cast"] = "Cast";
 	AluOp$1["Bitcast"] = "Bitcast";
@@ -825,8 +1101,11 @@ const AluGroup = {
 	Unary: new Set([
 		AluOp.Sin,
 		AluOp.Cos,
+		AluOp.Asin,
+		AluOp.Atan,
 		AluOp.Exp,
 		AluOp.Log,
+		AluOp.Sqrt,
 		AluOp.Reciprocal,
 		AluOp.Cast,
 		AluOp.Bitcast
@@ -847,8 +1126,11 @@ const AluGroup = {
 	RequiredFloat: new Set([
 		AluOp.Sin,
 		AluOp.Cos,
+		AluOp.Asin,
+		AluOp.Atan,
 		AluOp.Exp,
 		AluOp.Log,
+		AluOp.Sqrt,
 		AluOp.Reciprocal
 	])
 };
@@ -877,7 +1159,7 @@ var Kernel = class {
 		this.exp = exp.simplify();
 	}
 	hash(state) {
-		state.update(this.nargs, this.size, this.exp, this.reduction);
+		state.update(this.nargs).update(this.size).update(this.exp).update(this.reduction);
 	}
 	pprint() {
 		let details = PPrint.pp(`exp = ${this.exp}`);
@@ -890,7 +1172,7 @@ var Kernel = class {
 	}
 	/** The dtype of the values output by this kernel. */
 	get dtype() {
-		if (this.reduction) return this.reduction.fusion.dtype;
+		if (this.reduction) return this.reduction.epilogue.dtype;
 		else return this.exp.dtype;
 	}
 	/** The number of bytes in the output array when evaluating this kernel. */
@@ -914,22 +1196,23 @@ var Kernel = class {
 * at this level since they depend on GPU, versus CPU or Wasm.
 */
 var Reduction = class {
-	constructor(dtype, op, size, fusion = AluVar.acc(dtype)) {
+	constructor(dtype, op, size, epilogue = AluVar.acc(dtype)) {
 		this.dtype = dtype;
 		this.op = op;
 		this.size = size;
-		this.fusion = fusion;
+		this.epilogue = epilogue;
 		if (!AluGroup.Reduce.has(op)) throw new TypeError(`Unsupported reduction: ${op}`);
+		this.epilogue = epilogue.simplify();
 	}
 	hash(state) {
-		state.update(this.dtype, this.op, this.size, this.fusion);
+		state.update(this.dtype).update(this.op).update(this.size).update(this.epilogue);
 	}
 	toString() {
-		return `${this.op}{${this.size}} -> ${this.fusion}`;
+		return `${this.op}{${this.size}} -> ${this.epilogue}`;
 	}
 	/** Get the identity for this reduction operation. */
 	get identity() {
-		if (this.dtype === DType.Bool) return this.op === AluOp.Add || this.op === AluOp.Max ? false : true;
+		if (this.dtype === DType.Bool) return this.op === AluOp.Add || this.op === AluOp.Max ? 0 : 1;
 		else if (this.dtype === DType.Int32) {
 			if (this.op === AluOp.Add) return 0;
 			else if (this.op === AluOp.Mul) return 1;
@@ -940,7 +1223,7 @@ var Reduction = class {
 			else if (this.op === AluOp.Mul) return 1;
 			else if (this.op === AluOp.Min) return -1 >>> 0;
 			else if (this.op === AluOp.Max) return 0;
-		} else if (this.dtype === DType.Float32) {
+		} else if (isFloatDtype(this.dtype)) {
 			if (this.op === AluOp.Add) return 0;
 			else if (this.op === AluOp.Mul) return 1;
 			else if (this.op === AluOp.Min) return Infinity;
@@ -963,7 +1246,7 @@ var Reduction = class {
 			else if (this.op === AluOp.Mul) return values.reduce((a, b) => a * b >>> 0, 1);
 			else if (this.op === AluOp.Min) return values.reduce((a, b) => Math.min(a, b), -1 >>> 0);
 			else if (this.op === AluOp.Max) return values.reduce((a, b) => Math.max(a, b), 0);
-		} else if (this.dtype === DType.Float32) {
+		} else if (isFloatDtype(this.dtype)) {
 			if (this.op === AluOp.Add) return values.reduce((a, b) => a + b, 0);
 			else if (this.op === AluOp.Mul) return values.reduce((a, b) => a * b, 1);
 			else if (this.op === AluOp.Min) return values.reduce((a, b) => Math.min(a, b), Infinity);
@@ -975,12 +1258,13 @@ var Reduction = class {
 /** Expression for accessing `indices` in input array with the given shape. */
 function accessorGlobal(dtype, gid, st, indices) {
 	const [index, valid] = st.toAluExp(indices);
-	return AluExp.where(valid, AluExp.globalIndex(dtype, gid, index), AluExp.const(dtype, 0));
+	const [, len] = st.views[0].dataRange();
+	return AluExp.where(valid, AluExp.globalIndex(dtype, gid, len, index), AluExp.const(dtype, 0));
 }
 /** Expression for accessing `indices` in an array recipe with variable "idx". */
-function accessorAluExp(dtype, exp, st, indices) {
+function accessorAluExp(exp, st, indices) {
 	const [index, valid] = st.toAluExp(indices);
-	return AluExp.where(valid, exp.substitute({ idx: index }), AluExp.const(dtype, 0));
+	return AluExp.where(valid, exp.substitute({ idx: index }), AluExp.const(exp.dtype, 0));
 }
 function threefry2x32(k0, k1, c0, c1) {
 	const rotl32 = (x, r) => (x << r | x >>> 32 - r) >>> 0;
@@ -1164,6 +1448,25 @@ var View = class View {
 		if (this.#contiguous === void 0) this.#contiguous = this.size === 0 || this.offset === 0 && this.mask === null && deepEqual(this.strides, defaultStrides(this.shape));
 		return this.#contiguous;
 	}
+	/** Return the range of data being indexed in this view, or [0, 0] if none. */
+	dataRange() {
+		if (this.size === 0 || this.mask && this.mask[0][0] === this.mask[0][1]) return [0, 0];
+		let min = this.offset;
+		let max = this.offset;
+		for (let i = 0; i < this.ndim; i++) {
+			let [lo, hi] = this.mask ? this.mask[i] : [0, this.shape[i]];
+			--hi;
+			const s = this.strides[i];
+			if (s > 0) {
+				min += s * lo;
+				max += s * hi;
+			} else if (s < 0) {
+				min += s * hi;
+				max += s * lo;
+			}
+		}
+		return [min, max + 1];
+	}
 	/** Produce an AluExp for evaluating this view at an index. */
 	toAluExp(idxs) {
 		let iexpr = AluExp.i32(this.offset);
@@ -1478,6 +1781,39 @@ var ShapeTracker = class ShapeTracker {
 		}
 		return st.expand(newShape);
 	}
+	/**
+	* Repeat data in each axis by a positive number of repetitions.
+	*
+	* - If `tile` is true (default): [1, 2, 3] -> [1, 2, 3, 1, 2, 3].
+	* - If `tile` is false: [1, 2, 3] -> [1, 1, 2, 2, 3, 3].
+	*/
+	repeat(reps, tile = true) {
+		if (reps.length > this.shape.length) throw new Error(`Too many repeats ${jstr(reps)} for shape ${jstr(this.shape)}`);
+		if (reps.some((c) => c <= 0)) throw new Error(`Invalid repeats ${jstr(reps)}`);
+		if (reps.length === 0) return this;
+		const noop = this.shape.slice(0, -reps.length);
+		const shape = this.shape.slice(-reps.length);
+		return this.broadcast([...noop, ...shape.flatMap((s, i) => tile ? [reps[i], s] : [s, reps[i]])], shape.map((_, i) => noop.length + 2 * i + (tile ? 0 : 1))).reshape([...noop, ...shape.map((s, i) => s * reps[i])]);
+	}
+	/** Move axis i to axis j. */
+	moveaxis(i, j) {
+		const perm = range(this.shape.length);
+		perm.splice(i, 1);
+		perm.splice(j, 0, i);
+		return this.permute(perm);
+	}
+	/** Like pad(), but allows for negative values. */
+	padOrShrink(arg) {
+		const padArg = [];
+		const shrinkArg = [];
+		for (let i = 0; i < arg.length; i++) {
+			const [b, e] = arg[i];
+			if (b < -this.shape[i] || e < -this.shape[i] || b + e < -this.shape[i]) throw new Error(`Invalid padOrShrink ${jstr(arg)} for ${jstr(this.shape)}`);
+			padArg.push([Math.max(0, b), Math.max(0, e)]);
+			shrinkArg.push([Math.max(0, -b), this.shape[i] - Math.max(0, -e)]);
+		}
+		return this.shrink(shrinkArg).pad(padArg);
+	}
 };
 function applyLast(ar, f) {
 	return ar.toSpliced(ar.length - 1, 1, f(ar[ar.length - 1]));
@@ -1598,13 +1934,7 @@ function tuneNullopt(kernel) {
 	vars.gidx = AluExp.special(DType.Int32, "gidx", kernel.size);
 	if (kernel.reduction) vars.ridx = AluExp.special(DType.Int32, "ridx", kernel.reduction.size);
 	return {
-		exp: kernel.exp.rewrite((exp) => {
-			if (exp.op === AluOp.GlobalView) {
-				const gid = exp.arg[0];
-				const st = exp.arg[1];
-				return accessorGlobal(exp.dtype, gid, st, exp.src);
-			}
-		}).substitute(vars).simplify(),
+		exp: kernel.exp.substitute(vars).rewriteGlobalViews().simplify(),
 		outputIdxExp: AluExp.special(DType.Int32, "gidx", kernel.size),
 		threadCount: kernel.size,
 		size: { reduce: kernel.reduction ? kernel.reduction.size : 0 }
@@ -1699,13 +2029,19 @@ function tuneWebgpu(kernel) {
 		const s = dim.st.shape.slice(dim.upcast);
 		addIndices(s, AluVar.upcast);
 	}
-	const newExp = exp.rewrite((exp$1) => {
+	let newExp = exp.rewrite((exp$1) => {
 		if (exp$1.op === AluOp.GlobalView) {
 			const gid = exp$1.arg[0];
 			const st = exp$1.arg[1];
 			return accessorGlobal(exp$1.dtype, gid, st.compose(dim.st), indices);
 		}
 	});
+	const [iexpr, vexpr] = dim.st.toAluExp(indices);
+	if (vexpr.min !== 1) throw new Error("Invariant violation: vexpr !== true");
+	newExp = newExp.substitute({
+		gidx: AluExp.idiv(iexpr, AluExp.i32(reduction.size)).simplify(),
+		ridx: AluExp.mod(iexpr, AluExp.i32(reduction.size)).simplify()
+	});
 	const outputGidx = dim.outputSt.shape.slice(0, dim.groups);
 	const outputUpcast = dim.outputSt.shape.slice(dim.groups);
 	const [outputIdxExp, _] = dim.outputSt.toAluExp([...unravelAlu(outputGidx, AluExp.special(DType.Int32, "gidx", prod(outputGidx))), ...unravelAlu(outputUpcast, AluVar.upcast)]);
@@ -1727,7 +2063,7 @@ function tuneWebgpu(kernel) {
 //#endregion
 //#region src/backend/cpu.ts
 /** Most basic implementation of `Backend` for testing. */
-var CPUBackend = class {
+var CpuBackend = class {
 	type = "cpu";
 	maxArgs = Infinity;
 	#buffers;
@@ -1737,10 +2073,10 @@ var CPUBackend = class {
 		this.#nextSlot = 1;
 	}
 	malloc(size, initialData) {
-		const buffer = new ArrayBuffer(size);
+		const buffer = new Uint8Array(size);
 		if (initialData) {
 			if (initialData.byteLength !== size) throw new Error("initialData size does not match buffer size");
-			new Uint8Array(buffer).set(new Uint8Array(initialData));
+			buffer.set(initialData);
 		}
 		const slot = this.#nextSlot++;
 		this.#buffers.set(slot, {
@@ -1779,7 +2115,7 @@ var CPUBackend = class {
 		const { exp } = tuneNullopt(kernel);
 		const inputBuffers = inputs.map((slot) => this.#getBuffer(slot));
 		const outputBuffers = outputs.map((slot) => this.#getBuffer(slot));
-		const usedArgs = new Map(exp.collect((exp$1) => exp$1.op === AluOp.GlobalIndex).map((exp$1) => [exp$1.arg, exp$1.dtype]));
+		const usedArgs = new Map(exp.collect((exp$1) => exp$1.op === AluOp.GlobalIndex).map((exp$1) => [exp$1.arg[0], exp$1.dtype]));
 		const inputArrays = inputBuffers.map((buf, i) => {
 			const dtype = usedArgs.get(i);
 			if (!dtype) return null;
@@ -1801,7 +2137,7 @@ var CPUBackend = class {
 				}, globals);
 				acc = kernel.reduction.evaluate(acc, item);
 			}
-			outputArray[i] = kernel.reduction.fusion.evaluate({ acc });
+			outputArray[i] = kernel.reduction.epilogue.evaluate({ acc });
 		}
 	}
 	#getBuffer(slot) {
@@ -1811,16 +2147,1594 @@ var CPUBackend = class {
 	}
 };
 
+//#endregion
+//#region src/backend/wasm/allocator.ts
+/** Simple tensor memory allocator for WebAssembly linear memory. */
+var WasmAllocator = class {
+	#memory;
+	#headPtr;
+	#freeLists;
+	#allocatedBuffers;
+	constructor(memory) {
+		this.#memory = memory;
+		this.#headPtr = 64;
+		this.#freeLists = /* @__PURE__ */ new Map();
+		this.#allocatedBuffers = /* @__PURE__ */ new Map();
+	}
+	malloc(size) {
+		if (size === 0) return 0;
+		const sizeClass = this.#findSizeClass(size);
+		const freeList = this.#freeLists.get(sizeClass);
+		let ptr;
+		if (freeList && freeList.length > 0) ptr = freeList.pop();
+		else ptr = this.#bumpAlloc(sizeClass);
+		this.#allocatedBuffers.set(ptr, sizeClass);
+		return ptr;
+	}
+	free(ptr) {
+		if (ptr === 0) return;
+		const sizeClass = this.#allocatedBuffers.get(ptr);
+		if (sizeClass === void 0) throw new Error(`Attempting to free unallocated pointer: ${ptr}`);
+		const freeList = this.#freeLists.get(sizeClass);
+		if (freeList) freeList.push(ptr);
+		else this.#freeLists.set(sizeClass, [ptr]);
+		this.#allocatedBuffers.delete(ptr);
+	}
+	#bumpAlloc(size) {
+		const ptr = this.#headPtr;
+		size = size + 63 & -64;
+		this.#headPtr += size;
+		if (ptr + size > this.#memory.buffer.byteLength) this.#memory.grow((ptr + size + 65535 >> 16) - (this.#memory.buffer.byteLength >> 16));
+		return ptr;
+	}
+	#findSizeClass(size) {
+		if (size <= 512) return size + 63 & -64;
+		if (size <= 2048) return size + 511 & -512;
+		if (size <= 65536) {
+			let sizeClass = 4096;
+			while (sizeClass < size) sizeClass *= 2;
+			return sizeClass;
+		}
+		return size + 65535 & -65536;
+	}
+	getStats() {
+		const freeListSizes = /* @__PURE__ */ new Map();
+		for (const [sizeClass, freeList] of this.#freeLists) if (freeList.length > 0) freeListSizes.set(sizeClass, freeList.length);
+		return {
+			totalAllocated: this.#headPtr,
+			freeListSizes
+		};
+	}
+};
+
+//#endregion
+//#region src/backend/wasm/builtins.ts
+/**
+* Approximate e^x.
+*
+* Method: range-reduce x = k*ln2 + r with k = round(x/ln2), |r|<=~0.3466
+*         then e^x = 2^k * P(r), where P is 5th-order poly (Taylor).
+*/
+function wasm_exp(cg) {
+	return cg.function([cg.f32], [cg.f32], () => {
+		const k_f = cg.local.declare(cg.f32);
+		const k = cg.local.declare(cg.i32);
+		const r = cg.local.declare(cg.f32);
+		const p = cg.local.declare(cg.f32);
+		const scale = cg.local.declare(cg.f32);
+		cg.local.get(0);
+		cg.f32.const(1 / Math.LN2);
+		cg.f32.mul();
+		cg.f32.nearest();
+		cg.local.tee(k_f);
+		cg.i32.trunc_sat_f32_s();
+		cg.local.set(k);
+		cg.local.get(k);
+		cg.i32.const(127);
+		cg.i32.gt_s();
+		cg.if(cg.void);
+		cg.f32.const(Infinity);
+		cg.return();
+		cg.end();
+		cg.local.get(k);
+		cg.i32.const(-126);
+		cg.i32.lt_s();
+		cg.if(cg.void);
+		cg.f32.const(0);
+		cg.return();
+		cg.end();
+		cg.local.get(0);
+		cg.local.get(k_f);
+		cg.f32.const(Math.LN2);
+		cg.f32.mul();
+		cg.f32.sub();
+		cg.local.set(r);
+		cg.f32.const(1 / 120);
+		cg.local.get(r);
+		cg.f32.mul();
+		cg.f32.const(1 / 24);
+		cg.f32.add();
+		cg.local.get(r);
+		cg.f32.mul();
+		cg.f32.const(1 / 6);
+		cg.f32.add();
+		cg.local.get(r);
+		cg.f32.mul();
+		cg.f32.const(1 / 2);
+		cg.f32.add();
+		cg.local.get(r);
+		cg.f32.mul();
+		cg.f32.const(1);
+		cg.f32.add();
+		cg.local.get(r);
+		cg.f32.mul();
+		cg.f32.const(1);
+		cg.f32.add();
+		cg.local.set(p);
+		cg.local.get(k);
+		cg.i32.const(127);
+		cg.i32.add();
+		cg.i32.const(23);
+		cg.i32.shl();
+		cg.f32.reinterpret_i32();
+		cg.local.set(scale);
+		cg.local.get(p);
+		cg.local.get(scale);
+		cg.f32.mul();
+	});
+}
+/**
+* Approximate ln(x), x > 0.
+*
+* Method: decompose x = m * 2^e with m in [1,2), e integer (via bit ops)
+*         ln(x) = e*ln2 + ln(m);  use atanh-style series with t=(m-1)/(m+1)
+*         ln(m) ≈ 2*(t + t^3/3 + t^5/5 + t^7/7)
+*/
+function wasm_log(cg) {
+	return cg.function([cg.f32], [cg.f32], () => {
+		const bits = cg.local.declare(cg.i32);
+		const e = cg.local.declare(cg.i32);
+		const m = cg.local.declare(cg.f32);
+		const t = cg.local.declare(cg.f32);
+		const t2 = cg.local.declare(cg.f32);
+		const t3 = cg.local.declare(cg.f32);
+		const t5 = cg.local.declare(cg.f32);
+		const t7 = cg.local.declare(cg.f32);
+		const lnm = cg.local.declare(cg.f32);
+		const el2 = cg.local.declare(cg.f32);
+		cg.local.get(0);
+		cg.f32.const(0);
+		cg.f32.le();
+		cg.if(cg.void);
+		cg.f32.const(NaN);
+		cg.return();
+		cg.end();
+		cg.local.get(0);
+		cg.i32.reinterpret_f32();
+		cg.local.tee(bits);
+		cg.i32.const(23);
+		cg.i32.shr_u();
+		cg.i32.const(255);
+		cg.i32.and();
+		cg.i32.const(127);
+		cg.i32.sub();
+		cg.local.set(e);
+		cg.local.get(bits);
+		cg.i32.const(8388607);
+		cg.i32.and();
+		cg.i32.const(1065353216);
+		cg.i32.or();
+		cg.f32.reinterpret_i32();
+		cg.local.set(m);
+		cg.local.get(m);
+		cg.f32.const(1);
+		cg.f32.sub();
+		cg.local.get(m);
+		cg.f32.const(1);
+		cg.f32.add();
+		cg.f32.div();
+		cg.local.set(t);
+		cg.local.get(t);
+		cg.local.get(t);
+		cg.f32.mul();
+		cg.local.set(t2);
+		cg.local.get(t);
+		cg.local.get(t2);
+		cg.f32.mul();
+		cg.local.set(t3);
+		cg.local.get(t3);
+		cg.local.get(t2);
+		cg.f32.mul();
+		cg.local.set(t5);
+		cg.local.get(t5);
+		cg.local.get(t2);
+		cg.f32.mul();
+		cg.local.set(t7);
+		cg.local.get(t7);
+		cg.f32.const(1 / 7);
+		cg.f32.mul();
+		cg.local.get(t5);
+		cg.f32.const(1 / 5);
+		cg.f32.mul();
+		cg.f32.add();
+		cg.local.get(t3);
+		cg.f32.const(1 / 3);
+		cg.f32.mul();
+		cg.f32.add();
+		cg.local.get(t);
+		cg.f32.add();
+		cg.f32.const(2);
+		cg.f32.mul();
+		cg.local.set(lnm);
+		cg.local.get(e);
+		cg.f32.convert_i32_s();
+		cg.f32.const(Math.LN2);
+		cg.f32.mul();
+		cg.local.set(el2);
+		cg.local.get(el2);
+		cg.local.get(lnm);
+		cg.f32.add();
+	});
+}
+/**
+* Common helper to approximate sin(x) and cos(x).
+*
+* Method: reduce to y in [-π, π], then quadrant via q = round(y/(π/2))
+*         z = y - q*(π/2); use one of two polynomials on z:
+*         sin(z) ≈ z + z^3*(-1/6) + z^5*(1/120) + z^7*(-1/5040)
+*         cos(z) ≈ 1 + z^2*(-1/2) + z^4*(1/24) + z^6*(-1/720)
+*/
+function _sincos(cg) {
+	const y = cg.local.declare(cg.f32);
+	const qf = cg.local.declare(cg.f32);
+	const q = cg.local.declare(cg.i32);
+	const z = cg.local.declare(cg.f32);
+	const z2 = cg.local.declare(cg.f32);
+	const sz = cg.local.declare(cg.f32);
+	const cz = cg.local.declare(cg.f32);
+	cg.local.get(0);
+	cg.local.get(0);
+	cg.f32.const(1 / (2 * Math.PI));
+	cg.f32.mul();
+	cg.f32.nearest();
+	cg.local.tee(qf);
+	cg.f32.const(2 * Math.PI);
+	cg.f32.mul();
+	cg.f32.sub();
+	cg.local.set(y);
+	cg.local.get(y);
+	cg.f32.const(2 / Math.PI);
+	cg.f32.mul();
+	cg.f32.nearest();
+	cg.local.tee(qf);
+	cg.i32.trunc_f32_s();
+	cg.local.set(q);
+	cg.local.get(y);
+	cg.local.get(qf);
+	cg.f32.const(Math.PI / 2);
+	cg.f32.mul();
+	cg.f32.sub();
+	cg.local.tee(z);
+	cg.local.get(z);
+	cg.f32.mul();
+	cg.local.set(z2);
+	cg.f32.const(-1 / 5040);
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(1 / 120);
+	cg.f32.add();
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(-1 / 6);
+	cg.f32.add();
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(1);
+	cg.f32.add();
+	cg.local.get(z);
+	cg.f32.mul();
+	cg.local.set(sz);
+	cg.f32.const(-1 / 720);
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(1 / 24);
+	cg.f32.add();
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(-1 / 2);
+	cg.f32.add();
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(1);
+	cg.f32.add();
+	cg.local.set(cz);
+	return {
+		q,
+		sz,
+		cz
+	};
+}
+/**
+* Approximate sin(x).
+*
+* Quadrant mapping: k=q mod 4: 0: +sz, 1: +cz, 2: -sz, 3: -cz
+*/
+function wasm_sin(cg) {
+	return cg.function([cg.f32], [cg.f32], () => {
+		const { q, sz, cz } = _sincos(cg);
+		const mag = cg.local.declare(cg.f32);
+		cg.local.get(cz);
+		cg.local.get(sz);
+		cg.local.get(q);
+		cg.i32.const(1);
+		cg.i32.and();
+		cg.select();
+		cg.local.tee(mag);
+		cg.f32.neg();
+		cg.local.get(mag);
+		cg.local.get(q);
+		cg.i32.const(2);
+		cg.i32.and();
+		cg.select();
+	});
+}
+/**
+* Approximate cos(x).
+*
+* Quadrant mapping: k=q mod 4: 0: +cz, 1: -sz, 2: -cz, 3: +sz
+*/
+function wasm_cos(cg) {
+	return cg.function([cg.f32], [cg.f32], () => {
+		const { q, sz, cz } = _sincos(cg);
+		const mag = cg.local.declare(cg.f32);
+		cg.local.get(sz);
+		cg.local.get(cz);
+		cg.local.get(q);
+		cg.i32.const(1);
+		cg.i32.and();
+		cg.select();
+		cg.local.tee(mag);
+		cg.f32.neg();
+		cg.local.get(mag);
+		cg.local.get(q);
+		cg.i32.const(1);
+		cg.i32.add();
+		cg.i32.const(2);
+		cg.i32.and();
+		cg.select();
+	});
+}
+/** Helper function for approximating arctan(x).  */
+function _atan(cg) {
+	const x = cg.local.declare(cg.f32);
+	const abs_x = cg.local.declare(cg.f32);
+	const z = cg.local.declare(cg.f32);
+	const z2 = cg.local.declare(cg.f32);
+	const p = cg.local.declare(cg.f32);
+	cg.local.set(x);
+	cg.local.get(x);
+	cg.f32.abs();
+	cg.local.set(abs_x);
+	cg.f32.const(1);
+	cg.local.get(abs_x);
+	cg.f32.div();
+	cg.local.get(abs_x);
+	cg.local.get(abs_x);
+	cg.f32.const(1);
+	cg.f32.ge();
+	cg.select();
+	cg.local.set(z);
+	cg.local.get(z);
+	cg.local.get(z);
+	cg.f32.mul();
+	cg.local.set(z2);
+	cg.f32.const(.0415796528637);
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(.661705427875);
+	cg.f32.add();
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(.999998614341);
+	cg.f32.add();
+	cg.f32.const(.173698870181);
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(.994987933645);
+	cg.f32.add();
+	cg.local.get(z2);
+	cg.f32.mul();
+	cg.f32.const(1);
+	cg.f32.add();
+	cg.f32.div();
+	cg.local.get(z);
+	cg.f32.mul();
+	cg.local.set(p);
+	cg.f32.const(Math.PI / 2);
+	cg.local.get(p);
+	cg.f32.sub();
+	cg.local.get(p);
+	cg.local.get(abs_x);
+	cg.f32.const(1);
+	cg.f32.ge();
+	cg.select();
+	cg.local.get(x);
+	cg.f32.copysign();
+}
+/**
+* Approximate atan(x).
+*
+* Method: if |x| < 1, use rational approximation: atan(x) ≈ x * P(x^2) / Q(x^2)
+*         where P(u) = A0 + A1*u + A2*u^2 (degree 2)
+*               Q(u) = 1 + B1*u + B2*u^2 (degree 2)
+*         if |x| >= 1, use: atan(x) = sign(x)*π/2 - atan(1/x)
+*         (fitted coefficients, max error ~5e-7 on [0,1])
+*/
+function wasm_atan(cg) {
+	return cg.function([cg.f32], [cg.f32], () => {
+		cg.local.get(0);
+		_atan(cg);
+	});
+}
+/**
+* Approximate asin(x).
+*
+* Method: asin(x) = 2 * atan(x / (1 + sqrt(1 - x^2)))
+*/
+function wasm_asin(cg) {
+	return cg.function([cg.f32], [cg.f32], () => {
+		cg.local.get(0);
+		cg.f32.const(1);
+		cg.local.get(0);
+		cg.local.get(0);
+		cg.f32.mul();
+		cg.f32.sub();
+		cg.f32.sqrt();
+		cg.f32.const(1);
+		cg.f32.add();
+		cg.f32.div();
+		_atan(cg);
+		cg.f32.const(2);
+		cg.f32.mul();
+	});
+}
+/**
+* Threefry2x32 pseudorandom number generator.
+*
+* Takes two 32-bit keys and two 32-bit counters as input,
+* returns two 32-bit pseudorandom values.
+*/
+function wasm_threefry2x32(cg) {
+	return cg.function([
+		cg.i32,
+		cg.i32,
+		cg.i32,
+		cg.i32
+	], [cg.i32, cg.i32], () => {
+		const ks0 = cg.local.declare(cg.i32);
+		const ks1 = cg.local.declare(cg.i32);
+		const ks2 = cg.local.declare(cg.i32);
+		const x0 = cg.local.declare(cg.i32);
+		const x1 = cg.local.declare(cg.i32);
+		const mix = (rot) => {
+			cg.local.get(x0);
+			cg.local.get(x1);
+			cg.i32.add();
+			cg.local.set(x0);
+			cg.local.get(x1);
+			cg.i32.const(rot);
+			cg.i32.rotl();
+			cg.local.get(x0);
+			cg.i32.xor();
+			cg.local.set(x1);
+		};
+		const keySchedule = (k0, k1, round) => {
+			cg.local.get(x0);
+			cg.local.get(k0);
+			cg.i32.add();
+			cg.local.set(x0);
+			cg.local.get(x1);
+			cg.local.get(k1);
+			cg.i32.add();
+			cg.i32.const(round);
+			cg.i32.add();
+			cg.local.set(x1);
+		};
+		cg.local.get(0);
+		cg.local.set(ks0);
+		cg.local.get(1);
+		cg.local.set(ks1);
+		cg.local.get(0);
+		cg.local.get(1);
+		cg.i32.xor();
+		cg.i32.const(466688986);
+		cg.i32.xor();
+		cg.local.set(ks2);
+		cg.local.get(2);
+		cg.local.get(ks0);
+		cg.i32.add();
+		cg.local.set(x0);
+		cg.local.get(3);
+		cg.local.get(ks1);
+		cg.i32.add();
+		cg.local.set(x1);
+		mix(13), mix(15), mix(26), mix(6);
+		keySchedule(ks1, ks2, 1);
+		mix(17), mix(29), mix(16), mix(24);
+		keySchedule(ks2, ks0, 2);
+		mix(13), mix(15), mix(26), mix(6);
+		keySchedule(ks0, ks1, 3);
+		mix(17), mix(29), mix(16), mix(24);
+		keySchedule(ks1, ks2, 4);
+		mix(13), mix(15), mix(26), mix(6);
+		keySchedule(ks2, ks0, 5);
+		cg.local.get(x0);
+		cg.local.get(x1);
+	});
+}
+
+//#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);
+	}
+	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 concat(out, inp) {
+	out.push(...inp);
+}
+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;
+	v128;
+	i32x4;
+	f32x4;
+	memory;
+	void = {
+		typeId: 64,
+		name: "void"
+	};
+	#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.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));
+	}
+	loop(...type) {
+		this.#blockFrames.push({
+			idx: this.#typeStack.length,
+			ty: type
+		});
+		this._emit(3);
+		this._emit(encodeBlocktype(type));
+	}
+	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));
+	}
+	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}`);
+		}
+		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;
+	}
+	_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 = [];
+		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.min && 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);
+	}
+};
+var Local = class {
+	constructor(cg) {
+		this.cg = cg;
+	}
+	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));
+	}
+	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);
+	}
+};
+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));
+	};
+}
+var I32 = class {
+	constructor(cg) {
+		this.cg = cg;
+	}
+	get typeId() {
+		return 127;
+	}
+	get name() {
+		return "i32";
+	}
+	const(i) {
+		this.cg._emit(65);
+		this.cg._emit(encodeSigned(i));
+		this.cg._push(this);
+	}
+	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 = BINARY_OP("eqz", 69, "i32", "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");
+	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");
+};
+var F32 = class {
+	constructor(cg) {
+		this.cg = cg;
+	}
+	get typeId() {
+		return 125;
+	}
+	get name() {
+		return "f32";
+	}
+	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);
+	}
+	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");
+	load = LOAD_OP("load", 42, "f32");
+	store = STORE_OP("store", 56, "f32");
+	reinterpret_i32 = UNARY_OP("reinterpret_i32", 190, "i32", "f32");
+};
+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;
+	}
+	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");
+};
+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");
+};
+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");
+};
+
+//#endregion
+//#region src/backend/wasm.ts
+/** Backend that compiles into WebAssembly bytecode for immediate execution. */
+var WasmBackend = class {
+	type = "wasm";
+	maxArgs = 64;
+	#memory;
+	#nextSlot;
+	#allocator;
+	#buffers;
+	constructor() {
+		this.#memory = new WebAssembly.Memory({ initial: 0 });
+		this.#allocator = new WasmAllocator(this.#memory);
+		this.#nextSlot = 1;
+		this.#buffers = /* @__PURE__ */ new Map();
+	}
+	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);
+		}
+	}
+	async read(slot, start, count) {
+		return this.readSync(slot, start, count);
+	}
+	readSync(slot, start, count) {
+		const buffer = this.#getBuffer(slot);
+		if (start === void 0) start = 0;
+		if (count === void 0) count = buffer.byteLength - start;
+		return buffer.slice(start, start + count);
+	}
+	async prepare(kernel) {
+		return this.prepareSync(kernel);
+	}
+	prepareSync(kernel) {
+		const bytes = codegenWasm(kernel);
+		const module$1 = new WebAssembly.Module(bytes);
+		return new Executable(kernel, { module: module$1 });
+	}
+	dispatch(exe, inputs, outputs) {
+		const instance = new WebAssembly.Instance(exe.data.module, { env: { memory: this.#memory } });
+		const func = instance.exports.kernel;
+		const ptrs = [...inputs, ...outputs].map((slot) => this.#buffers.get(slot).ptr);
+		func(...ptrs);
+	}
+	#getBuffer(slot) {
+		const buffer = this.#buffers.get(slot);
+		if (!buffer) throw new SlotError(slot);
+		return new Uint8Array(this.#memory.buffer, buffer.ptr, buffer.size);
+	}
+};
+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 cg = new CodeGenerator();
+	cg.memory.import("env", "memory");
+	const distinctOps = union(tune.exp.distinctOps(), re?.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)) funcs.exp = wasm_exp(cg);
+	if (distinctOps.has(AluOp.Log)) funcs.log = wasm_log(cg);
+	if (distinctOps.has(AluOp.Threefry2x32)) funcs.threefry2x32 = wasm_threefry2x32(cg);
+	const kernelFunc = cg.function(rep(kernel.nargs + 1, cg.i32), [], () => {
+		const gidx = cg.local.declare(cg.i32);
+		cg.loop(cg.void);
+		cg.block(cg.void);
+		cg.local.get(gidx);
+		cg.i32.const(kernel.size);
+		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();
+		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 (re.dtype === DType.Float32) {
+				cg.local.get(acc);
+				if (re.op === AluOp.Min) cg.f32.min();
+				else cg.f32.max();
+			} else if ([
+				DType.Int32,
+				DType.Uint32,
+				DType.Bool
+			].includes(re.dtype)) {
+				const local = cg.local.declare(cg.i32);
+				cg.local.tee(local);
+				cg.local.get(acc);
+				cg.local.get(local);
+				cg.local.get(acc);
+				if (re.op === AluOp.Min) if (re.dtype === DType.Int32) cg.i32.lt_s();
+				else cg.i32.lt_u();
+				else if (re.dtype === DType.Int32) cg.i32.gt_s();
+				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, kernel.reduction.epilogue, { acc });
+		} 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();
+}
+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);
+		}
+	};
+	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 (dtype === DType.Float32) cg.f32.div(), cg.f32.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 (dtype === DType.Float32) {
+				const a = cg.local.declare(cg.f32);
+				const b = cg.local.declare(cg.f32);
+				cg.local.set(b);
+				cg.local.tee(a);
+				cg.local.get(a);
+				cg.local.get(b);
+				cg.f32.div();
+				cg.f32.trunc();
+				cg.local.get(b);
+				cg.f32.mul();
+				cg.f32.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 (dtype === DType.Float32) if (op === AluOp.Min) cg.f32.min();
+			else cg.f32.max();
+			else if (dtype === DType.Int32 || dtype === DType.Uint32) {
+				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.Cmplt) {
+				const srcDtype = src[0].dtype;
+				if (srcDtype === DType.Float32) cg.f32.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)) if (op === AluOp.Sin) gen(src[0]), cg.call(funcs.sin);
+		else if (op === AluOp.Cos) gen(src[0]), cg.call(funcs.cos);
+		else if (op === AluOp.Asin) gen(src[0]), cg.call(funcs.asin);
+		else if (op === AluOp.Atan) gen(src[0]), cg.call(funcs.atan);
+		else if (op === AluOp.Exp) gen(src[0]), cg.call(funcs.exp);
+		else if (op === AluOp.Log) gen(src[0]), cg.call(funcs.log);
+		else if (op === AluOp.Sqrt) gen(src[0]), cg.f32.sqrt();
+		else if (op === AluOp.Reciprocal) cg.f32.const(1), gen(src[0]), cg.f32.div();
+		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 (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 (i32repr);
+			else throw new UnsupportedOpError(op, dtype, "wasm", dtype0);
+			else if (dtype === DType.Float32) if (dtype0 === DType.Float32);
+			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.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 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;
+			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));
+			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);
+}
+function dty(cg, op, dtype) {
+	switch (dtype) {
+		case DType.Float32: return cg.f32;
+		case DType.Int32:
+		case DType.Uint32:
+		case DType.Bool: return cg.i32;
+		default: throw new UnsupportedOpError(op, dtype, "wasm");
+	}
+}
+
 //#endregion
 //#region src/backend.ts
-const devices = ["cpu", "webgpu"];
-let defaultBackend = "cpu";
+const devices = [
+	"cpu",
+	"wasm",
+	"webgpu"
+];
+let defaultBackend = "wasm";
 const initializedBackends = /* @__PURE__ */ new Map();
-initializedBackends.set("cpu", new CPUBackend());
-/** Set the default device backend (must be initialized). */
-function setDevice(device) {
-	if (initializedBackends.has(device)) defaultBackend = device;
+initializedBackends.set("cpu", new CpuBackend());
+initializedBackends.set("wasm", new WasmBackend());
+/** Configure the default device for arrays. */
+function defaultDevice(device) {
+	if (device !== void 0) if (initializedBackends.has(device)) defaultBackend = device;
 	else throw new Error(`Backend not initialized: ${device}`);
+	return defaultBackend;
 }
 /**
 * Initialize `jax-js` library backends.
@@ -1841,12 +3755,13 @@ async function init(...devicesToInit) {
 }
 /** Create a backend, if available. Internal function called by `init()`. */
 async function createBackend(device) {
-	if (device === "cpu") return new CPUBackend();
+	if (device === "cpu") return new CpuBackend();
+	else if (device === "wasm") return new WasmBackend();
 	else if (device === "webgpu") {
 		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-c5Fe8nx8.cjs"));
+		const { WebGPUBackend } = await Promise.resolve().then(() => require("./webgpu-BVdMaO9T.cjs"));
 		const importantLimits = [
 			"maxBufferSize",
 			"maxComputeInvocationsPerWorkgroup",
@@ -1859,8 +3774,12 @@ async function createBackend(device) {
 			"maxStorageBuffersPerShaderStage",
 			"maxStorageTexturesPerShaderStage"
 		];
+		const requestedFeatures = ["shader-f16", "timestamp-query"];
 		try {
-			const device$1 = await adapter.requestDevice({ requiredLimits: Object.fromEntries(importantLimits.map((feature) => [feature, adapter.limits[feature]])) });
+			const device$1 = await adapter.requestDevice({
+				requiredLimits: Object.fromEntries(importantLimits.map((limit) => [limit, adapter.limits[limit]])),
+				requiredFeatures: requestedFeatures.filter((feature) => adapter.features.has(feature))
+			});
 			return new WebGPUBackend(device$1);
 		} catch (error) {
 			console.error("Unexpected error requesting WebGPU device:", error);
@@ -1886,6 +3805,13 @@ var SlotError = class extends Error {
 		super(`Used a buffer that is invalid or already freed: ${slot}`);
 	}
 };
+var UnsupportedOpError = class extends Error {
+	constructor(op, dtype, device, arg) {
+		let msg = `${op || ""}<${dtype}> not supported in ${device} backend`;
+		if (arg !== void 0) msg += ` with arg ${JSON.stringify(arg)}`;
+		super(msg);
+	}
+};
 
 //#endregion
 Object.defineProperty(exports, 'AluExp', {
@@ -1966,6 +3892,12 @@ Object.defineProperty(exports, 'SlotError', {
     return SlotError;
   }
 });
+Object.defineProperty(exports, 'UnsupportedOpError', {
+  enumerable: true,
+  get: function () {
+    return UnsupportedOpError;
+  }
+});
 Object.defineProperty(exports, 'accessorAluExp', {
   enumerable: true,
   get: function () {
@@ -1996,6 +3928,12 @@ Object.defineProperty(exports, 'deepEqual', {
     return deepEqual;
   }
 });
+Object.defineProperty(exports, 'defaultDevice', {
+  enumerable: true,
+  get: function () {
+    return defaultDevice;
+  }
+});
 Object.defineProperty(exports, 'devices', {
   enumerable: true,
   get: function () {
@@ -2008,6 +3946,12 @@ Object.defineProperty(exports, 'dtypedArray', {
     return dtypedArray;
   }
 });
+Object.defineProperty(exports, 'dtypedJsArray', {
+  enumerable: true,
+  get: function () {
+    return dtypedJsArray;
+  }
+});
 Object.defineProperty(exports, 'findPow2', {
   enumerable: true,
   get: function () {
@@ -2050,6 +3994,12 @@ Object.defineProperty(exports, 'isPermutation', {
     return isPermutation;
   }
 });
+Object.defineProperty(exports, 'normalizeAxis', {
+  enumerable: true,
+  get: function () {
+    return normalizeAxis;
+  }
+});
 Object.defineProperty(exports, 'partitionList', {
   enumerable: true,
   get: function () {
@@ -2062,6 +4012,12 @@ Object.defineProperty(exports, 'prod', {
     return prod;
   }
 });
+Object.defineProperty(exports, 'promoteTypes', {
+  enumerable: true,
+  get: function () {
+    return promoteTypes;
+  }
+});
 Object.defineProperty(exports, 'range', {
   enumerable: true,
   get: function () {
@@ -2086,10 +4042,10 @@ Object.defineProperty(exports, 'runWithCache', {
     return runWithCache;
   }
 });
-Object.defineProperty(exports, 'setDevice', {
+Object.defineProperty(exports, 'setDebug', {
   enumerable: true,
   get: function () {
-    return setDevice;
+    return setDebug;
   }
 });
 Object.defineProperty(exports, 'strip1', {
@@ -2110,6 +4066,12 @@ Object.defineProperty(exports, 'tuneWebgpu', {
     return tuneWebgpu;
   }
 });
+Object.defineProperty(exports, 'union', {
+  enumerable: true,
+  get: function () {
+    return union;
+  }
+});
 Object.defineProperty(exports, 'unravelAlu', {
   enumerable: true,
   get: function () {
@@ -2127,4 +4089,10 @@ Object.defineProperty(exports, 'zip', {
   get: function () {
     return zip;
   }
+});
+Object.defineProperty(exports, 'zipn', {
+  enumerable: true,
+  get: function () {
+    return zipn;
+  }
 });