@jax-js/jax 0.0.4 → 0.1.0

package/dist/index.cjs

@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const require_backend = require('./backend-Ss1Mev_-.cjs');
+const require_backend = require('./backend-FtkbO6pI.cjs');
 
 //#region src/tree.ts
 var tree_exports = {};
@@ -60,6 +60,10 @@ var JsTreeDef = class JsTreeDef {
 		this.nodeMetadata = nodeMetadata;
 		this.childTreedefs = childTreedefs;
 	}
+	/** Get the total number of leaves in the tree. */
+	get size() {
+		return this.nodeType === NodeType.Leaf ? 1 : this.childTreedefs.reduce((a, b) => a + b.size, 0);
+	}
 	/** Returns a string representation of this tree definition. */
 	toString(root = true) {
 		if (root) return "JsTreeDef(" + this.toString(false) + ")";
@@ -215,6 +219,16 @@ function pool(st, ks, strides = 1, dilation = 1) {
 	const s_ = strides;
 	const d_ = dilation;
 	const o_ = require_backend.zipn(i_, d_, ks, s_).map(([i, d, k, s]) => Math.ceil((i - d * (k - 1)) / s));
+	if (d_.every((d) => d === 1) && ks.every((k, j) => k <= s_[j])) {
+		st = st.padOrShrink([...noop.map(() => [0, 0]), ...require_backend.zipn(i_, o_, s_).map(([i, o, s]) => [0, o * s - i])]);
+		st = st.reshape([...noop, ...require_backend.zip(o_, s_).flatMap(([o, s]) => [o, s])]).shrink([...noop.map((x) => [0, x]), ...require_backend.zip(o_, ks).flatMap(([o, k]) => [[0, o], [0, k]])]);
+		st = st.permute([
+			...require_backend.range(noop.length),
+			...ks.map((_, j) => noop.length + 2 * j),
+			...ks.map((_, j) => noop.length + 2 * j + 1)
+		]);
+		return st;
+	}
 	const f_ = require_backend.zipn(o_, s_, i_, d_, ks).map(([o, s, i, d, k]) => 1 + Number(o * s > i - d * (k - 1)));
 	const kidf = require_backend.zipn(ks, i_, d_, f_);
 	st = st.repeat([...require_backend.rep(noop.length, 1), ...kidf.map(([k, i, d, f]) => Math.ceil(k * (i * f + d) / i))]);
@@ -249,6 +263,12 @@ function poolTranspose(st, inShape, ks, strides = 1, dilation = 1) {
 	const s_ = strides;
 	const d_ = dilation;
 	const o_ = require_backend.zipn(i_, d_, ks, s_).map(([i, d, k, s]) => Math.ceil((i - d * (k - 1)) / s));
+	if (d_.every((d) => d === 1) && ks.every((k, j) => k <= s_[j])) {
+		st = st.permute([...require_backend.range(noop.length), ...ks.flatMap((_, j) => [noop.length + j, noop.length + o_.length + j])]);
+		st = st.pad([...noop.map(() => [0, 0]), ...require_backend.zip(s_, ks).flatMap(([s, k]) => [[0, 0], [0, s - k]])]).reshape([...noop, ...require_backend.zip(o_, s_).map(([o, s]) => o * s)]);
+		st = st.padOrShrink([...noop.map(() => [0, 0]), ...require_backend.zipn(i_, o_, s_).map(([i, o, s]) => [0, i - o * s])]);
+		return st.reshape(st.shape.concat(require_backend.rep(ks.length, 1)));
+	}
 	if (!require_backend.deepEqual(o_, st.shape.slice(noop.length, noop.length + ks.length))) throw new Error("poolTranspose() called with mismatched output shape");
 	const f_ = require_backend.zipn(o_, s_, i_, d_, ks).map(([o, s, i, d, k]) => 1 + Number(o * s > i - d * (k - 1)));
 	const kidf = require_backend.zipn(ks, i_, d_, f_);
@@ -358,6 +378,8 @@ let Primitive = /* @__PURE__ */ function(Primitive$1) {
 	Primitive$1["Atan"] = "atan";
 	Primitive$1["Exp"] = "exp";
 	Primitive$1["Log"] = "log";
+	Primitive$1["Erf"] = "erf";
+	Primitive$1["Erfc"] = "erfc";
 	Primitive$1["Sqrt"] = "sqrt";
 	Primitive$1["Min"] = "min";
 	Primitive$1["Max"] = "max";
@@ -435,6 +457,12 @@ function exp$1(x) {
 function log$1(x) {
 	return bind1(Primitive.Log, [x]);
 }
+function erf$1(x) {
+	return bind1(Primitive.Erf, [x]);
+}
+function erfc$1(x) {
+	return bind1(Primitive.Erfc, [x]);
+}
 function sqrt$1(x) {
 	return bind1(Primitive.Sqrt, [x]);
 }
@@ -596,6 +624,21 @@ var Trace = class {
 		this.main = main;
 	}
 };
+/**
+* Broadcast shapes and promote types with casting for two avals.
+*
+* This implements the weak type behavior described in `promoteTypes()`, but not
+* implemented in that function as `weakType` is not passed.
+*/
+function promoteAvals(a, b) {
+	const shape$1 = require_backend.generalBroadcast(a.shape, b.shape);
+	const weakType = a.weakType && b.weakType;
+	let dtype;
+	if (a.weakType === b.weakType) dtype = require_backend.promoteTypes(a.dtype, b.dtype);
+	else if (a.weakType) dtype = require_backend.promoteTypes(b.dtype, require_backend.DType.Uint32);
+	else dtype = require_backend.promoteTypes(a.dtype, require_backend.DType.Uint32);
+	return new ShapedArray(shape$1, dtype, weakType);
+}
 var Tracer = class Tracer {
 	/** @ignore */
 	_trace;
@@ -610,10 +653,19 @@ var Tracer = class Tracer {
 	get size() {
 		return require_backend.prod(this.shape);
 	}
-	/** The dtype of the array. */
+	/** The dtype of elements stored in the array. */
 	get dtype() {
 		return this.aval.dtype;
 	}
+	/**
+	* Whether the array is weakly typed.
+	*
+	* Weakly typed arrays will cast to the dtype of the other operand. See
+	* `promoteTypes()` for details.
+	*/
+	get weakType() {
+		return this.aval.weakType;
+	}
 	/** The number of dimensions of the array. */
 	get ndim() {
 		return this.shape.length;
@@ -850,12 +902,13 @@ function getShape(x) {
 	return x instanceof Tracer ? x.shape : [];
 }
 var ShapedArray = class ShapedArray {
-	constructor(shape$1, dtype) {
+	constructor(shape$1, dtype, weakType) {
 		this.shape = shape$1;
 		this.dtype = dtype;
+		this.weakType = weakType;
 	}
 	static fromAval(aval) {
-		return new ShapedArray(aval.shape, aval.dtype);
+		return new ShapedArray(aval.shape, aval.dtype, aval.weakType);
 	}
 	get ndim() {
 		return this.shape.length;
@@ -869,7 +922,7 @@ var ShapedArray = class ShapedArray {
 };
 function getAval(x) {
 	if (x instanceof Tracer) return x.aval;
-	else if (typeof x === "boolean" || typeof x === "number") return new ShapedArray([], typeof x === "boolean" ? require_backend.DType.Bool : require_backend.DType.Float32);
+	else if (typeof x === "boolean" || typeof x === "number") return new ShapedArray([], typeof x === "boolean" ? require_backend.DType.Bool : require_backend.DType.Float32, typeof x === "boolean" ? false : true);
 	else throw new TypeError(`Unknown value: ${x}`);
 }
 function bind(prim, args, params = {}) {
@@ -1152,12 +1205,18 @@ function reshapeViews(exp$2, mapping, reduceAxis = false) {
 		} else if (exp$3.op === require_backend.AluOp.GlobalIndex) throw new Error("internal: reshapeViews() called with GlobalIndex op");
 	});
 }
-function broadcastedJit(fn) {
+function broadcastedJit(fn, opts) {
 	return (nargs, exps, avals, params) => {
-		const newShape = avals.map((aval) => aval.shape).reduce(generalBroadcast);
-		exps = exps.map((exp$3) => reshapeViews(exp$3, (st) => {
-			if (!require_backend.deepEqual(st.shape, newShape)) return st.broadcast(newShape, require_backend.range(newShape.length - st.shape.length));
-		}));
+		let { shape: newShape, dtype: newDtype } = avals.reduce(promoteAvals);
+		const skipCastIdx = opts?.skipCastIdx ?? [];
+		if (skipCastIdx.length) newDtype = avals.filter((_, i) => !skipCastIdx.includes(i)).reduce(promoteAvals).dtype;
+		exps = exps.map((exp$3, i) => {
+			exp$3 = reshapeViews(exp$3, (st) => {
+				if (!require_backend.deepEqual(st.shape, newShape)) return st.broadcast(newShape, require_backend.range(newShape.length - st.shape.length));
+			});
+			if (exp$3.dtype !== newDtype && !skipCastIdx.includes(i)) exp$3 = require_backend.AluExp.cast(newDtype, exp$3);
+			return exp$3;
+		});
 		const exp$2 = fn(exps, params);
 		return new require_backend.Kernel(nargs, require_backend.prod(newShape), exp$2);
 	};
@@ -1191,7 +1250,7 @@ const jitRules = {
 		const k1 = reshapeViews(keys[1], mapping);
 		const c0 = require_backend.AluExp.u32(0);
 		const c1 = require_backend.AluExp.cast(require_backend.DType.Uint32, require_backend.AluVar.gidx);
-		const exp$2 = require_backend.AluExp.threefry2x32(c0, c1, k0, k1, mode);
+		const exp$2 = require_backend.AluExp.threefry2x32(k0, k1, c0, c1, mode);
 		return new require_backend.Kernel(nargs, require_backend.prod(shape$1), exp$2);
 	},
 	[Primitive.Sin]: unopJit(require_backend.AluExp.sin),
@@ -1200,6 +1259,8 @@ const jitRules = {
 	[Primitive.Atan]: unopJit(require_backend.AluExp.atan),
 	[Primitive.Exp]: unopJit(require_backend.AluExp.exp),
 	[Primitive.Log]: unopJit(require_backend.AluExp.log),
+	[Primitive.Erf]: unopJit(require_backend.AluExp.erf),
+	[Primitive.Erfc]: unopJit(require_backend.AluExp.erfc),
 	[Primitive.Sqrt]: unopJit(require_backend.AluExp.sqrt),
 	[Primitive.Min]: broadcastedJit(([a, b]) => require_backend.AluExp.min(a, b)),
 	[Primitive.Max]: broadcastedJit(([a, b]) => require_backend.AluExp.max(a, b)),
@@ -1232,7 +1293,7 @@ const jitRules = {
 	[Primitive.Dot](nargs, [a, b], [as, bs]) {
 		const k1 = jitRules[Primitive.Mul](nargs, [a, b], [as, bs], {});
 		const c = k1.exp;
-		const cs = new ShapedArray(generalBroadcast(as.shape, bs.shape), c.dtype);
+		const cs = promoteAvals(as, bs);
 		return jitRules[Primitive.Reduce](nargs, [c], [cs], {
 			op: require_backend.AluOp.Add,
 			axis: [cs.ndim - 1]
@@ -1242,12 +1303,12 @@ const jitRules = {
 		const [stX, stY] = prepareConv(require_backend.ShapeTracker.fromShape(as.shape), require_backend.ShapeTracker.fromShape(bs.shape), params);
 		a = reshapeViews(a, (st) => st.compose(stX));
 		b = reshapeViews(b, (st) => st.compose(stY));
-		as = new ShapedArray(stX.shape, as.dtype);
-		bs = new ShapedArray(stY.shape, bs.dtype);
+		as = new ShapedArray(stX.shape, as.dtype, as.weakType);
+		bs = new ShapedArray(stY.shape, bs.dtype, bs.weakType);
 		return jitRules[Primitive.Dot](nargs, [a, b], [as, bs], {});
 	},
 	[Primitive.Compare]: broadcastedJit(([a, b], { op }) => aluCompare(a, b, op)),
-	[Primitive.Where]: broadcastedJit(([cond, a, b]) => require_backend.AluExp.where(cond, a, b)),
+	[Primitive.Where]: broadcastedJit(([cond, a, b]) => require_backend.AluExp.where(cond, a, b), { skipCastIdx: [0] }),
 	[Primitive.Transpose]: reshapeJit((st, { perm }) => st.permute(perm)),
 	[Primitive.Broadcast]: reshapeJit((st, { shape: shape$1, axis }) => st.broadcast(shape$1, axis)),
 	[Primitive.Reshape]: reshapeJit((st, { shape: shape$1 }) => st.reshape(shape$1)),
@@ -1260,7 +1321,7 @@ const jitRules = {
 	[Primitive.Pad]: reshapeJit((st, { width }) => st.pad(width)),
 	[Primitive.Gather](nargs, [x, ...indices], [xs, ...indicesShapes], { axis, outDim }) {
 		const axisSet = new Set(axis);
-		const indexShape = indicesShapes.map((c) => c.shape).reduce(generalBroadcast);
+		const indexShape = indicesShapes.map((c) => c.shape).reduce(require_backend.generalBroadcast);
 		const finalShape = xs.shape.filter((_, i) => !axisSet.has(i));
 		finalShape.splice(outDim, 0, ...indexShape);
 		const idxAll = require_backend.unravelAlu(finalShape, require_backend.AluVar.gidx);
@@ -1296,9 +1357,10 @@ function splitGraphDataflow(backend, jaxpr) {
 		Primitive.Conv,
 		Primitive.PoolTranspose
 	];
+	const heterogeneousViewPrimitives = [Primitive.Gather, Primitive.RandomBits];
 	for (let i = jaxpr.eqns.length - 1; i >= 0; i--) {
 		const eqn = jaxpr.eqns[i];
-		if (reducePrimitives.includes(eqn.primitive) || eqn.primitive === Primitive.Gather || eqn.outBinders.some((v) => blackNodes.has(v))) {
+		if (reducePrimitives.includes(eqn.primitive) || heterogeneousViewPrimitives.includes(eqn.primitive) || eqn.outBinders.some((v) => blackNodes.has(v))) {
 			for (const v of eqn.outBinders) {
 				blackNodes.add(v);
 				p1NextBlack.set(v, v);
@@ -1417,7 +1479,7 @@ var PendingExecute = class {
 /**
 * A multidimensional numeric array with data stored on CPU or GPU.
 *
-* This is the library's core data type. Equivalent to `jnp.Array` from JAX, or
+* This is the library's core data type. Equivalent to `jax.Array` from JAX, or
 * `torch.Tensor`.
 *
 * Not to be confused with the JavaScript "Array" constructor. Avoid importing
@@ -1428,9 +1490,11 @@ var Array$1 = class Array$1 extends Tracer {
 	static #nextId = 1001;
 	id;
 	#dtype;
+	#weakType;
 	#source;
 	#st;
 	#backend;
+	#committed;
 	#rc;
 	#pendingSet;
 	/**
@@ -1439,21 +1503,23 @@ var Array$1 = class Array$1 extends Tracer {
 	* is a backend `Slot`, this constructor _takes ownership_ of the slot. It
 	* will be freed when the array is disposed.
 	*/
-	constructor(source, st, dtype, backend, { pending = null } = {}) {
+	constructor(args) {
 		super(baseArrayTrace);
 		this.id = Array$1.#nextId++;
-		this.#dtype = dtype;
-		this.#source = source;
-		this.#st = st;
-		this.#backend = backend;
+		this.#dtype = args.dtype;
+		this.#weakType = args.weakType;
+		this.#source = args.source;
+		this.#st = args.st;
+		this.#backend = args.backend;
+		this.#committed = args.committed;
 		this.#rc = 1;
-		this.#pendingSet = new Set(pending);
+		this.#pendingSet = new Set(args.pending);
 		if (this.#pendingSet.size === 0) this.#pendingSet = null;
-		else if (source instanceof require_backend.AluExp) throw new Error("internal: AluExp source cannot have pending executes");
+		else if (this.#source instanceof require_backend.AluExp) throw new Error("internal: AluExp source cannot have pending executes");
 	}
 	/** @ignore */
 	get aval() {
-		return new ShapedArray(this.#st.shape, this.#dtype);
+		return new ShapedArray(this.#st.shape, this.#dtype, this.#weakType);
 	}
 	/** Return a simple string representation of the array's dimensions. */
 	toString() {
@@ -1465,6 +1531,18 @@ var Array$1 = class Array$1 extends Tracer {
 	#check() {
 		if (this.#rc <= 0) throw new UseAfterFreeError(this);
 	}
+	/** Construct an array, copying fields from `this`. */
+	#newArrayFrom(args) {
+		return new Array$1({
+			source: args.source ?? this.#source,
+			st: args.st ?? this.#st,
+			dtype: args.dtype ?? this.#dtype,
+			weakType: this.#weakType,
+			backend: args.backend ?? this.#backend,
+			committed: args.committed ?? this.#committed,
+			pending: args.pending ?? this.#pending ?? void 0
+		});
+	}
 	get ref() {
 		this.#check();
 		this.#rc++;
@@ -1504,7 +1582,10 @@ var Array$1 = class Array$1 extends Tracer {
 		const pending = this.#pending;
 		for (const exe of pending) exe.updateRc(1);
 		if (typeof this.#source === "number") this.#backend.incRef(this.#source);
-		const ar = new Array$1(this.#source, st, this.#dtype, this.#backend, { pending });
+		const ar = this.#newArrayFrom({
+			st,
+			pending
+		});
 		this.dispose();
 		return ar;
 	}
@@ -1514,9 +1595,10 @@ var Array$1 = class Array$1 extends Tracer {
 	*/
 	#gather(indices, axis, outDim) {
 		this.#check();
-		if (indices.some((a) => a.#backend !== this.#backend)) throw new TypeError(`Gather indices must have the same backend: ${this.#backend.type}`);
 		const axisSet = new Set(axis);
 		if (axisSet.size !== axis.length) throw new TypeError("Gather axis must not have duplicates");
+		if (indices.some((a) => a.#committed && a.#backend !== this.#backend)) throw new TypeError(`Gather indices must have the same backend: ${this.#backend.type}`);
+		indices = indices.map((ar) => ar._putSync(this.#backend));
 		indices = Array$1.#broadcastArrays(indices);
 		const indexShape = indices[0].shape;
 		const finalShape = this.shape.filter((_, i) => !axisSet.has(i));
@@ -1553,7 +1635,11 @@ var Array$1 = class Array$1 extends Tracer {
 		pending.push(new PendingExecute(this.#backend, kernel, inputs, [output]));
 		this.dispose();
 		for (const ar of indices) ar.dispose();
-		return new Array$1(output, require_backend.ShapeTracker.fromShape(finalShape), this.#dtype, this.#backend, { pending });
+		return this.#newArrayFrom({
+			source: output,
+			st: require_backend.ShapeTracker.fromShape(finalShape),
+			pending
+		});
 	}
 	/** Move axes to the rightmost dimension of the shape. */
 	#moveAxesDown(axis) {
@@ -1576,11 +1662,17 @@ var Array$1 = class Array$1 extends Tracer {
 		return this.#reshape(this.#st.permute(perm));
 	}
 	#unary(op, dtypeOutput) {
+		const weakType = !dtypeOutput && this.#weakType;
 		dtypeOutput ??= this.#dtype;
 		this.#check();
 		if (this.#source instanceof require_backend.AluExp) {
 			const exp$3 = new require_backend.AluExp(op, dtypeOutput, [this.#source]);
-			return new Array$1(exp$3.simplify(), this.#st, dtypeOutput, this.#backend);
+			this.dispose();
+			return this.#newArrayFrom({
+				source: exp$3.simplify(),
+				dtype: dtypeOutput,
+				weakType
+			});
 		}
 		const indices = require_backend.unravelAlu(this.#st.shape, require_backend.AluVar.gidx);
 		const exp$2 = new require_backend.AluExp(op, dtypeOutput, [require_backend.AluExp.globalView(this.#dtype, 0, this.#st, indices)]);
@@ -1590,41 +1682,67 @@ var Array$1 = class Array$1 extends Tracer {
 		for (const exe of pending) exe.updateRc(1);
 		pending.push(new PendingExecute(this.#backend, kernel, [this.#source], [output]));
 		this.dispose();
-		return new Array$1(output, require_backend.ShapeTracker.fromShape(this.shape), dtypeOutput, this.#backend, { pending });
+		return this.#newArrayFrom({
+			source: output,
+			st: require_backend.ShapeTracker.fromShape(this.shape),
+			dtype: dtypeOutput,
+			weakType,
+			pending
+		});
 	}
 	#binary(op, other) {
-		const custom = (src) => new require_backend.AluExp(op, this.#dtype, src);
+		const custom = (src) => new require_backend.AluExp(op, src[0].dtype, src);
 		return Array$1.#naryCustom(op, custom, [this, other]);
 	}
-	static #naryCustom(name, custom, arrays, { dtypeOverride, dtypeOutput, reduceAxis } = {}) {
+	static #naryCustom(name, custom, arrays, { dtypeOverride, strongTypeOutput, reduceAxis } = {}) {
 		const n = arrays.length;
-		const backend = arrays[0].#backend;
 		if (n === 0) throw new TypeError(`No inputs for ${name}`);
 		for (const ar of arrays) ar.#check();
-		let dtype;
-		for (let i = 0; i < n; i++) {
-			if (dtypeOverride?.[i]) {
-				if (arrays[i].#dtype !== dtypeOverride[i]) throw new TypeError(`Wrong dtype in ${name}: expected ${dtypeOverride[i]}, got ${arrays[i].#dtype}`);
-			} else if (!dtype) dtype = arrays[i].#dtype;
-			else if (arrays[i].#dtype !== dtype) throw new TypeError(`Dtype mismatch in ${name}: ${dtype} vs ${arrays[i].#dtype}`);
-			if (arrays[i].#backend !== backend) throw new TypeError(`Backend mismatch in ${name}: ${backend.type} vs ${arrays[i].#backend.type}`);
-		}
-		dtypeOutput ??= dtype;
-		if (!dtypeOutput) throw new TypeError("nary operation with no dtype");
+		let castDtype;
+		let castWeakType = true;
+		for (let i = 0; i < n; i++) if (dtypeOverride?.[i]) {
+			if (arrays[i].#dtype !== dtypeOverride[i]) throw new TypeError(`Wrong dtype in ${name}: expected ${dtypeOverride[i]}, got ${arrays[i].#dtype}`);
+		} else if (castDtype === void 0) {
+			castDtype = arrays[i].#dtype;
+			castWeakType = arrays[i].#weakType;
+		} else ({dtype: castDtype, weakType: castWeakType} = promoteAvals(new ShapedArray([], castDtype, castWeakType), new ShapedArray([], arrays[i].#dtype, arrays[i].#weakType)));
+		const weakType = castWeakType && !strongTypeOutput;
+		const { backend, committed } = Array$1.#computeBackend(name, arrays);
+		arrays = arrays.map((ar) => ar._putSync(backend));
 		arrays = Array$1.#broadcastArrays(arrays);
 		const newShape = [...arrays[0].shape];
 		if (arrays.every((ar) => ar.#source instanceof require_backend.AluExp) && !reduceAxis) {
+			const sources = arrays.map((ar, i) => {
+				if (!dtypeOverride?.[i]) return require_backend.AluExp.cast(castDtype, ar.#source);
+				else return ar.#source;
+			});
 			if (arrays.every((ar) => require_backend.deepEqual(ar.#st, arrays[0].#st))) {
-				const exp$4 = custom(arrays.map((ar) => ar.#source));
-				return new Array$1(exp$4.simplify(), arrays[0].#st, exp$4.dtype, backend);
+				const exp$4 = custom(sources);
+				arrays.forEach((ar) => ar.dispose());
+				return new Array$1({
+					source: exp$4.simplify(),
+					st: arrays[0].#st,
+					dtype: exp$4.dtype,
+					weakType,
+					backend,
+					committed
+				});
 			}
-			const exp$3 = custom(arrays.map((ar) => {
-				const src$1 = ar.#source;
+			const exp$3 = custom(arrays.map((ar, i) => {
+				const src$1 = sources[i];
 				if (ar.#st.contiguous) return src$1;
 				return require_backend.accessorAluExp(src$1, ar.#st, require_backend.unravelAlu(newShape, require_backend.AluVar.idx));
 			}));
 			const st = require_backend.ShapeTracker.fromShape(newShape);
-			return new Array$1(exp$3.simplify(), st, exp$3.dtype, backend);
+			arrays.forEach((ar) => ar.dispose());
+			return new Array$1({
+				source: exp$3.simplify(),
+				st,
+				dtype: exp$3.dtype,
+				weakType,
+				backend,
+				committed
+			});
 		}
 		let indices;
 		if (!reduceAxis) indices = require_backend.unravelAlu(newShape, require_backend.AluVar.gidx);
@@ -1634,14 +1752,19 @@ var Array$1 = class Array$1 extends Tracer {
 		}
 		const inputs = [];
 		const src = [];
-		for (const ar of arrays) if (ar.#source instanceof require_backend.AluExp) src.push(require_backend.accessorAluExp(ar.#source, ar.#st, indices));
-		else {
-			let gid = inputs.indexOf(ar.#source);
-			if (gid === -1) {
-				gid = inputs.length;
-				inputs.push(ar.#source);
+		for (const [i, ar] of arrays.entries()) {
+			let nextSrc;
+			if (ar.#source instanceof require_backend.AluExp) nextSrc = require_backend.accessorAluExp(ar.#source, ar.#st, indices);
+			else {
+				let gid = inputs.indexOf(ar.#source);
+				if (gid === -1) {
+					gid = inputs.length;
+					inputs.push(ar.#source);
+				}
+				nextSrc = require_backend.AluExp.globalView(ar.#dtype, gid, ar.#st, indices);
 			}
-			src.push(require_backend.AluExp.globalView(ar.#dtype, gid, ar.#st, indices));
+			if (!dtypeOverride?.[i]) nextSrc = require_backend.AluExp.cast(castDtype, nextSrc);
+			src.push(nextSrc);
 		}
 		const exp$2 = custom(src);
 		let re = void 0;
@@ -1654,13 +1777,19 @@ var Array$1 = class Array$1 extends Tracer {
 		const pending = new Set([...arrays.flatMap((ar) => ar.#pending)]);
 		for (const exe of pending) exe.updateRc(1);
 		pending.add(new PendingExecute(backend, kernel, inputs, [output]));
-		for (const ar of arrays) ar.dispose();
-		return new Array$1(output, require_backend.ShapeTracker.fromShape(newShape), dtypeOutput, backend, { pending });
+		arrays.forEach((ar) => ar.dispose());
+		return new Array$1({
+			source: output,
+			st: require_backend.ShapeTracker.fromShape(newShape),
+			dtype: kernel.dtype,
+			weakType,
+			backend,
+			committed,
+			pending
+		});
 	}
 	/** Reduce the last dimension of the array by an operation. */
 	#reduce(op) {
-		this.#check();
-		if (this.ndim === 0) throw new Error("Cannot reduce a scalar");
 		const shape$1 = this.shape;
 		const reduction = new require_backend.Reduction(this.#dtype, op, shape$1[shape$1.length - 1]);
 		const newShape = shape$1.slice(0, -1);
@@ -1679,7 +1808,11 @@ var Array$1 = class Array$1 extends Tracer {
 		for (const exe of pending) exe.updateRc(1);
 		pending.push(new PendingExecute(this.#backend, kernel, inputs, [output]));
 		this.dispose();
-		return new Array$1(output, require_backend.ShapeTracker.fromShape(newShape), this.#dtype, this.#backend, { pending });
+		return this.#newArrayFrom({
+			source: output,
+			st: require_backend.ShapeTracker.fromShape(newShape),
+			pending
+		});
 	}
 	/**
 	* Normalizes this array into one backed by a `Slot`.
@@ -1715,20 +1848,37 @@ var Array$1 = class Array$1 extends Tracer {
 	}
 	#dataInline() {
 		this.#check();
-		const exp$2 = this.#source;
-		const ar = new Array$1(exp$2, this.#st, this.dtype, require_backend.getBackend("cpu"));
+		if (!(this.#source instanceof require_backend.AluExp)) throw new Error("internal: #dataInline called on non-AluExp source");
+		const ar = this.#newArrayFrom({ backend: require_backend.getBackend("cpu") });
 		this.dispose();
 		return ar.dataSync();
 	}
 	static #broadcastArrays(arrays) {
 		if (arrays.length === 0) throw new Error("Need at least one array to broadcast");
 		if (arrays.length === 1) return arrays;
-		const newShape = arrays.map((a) => a.shape).reduce(generalBroadcast);
+		const newShape = arrays.map((a) => a.shape).reduce(require_backend.generalBroadcast);
 		return arrays.map((ar) => {
 			if (require_backend.deepEqual(ar.shape, newShape)) return ar;
 			return ar.#reshape(ar.#st.broadcast(newShape, require_backend.range(newShape.length - ar.ndim)));
 		});
 	}
+	static #computeBackend(name, arrays) {
+		const committed = arrays.filter((ar) => ar.#committed);
+		if (committed.length > 0) {
+			const backend = committed[0].#backend;
+			for (const ar of committed) if (ar.#backend !== backend) throw new Error(`Device mismatch in ${name} between committed arrays on (${backend.type}, ${ar.#backend.type}), please move to the same device with devicePut()`);
+			return {
+				backend,
+				committed: true
+			};
+		} else {
+			const backend = arrays.length > 0 ? arrays[0].#backend : require_backend.getBackend();
+			return {
+				backend,
+				committed: false
+			};
+		}
+	}
 	/** Realize the array and return it as data. */
 	async data() {
 		if (this.#source instanceof require_backend.AluExp && this.size < inlineArrayLimit && this.device !== "cpu") return this.#dataInline();
@@ -1842,14 +1992,18 @@ var Array$1 = class Array$1 extends Tracer {
 					x.#backend.incRef(x.#source);
 					const pending = x.#pending;
 					for (const exe of pending) exe.updateRc(1);
-					const y = new Array$1(x.#source, x.#st, dtype, x.#backend, { pending });
+					const y = x.#newArrayFrom({
+						dtype,
+						weakType: false,
+						pending
+					});
 					x.dispose();
 					return [y];
 				}
 			},
 			[Primitive.RandomBits]([k0, k1], { shape: shape$1, mode }) {
-				const keyShape = generalBroadcast(k0.shape, k1.shape);
-				if (!require_backend.deepEqual(generalBroadcast(keyShape, shape$1), shape$1)) throw new TypeError(`Keys of shapes ${k0.shape} and ${k1.shape} cannot be broadcast to shape ${shape$1}`);
+				const keyShape = require_backend.generalBroadcast(k0.shape, k1.shape);
+				if (!require_backend.deepEqual(require_backend.generalBroadcast(keyShape, shape$1), shape$1)) throw new TypeError(`Keys of shapes ${k0.shape} and ${k1.shape} cannot be broadcast to shape ${shape$1}`);
 				const c0 = zeros(shape$1, {
 					dtype: require_backend.DType.Uint32,
 					device: k0.device
@@ -1884,6 +2038,12 @@ var Array$1 = class Array$1 extends Tracer {
 			[Primitive.Log]([x]) {
 				return [x.#unary(require_backend.AluOp.Log)];
 			},
+			[Primitive.Erf]([x]) {
+				return [x.#unary(require_backend.AluOp.Erf)];
+			},
+			[Primitive.Erfc]([x]) {
+				return [x.#unary(require_backend.AluOp.Erfc)];
+			},
 			[Primitive.Sqrt]([x]) {
 				return [x.#unary(require_backend.AluOp.Sqrt)];
 			},
@@ -1917,7 +2077,7 @@ var Array$1 = class Array$1 extends Tracer {
 			},
 			[Primitive.Compare]([x, y], { op }) {
 				const custom = ([x$1, y$1]) => aluCompare(x$1, y$1, op);
-				return [Array$1.#naryCustom("compare", custom, [x, y], { dtypeOutput: require_backend.DType.Bool })];
+				return [Array$1.#naryCustom("compare", custom, [x, y], { strongTypeOutput: true })];
 			},
 			[Primitive.Where]([cond, x, y]) {
 				const custom = ([cond$1, x$1, y$1]) => require_backend.AluExp.where(cond$1, x$1, y$1);
@@ -1952,7 +2112,8 @@ var Array$1 = class Array$1 extends Tracer {
 			},
 			[Primitive.JitCall](args, { jaxpr, numConsts }) {
 				if (jaxpr.inBinders.length !== args.length) throw new Error(`jit_call expects ${jaxpr.inBinders.length} args, got ${args.length}`);
-				const backend = require_backend.getBackend();
+				const { backend, committed } = Array$1.#computeBackend("jit_call", args);
+				args = args.map((ar) => ar._putSync(backend));
 				const consts = args.slice(0, numConsts);
 				const tracers = args.slice(numConsts);
 				const jp = jitCompile(backend, jaxpr, consts);
@@ -1963,43 +2124,66 @@ var Array$1 = class Array$1 extends Tracer {
 				pending.splice(0, 0, ...prevPending);
 				args.forEach((x) => x.dispose());
 				return outputs.map((source, i) => {
-					return new Array$1(source, require_backend.ShapeTracker.fromShape(jaxpr.outs[i].aval.shape), jaxpr.outs[i].aval.dtype, backend, { pending });
+					return new Array$1({
+						source,
+						st: require_backend.ShapeTracker.fromShape(jaxpr.outs[i].aval.shape),
+						dtype: jaxpr.outs[i].aval.dtype,
+						weakType: jaxpr.outs[i].aval.weakType,
+						backend,
+						committed,
+						pending
+					});
 				});
 			}
 		};
 	}
+	/** @private */
 	_realizeSource() {
 		this.#realize();
 		return this.#source;
 	}
+	/** @private Put this array on a new backend, asynchronously. */
+	async _put(backend) {
+		if (this.#backend === backend) return this;
+		if (this.#source instanceof require_backend.AluExp) {
+			const ar = this.#newArrayFrom({
+				backend,
+				committed: true
+			});
+			this.dispose();
+			return ar;
+		} else {
+			const data = await this.data();
+			return arrayFromData(data, this.shape, {
+				dtype: this.#dtype,
+				device: backend.type
+			}, this.#weakType);
+		}
+	}
+	/** @private Put this array on a new backend, synchronously. */
+	_putSync(backend) {
+		if (this.#backend === backend) return this;
+		if (this.#source instanceof require_backend.AluExp) {
+			const ar = this.#newArrayFrom({
+				backend,
+				committed: true
+			});
+			this.dispose();
+			return ar;
+		} else {
+			const data = this.dataSync();
+			return arrayFromData(data, this.shape, {
+				dtype: this.#dtype,
+				device: backend.type
+			}, this.#weakType);
+		}
+	}
 };
-/** Construct an array from a single scalar constant. */
-function scalar(value, { dtype, device } = {}) {
-	if (typeof value === "number") {
-		dtype ??= require_backend.DType.Float32;
-		if (![
-			require_backend.DType.Float32,
-			require_backend.DType.Float16,
-			require_backend.DType.Int32,
-			require_backend.DType.Uint32
-		].includes(dtype)) throw new TypeError(`Mismatched dtype for scalar ${value}`);
-	} else if (typeof value === "boolean") {
-		dtype ??= require_backend.DType.Bool;
-		if (![
-			require_backend.DType.Float32,
-			require_backend.DType.Float16,
-			require_backend.DType.Int32,
-			require_backend.DType.Uint32,
-			require_backend.DType.Bool
-		].includes(dtype)) throw new TypeError(`Mismatched dtype for scalar ${value}`);
-	} else throw new TypeError(`Invalid type for scalar ${value}`);
-	return new Array$1(require_backend.AluExp.const(dtype, value), require_backend.ShapeTracker.fromShape([]), dtype, require_backend.getBackend(device));
-}
 /** Constructor for creating a new array from data. */
 function array(values, { shape: shape$1, dtype, device } = {}) {
 	if (values instanceof Tracer) {
 		if (shape$1 && !require_backend.deepEqual(values.shape, shape$1)) values = values.reshape(shape$1);
-		if (dtype && values.dtype !== dtype) throw new Error("array astype not implemented yet");
+		if (dtype && values.dtype !== dtype) values = values.astype(dtype);
 		return values;
 	} else if (ArrayBuffer.isView(values)) return arrayFromData(values, shape$1 ?? [values.length], {
 		dtype,
@@ -2021,6 +2205,10 @@ function array(values, { shape: shape$1, dtype, device } = {}) {
 			dtype,
 			device
 		});
+		if (size$1 === 1) return full(shape$1, flat[0], {
+			dtype,
+			device
+		});
 		if (typeof flat[0] === "boolean") {
 			dtype = dtype ?? require_backend.DType.Bool;
 			const data = new Int32Array(flat.map((x) => x ? 1 : 0));
@@ -2029,46 +2217,52 @@ function array(values, { shape: shape$1, dtype, device } = {}) {
 				device
 			});
 		} else {
+			const weakType = dtype == void 0;
 			dtype = dtype ?? require_backend.DType.Float32;
 			const data = require_backend.dtypedJsArray(dtype, flat);
 			return arrayFromData(data, shape$1, {
 				dtype,
 				device
-			});
+			}, weakType);
 		}
 	}
 }
-function arrayFromData(data, shape$1, { dtype, device } = {}) {
+function arrayFromData(data, shape$1, { dtype, device }, weakType = false) {
+	if (data instanceof Float32Array) {
+		if (dtype && dtype !== require_backend.DType.Float32) throw new Error("Float32Array must have float32 type");
+		dtype ??= require_backend.DType.Float32;
+	} else if (data instanceof Int32Array) {
+		if (dtype && dtype !== require_backend.DType.Int32 && dtype !== require_backend.DType.Bool) throw new Error("Int32Array must have int32 or bool type");
+		dtype ??= require_backend.DType.Int32;
+	} else if (data instanceof Uint32Array) {
+		if (dtype && dtype !== require_backend.DType.Uint32) throw new Error("Uint32Array must have uint32 type");
+		dtype ??= require_backend.DType.Uint32;
+	} else if (data instanceof Float16Array) {
+		if (dtype && dtype !== require_backend.DType.Float16) throw new Error("Float16Array must have float16 type");
+		dtype ??= require_backend.DType.Float16;
+	} else throw new Error("Unsupported data array type: " + data.constructor.name);
 	if (data.length < inlineArrayLimit) {
 		let allEqual = true;
 		for (let i = 1; i < data.length; i++) if (data[i] !== data[0]) {
 			allEqual = false;
 			break;
 		}
-		if (allEqual) return full(shape$1, data[0], {
-			dtype,
-			device
-		});
+		if (allEqual) {
+			const sa = new ShapedArray(shape$1, dtype, weakType);
+			return fullInternal(sa, data[0], device);
+		}
 	}
 	const backend = require_backend.getBackend(device);
-	if (ArrayBuffer.isView(data)) {
-		const buf = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-		if (data instanceof Float32Array) {
-			if (dtype && dtype !== require_backend.DType.Float32) throw new Error("Float32Array must have float32 type");
-			dtype ??= require_backend.DType.Float32;
-		} else if (data instanceof Int32Array) {
-			if (dtype && dtype !== require_backend.DType.Int32 && dtype !== require_backend.DType.Bool) throw new Error("Int32Array must have int32 or bool type");
-			dtype ??= require_backend.DType.Int32;
-		} else if (data instanceof Uint32Array) {
-			if (dtype && dtype !== require_backend.DType.Uint32) throw new Error("Uint32Array must have uint32 type");
-			dtype ??= require_backend.DType.Uint32;
-		} else if (data instanceof Float16Array) {
-			if (dtype && dtype !== require_backend.DType.Float16) throw new Error("Float16Array must have float16 type");
-			dtype ??= require_backend.DType.Float16;
-		} else throw new Error("Unsupported data array type: " + data.constructor.name);
-		const slot = backend.malloc(data.byteLength, buf);
-		return new Array$1(slot, require_backend.ShapeTracker.fromShape(shape$1), dtype, backend);
-	} else throw new Error("Unsupported data type: " + data.constructor.name);
+	const buf = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	const slot = backend.malloc(data.byteLength, buf);
+	return new Array$1({
+		source: slot,
+		st: require_backend.ShapeTracker.fromShape(shape$1),
+		dtype,
+		weakType,
+		backend,
+		committed: device != void 0
+	});
 }
 function dataToJs(dtype, data, shape$1) {
 	if (shape$1.length === 0) return dtype === require_backend.DType.Bool ? Boolean(data[0]) : data[0];
@@ -2084,7 +2278,7 @@ function dataToJs(dtype, data, shape$1) {
 /** If x is a value, lift it into an array, otherwise leave it be. */
 function pureArray(x) {
 	if (x instanceof Tracer) return x;
-	else return scalar(x);
+	else return array(x);
 }
 var EvalTrace = class extends Trace {
 	pure = (x) => pureArray(x);
@@ -2095,20 +2289,28 @@ var EvalTrace = class extends Trace {
 };
 const baseArrayTrace = new EvalTrace(newMain(EvalTrace, null));
 const implRules = Array$1._implRules();
+function fullInternal(aval, fillValue, device) {
+	return new Array$1({
+		source: require_backend.AluExp.const(aval.dtype, fillValue),
+		st: require_backend.ShapeTracker.fromShape(aval.shape),
+		dtype: aval.dtype,
+		weakType: aval.weakType,
+		backend: require_backend.getBackend(device),
+		committed: device != void 0
+	});
+}
 function zerosLike$1(val, dtype) {
-	const aval = getAval(val);
-	if (val instanceof Tracer) val.dispose();
-	return zeros(aval.shape, { dtype: dtype ?? aval.dtype });
+	return fullLike(val, 0, dtype);
 }
 function onesLike$1(val, dtype) {
-	const aval = getAval(val);
-	if (val instanceof Tracer) val.dispose();
-	return ones(aval.shape, { dtype: dtype ?? aval.dtype });
+	return fullLike(val, 1, dtype);
 }
 function fullLike(val, fillValue, dtype) {
 	const aval = getAval(val);
 	if (val instanceof Tracer) val.dispose();
-	return full(aval.shape, fillValue, { dtype: dtype ?? aval.dtype });
+	if (fillValue instanceof Tracer) throw new Error("numpy.fullLike() with array argument not implemented yet");
+	const sa = new ShapedArray(aval.shape, dtype ?? aval.dtype, aval.weakType);
+	return fullInternal(sa, fillValue);
 }
 /** Return a new array of given shape and type, filled with zeros. */
 function zeros(shape$1, { dtype, device } = {}) {
@@ -2126,19 +2328,14 @@ function ones(shape$1, { dtype, device } = {}) {
 }
 /** Return a new array of given shape and type, filled with `fill_value`. */
 function full(shape$1, fillValue, { dtype, device } = {}) {
-	let source;
-	if (typeof fillValue === "number") {
-		dtype = dtype ?? require_backend.DType.Float32;
-		source = require_backend.AluExp.const(dtype, fillValue);
-	} else if (typeof fillValue === "bigint") {
-		dtype = dtype ?? require_backend.DType.Int32;
-		source = require_backend.AluExp.const(dtype, Number(fillValue));
-	} else if (typeof fillValue === "boolean") {
+	let weakType = dtype == void 0;
+	if (typeof fillValue === "number") dtype = dtype ?? require_backend.DType.Float32;
+	else if (typeof fillValue === "boolean") {
 		dtype = dtype ?? require_backend.DType.Bool;
-		source = require_backend.AluExp.const(dtype, fillValue ? 1 : 0);
+		weakType = false;
 	} else if (fillValue instanceof Tracer) throw new Error("numpy.full() with array argument not implemented yet");
 	else throw new TypeError(`Invalid type for full: ${fillValue}`);
-	return new Array$1(source, require_backend.ShapeTracker.fromShape(shape$1), dtype ?? require_backend.DType.Float32, require_backend.getBackend(device));
+	return fullInternal(new ShapedArray(shape$1, dtype, weakType), fillValue, device);
 }
 /**
 * Create an identity matrix.
@@ -2148,6 +2345,7 @@ function full(shape$1, fillValue, { dtype, device } = {}) {
 */
 function eye(numRows, numCols, { dtype, device } = {}) {
 	numCols = numCols ?? numRows;
+	const weakType = dtype == void 0;
 	dtype = dtype ?? require_backend.DType.Float32;
 	if (numCols < numRows) {
 		const arr = eye(numCols, numRows, {
@@ -2161,7 +2359,14 @@ function eye(numRows, numCols, { dtype, device } = {}) {
 		device
 	});
 	const exp$2 = require_backend.AluExp.cmplt(require_backend.AluExp.mod(require_backend.AluVar.idx, require_backend.AluExp.i32(numCols + 1)), require_backend.AluExp.i32(1));
-	return new Array$1(require_backend.AluExp.cast(dtype, exp$2), require_backend.ShapeTracker.fromShape([numRows, numCols]), dtype, require_backend.getBackend(device));
+	return new Array$1({
+		source: require_backend.AluExp.cast(dtype, exp$2),
+		st: require_backend.ShapeTracker.fromShape([numRows, numCols]),
+		dtype,
+		weakType,
+		backend: require_backend.getBackend(device),
+		committed: device != void 0
+	});
 }
 /** Return the identity matrix, with ones on the main diagonal. */
 function identity$1(n, { dtype, device } = {}) {
@@ -2198,7 +2403,14 @@ function arange(start, stop, step = 1, { dtype, device } = {}) {
 	});
 	const exp$2 = require_backend.AluExp.add(require_backend.AluExp.const(dtype, start), require_backend.AluExp.mul(require_backend.AluExp.cast(dtype, require_backend.AluVar.idx), require_backend.AluExp.const(dtype, step)));
 	const st = require_backend.ShapeTracker.fromShape([size$1]);
-	return new Array$1(exp$2, st, dtype, require_backend.getBackend(device));
+	return new Array$1({
+		source: exp$2,
+		st,
+		dtype,
+		weakType: false,
+		backend: require_backend.getBackend(device),
+		committed: device != void 0
+	});
 }
 /**
 * Return evenly spaced numbers over a specified interval.
@@ -2216,10 +2428,10 @@ function linspace(start, stop, num = 50, endpoint = true, { dtype, device } = {}
 		dtype,
 		device
 	});
-	else if (num === 1) return scalar(start, {
+	else if (num === 1) return full([1], start, {
 		dtype,
 		device
-	}).reshape([1]);
+	});
 	else if (start === stop) return full([num], start, {
 		dtype,
 		device
@@ -2228,7 +2440,14 @@ function linspace(start, stop, num = 50, endpoint = true, { dtype, device } = {}
 	const denom = endpoint ? num - 1 : num;
 	const exp$2 = require_backend.AluExp.cast(dtype, require_backend.AluExp.add(require_backend.AluExp.f32(start), require_backend.AluExp.mul(require_backend.AluExp.f32(delta / denom), require_backend.AluExp.cast(require_backend.DType.Float32, require_backend.AluVar.idx))));
 	const st = require_backend.ShapeTracker.fromShape([num]);
-	return new Array$1(exp$2, st, dtype, require_backend.getBackend(device));
+	return new Array$1({
+		source: exp$2,
+		st,
+		dtype,
+		weakType: false,
+		backend: require_backend.getBackend(device),
+		committed: device != void 0
+	});
 }
 function aluCompare(a, b, op) {
 	switch (op) {
@@ -2240,35 +2459,6 @@ function aluCompare(a, b, op) {
 		case CompareOp.LessEqual: return require_backend.AluExp.add(require_backend.AluExp.cmplt(a, b), require_backend.AluExp.cmpne(a, b).not());
 	}
 }
-/**
-* Implements a NumPy-style generalized broadcast rule on two array shapes.
-*
-* "When operating on two arrays, NumPy compares their shapes element-wise. It
-* starts with the trailing (i.e. rightmost) dimension and works its way left.
-* Two dimensions are compatible when:
-*   1. they are equal, or
-*   2. one of them is 1."
-*
-* Throws a TypeError if the broadcast is not possible.
-*
-* <https://numpy.org/doc/stable/user/basics.broadcasting.html#general-broadcasting-rules>
-*/
-function generalBroadcast(a, b) {
-	const out = [];
-	let i = a.length - 1;
-	let j = b.length - 1;
-	for (; i >= 0 && j >= 0; i--, j--) {
-		const x = a[i];
-		const y = b[j];
-		if (x === y) out.push(x);
-		else if (x === 1) out.push(y);
-		else if (y === 1) out.push(x);
-		else throw new TypeError(`Incompatible array broadcast shapes: ${a} vs ${b}`);
-	}
-	for (; i >= 0; i--) out.push(a[i]);
-	for (; j >= 0; j--) out.push(b[j]);
-	return out.reverse();
-}
 
 //#endregion
 //#region node_modules/.pnpm/@oxc-project+runtime@0.78.0/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js
@@ -2348,13 +2538,15 @@ var Var = class Var {
 };
 /** Literal in a Jaxpr expression. Currently, only scalars are supported. */
 var Lit = class {
-	dtype;
 	value;
 	aval;
-	constructor(dtype, value) {
-		this.dtype = dtype;
+	get dtype() {
+		return this.aval.dtype;
+	}
+	constructor(aval, value) {
+		if (aval.shape.length !== 0) throw new Error(`internal: Lit must be a scalar`);
 		this.value = value;
-		this.aval = new ShapedArray([], dtype);
+		this.aval = ShapedArray.fromAval(aval);
 	}
 };
 function atomIsLit(atom, literal) {
@@ -2478,14 +2670,19 @@ var Jaxpr = class Jaxpr {
 				const c = eqn.outBinders[0];
 				if (atomIsLit(a, 0)) context.set(c, b);
 				else if (atomIsLit(b, 0)) context.set(c, a);
-				else if (atomIsLit(a) && atomIsLit(b)) context.set(c, new Lit(a.dtype, a.dtype === require_backend.DType.Bool ? Math.min(a.value + b.value, 1) : a.value + b.value));
+				else if (atomIsLit(a) && atomIsLit(b)) context.set(c, new Lit(promoteAvals(a.aval, b.aval), a.dtype === require_backend.DType.Bool ? Math.min(a.value + b.value, 1) : a.value + b.value));
+				else newEqns.push(eqn);
+			} else if (eqn.primitive === Primitive.Neg) {
+				const [a] = inputs;
+				const c = eqn.outBinders[0];
+				if (atomIsLit(a)) context.set(c, new Lit(a.aval, -a.value));
 				else newEqns.push(eqn);
 			} else if (eqn.primitive === Primitive.Mul) {
 				const [a, b] = inputs;
 				const c = eqn.outBinders[0];
 				if (atomIsLit(a, 1)) context.set(c, b);
 				else if (atomIsLit(b, 1)) context.set(c, a);
-				else if (atomIsLit(a) && atomIsLit(b)) context.set(c, new Lit(a.dtype, a.value * b.value));
+				else if (atomIsLit(a) && atomIsLit(b)) context.set(c, new Lit(promoteAvals(a.aval, b.aval), a.value * b.value));
 				else newEqns.push(eqn);
 			} else if (eqn.primitive === Primitive.Idiv) {
 				const [a, b] = inputs;
@@ -2583,7 +2780,7 @@ function evalJaxpr(jaxpr, args) {
 		if (x instanceof Var) {
 			remainingRefs.set(x, (remainingRefs.get(x) ?? 0) - 1);
 			return env.get(x);
-		} else return scalar(x.value, { dtype: x.dtype });
+		} else return array(x.value, { dtype: x.dtype });
 	};
 	const write = (v, val) => {
 		if (env.has(v)) throw new Error(`Variable already bound: ${v}`);
@@ -2642,7 +2839,7 @@ var JaxprTrace = class extends Trace {
 		let tracer = this.builder.constTracers.get(val);
 		if (tracer === void 0) {
 			tracer = this.builder.newTracer(this, ShapedArray.fromAval(getAval(val)));
-			this.builder.addConst(tracer, val instanceof Tracer ? val.ref : scalar(val));
+			this.builder.addConst(tracer, val instanceof Tracer ? val.ref : array(val));
 		}
 		return tracer;
 	}
@@ -2711,7 +2908,7 @@ function _inlineLiterals(jaxpr, consts) {
 	const newConsts = [];
 	for (let i = 0; i < consts.length; i++) if (ndim$1(consts[i]) === 0 && consts[i] instanceof Array$1) {
 		const ar = consts[i];
-		literals.set(jaxpr.inBinders[i], new Lit(ar.dtype, ar.dataSync()[0]));
+		literals.set(jaxpr.inBinders[i], new Lit(ar.aval, ar.dataSync()[0]));
 	} else {
 		constBinders.push(jaxpr.inBinders[i]);
 		newConsts.push(consts[i]);
@@ -2724,13 +2921,12 @@ function _inlineLiterals(jaxpr, consts) {
 }
 function binopAbstractEval([x, y]) {
 	if (!(x instanceof ShapedArray) || !(y instanceof ShapedArray)) throw new TypeError("binopAbstractEval expects ShapedArray inputs");
-	if (x.dtype !== y.dtype) throw new TypeError(`Mismatched dtypes: ${x.dtype} vs ${y.dtype}`);
-	return [new ShapedArray(generalBroadcast(x.shape, y.shape), x.dtype)];
+	return [promoteAvals(x, y)];
 }
 function compareAbstractEval([x, y]) {
 	if (!(x instanceof ShapedArray) || !(y instanceof ShapedArray)) throw new TypeError("compareAbstractEval expects ShapedArray inputs");
-	if (x.dtype !== y.dtype) throw new TypeError(`Mismatched dtypes: ${x.dtype} vs ${y.dtype}`);
-	return [new ShapedArray(generalBroadcast(x.shape, y.shape), require_backend.DType.Bool)];
+	const aval = promoteAvals(x, y);
+	return [new ShapedArray(aval.shape, require_backend.DType.Bool, false)];
 }
 function vectorizedUnopAbstractEval([x]) {
 	return [ShapedArray.fromAval(x)];
@@ -2743,18 +2939,18 @@ const abstractEvalRules = {
 	[Primitive.Reciprocal]: vectorizedUnopAbstractEval,
 	[Primitive.StopGradient]: vectorizedUnopAbstractEval,
 	[Primitive.Cast]([x], { dtype }) {
-		return [new ShapedArray(x.shape, dtype)];
+		return [new ShapedArray(x.shape, dtype, false)];
 	},
 	[Primitive.Bitcast]([x], { dtype }) {
 		if (x.dtype === require_backend.DType.Bool || dtype === require_backend.DType.Bool) throw new TypeError("Bitcast to/from bool is not allowed");
 		if (require_backend.byteWidth(x.dtype) !== require_backend.byteWidth(dtype)) throw new TypeError(`Bitcast from ${x.dtype} to ${dtype} with different byte width`);
-		return [new ShapedArray(x.shape, dtype)];
+		return [new ShapedArray(x.shape, dtype, false)];
 	},
 	[Primitive.RandomBits]([k0, k1], { shape: shape$1 }) {
 		if (k0.dtype !== require_backend.DType.Uint32 || k1.dtype !== require_backend.DType.Uint32) throw new TypeError(`RandomBits requires uint32 keys, got ${k0.dtype} and ${k1.dtype}`);
-		const keyShape = generalBroadcast(k0.shape, k1.shape);
-		if (!require_backend.deepEqual(generalBroadcast(keyShape, shape$1), shape$1)) throw new TypeError(`Keys of shapes ${k0.shape} and ${k1.shape} cannot be broadcast to shape ${shape$1}`);
-		return [new ShapedArray(shape$1, require_backend.DType.Uint32)];
+		const keyShape = require_backend.generalBroadcast(k0.shape, k1.shape);
+		if (!require_backend.deepEqual(require_backend.generalBroadcast(keyShape, shape$1), shape$1)) throw new TypeError(`Keys of shapes ${k0.shape} and ${k1.shape} cannot be broadcast to shape ${shape$1}`);
+		return [new ShapedArray(shape$1, require_backend.DType.Uint32, false)];
 	},
 	[Primitive.Sin]: vectorizedUnopAbstractEval,
 	[Primitive.Cos]: vectorizedUnopAbstractEval,
@@ -2762,61 +2958,62 @@ const abstractEvalRules = {
 	[Primitive.Atan]: vectorizedUnopAbstractEval,
 	[Primitive.Exp]: vectorizedUnopAbstractEval,
 	[Primitive.Log]: vectorizedUnopAbstractEval,
+	[Primitive.Erf]: vectorizedUnopAbstractEval,
+	[Primitive.Erfc]: vectorizedUnopAbstractEval,
 	[Primitive.Sqrt]: vectorizedUnopAbstractEval,
 	[Primitive.Min]: binopAbstractEval,
 	[Primitive.Max]: binopAbstractEval,
 	[Primitive.Reduce]([x], { axis }) {
 		const axisSet = new Set(axis);
 		const newShape = x.shape.filter((_, i) => !axisSet.has(i));
-		return [new ShapedArray(newShape, x.dtype)];
+		return [new ShapedArray(newShape, x.dtype, x.weakType)];
 	},
 	[Primitive.Pool]([x], { window, strides }) {
 		const shape$1 = checkPoolShape(x.shape, window, strides);
-		return [new ShapedArray(shape$1, x.dtype)];
+		return [new ShapedArray(shape$1, x.dtype, x.weakType)];
 	},
 	[Primitive.PoolTranspose]([x], { inShape, window, strides }) {
 		const shape$1 = checkPoolShape(inShape, window, strides);
 		if (!require_backend.deepEqual(shape$1, x.shape)) throw new TypeError(`PoolTranspose shape mismatch: expected ${JSON.stringify(shape$1)}, got ${JSON.stringify(x.shape)}`);
-		return [new ShapedArray(inShape, x.dtype)];
+		return [new ShapedArray(inShape, x.dtype, x.weakType)];
 	},
 	[Primitive.Dot]([x, y]) {
-		if (x.dtype !== y.dtype) throw new TypeError(`Dot dtype mismatch, got ${x.dtype} vs ${y.dtype}`);
 		if (x.ndim === 0 && y.ndim === 0) throw new TypeError("Dot requires at least 1D inputs");
-		const shape$1 = generalBroadcast(x.shape, y.shape);
+		const { shape: shape$1, dtype, weakType } = promoteAvals(x, y);
 		shape$1.splice(-1, 1);
-		return [new ShapedArray(shape$1, x.dtype)];
+		return [new ShapedArray(shape$1, dtype, weakType)];
 	},
 	[Primitive.Conv]([lhs, rhs], params) {
-		if (lhs.dtype !== rhs.dtype) throw new TypeError(`Conv dtype mismatch, got ${lhs.dtype} vs ${rhs.dtype}`);
+		const { dtype, weakType } = promoteAvals(new ShapedArray([], lhs.dtype, lhs.weakType), new ShapedArray([], rhs.dtype, rhs.weakType));
 		const shape$1 = checkConvShape(lhs.shape, rhs.shape, params);
-		return [new ShapedArray(shape$1, lhs.dtype)];
+		return [new ShapedArray(shape$1, dtype, weakType)];
 	},
 	[Primitive.Compare]: compareAbstractEval,
 	[Primitive.Where]([cond, x, y]) {
 		if (cond.dtype !== require_backend.DType.Bool) throw new TypeError(`Condition must be boolean, got ${cond.dtype}`);
-		if (x.dtype !== y.dtype) throw new TypeError(`Mismatched dtypes: ${x.dtype} vs ${y.dtype}`);
-		const shape$1 = generalBroadcast(cond.shape, generalBroadcast(x.shape, y.shape));
-		return [new ShapedArray(shape$1, x.dtype)];
+		const xy = promoteAvals(x, y);
+		const shape$1 = require_backend.generalBroadcast(cond.shape, xy.shape);
+		return [new ShapedArray(shape$1, xy.dtype, xy.weakType)];
 	},
 	[Primitive.Transpose]([x], { perm }) {
-		return [new ShapedArray(perm.map((i) => x.shape[i]), x.dtype)];
+		return [new ShapedArray(perm.map((i) => x.shape[i]), x.dtype, x.weakType)];
 	},
 	[Primitive.Broadcast]([x], { shape: shape$1 }) {
-		return [new ShapedArray(shape$1, x.dtype)];
+		return [new ShapedArray(shape$1, x.dtype, x.weakType)];
 	},
 	[Primitive.Reshape]([x], { shape: shape$1 }) {
-		return [new ShapedArray(shape$1, x.dtype)];
+		return [new ShapedArray(shape$1, x.dtype, x.weakType)];
 	},
 	[Primitive.Flip]([x], _) {
-		return [new ShapedArray(x.shape, x.dtype)];
+		return [ShapedArray.fromAval(x)];
 	},
 	[Primitive.Shrink]([x], { slice }) {
 		const newShape = slice.map((s) => s[1] - s[0]);
-		return [new ShapedArray(newShape, x.dtype)];
+		return [new ShapedArray(newShape, x.dtype, x.weakType)];
 	},
 	[Primitive.Pad]([x], { width }) {
 		const newShape = x.shape.map((dim, i) => dim + width[i][0] + width[i][1]);
-		return [new ShapedArray(newShape, x.dtype)];
+		return [new ShapedArray(newShape, x.dtype, x.weakType)];
 	},
 	[Primitive.Gather]([x, ...indices], { axis, outDim }) {
 		for (const a of indices) if (a.dtype !== require_backend.DType.Int32 && a.dtype !== require_backend.DType.Uint32) throw new TypeError(`Gather indices must be Int32 or Uint32, got ${a.dtype}`);
@@ -2826,10 +3023,10 @@ const abstractEvalRules = {
 		if (outDim < 0 || outDim > x.shape.length - axis.length) throw new TypeError("Gather outDim out of bounds");
 		const axisSet = new Set(axis);
 		if (axisSet.size !== axis.length) throw new TypeError("Gather axes are not unique");
-		const gatherShape = indices.reduce((shape$1, a) => generalBroadcast(shape$1, a.shape), []);
+		const gatherShape = indices.reduce((shape$1, a) => require_backend.generalBroadcast(shape$1, a.shape), []);
 		const newShape = x.shape.filter((_, i) => !axisSet.has(i));
 		newShape.splice(outDim, 0, ...gatherShape);
-		return [new ShapedArray(newShape, x.dtype)];
+		return [new ShapedArray(newShape, x.dtype, x.weakType)];
 	},
 	[Primitive.JitCall](args, { jaxpr }) {
 		const { inTypes, outTypes } = typecheckJaxpr(jaxpr);
@@ -2896,6 +3093,7 @@ function jit$1(f, opts) {
 		const cacheKey = JSON.stringify(jaxprArgs);
 		const { jaxpr, consts, treedef: outTree } = require_backend.runWithCache(cache, cacheKey, () => makeJaxpr$1(f, opts)(...jaxprArgs));
 		const outs = bind(Primitive.JitCall, [...consts.map((c) => c.ref), ...argsFlat], {
+			name: f.name || "closure",
 			jaxpr,
 			numConsts: consts.length
 		});
@@ -3015,6 +3213,16 @@ const jvpRules = {
 	[Primitive.Log]([x], [dx]) {
 		return [[log$1(x.ref)], [reciprocal$1(x).mul(dx)]];
 	},
+	[Primitive.Erf]([x], [dx]) {
+		const coeff = 2 / Math.sqrt(Math.PI);
+		const expTerm = exp$1(neg(x.ref.mul(x.ref)));
+		return [[erf$1(x)], [expTerm.mul(coeff).mul(dx)]];
+	},
+	[Primitive.Erfc]([x], [dx]) {
+		const coeff = -2 / Math.sqrt(Math.PI);
+		const expTerm = exp$1(neg(x.ref.mul(x.ref)));
+		return [[erfc$1(x)], [expTerm.mul(coeff).mul(dx)]];
+	},
 	[Primitive.Sqrt]([x], [dx]) {
 		const z = sqrt$1(x);
 		return [[z.ref], [reciprocal$1(z.mul(2)).mul(dx)]];
@@ -3058,13 +3266,14 @@ const jvpRules = {
 		const indicesRef = indices.map((t) => t.ref);
 		return [[gather(x, indices, axis, outDim)], [gather(dx, indicesRef, axis, outDim)]];
 	},
-	[Primitive.JitCall](primals, tangents, { jaxpr }) {
+	[Primitive.JitCall](primals, tangents, { name, jaxpr }) {
 		const { newJaxpr, newConsts } = jvpJaxpr(jaxpr);
 		const outs = bind(Primitive.JitCall, [
 			...newConsts.map((c) => c.ref),
 			...primals,
 			...tangents
 		], {
+			name: `${name}_jvp`,
 			jaxpr: newJaxpr,
 			numConsts: newConsts.length
 		});
@@ -3119,7 +3328,7 @@ var import_usingCtx = /* @__PURE__ */ __toESM(require_usingCtx(), 1);
 function mappedAval(batchDim, aval) {
 	const shape$1 = [...aval.shape];
 	shape$1.splice(batchDim, 1);
-	return new ShapedArray(shape$1, aval.dtype);
+	return new ShapedArray(shape$1, aval.dtype, aval.weakType);
 }
 /** Move one axis to a different index. */
 function moveaxis$1(x, src, dst) {
@@ -3176,6 +3385,10 @@ var BatchTrace = class extends Trace {
 		const [valsIn, bdimsIn] = require_backend.unzip2(tracers.map((t) => [t.val, t.batchDim]));
 		const vmapRule = vmapRules[primitive];
 		if (vmapRule === void 0) throw new Error(`No vmap rule for: ${primitive}`);
+		if (bdimsIn.every((d) => d === null)) {
+			const valOuts$1 = bind(primitive, valsIn, params);
+			return valOuts$1.map((x) => new BatchTracer(this, x, null));
+		}
 		const [valOuts, bdimOuts] = vmapRule(this.axisSize, valsIn, bdimsIn, params);
 		return require_backend.zip(valOuts, bdimOuts).map(([x, bd]) => new BatchTracer(this, x, bd));
 	}
@@ -3183,24 +3396,28 @@ var BatchTrace = class extends Trace {
 		return this.main.globalData;
 	}
 };
-function handleScalarBroadcasting(nd, x, d) {
-	if (d === null || nd === ndim$1(x)) return x;
-	else {
-		const axis = require_backend.range(ndim$1(x), nd);
-		const shape$1 = [...x.shape, ...axis.map(() => 1)];
-		return broadcast(x, shape$1, axis);
-	}
-}
-/** Process a primitive with built-in broadcasting. */
+/**
+* Process a primitive with built-in broadcasting.
+*
+* Reference: https://github.com/jax-ml/jax/blob/jax-v0.8.1/jax/_src/interpreters/batching.py#L1029
+*/
 function broadcastBatcher(op) {
 	return (axisSize, args, dims) => {
 		if (args.length === 0) throw new Error("Empty list in broadcastBatcher");
-		const idx = dims.findIndex((d) => d !== null);
-		if (idx === -1) return [[op(...args)], [null]];
-		if (require_backend.zip(args, dims).every(([x, d]) => ndim$1(x) === 0 || require_backend.deepEqual(x.shape, args[idx].shape) && d === dims[idx])) return [[op(...args)], [dims[idx]]];
-		args = args.map((x, i) => ndim$1(x) > 0 ? moveBatchAxis(axisSize, dims[i], 0, x) : x);
-		const nd = Math.max(...args.map(ndim$1));
-		args = args.map((x, i) => handleScalarBroadcasting(nd, x, dims[i]));
+		const nd = Math.max(...args.map((x, i) => ndim$1(x) + (dims[i] === null ? 1 : 0)));
+		const firstIdx = dims.findIndex((d) => d !== null);
+		const firstBdim = dims[firstIdx] - args[firstIdx].ndim;
+		if (require_backend.zip(args, dims).every(([x, d]) => d === null && ndim$1(x) < -firstBdim || d !== null && d - x.ndim === firstBdim)) return [[op(...args)], [nd + firstBdim]];
+		args = args.map((x, i) => {
+			if (dims[i] === null) return x;
+			x = moveBatchAxis(axisSize, dims[i], 0, x);
+			if (x.ndim < nd) x = x.reshape([
+				x.shape[0],
+				...require_backend.rep(nd - x.ndim, 1),
+				...x.shape.slice(1)
+			]);
+			return x;
+		});
 		return [[op(...args)], [0]];
 	};
 }
@@ -3224,17 +3441,18 @@ const vmapRules = {
 	[Primitive.Atan]: unopBatcher(atan$1),
 	[Primitive.Exp]: unopBatcher(exp$1),
 	[Primitive.Log]: unopBatcher(log$1),
+	[Primitive.Erf]: unopBatcher(erf$1),
+	[Primitive.Erfc]: unopBatcher(erfc$1),
 	[Primitive.Sqrt]: unopBatcher(sqrt$1),
 	[Primitive.Min]: broadcastBatcher(min$1),
 	[Primitive.Max]: broadcastBatcher(max$1),
 	[Primitive.Reduce](axisSize, [x], [xBdim], { op, axis }) {
-		if (xBdim === null) return [[reduce(x, op, axis)], [null]];
+		require_backend.assertNonNull(xBdim);
 		const newAxis = axis.map((ax) => ax + (xBdim <= ax ? 1 : 0));
 		const outBdim = xBdim - axis.filter((ax) => ax < xBdim).length;
 		return [[reduce(x, op, newAxis)], [outBdim]];
 	},
 	[Primitive.Dot](axisSize, [x, y], [xBdim, yBdim]) {
-		if (xBdim === null && yBdim === null) return [[dot$1(x, y)], [null]];
 		x = moveBatchAxis(axisSize, xBdim, x.ndim - (xBdim === null ? 1 : 2), x);
 		y = moveBatchAxis(axisSize, yBdim, y.ndim - (yBdim === null ? 1 : 2), y);
 		const z = dot$1(x, y);
@@ -3243,29 +3461,72 @@ const vmapRules = {
 	[Primitive.Compare](axisSize, args, dims, { op }) {
 		return broadcastBatcher((x, y) => compare(x, y, op))(axisSize, args, dims, {});
 	},
+	[Primitive.Where]: broadcastBatcher(where$1),
+	[Primitive.Transpose](axisSize, [x], [xBdim], { perm }) {
+		require_backend.assertNonNull(xBdim);
+		const newPerm = perm.map((p) => p + (xBdim <= p ? 1 : 0));
+		newPerm.splice(xBdim, 0, xBdim);
+		return [[transpose$1(x, newPerm)], [xBdim]];
+	},
+	[Primitive.Broadcast](axisSize, [x], [xBdim], { shape: shape$1, axis }) {
+		require_backend.assertNonNull(xBdim);
+		const newShape = shape$1.toSpliced(xBdim, 0, axisSize);
+		const newAxis = axis.map((ax) => ax + (xBdim <= ax ? 1 : 0));
+		return [[broadcast(x, newShape, newAxis)], [xBdim]];
+	},
 	[Primitive.Reshape](axisSize, [x], [xBdim], { shape: shape$1 }) {
-		if (xBdim === null) return [[reshape$1(x, shape$1)], [null]];
 		x = moveBatchAxis(axisSize, xBdim, 0, x);
 		return [[reshape$1(x, [axisSize, ...shape$1])], [0]];
 	},
 	[Primitive.Flip](axisSize, [x], [xBdim], { axis }) {
-		if (xBdim === null) return [[flip$1(x, axis)], [null]];
+		require_backend.assertNonNull(xBdim);
 		const newAxis = axis.map((ax) => ax + (xBdim <= ax ? 1 : 0));
 		return [[flip$1(x, newAxis)], [xBdim]];
 	},
 	[Primitive.Shrink](axisSize, [x], [xBdim], { slice }) {
-		if (xBdim === null) return [[shrink(x, slice)], [null]];
+		require_backend.assertNonNull(xBdim);
 		const newSlice = slice.toSpliced(xBdim, 0, [0, axisSize]);
 		return [[shrink(x, newSlice)], [xBdim]];
 	},
 	[Primitive.Pad](axisSize, [x], [xBdim], { width }) {
-		if (xBdim === null) return [[pad$1(x, width)], [null]];
+		require_backend.assertNonNull(xBdim);
 		const newWidth = width.toSpliced(xBdim, 0, [0, 0]);
 		return [[pad$1(x, newWidth)], [xBdim]];
 	},
-	[Primitive.JitCall](axisSize, args, dims, { jaxpr }) {
+	[Primitive.Gather](axisSize, [x, ...indices], [xBdim, ...indicesBdim], { axis, outDim }) {
+		if (indicesBdim.every((d) => d === null)) {
+			require_backend.assertNonNull(xBdim);
+			const newAxis = axis.map((ax) => ax + (xBdim <= ax ? 1 : 0));
+			let newBdim = xBdim - axis.filter((ax) => ax < xBdim).length;
+			let newOutDim = outDim;
+			if (newOutDim < newBdim) newBdim += axis.length;
+			else newOutDim += 1;
+			return [[gather(x, indices, newAxis, newOutDim)], [newBdim]];
+		}
+		const nd = Math.max(...indices.map((m, i) => ndim$1(m) + (indicesBdim[i] === null ? 1 : 0)));
+		indices = indices.map((m, i) => {
+			if (indicesBdim[i] === null) return m;
+			m = moveBatchAxis(axisSize, indicesBdim[i], 0, m);
+			if (m.ndim < nd) m = m.reshape([
+				m.shape[0],
+				...require_backend.rep(nd - m.ndim, 1),
+				...m.shape.slice(1)
+			]);
+			return m;
+		});
+		if (xBdim === null) return [[gather(x, indices, axis, outDim)], [outDim]];
+		else {
+			x = moveBatchAxis(axisSize, xBdim, 0, x);
+			const newAxis = [0, ...axis.map((ax) => ax + 1)];
+			const extraBatchIndex = arange(axisSize).reshape([-1, ...require_backend.rep(nd - 1, 1)]);
+			indices.splice(0, 0, extraBatchIndex);
+			return [[gather(x, indices, newAxis, outDim)], [outDim]];
+		}
+	},
+	[Primitive.JitCall](axisSize, args, dims, { name, jaxpr }) {
 		const { newJaxpr, newConsts } = vmapJaxpr(jaxpr, axisSize, dims);
 		const outs = bind(Primitive.JitCall, [...newConsts.map((c) => c.ref), ...args], {
+			name: `${name}_vmap`,
 			jaxpr: newJaxpr,
 			numConsts: newConsts.length
 		});
@@ -3281,7 +3542,7 @@ function vmapJaxpr(jaxpr, axisSize, dims) {
 		if (dims[i] === null) return v.aval;
 		const shape$1 = [...v.aval.shape];
 		shape$1.splice(dims[i], 0, axisSize);
-		return new ShapedArray(shape$1, v.aval.dtype);
+		return new ShapedArray(shape$1, v.aval.dtype, v.aval.weakType);
 	});
 	const { jaxpr: newJaxpr, consts: newConsts } = makeJaxpr$1((args) => vmapFlat(jaxprAsFun(jaxpr), dims, args))(inAvals);
 	const result = {
@@ -3321,12 +3582,14 @@ function vmapFlat(f, inAxes, args) {
 function vmap$1(f, inAxes = 0) {
 	return (...args) => {
 		const [argsFlat, inTree] = flatten(args);
-		let inAxesFlat;
+		let inAxesFlat = [];
 		if (typeof inAxes === "number") inAxesFlat = require_backend.rep(argsFlat.length, inAxes);
+		else for (let i = 0; i < args.length; i++) if (inAxes[i] == null) inAxesFlat.push(...require_backend.rep(inTree.childTreedefs[i].size, null));
+		else if (typeof inAxes[i] === "number") inAxesFlat.push(...require_backend.rep(inTree.childTreedefs[i].size, inAxes[i]));
 		else {
-			let inTree2;
-			[inAxesFlat, inTree2] = flatten(inAxes);
-			if (!inTree.equals(inTree2)) throw new TreeMismatchError("vmap", inTree, inTree2);
+			const [axesFlat, axesTreeDef] = flatten(inAxes[i]);
+			if (!inTree.childTreedefs[i].equals(axesTreeDef)) throw new TreeMismatchError("vmap", inTree.childTreedefs[i], axesTreeDef);
+			inAxesFlat.push(...axesFlat);
 		}
 		const [fFlat, outTree] = flattenFun(f, inTree);
 		const outsFlat = vmapFlat(fFlat, inAxesFlat, argsFlat);
@@ -3494,8 +3757,8 @@ var PartialEvalTrace = class extends Trace {
 	processPrimitive(primitive, tracers, params) {
 		if (tracers.every((t) => t.pval.isKnown)) return bind(primitive, tracers.map((t) => t.fullLower()), params);
 		if (primitive === Primitive.JitCall) {
-			const { jaxpr, numConsts } = params;
-			return this.#partialEvalJaxpr(jaxpr, numConsts, tracers);
+			const { name, jaxpr, numConsts } = params;
+			return this.#partialEvalJaxpr(name, jaxpr, numConsts, tracers);
 		}
 		const tracersIn = tracers.map((t) => this.instantiateConst(t));
 		const avalsIn = tracersIn.map((t) => t.pval.aval);
@@ -3521,12 +3784,13 @@ var PartialEvalTrace = class extends Trace {
 	*
 	* Used when encountering a JitCall rule during the trace.
 	*/
-	#partialEvalJaxpr(jaxpr, numConsts, tracers) {
+	#partialEvalJaxpr(name, jaxpr, numConsts, tracers) {
 		jaxpr = jaxpr.flatten();
 		const inUnknowns = tracers.map((t) => !t.pval.isKnown);
 		const { jaxpr1, jaxpr2, outUnknowns, numRes } = partialEvalJaxpr(jaxpr, inUnknowns);
 		const [knownTracers, unknownTracers] = require_backend.partitionList(inUnknowns, tracers);
 		const outs1Res = bind(Primitive.JitCall, knownTracers.map((t) => t.ref.fullLower()), {
+			name: `${name}_peval`,
 			jaxpr: jaxpr1,
 			numConsts: 0
 		});
@@ -3538,6 +3802,7 @@ var PartialEvalTrace = class extends Trace {
 			prim: Primitive.JitCall,
 			tracersIn: resTracers.concat(unknownTracers),
 			params: {
+				name: `${name}_resid`,
 				jaxpr: jaxpr2,
 				numConsts: 0
 			},
@@ -3680,7 +3945,7 @@ function evalJaxprTransposed(jaxpr, args, cotangents) {
 	}
 	for (let i = jaxpr.eqns.length - 1; i >= 0; i--) {
 		const eqn = jaxpr.eqns[i];
-		const primalsIn = eqn.inputs.map((v) => v instanceof Lit ? scalar(v.value, { dtype: v.dtype }) : knownPrimals.has(v) ? knownPrimals.get(v).ref : new UndefPrimal(v.aval));
+		const primalsIn = eqn.inputs.map((v) => v instanceof Lit ? array(v.value, { dtype: v.dtype }) : knownPrimals.has(v) ? knownPrimals.get(v).ref : new UndefPrimal(v.aval));
 		const cotangentsOut = eqn.outBinders.map(readCotangent);
 		const rule = transposeRules[eqn.primitive];
 		if (!rule) throw new TypeError(`Backward pass not implemented for ${eqn.primitive}`);
@@ -3765,7 +4030,7 @@ const transposeRules = {
 	},
 	[Primitive.Dot]([ct], [x, y]) {
 		if (x instanceof UndefPrimal === y instanceof UndefPrimal) throw new NonlinearError(Primitive.Dot);
-		const axisSize = generalBroadcast(x.aval.shape, y.aval.shape).slice(-1)[0];
+		const axisSize = require_backend.generalBroadcast(x.aval.shape, y.aval.shape).slice(-1)[0];
 		ct = broadcast(ct, ct.shape.concat(axisSize), [-1]);
 		return [x instanceof UndefPrimal ? unbroadcast(mul(ct, y), x) : null, y instanceof UndefPrimal ? unbroadcast(mul(x, ct), y) : null];
 	},
@@ -3860,7 +4125,7 @@ const transposeRules = {
 		if (indices.some((i) => i instanceof UndefPrimal)) throw new NonlinearError(Primitive.Gather);
 		throw new Error("Gather transpose rule is not yet implemented, requires complex Scatter sum operation");
 	},
-	[Primitive.JitCall](cts, args, { jaxpr }) {
+	[Primitive.JitCall](cts, args, { name, jaxpr }) {
 		const undefPrimals = args.map((x) => x instanceof UndefPrimal);
 		const { newJaxpr, newConsts } = transposeJaxpr(jaxpr, undefPrimals);
 		const residuals = args.filter((x, i$1) => !undefPrimals[i$1]);
@@ -3869,6 +4134,7 @@ const transposeRules = {
 			...residuals,
 			...cts
 		], {
+			name: `${name}_t`,
 			jaxpr: newJaxpr,
 			numConsts: newConsts.length
 		});
@@ -3943,7 +4209,7 @@ function valueAndGrad$1(f) {
 		const [y, fVjp] = vjp$1(f, x[0], ...x.slice(1).map(stopGradient));
 		if (!(y instanceof Tracer) || ndim$1(y) !== 0) throw new TypeError("grad requires a scalar output");
 		if (!require_backend.isFloatDtype(y.dtype)) throw new TypeError("grad only supports floating-point dtypes");
-		const [ct, ...rest] = fVjp(scalar(1, { dtype: y.dtype }));
+		const [ct, ...rest] = fVjp(onesLike$1(y.ref));
 		for (const r of rest) dispose(r);
 		fVjp.dispose();
 		return [y, ct];
@@ -3971,7 +4237,10 @@ __export(lax_exports, {
 	conv: () => conv$1,
 	convGeneralDilated: () => convGeneralDilated,
 	convWithGeneralPadding: () => convWithGeneralPadding,
-	reduceWindow: () => reduceWindow
+	erf: () => erf,
+	erfc: () => erfc,
+	reduceWindow: () => reduceWindow,
+	stopGradient: () => stopGradient$1
 });
 function padtypeToPads(inShape, filterShape, strides, dilation, padding) {
 	const padType = padding.toUpperCase();
@@ -4030,6 +4299,28 @@ function reduceWindow(operand, computation, windowDimensions, windowStrides) {
 		strides: windowStrides
 	}));
 }
+/** The error function: `erf(x) = 2/sqrt(pi) * int[0..x] exp(-t^2) dt`. */
+function erf(x) {
+	return erf$1(x);
+}
+/**
+* The complementary error function: `erfc(x) = 1 - erf(x)`.
+*
+* This function is more accurate than `1 - erf(x)` for large values of `x`,
+* where `erf(x)` is very close to 1.
+*/
+function erfc(x) {
+	return erfc$1(x);
+}
+/**
+* Stops gradient computation.
+*
+* Behaves as the identity function but prevents the flow of gradients during
+* forward or reverse-mode automatic differentiation.
+*/
+function stopGradient$1(x) {
+	return stopGradient(x);
+}
 
 //#endregion
 //#region src/numpy.ts
@@ -4092,6 +4383,9 @@ __export(numpy_exports, {
 	fullLike: () => fullLike$1,
 	greater: () => greater,
 	greaterEqual: () => greaterEqual,
+	hamming: () => hamming,
+	hann: () => hann,
+	heaviside: () => heaviside,
 	hstack: () => hstack,
 	hypot: () => hypot,
 	identity: () => identity$1,
@@ -4313,7 +4607,7 @@ function argmin(a, axis, opts) {
 	} else axis = require_backend.checkAxis(axis, a.ndim);
 	const shape$1 = a.shape;
 	const isMax = equal(a, min(a.ref, axis, { keepdims: true }));
-	const length = scalar(shape$1[axis], {
+	const length = array(shape$1[axis], {
 		dtype: int32,
 		device: a.device
 	});
@@ -4337,7 +4631,7 @@ function argmax(a, axis, opts) {
 	} else axis = require_backend.checkAxis(axis, a.ndim);
 	const shape$1 = a.shape;
 	const isMax = equal(a, max(a.ref, axis, { keepdims: true }));
-	const length = scalar(shape$1[axis], {
+	const length = array(shape$1[axis], {
 		dtype: int32,
 		device: a.device
 	});
@@ -4521,7 +4815,7 @@ function broadcastTo(a, shape$1) {
 /** Broadcast input shapes to a common output shape. */
 function broadcastShapes(...shapes) {
 	if (shapes.length === 0) return [];
-	return shapes.reduce(generalBroadcast);
+	return shapes.reduce(require_backend.generalBroadcast);
 }
 /** Broadcast arrays to a common shape. */
 function broadcastArrays(...arrays) {
@@ -4731,6 +5025,32 @@ function sign(x) {
 	x = fudgeArray(x);
 	return where(notEqual(x.ref, 0), where(less(x.ref, 0), -1, 1), 0);
 }
+/**
+* Return the Hamming window of size M, a taper with a weighted cosine bell.
+*
+* `w(n) = 0.54 - 0.46 * cos(2πn/(M-1))` for `0 <= n <= M-1`.
+*/
+function hamming(M) {
+	return cos(linspace(0, 2 * Math.PI, M)).mul(-.46).add(.54);
+}
+/**
+* Return the Hann window of size M, a taper with a weighted cosine bell.
+*
+* `w(n) = 0.5 - 0.5 * cos(2πn/(M-1))` for `0 <= n <= M-1`.
+*/
+function hann(M) {
+	return cos(linspace(0, 2 * Math.PI, M)).mul(-.5).add(.5);
+}
+/**
+* @function
+* Compute the Heaviside step function. It is defined piecewise:
+* - `heaviside(x1, x2) = 0` for `x1 < 0`,
+* - `heaviside(x1, x2) = x2` for `x1 == 0`,
+* - `heaviside(x1, x2) = 1` for `x1 > 0`.
+*/
+const heaviside = jit$1(function heaviside$1(x1, x2) {
+	return where(less(x1.ref, 0), 0, where(equal(x1, 0), x2, 1));
+});
 /** Calculate element-wise square of the input array. */
 function square(x) {
 	x = fudgeArray(x);
@@ -4750,10 +5070,10 @@ function acos(x) {
 * Return element-wise hypotenuse for the given legs of a right triangle.
 *
 * In the original NumPy/JAX implementation, this function is more numerically
-* stable than sqrt(x1**2 + x2**2). We don't currently implement those stability
-* improvements.
+* stable than `sqrt(x1**2 + x2**2)`. We don't currently implement those
+* stability improvements.
 */
-const hypot = jit$1((x1, x2) => {
+const hypot = jit$1(function hypot$1(x1, x2) {
 	return sqrt(square(x1).add(square(x2)));
 });
 /**
@@ -4769,7 +5089,7 @@ const hypot = jit$1((x1, x2) => {
 *
 * The output is ill-defined when both x and y are zero.
 */
-const atan2 = jit$1((y, x) => {
+const atan2 = jit$1(function atan2$1(y, x) {
 	const r = sqrt(square(x.ref).add(square(y.ref)));
 	const xNeg = less(x.ref, 0);
 	const numer = where(xNeg.ref, r.ref.sub(x.ref), y.ref);
@@ -4837,13 +5157,13 @@ const degrees = rad2deg;
 * @function
 * Computes first array raised to power of second array, element-wise.
 */
-const power = jit$1((x1, x2) => {
+const power = jit$1(function power$1(x1, x2) {
 	return exp(log(x1).mul(x2));
 });
 /** @function Alias of `jax.numpy.power()`. */
 const pow = power;
 /** @function Calculate the element-wise cube root of the input array. */
-const cbrt = jit$1((x) => {
+const cbrt = jit$1(function cbrt$1(x) {
 	const sgn = where(less(x.ref, 0), -1, 1);
 	return sgn.ref.mul(exp(log(x.mul(sgn)).mul(1 / 3)));
 });
@@ -4853,7 +5173,7 @@ const cbrt = jit$1((x) => {
 *
 * `sinh(x) = (exp(x) - exp(-x)) / 2`
 */
-const sinh = jit$1((x) => {
+const sinh = jit$1(function sinh$1(x) {
 	const ex = exp(x);
 	const emx = reciprocal(ex.ref);
 	return ex.sub(emx).mul(.5);
@@ -4864,7 +5184,7 @@ const sinh = jit$1((x) => {
 *
 * `cosh(x) = (exp(x) + exp(-x)) / 2`
 */
-const cosh = jit$1((x) => {
+const cosh = jit$1(function cosh$1(x) {
 	const ex = exp(x);
 	const emx = reciprocal(ex.ref);
 	return ex.add(emx).mul(.5);
@@ -4875,7 +5195,7 @@ const cosh = jit$1((x) => {
 *
 * `tanh(x) = sinh(x)/cosh(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x))`
 */
-const tanh = jit$1((x) => {
+const tanh = jit$1(function tanh$1(x) {
 	const negsgn = where(less(x.ref, 0), 1, -1);
 	const en2x = exp(x.mul(negsgn.ref).mul(2));
 	return en2x.ref.sub(1).div(en2x.add(1)).mul(negsgn);
@@ -4886,7 +5206,7 @@ const tanh = jit$1((x) => {
 *
 * `arcsinh(x) = ln(x + sqrt(x^2 + 1))`
 */
-const arcsinh = jit$1((x) => {
+const arcsinh = jit$1(function arcsinh$1(x) {
 	return log(x.ref.add(sqrt(square(x).add(1))));
 });
 /**
@@ -4895,7 +5215,7 @@ const arcsinh = jit$1((x) => {
 *
 * `arccosh(x) = ln(x + sqrt(x^2 - 1))`
 */
-const arccosh = jit$1((x) => {
+const arccosh = jit$1(function arccosh$1(x) {
 	return log(x.ref.add(sqrt(square(x).sub(1))));
 });
 /**
@@ -4904,7 +5224,7 @@ const arccosh = jit$1((x) => {
 *
 * `arctanh(x) = 0.5 * ln((1 + x) / (1 - x))`
 */
-const arctanh = jit$1((x) => {
+const arctanh = jit$1(function arctanh$1(x) {
 	return log(add(1, x.ref).div(subtract(1, x))).mul(.5);
 });
 /** @function Alias of `jax.numpy.arcsinh()`. */
@@ -5020,7 +5340,9 @@ function softSign(x) {
 *
 * Reference: https://en.wikipedia.org/wiki/Swish_function
 */
-const silu = jit$1((x) => x.ref.mul(sigmoid(x)));
+const silu = jit$1(function silu$1(x) {
+	return x.ref.mul(sigmoid(x));
+});
 /**
 * @function
 * Sigmoid-weighted Linear Unit (SiLU) activation function, also known as
@@ -5073,18 +5395,20 @@ function celu(x, alpha = 1) {
 * @function
 * Gaussion error linear unit (GELU) activation function.
 *
-* This is computed element-wise. Currently jax-js does not support the erf() or
-* gelu() functions exactly as primitives, so an approximation is used:
-* `gelu(x) ~= x * 0.5 * (1 + tanh(sqrt(2/pi) * (x + 0.044715 * x^3)))`.
+* This is computed element-wise. There are two variants depending on whether
+* `approximate` is set (default true):
 *
-* Reference: https://ml-explore.github.io/mlx/build/html/python/nn/_autosummary_functions/mlx.nn.gelu_approx.html
+* - Approximate: `gelu(x) ~= x * 0.5 * (1 + tanh(sqrt(2/pi) * (x + 0.044715 * x^3)))`
+* - Exact: `gelu(x) = x * 0.5 * erfc(-x / sqrt(2))`
 *
-* This will be improved in the future.
+* Reference: https://ml-explore.github.io/mlx/build/html/python/nn/_autosummary_functions/mlx.nn.gelu_approx.html
 */
-const gelu = jit$1((x) => {
-	const SQRT_2_OVER_PI = Math.sqrt(2 / Math.PI);
-	return x.ref.mul(.5).mul(tanh(x.ref.mul(x.ref.mul(x).mul(.044715).add(1)).mul(SQRT_2_OVER_PI)).add(1));
-});
+const gelu = jit$1(function gelu$1(x, opts) {
+	if (opts?.approximate ?? true) {
+		const SQRT_2_OVER_PI = Math.sqrt(2 / Math.PI);
+		return x.ref.mul(.5).mul(tanh(x.ref.mul(x.ref.mul(x).mul(.044715).add(1)).mul(SQRT_2_OVER_PI)).add(1));
+	} else return x.ref.mul(.5).mul(erfc$1(negative(x.ref.mul(Math.SQRT1_2))));
+}, { staticArgnums: [1] });
 /**
 * Gated linear unit (GLU) activation function.
 *
@@ -5252,8 +5576,11 @@ function bits(key$1, shape$1 = []) {
 	const keyShape = validateKeyShape(key$1);
 	return randomBits(key$1.ref.slice(...keyShape.map(() => null), 0), key$1.slice(...keyShape.map(() => null), 1), shape$1);
 }
-/** Sample uniform random values in [minval, maxval) with given shape. */
-function uniform(key$1, shape$1 = [], { minval = 0, maxval = 1 } = {}) {
+/**
+* @function
+* Sample uniform random values in [minval, maxval) with given shape.
+*/
+const uniform = jit$1(function uniform$1(key$1, shape$1 = [], { minval = 0, maxval = 1 } = {}) {
 	if (minval >= maxval) throw new Error(`Invalid range: [${minval}, ${maxval}).`);
 	const mantissa = bits(key$1, shape$1).div(array(512, {
 		dtype: require_backend.DType.Uint32,
@@ -5266,7 +5593,7 @@ function uniform(key$1, shape$1 = [], { minval = 0, maxval = 1 } = {}) {
 	const rand = bitcast(float12, require_backend.DType.Float32).sub(1);
 	if (minval === 0 && maxval === 1) return rand;
 	else return rand.mul(maxval - minval).add(minval);
-}
+}, { staticArgnums: [1, 2] });
 /**
 * Sample Bernoulli random variables with given mean (0,1 categorical).
 *
@@ -5277,26 +5604,49 @@ function bernoulli(key$1, p = .5, shape$1 = []) {
 	p = fudgeArray(p);
 	return uniform(key$1, shape$1).less(p);
 }
-/** Sample exponential random values according to `p(x) = exp(-x)`. */
-function exponential(key$1, shape$1 = []) {
+/**
+* @function
+* Sample exponential random values according to `p(x) = exp(-x)`.
+*/
+const exponential = jit$1(function exponential$1(key$1, shape$1 = []) {
 	const u = uniform(key$1, shape$1);
 	return negative(log1p(negative(u)));
-}
+}, { staticArgnums: [1] });
 /**
+* @function
 * Sample random values according to `p(x) = 1/sqrt(2pi) * exp(-x^2/2)`.
 *
 * Unlike JAX, this uses the Box-Muller transform. JAX uses the erf_inv primitive instead and
 * directly inverts the CDF, but we don't have support for that yet. Outputs will not be
 * bitwise identical to JAX.
 */
-function normal(key$1, shape$1 = []) {
+const normal = jit$1(function normal$1(key$1, shape$1 = []) {
 	const [k1, k2] = split(key$1, 2);
 	const u1 = uniform(k1, shape$1);
 	const u2 = uniform(k2, shape$1);
 	const radius = sqrt(log1p(negative(u1)).mul(-2));
 	const theta = u2.mul(2 * Math.PI);
 	return radius.mul(cos(theta));
-}
+}, { staticArgnums: [1] });
+
+//#endregion
+//#region src/scipy-special.ts
+var scipy_special_exports = {};
+__export(scipy_special_exports, {
+	erf: () => erf,
+	erfc: () => erfc,
+	logSoftmax: () => logSoftmax,
+	logit: () => logit,
+	logsumexp: () => logsumexp,
+	softmax: () => softmax
+});
+/**
+* @function
+* The logit function, `logit(p) = log(p / (1-p))`.
+*/
+const logit = jit$1(function logit$1(x) {
+	return log(x.ref.div(subtract(1, x)));
+});
 
 //#endregion
 //#region src/polyfills.ts
@@ -5391,6 +5741,24 @@ async function blockUntilReady(x) {
 	await Promise.all(promises);
 	return x;
 }
+/**
+* Transfer `x` to `device`.
+*
+* `x` may be a nested container of arrays or scalars. The resulting structure
+* is committed to the device.
+*
+* If `device` is not specified, this function behaves as identity if the input
+* is already an `Array`, otherwise it places the scalar uncommitted on the
+* default device.
+*/
+async function devicePut(x, device) {
+	const [xflat, structure$1] = flatten(x);
+	const yflat = await Promise.all(xflat.map((leaf) => {
+		if (leaf instanceof Array$1) return device ? leaf._put(require_backend.getBackend(device)) : Promise.resolve(leaf);
+		else return Promise.resolve(array(leaf, { device }));
+	}));
+	return unflatten(structure$1, yflat);
+}
 
 //#endregion
 exports.Array = Array$1;
@@ -5398,6 +5766,7 @@ exports.DType = require_backend.DType;
 exports.Jaxpr = Jaxpr;
 exports.blockUntilReady = blockUntilReady;
 exports.defaultDevice = require_backend.defaultDevice;
+exports.devicePut = devicePut;
 exports.devices = require_backend.devices;
 exports.grad = grad;
 exports.init = require_backend.init;
@@ -5432,6 +5801,12 @@ Object.defineProperty(exports, 'random', {
     return random_exports;
   }
 });
+Object.defineProperty(exports, 'scipySpecial', {
+  enumerable: true,
+  get: function () {
+    return scipy_special_exports;
+  }
+});
 exports.setDebug = require_backend.setDebug;
 Object.defineProperty(exports, 'tree', {
   enumerable: true,
@@ -5441,4 +5816,5 @@ Object.defineProperty(exports, 'tree', {
 });
 exports.valueAndGrad = valueAndGrad;
 exports.vjp = vjp;
-exports.vmap = vmap;
+exports.vmap = vmap;
+//# sourceMappingURL=index.cjs.map