@jax-js/jax 0.0.1 → 0.0.3

package/dist/chunk-B2GFURUN.js

@@ -1,1978 +0,0 @@
-var __defProp = Object.defineProperty;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __using = (stack, value, async) => {
-  if (value != null) {
-    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
-    var dispose, inner;
-    if (async) dispose = value[__knownSymbol("asyncDispose")];
-    if (dispose === void 0) {
-      dispose = value[__knownSymbol("dispose")];
-      if (async) inner = dispose;
-    }
-    if (typeof dispose !== "function") __typeError("Object not disposable");
-    if (inner) dispose = function() {
-      try {
-        inner.call(this);
-      } catch (e) {
-        return Promise.reject(e);
-      }
-    };
-    stack.push([async, dispose, value]);
-  } else if (async) {
-    stack.push([async]);
-  }
-  return value;
-};
-var __callDispose = (stack, error, hasError) => {
-  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
-    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
-  };
-  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
-  var next = (it) => {
-    while (it = stack.pop()) {
-      try {
-        var result = it[1] && it[1].call(it[2]);
-        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
-      } catch (e) {
-        fail(e);
-      }
-    }
-    if (hasError) throw error;
-  };
-  return next();
-};
-
-// src/utils.ts
-var DEBUG = 3;
-function unzip2(pairs) {
-  const lst1 = [];
-  const lst2 = [];
-  for (const [x, y] of pairs) {
-    lst1.push(x);
-    lst2.push(y);
-  }
-  return [lst1, lst2];
-}
-function zip(xs, ys) {
-  return xs.map((x, i) => [x, ys[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);
-}
-function prod(arr) {
-  return arr.reduce((acc, x) => acc * x, 1);
-}
-function intdiv(a, b) {
-  return Math.floor(a / b);
-}
-function clamp(x, min, max) {
-  return Math.max(min, Math.min(max, x));
-}
-function deepEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (typeof a !== "object" || typeof b !== "object") {
-    return false;
-  }
-  if (a === null || b === null) {
-    return false;
-  }
-  if (Object.keys(a).length !== Object.keys(b).length) {
-    return false;
-  }
-  for (const key of Object.keys(a)) {
-    if (!deepEqual(a[key], b[key])) {
-      return false;
-    }
-  }
-  return true;
-}
-function partitionList(which, array) {
-  const falseList = [];
-  const trueList = [];
-  for (let i = 0; i < which.length; i++) {
-    if (which[i]) {
-      trueList.push(array[i]);
-    } else {
-      falseList.push(array[i]);
-    }
-  }
-  return [falseList, trueList];
-}
-function lexCompare(a, b) {
-  const minLength = Math.min(a.length, b.length);
-  for (let i = 0; i < minLength; i++) {
-    if (a[i] < b[i]) return -1;
-    if (a[i] > b[i]) return 1;
-  }
-  return a.length - b.length;
-}
-function range(start, stop, step = 1) {
-  if (stop === void 0) {
-    stop = start;
-    start = 0;
-  }
-  const result = [];
-  for (let i = start; i < stop; i += step) {
-    result.push(i);
-  }
-  return result;
-}
-function isPermutation(axis, n) {
-  if (axis.length !== n) return false;
-  const seen = /* @__PURE__ */ new Set();
-  for (const x of axis) {
-    if (x < 0 || x >= n) return false;
-    seen.add(x);
-  }
-  return seen.size === n;
-}
-function invertPermutation(axis) {
-  const n = axis.length;
-  if (!isPermutation(axis, n))
-    throw new Error("invertPermutation: axis is not a permutation");
-  const result = new Array(n);
-  for (let i = 0; i < n; i++) {
-    result[axis[i]] = i;
-  }
-  return result;
-}
-function toposort(terminals, parents) {
-  const childCounts = /* @__PURE__ */ new Map();
-  const stack = [...new Set(terminals)];
-  while (true) {
-    const node = stack.pop();
-    if (!node) break;
-    for (const parent of parents(node)) {
-      if (childCounts.has(parent)) {
-        childCounts.set(parent, childCounts.get(parent) + 1);
-      } else {
-        childCounts.set(parent, 1);
-        stack.push(parent);
-      }
-    }
-  }
-  for (const node of terminals) {
-    childCounts.set(node, childCounts.get(node) - 1);
-  }
-  const order = [];
-  const frontier = terminals.filter((n) => !childCounts.get(n));
-  while (true) {
-    const node = frontier.pop();
-    if (!node) break;
-    order.push(node);
-    for (const parent of parents(node)) {
-      const c = childCounts.get(parent) - 1;
-      childCounts.set(parent, c);
-      if (c == 0) {
-        frontier.push(parent);
-      }
-    }
-  }
-  return order.reverse();
-}
-function findPow2(hint, max) {
-  if (max < 1) {
-    throw new Error("max must be a positive integer");
-  }
-  let ret = 1;
-  while (ret < hint && 2 * ret <= max) {
-    ret *= 2;
-  }
-  return ret;
-}
-function recursiveFlatten(ar) {
-  if (!Array.isArray(ar)) return [ar];
-  return ar.flat(Infinity);
-}
-function strip1(str) {
-  if (str[0] === "(" && str[str.length - 1] === ")") {
-    return str.slice(1, -1);
-  }
-  return str;
-}
-var FpHash = class _FpHash {
-  value = 8773157n;
-  #update(x) {
-    const base = 873192869n;
-    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));
-        } else {
-          const ar = new Float64Array([x]);
-          this.#update(new DataView(ar.buffer).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);
-      }
-    }
-    return this;
-  }
-  static hash(...values) {
-    return new _FpHash().update(...values).value;
-  }
-};
-function runWithCache(cache, key, thunk) {
-  if (cache.has(key)) {
-    return cache.get(key);
-  } else {
-    const value = thunk();
-    cache.set(key, value);
-    return value;
-  }
-}
-
-// src/alu.ts
-var DType = /* @__PURE__ */ ((DType2) => {
-  DType2["Float32"] = "float32";
-  DType2["Int32"] = "int32";
-  DType2["Bool"] = "bool";
-  DType2["Complex64"] = "complex64";
-  return DType2;
-})(DType || {});
-var isFloatDtype = (dtype) => dtype === "float32" /* Float32 */ || dtype === "complex64" /* Complex64 */;
-var AluExp = class _AluExp {
-  constructor(op, dtype, src, arg = void 0) {
-    this.op = op;
-    this.dtype = dtype;
-    this.src = src;
-    this.arg = arg;
-    if (AluGroup.RequiredFloat.has(op) && !isFloatDtype(dtype)) {
-      throw new TypeError(`Unsupported dtype for ${op}: ${dtype}`);
-    }
-  }
-  #hash;
-  #simplified;
-  #range;
-  static add(a, b) {
-    return new _AluExp("Add" /* Add */, a.dtype, [a, b]);
-  }
-  static sub(a, b) {
-    return new _AluExp("Sub" /* Sub */, a.dtype, [a, b]);
-  }
-  static mul(a, b) {
-    return new _AluExp("Mul" /* Mul */, a.dtype, [a, b]);
-  }
-  static idiv(a, b) {
-    return new _AluExp("Idiv" /* Idiv */, a.dtype, [a, b]);
-  }
-  static mod(a, b) {
-    return new _AluExp("Mod" /* Mod */, a.dtype, [a, b]);
-  }
-  static min(a, b) {
-    return new _AluExp("Min" /* Min */, a.dtype, [a, b]);
-  }
-  static max(a, b) {
-    return new _AluExp("Max" /* Max */, a.dtype, [a, b]);
-  }
-  static sin(a) {
-    return new _AluExp("Sin" /* Sin */, a.dtype, [a]);
-  }
-  static cos(a) {
-    return new _AluExp("Cos" /* Cos */, a.dtype, [a]);
-  }
-  static exp(a) {
-    return new _AluExp("Exp" /* Exp */, a.dtype, [a]);
-  }
-  static log(a) {
-    return new _AluExp("Log" /* Log */, a.dtype, [a]);
-  }
-  static reciprocal(a) {
-    return new _AluExp("Reciprocal" /* Reciprocal */, a.dtype, [a]);
-  }
-  static cast(dtype, a) {
-    if (a.dtype === dtype) return a;
-    return new _AluExp("Cast" /* Cast */, dtype, [a]);
-  }
-  static cmplt(a, b) {
-    return new _AluExp("Cmplt" /* Cmplt */, "bool" /* Bool */, [a, b]);
-  }
-  static cmpne(a, b) {
-    return new _AluExp("Cmpne" /* Cmpne */, "bool" /* Bool */, [a, b]);
-  }
-  static where(cond, a, b) {
-    return new _AluExp("Where" /* Where */, a.dtype, [cond, a, b]);
-  }
-  static const(dtype, value) {
-    if (dtype === "bool" /* Bool */) {
-      value = Number(Boolean(value));
-    } else if (dtype === "int32" /* Int32 */) {
-      value = Math.trunc(value);
-    }
-    if (typeof value !== "number") {
-      throw new TypeError(
-        `Expected a number for constant, got ${typeof value}: ${value}`
-      );
-    }
-    return new _AluExp("Const" /* Const */, dtype, [], value);
-  }
-  static special(dtype, name, n) {
-    return new _AluExp("Special" /* Special */, dtype, [], [name, n]);
-  }
-  static variable(dtype, name) {
-    return new _AluExp("Variable" /* Variable */, dtype, [], name);
-  }
-  static globalIndex(dtype, gid, bufidx) {
-    return new _AluExp("GlobalIndex" /* GlobalIndex */, dtype, [bufidx], gid);
-  }
-  static globalView(dtype, gid, st, indices) {
-    return new _AluExp("GlobalView" /* GlobalView */, dtype, indices, [gid, st]);
-  }
-  static i32(value) {
-    return _AluExp.const("int32" /* Int32 */, value);
-  }
-  static f32(value) {
-    return _AluExp.const("float32" /* Float32 */, value);
-  }
-  static bool(value) {
-    return _AluExp.const("bool" /* Bool */, Number(value));
-  }
-  not() {
-    if (this.dtype !== "bool" /* Bool */) {
-      throw new Error("not() can only be called on boolean expressions");
-    }
-    return _AluExp.cmpne(this, _AluExp.const("bool" /* Bool */, true));
-  }
-  /** Compute a reasonable expression hash with low collision rate. */
-  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);
-    this.#hash = hasher.value;
-    return this.#hash;
-  }
-  hash(state) {
-    state.update(this.getHash());
-  }
-  /** Substitute variables in this AluExp to values. */
-  substitute(variables) {
-    return this.rewrite((exp) => {
-      if (exp.op === "Variable" /* Variable */ && Object.hasOwn(variables, exp.arg)) {
-        if (exp.dtype !== variables[exp.arg].dtype) {
-          throw new Error(
-            `Type mismatch: ${exp.dtype} vs ${variables[exp.arg].dtype}`
-          );
-        }
-        return variables[exp.arg];
-      }
-    });
-  }
-  /** Reindex gid values in this expression as needed. */
-  reindexGids(gidMap) {
-    return this.rewrite((exp) => {
-      if (exp.op === "GlobalIndex" /* GlobalIndex */) {
-        const gid = exp.arg;
-        const newGid = gidMap.get(gid);
-        if (newGid !== void 0 && newGid !== gid) {
-          return _AluExp.globalIndex(exp.dtype, newGid, exp.src[0]);
-        }
-      } else if (exp.op === "GlobalView" /* GlobalView */) {
-        const gid = exp.arg[0];
-        const newGid = gidMap.get(gid);
-        if (newGid !== void 0 && newGid !== gid) {
-          return _AluExp.globalView(exp.dtype, newGid, exp.arg[1], exp.src);
-        }
-      }
-    });
-  }
-  #computeRange() {
-    if (this.#range !== void 0) return this.#range;
-    const src = this.src;
-    const minMax4 = (f) => {
-      const [r1, r2] = [src[0].#computeRange(), src[1].#computeRange()];
-      const values = [
-        f(r1[0], r2[0]),
-        f(r1[0], r2[1]),
-        f(r1[1], r2[0]),
-        f(r1[1], r2[1])
-      ];
-      return [Math.min(...values), Math.max(...values)];
-    };
-    let ret;
-    switch (this.op) {
-      case "Add" /* Add */:
-        ret = [src[0].min + src[1].min, src[0].max + src[1].max];
-        break;
-      case "Sub" /* Sub */:
-        ret = [src[0].min - src[1].max, src[0].max - src[1].min];
-        break;
-      case "Mul" /* Mul */: {
-        ret = minMax4((a, b) => a * b);
-        break;
-      }
-      case "Idiv" /* Idiv */: {
-        ret = minMax4((a, b) => Math.floor(a / b));
-        break;
-      }
-      case "Mod" /* Mod */: {
-        let divisorRange = src[1].#computeRange();
-        if (divisorRange[0] <= 0 && divisorRange[1] >= 0) {
-          divisorRange = [0, Math.max(-divisorRange[0], divisorRange[1])];
-        }
-        const maxDivisor = isFloatDtype(this.dtype) ? divisorRange[1] : divisorRange[1] - 1;
-        ret = [
-          clamp(src[0].min, -maxDivisor, 0),
-          clamp(src[0].max, 0, maxDivisor)
-        ];
-        break;
-      }
-      case "Min" /* Min */:
-        ret = [
-          Math.min(src[0].min, src[1].min),
-          Math.min(src[0].max, src[1].max)
-        ];
-        break;
-      case "Max" /* Max */:
-        ret = [
-          Math.max(src[0].min, src[1].min),
-          Math.max(src[0].max, src[1].max)
-        ];
-        break;
-      case "Sin" /* Sin */:
-        ret = [Math.sin(src[0].min), Math.sin(src[0].max)];
-        break;
-      case "Cos" /* Cos */:
-        ret = [Math.cos(src[0].min), Math.cos(src[0].max)];
-        break;
-      case "Exp" /* Exp */:
-        ret = [Math.exp(src[0].min), Math.exp(src[0].max)];
-        break;
-      case "Log" /* Log */:
-        ret = [Math.log(src[0].min), Math.log(src[0].max)];
-        break;
-      case "Reciprocal" /* Reciprocal */:
-        if (src[0].min <= 0 && src[0].max >= 0) return [-Infinity, Infinity];
-        ret = [1 / src[0].max, 1 / src[0].min];
-        break;
-      case "Cast" /* Cast */:
-        if (this.dtype === "bool" /* 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 === "int32" /* Int32 */) {
-          ret = [Math.trunc(src[0].min), Math.trunc(src[0].max)];
-        } else {
-          ret = [src[0].min, src[0].max];
-        }
-        break;
-      case "Cmplt" /* Cmplt */:
-        ret = [0, 1];
-        break;
-      case "Cmpne" /* Cmpne */:
-        ret = [0, 1];
-        break;
-      case "Where" /* Where */:
-        ret = [
-          Math.min(src[1].min, src[2].min),
-          Math.max(src[1].max, src[2].max)
-        ];
-        break;
-      case "Const" /* Const */:
-        ret = [this.arg, this.arg];
-        break;
-      case "Special" /* Special */:
-        ret = [0, this.arg[1] - 1];
-        break;
-      default:
-        ret = [-Infinity, Infinity];
-    }
-    if (isNaN(ret[0]) || isNaN(ret[1])) {
-      ret = [-Infinity, Infinity];
-    }
-    if (this.dtype === "bool" /* Bool */) {
-      ret[0] = clamp(ret[0], 0, 1);
-      ret[1] = clamp(ret[1], 0, 1);
-    }
-    this.#range = ret;
-    return ret;
-  }
-  get min() {
-    return this.#computeRange()[0];
-  }
-  get max() {
-    return this.#computeRange()[1];
-  }
-  #isConstInt() {
-    return this.op === "Const" /* Const */ && this.dtype === "int32" /* Int32 */;
-  }
-  /**
-   * 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 simplified = this.#simplifyInner(cache);
-    const simplifiedHash = simplified.getHash();
-    if (cache.has(simplifiedHash)) {
-      const prevSimplified = cache.get(simplifiedHash);
-      cache.set(hash, prevSimplified);
-      this.#simplified = prevSimplified;
-      return prevSimplified;
-    } else {
-      cache.set(hash, simplified);
-      cache.set(simplifiedHash, simplified);
-      this.#simplified = simplified;
-      return simplified;
-    }
-  }
-  #simplifyInner(cache) {
-    const src = this.src.map((x) => x.simplify(cache));
-    const { op } = this;
-    if (src.every((x) => x.op === "Const" /* Const */) && !AluGroup.Variable.has(op)) {
-      const newExp2 = new _AluExp(op, this.dtype, src, this.arg);
-      return _AluExp.const(this.dtype, newExp2.evaluate({}));
-    }
-    if (op !== "Const" /* Const */ && this.min === this.max) {
-      return _AluExp.const(this.dtype, this.min);
-    }
-    if (AluGroup.Binary.has(op)) {
-      for (let i = 0; i < 2; i++) {
-        if (src[i].op !== "Const" /* Const */) continue;
-        const x = src[i].arg;
-        if (op === "Add" /* Add */ && x === 0) return src[1 - i];
-        if (op === "Sub" /* Sub */ && i === 1 && x === 0) return src[1 - i];
-        if (op === "Mul" /* Mul */ && x === 1) return src[1 - i];
-        if (op === "Mul" /* Mul */ && x === 0) return _AluExp.const(this.dtype, 0);
-        if (op === "Idiv" /* Idiv */ && i === 1 && x === 1) return src[1 - i];
-      }
-    }
-    if ((op === "Add" /* Add */ || op === "Sub" /* Sub */) && src[1].op === "Mul" /* Mul */) {
-      const [a, b] = src[1].src;
-      const opNeg = op === "Add" /* Add */ ? "Sub" /* Sub */ : "Add" /* Add */;
-      if (a.op === "Const" /* Const */ && a.arg === -1) {
-        return new _AluExp(opNeg, this.dtype, [src[0], b]);
-      } else if (b.op === "Const" /* Const */ && b.arg === -1) {
-        return new _AluExp(opNeg, this.dtype, [src[0], a]);
-      }
-    }
-    if (op === "Mod" /* Mod */ && src[1].op === "Const" /* Const */ && src[0].min >= 0 && src[0].max < src[1].arg) {
-      return src[0];
-    }
-    if (op === "Add" /* Add */ && src[0].op === "Mul" /* Mul */ && src[0].src[1].#isConstInt() && src[1].op === "Mod" /* Mod */ && src[1].src[1].#isConstInt() && src[0].src[1].arg === src[1].src[1].arg) {
-      const [mul, mod] = src;
-      const check = (exp) => {
-        return exp.op === "Idiv" /* Idiv */ && exp.src[1].#isConstInt() && exp.src[1].arg === mod.src[1].arg && exp.src[0] === mod.src[0];
-      };
-      if (check(mul.src[0])) return mod.src[0];
-      if (mul.src[0].op === "Mod" /* Mod */) {
-        const [x, y] = mul.src[0].src;
-        if (check(x)) {
-          return _AluExp.mod(mod.src[0], _AluExp.mul(mod.src[1], y)).simplify(
-            cache
-          );
-        }
-      }
-    }
-    if (op === "Idiv" /* Idiv */ && src[1].#isConstInt()) {
-      const [numer, denom] = src;
-      const B = denom.arg;
-      for (let i = 0; i < 2; i++) {
-        if (numer.op === "Mul" /* Mul */ && numer.src[i].#isConstInt()) {
-          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));
-            return ret.simplify(cache);
-          }
-        }
-        for (let j = 0; j < 2; j++) {
-          if (numer.op === "Add" /* Add */ && numer.src[j].op === "Mul" /* Mul */ && numer.src[j].src[i].#isConstInt()) {
-            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));
-              return ret.simplify(cache);
-            }
-          }
-        }
-      }
-    }
-    if (op === "Mod" /* 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 === "Add" /* 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);
-        }
-      }
-    }
-    if (op === "Cmplt" /* Cmplt */) {
-      if (src[0].min >= src[1].max) return _AluExp.const("bool" /* Bool */, false);
-      if (src[0].max < src[1].min) return _AluExp.const("bool" /* Bool */, true);
-    }
-    if (op === "Cmpne" /* Cmpne */) {
-      if (src[0].max < src[1].min || src[0].min > src[1].max)
-        return _AluExp.const("bool" /* Bool */, true);
-    }
-    if (op === "Where" /* Where */) {
-      if (src[0].max === 0) return src[2];
-      if (src[0].min === 1) return src[1];
-    }
-    const newExp = src.every((s, i) => s === this.src[i]) ? this : new _AluExp(op, this.dtype, src, this.arg);
-    return newExp;
-  }
-  /** Resolve this to a value, or `undefined` if not possible. */
-  resolve() {
-    const x = this.simplify();
-    if (x.op === "Const" /* Const */) return x.arg;
-    return void 0;
-  }
-  /**
-   * Evaluate the expression on CPU, returning the result.
-   *
-   * Typically you would compile the AluExp as a representation to a lower-level
-   * language. This is just to define the semantics and help debug.
-   *
-   * Note that the representation of Bool is as a number (0 or 1) here.
-   */
-  evaluate(context, globals) {
-    if (AluGroup.Binary.has(this.op) || AluGroup.Compare.has(this.op)) {
-      const x = this.src[0].evaluate(context, globals);
-      const y = this.src[1].evaluate(context, globals);
-      switch (this.op) {
-        case "Add" /* Add */:
-          return this.dtype === "bool" /* Bool */ ? Number(x || y) : x + y;
-        case "Sub" /* Sub */:
-          return x - y;
-        case "Mul" /* Mul */:
-          return this.dtype === "bool" /* Bool */ ? Number(x && y) : x * y;
-        case "Idiv" /* Idiv */:
-          return Math.trunc(x / y);
-        // Consistent with signed Mod.
-        case "Mod" /* Mod */:
-          return x % y;
-        case "Min" /* Min */:
-          return Math.min(x, y);
-        case "Max" /* Max */:
-          return Math.max(x, y);
-        case "Cmplt" /* Cmplt */:
-          return x < y;
-        case "Cmpne" /* Cmpne */:
-          return x != y;
-        default:
-          throw new Error(`Missing implemementation for ${this.op}`);
-      }
-    }
-    if (AluGroup.Unary.has(this.op)) {
-      const x = this.src[0].evaluate(context, globals);
-      switch (this.op) {
-        case "Sin" /* Sin */:
-          return Math.sin(x);
-        case "Cos" /* Cos */:
-          return Math.cos(x);
-        case "Exp" /* Exp */:
-          return Math.exp(x);
-        case "Log" /* Log */:
-          return Math.log(x);
-        case "Reciprocal" /* Reciprocal */:
-          return 1 / x;
-        case "Cast" /* Cast */:
-          if (this.dtype === "int32" /* Int32 */) return Math.floor(x);
-          else if (this.dtype === "float32" /* Float32 */) return x;
-          else if (this.dtype === "bool" /* Bool */) return Number(Boolean(x));
-          else throw new Error(`Unsupported cast to ${this.dtype}`);
-        default:
-          throw new Error(`Missing implemementation for ${this.op}`);
-      }
-    }
-    switch (this.op) {
-      case "Where" /* Where */:
-        return this.src[0].evaluate(context, globals) ? this.src[1].evaluate(context, globals) : this.src[2].evaluate(context, globals);
-      case "Const" /* Const */:
-        return this.arg;
-      case "Special" /* Special */:
-        return context[this.arg[0]];
-      case "Variable" /* Variable */:
-        return context[this.arg];
-      case "GlobalIndex" /* GlobalIndex */: {
-        if (!globals) throw new Error("Missing globals function");
-        const gid = this.arg;
-        const bufidx = this.src[0].evaluate(context, globals);
-        return globals(gid, bufidx);
-      }
-      case "GlobalView" /* GlobalView */: {
-        if (!globals) throw new Error("Missing globals function");
-        const gid = this.arg[0];
-        const st = this.arg[1];
-        const [iexpr, vexpr] = st.toAluExp(this.src);
-        if (vexpr.evaluate(context, globals)) {
-          const bufidx = iexpr.evaluate(context, globals);
-          return globals(gid, bufidx);
-        } else {
-          return 0;
-        }
-      }
-      default:
-        throw new Error(`Missing implemementation for ${this.op}`);
-    }
-  }
-  /** Get this expression in debug format as a string. */
-  toString() {
-    const BIN_SYM = {
-      ["Add" /* Add */]: "+",
-      ["Sub" /* Sub */]: "-",
-      ["Mul" /* Mul */]: "*",
-      ["Idiv" /* Idiv */]: "/",
-      ["Mod" /* Mod */]: "%"
-    };
-    const CMP_SYM = {
-      ["Cmplt" /* Cmplt */]: "<",
-      ["Cmpne" /* Cmpne */]: "!="
-    };
-    const UNARY_SYM = {
-      ["Sin" /* Sin */]: "sin",
-      ["Cos" /* Cos */]: "cos",
-      ["Exp" /* Exp */]: "exp",
-      ["Log" /* Log */]: "log",
-      ["Reciprocal" /* Reciprocal */]: "1/"
-    };
-    return this.fold((node, parts) => {
-      switch (node.op) {
-        case "Const" /* Const */:
-          return "" + (node.dtype === "bool" /* Bool */ ? Boolean(node.arg) : node.arg);
-        case "Variable" /* Variable */:
-          return `$${node.arg}:${node.dtype}`;
-        case "Special" /* Special */: {
-          const [name, n] = node.arg;
-          return `#${name}{${n}}`;
-        }
-        case "GlobalIndex" /* GlobalIndex */:
-          return `G_${node.arg}<${node.dtype}>[${strip1(parts[0])}]`;
-        case "GlobalView" /* GlobalView */: {
-          const [gid, st] = node.arg;
-          const shape = st.shape.join(",");
-          const cont = st.contiguous ? "c" : "nc";
-          return `GV_${gid}<${node.dtype}>{${shape}${cont ? "" : "*"}}[${parts.map(strip1).join(", ")}]`;
-        }
-      }
-      if (BIN_SYM[node.op]) {
-        return `(${parts[0]} ${BIN_SYM[node.op]} ${parts[1]})`;
-      }
-      if (CMP_SYM[node.op]) {
-        return `(${parts[0]} ${CMP_SYM[node.op]} ${parts[1]})`;
-      }
-      if (UNARY_SYM[node.op]) {
-        return `${UNARY_SYM[node.op]}${parts[0]}`;
-      }
-      if (node.op === "Cast" /* Cast */) {
-        return `Cast<${node.dtype}>(${strip1(parts[0])})`;
-      }
-      return `${node.op}(${parts.map(strip1).join(", ")})`;
-    });
-  }
-  /** Generic fold() operation with a reducer over the expression tree. */
-  fold(reducer) {
-    const visited = /* @__PURE__ */ new Map();
-    const recurse = (exp) => {
-      if (visited.has(exp)) return visited.get(exp);
-      const mappedSrc = exp.src.map((s) => recurse(s));
-      const result = reducer(exp, mappedSrc);
-      visited.set(exp, result);
-      return result;
-    };
-    return recurse(this);
-  }
-  /** Rewrite the expression recursively using a visitor. */
-  rewrite(visitor) {
-    return this.fold((exp, newSrc) => {
-      if (newSrc.length === exp.src.length && newSrc.every((s, i) => s === exp.src[i])) {
-        return visitor(exp) ?? exp;
-      } else {
-        const newExp = new _AluExp(exp.op, exp.dtype, newSrc, exp.arg);
-        return visitor(newExp) ?? newExp;
-      }
-    });
-  }
-  /** Collect all nodes that satisfy a predicate. */
-  collect(predicate) {
-    const result = [];
-    this.fold((exp) => {
-      if (predicate(exp)) result.push(exp);
-    });
-    return result;
-  }
-};
-var AluGroup = {
-  Binary: /* @__PURE__ */ new Set([
-    "Add" /* Add */,
-    "Sub" /* Sub */,
-    "Mul" /* Mul */,
-    "Idiv" /* Idiv */,
-    "Mod" /* Mod */,
-    "Min" /* Min */,
-    "Max" /* Max */
-  ]),
-  Unary: /* @__PURE__ */ new Set([
-    "Sin" /* Sin */,
-    "Cos" /* Cos */,
-    "Exp" /* Exp */,
-    "Log" /* Log */,
-    "Reciprocal" /* Reciprocal */,
-    "Cast" /* Cast */
-  ]),
-  Compare: /* @__PURE__ */ new Set(["Cmplt" /* Cmplt */, "Cmpne" /* Cmpne */]),
-  Variable: /* @__PURE__ */ new Set([
-    "Special" /* Special */,
-    "Variable" /* Variable */,
-    "GlobalIndex" /* GlobalIndex */,
-    "GlobalView" /* GlobalView */
-  ]),
-  Reduce: /* @__PURE__ */ new Set(["Add" /* Add */, "Mul" /* Mul */, "Min" /* Min */, "Max" /* Max */]),
-  RequiredFloat: /* @__PURE__ */ new Set([
-    "Sin" /* Sin */,
-    "Cos" /* Cos */,
-    "Exp" /* Exp */,
-    "Log" /* Log */,
-    "Reciprocal" /* Reciprocal */
-  ])
-};
-var AluVar = {
-  gidx: AluExp.variable("int32" /* Int32 */, "gidx"),
-  // global index
-  ridx: AluExp.variable("int32" /* Int32 */, "ridx"),
-  // reduction index
-  acc: (dtype) => AluExp.variable(dtype, "acc"),
-  // accumulator
-  idx: AluExp.variable("int32" /* Int32 */, "idx"),
-  // virtual "array index"
-  unroll: AluExp.variable("int32" /* Int32 */, "unroll"),
-  // unroll index, inside loop
-  upcast: AluExp.variable("int32" /* Int32 */, "upcast")
-  // upcast index, inside loop
-};
-var Kernel = class {
-  constructor(nargs, size, exp, reduction) {
-    this.nargs = nargs;
-    this.size = size;
-    this.exp = exp;
-    this.reduction = reduction;
-    this.exp = exp.simplify();
-  }
-  hash(state) {
-    state.update(this.nargs, this.size, this.exp, this.reduction);
-  }
-};
-var Reduction = class {
-  constructor(dtype, op, size, fusion = AluVar.acc(dtype)) {
-    this.dtype = dtype;
-    this.op = op;
-    this.size = size;
-    this.fusion = fusion;
-    if (!AluGroup.Reduce.has(op)) {
-      throw new TypeError(`Unsupported reduction: ${op}`);
-    }
-  }
-  hash(state) {
-    state.update(this.dtype, this.op, this.size, this.fusion);
-  }
-  /** Get the identity for this reduction operation. */
-  get identity() {
-    if (this.dtype === "bool" /* Bool */) {
-      return this.op === "Add" /* Add */ || this.op === "Max" /* Max */ ? false : true;
-    } else if (this.dtype === "int32" /* Int32 */) {
-      if (this.op === "Add" /* Add */) return 0;
-      else if (this.op === "Mul" /* Mul */) return 1;
-      else if (this.op === "Min" /* Min */) return -1 >>> 1;
-      else if (this.op === "Max" /* Max */) return 1 << 31;
-    } else if (this.dtype === "float32" /* Float32 */) {
-      if (this.op === "Add" /* Add */) return 0;
-      else if (this.op === "Mul" /* Mul */) return 1;
-      else if (this.op === "Min" /* Min */) return Infinity;
-      else if (this.op === "Max" /* Max */) return -Infinity;
-    }
-    throw new TypeError(`Unsupported reduction: ${this.op} ${this.dtype}`);
-  }
-  /** Evaluate this operation on CPU. */
-  evaluate(...values) {
-    if (this.dtype === "bool" /* Bool */) {
-      if (this.op === "Add" /* Add */ || this.op === "Max" /* Max */) {
-        return values.reduce((a, b) => a || b, true);
-      } else if (this.op === "Mul" /* Mul */ || this.op === "Min" /* Min */) {
-        return values.reduce((a, b) => a && b, true);
-      }
-    } else if (this.dtype === "int32" /* Int32 */) {
-      if (this.op === "Add" /* Add */) {
-        return values.reduce((a, b) => a + b | 0, 0);
-      } else if (this.op === "Mul" /* Mul */) {
-        return values.reduce((a, b) => a * b | 0, 1);
-      } else if (this.op === "Min" /* Min */) {
-        return values.reduce(
-          (a, b) => Math.min(a, b),
-          -1 >>> 1
-        );
-      } else if (this.op === "Max" /* Max */) {
-        return values.reduce((a, b) => Math.max(a, b), 1 << 31);
-      }
-    } else if (this.dtype === "float32" /* Float32 */) {
-      if (this.op === "Add" /* Add */) {
-        return values.reduce((a, b) => a + b, 0);
-      } else if (this.op === "Mul" /* Mul */) {
-        return values.reduce((a, b) => a * b, 1);
-      } else if (this.op === "Min" /* Min */) {
-        return values.reduce(
-          (a, b) => Math.min(a, b),
-          Infinity
-        );
-      } else if (this.op === "Max" /* Max */) {
-        return values.reduce(
-          (a, b) => Math.max(a, b),
-          -Infinity
-        );
-      }
-    }
-    throw new TypeError(`Unsupported reduction: ${this.op} ${this.dtype}`);
-  }
-};
-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)
-  );
-}
-function accessorAluExp(exp, st, indices) {
-  const [index, valid] = st.toAluExp(indices);
-  return AluExp.where(valid, exp.substitute({ idx: index }), AluExp.f32(0));
-}
-
-// src/shape.ts
-var jstr = JSON.stringify;
-function canonicalizeStrides(shape, strides) {
-  const newStrides = [];
-  for (let i = 0; i < shape.length; i++) {
-    if (shape[i] === 1) newStrides.push(0);
-    else newStrides.push(strides[i]);
-  }
-  return newStrides;
-}
-function defaultStrides(shape) {
-  if (shape.length === 0) return [];
-  const strides = rep(shape.length, 1);
-  for (let i = shape.length - 1; i > 0; i--) {
-    strides[i - 1] = shape[i] * strides[i];
-  }
-  return canonicalizeStrides(shape, strides);
-}
-function mergeDims(shape, strides, mask) {
-  if (shape.length === 0) return [];
-  if (shape.length !== strides.length || mask && shape.length !== mask.length) {
-    throw new Error("internal: invalid args to mergeDims");
-  }
-  const ret = [
-    [shape[0], strides[0], strides[0] !== 0 ? shape[0] : 0]
-  ];
-  let merging = mask ? mask[0][1] - mask[0][0] === 1 : shape[0] === 1;
-  for (let i = 1; i < shape.length; i++) {
-    const [s, st] = [shape[i], strides[i]];
-    if (s === 1) continue;
-    const [lastS, lastSt, lastPreExpandS] = ret[ret.length - 1];
-    if (merging || lastSt === 0 || lastSt === s * st) {
-      ret[ret.length - 1] = [lastS * s, st, merging ? s : lastPreExpandS * s];
-    } else {
-      ret.push([s, st, s]);
-    }
-    merging = mask ? mask[i][1] - mask[i][0] === 1 : false;
-  }
-  return ret;
-}
-function reshapeMask(maskInput, oldShape, newShape) {
-  const newMask = [];
-  let rMasksI = maskInput.length;
-  let rShapeI = oldShape.length;
-  let rNewShapeI = newShape.length;
-  const rMasks = () => rMasksI ? maskInput[--rMasksI] : [0, 1];
-  const rShape = () => rShapeI ? oldShape[--rShapeI] : 1;
-  const rNewShape = () => rNewShapeI ? newShape[--rNewShapeI] : 1;
-  let currStride = 1;
-  let [oldDim, newDim, mask] = [rShape(), rNewShape(), rMasks()];
-  while (newMask.length < newShape.length) {
-    const [l, r] = mask;
-    const nextStride = newDim * currStride;
-    if (oldDim === nextStride) {
-      newMask.push([intdiv(l, currStride), intdiv(r - 1, currStride) + 1]);
-      currStride = 1;
-      [oldDim, newDim, mask] = [rShape(), rNewShape(), rMasks()];
-    } else if (oldDim > nextStride) {
-      if (oldDim % nextStride !== 0) return null;
-      if ((l % nextStride !== 0 || r % nextStride !== 0) && intdiv(l, nextStride) !== intdiv(r - 1, nextStride))
-        return null;
-      newMask.push([
-        intdiv(l % nextStride, currStride),
-        intdiv((r - 1) % nextStride, currStride) + 1
-      ]);
-      [currStride, newDim] = [nextStride, rNewShape()];
-    } else {
-      const nextMask = rMasks();
-      if (!deepEqual(mask, [0, oldDim]) && l !== r && nextMask[1] - nextMask[0] !== 1)
-        return null;
-      mask = [nextMask[0] * oldDim + l, (nextMask[1] - 1) * oldDim + r];
-      oldDim *= rShape();
-    }
-  }
-  return newMask.reverse();
-}
-var View = class _View {
-  constructor(shape, strides, offset, mask) {
-    this.shape = shape;
-    this.strides = strides;
-    this.offset = offset;
-    this.mask = mask;
-  }
-  // Cached, computed property values.
-  #size;
-  #contiguous;
-  static create(shape, strides, offset = 0, mask = null) {
-    if (shape.some((s) => s < 0))
-      throw new Error("View shape must be non-negative");
-    strides = strides ? canonicalizeStrides(shape, strides) : defaultStrides(shape);
-    if (shape.includes(0)) {
-      return new _View(shape, rep(shape.length, 0), 0, null);
-    }
-    if (mask !== null && mask.every(([b, e], i) => b === 0 && e === shape[i])) {
-      mask = null;
-    }
-    if (mask !== null) {
-      const elimDims = [];
-      let hasNoData = false;
-      for (let i = 0; i < shape.length; i++) {
-        const [b, e] = mask[i];
-        if (b + 1 >= e) elimDims.push(i);
-        if (b >= e) hasNoData = true;
-      }
-      if (elimDims.length) {
-        if (hasNoData) {
-          strides = rep(shape.length, 0);
-          offset = 0;
-          mask = rep(shape.length, () => [0, 0]);
-        }
-        for (const i of elimDims) {
-          offset += strides[i] * mask[i][0];
-          strides[i] = 0;
-        }
-      }
-    }
-    return new _View(shape, strides, offset, mask);
-  }
-  get ndim() {
-    return this.shape.length;
-  }
-  get size() {
-    if (this.#size === void 0) this.#size = prod(this.shape);
-    return this.#size;
-  }
-  /** Whether this is a default, contiguous, unaltered view of the data (identity). */
-  get contiguous() {
-    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;
-  }
-  /** Produce an AluExp for evaluating this view at an index. */
-  toAluExp(idxs) {
-    let iexpr = AluExp.i32(this.offset);
-    let vexpr = AluExp.bool(true);
-    for (let i = this.ndim - 1; i >= 0; i--) {
-      const idx = idxs[i];
-      if (this.shape[i] !== 1 && this.strides[i] !== 0) {
-        iexpr = AluExp.add(AluExp.mul(idx, AluExp.i32(this.strides[i])), iexpr);
-      }
-      if (this.mask) {
-        if (this.mask[i][0] !== 0)
-          vexpr = AluExp.mul(
-            AluExp.cmplt(idx, AluExp.i32(this.mask[i][0])).not(),
-            vexpr
-          );
-        if (this.mask[i][1] !== this.shape[i])
-          vexpr = AluExp.mul(
-            AluExp.cmplt(idx, AluExp.i32(this.mask[i][1])),
-            vexpr
-          );
-      }
-    }
-    return [iexpr, vexpr];
-  }
-  /**
-   * Try to compose this view with another one. `this` view is applied first,
-   * followed by the argument. If this is not possible for the specific views,
-   * return `null` instead.
-   *
-   * If composable, return a combined view with the same shape as `v1`.
-   *
-   * This is very tricky. The shapes of v1 and v2 may be different, and in that
-   * case, we do some math to figure out whether they're compatible.
-   */
-  compose(v1) {
-    const v2 = this;
-    if (v2.contiguous) return v1;
-    if (v1.contiguous) {
-      if (deepEqual(v1.shape, v2.shape)) return v2;
-      if (v1.size === v2.size) {
-        const ret = v2.reshape(v1.shape);
-        if (ret !== null) return ret;
-      }
-    }
-    if (v1.mask !== null) {
-      const newV1 = v1.shrink(v1.mask);
-      const merged = v2.compose(newV1);
-      return merged ? merged.pad(zip(v1.mask, v1.shape).map(([m, s]) => [m[0], s - m[1]])) : null;
-    }
-    const origin = unravel(v2.shape, v1.offset);
-    const terms = rep(v2.ndim, () => []);
-    const strides = rep(v1.ndim, 0);
-    for (let d1 = 0; d1 < v1.strides.length; d1++) {
-      const st = v1.strides[d1];
-      if (st === 0) {
-        continue;
-      }
-      const unravelOffset = unravel(v2.shape, v1.offset + st);
-      for (let d2 = 0; d2 < v2.ndim; d2++) {
-        const o = origin[d2];
-        const diff = unravelOffset[d2] - o;
-        if (diff === 0) {
-          continue;
-        }
-        terms[d2].push([d1, diff]);
-        strides[d1] += diff * v2.strides[d2];
-      }
-    }
-    let [mergedSize, mergedTermMin, mergedTermMax] = [1, 0, 0];
-    const extents = [];
-    for (let i = v2.ndim - 1; i >= 0; i--) {
-      const term = terms[i];
-      const s = v2.shape[i];
-      let [tmin, tmax] = [origin[i], origin[i]];
-      for (const [d1, s1] of term) {
-        if (s1 > 0) tmax += (v1.shape[d1] - 1) * s1;
-        else if (s1 < 0) tmin += (v1.shape[d1] - 1) * s1;
-      }
-      mergedTermMin += tmin * mergedSize;
-      mergedTermMax += tmax * mergedSize;
-      mergedSize *= s;
-      if (mergedTermMin >= 0 && mergedTermMax < mergedSize) {
-        extents.push([mergedSize, mergedTermMin, mergedTermMax]);
-        [mergedSize, mergedTermMin, mergedTermMax] = [1, 0, 0];
-      }
-    }
-    if (mergedTermMin !== 0 || mergedTermMax !== 0) return null;
-    extents.reverse();
-    const v2Shape = extents.map(([s]) => s);
-    if (!deepEqual(v2Shape, v2.shape)) {
-      const reshapedV2 = v2.reshape(v2Shape);
-      if (reshapedV2 === null) return null;
-      if (!deepEqual(reshapedV2.shape, v2.shape)) return reshapedV2.compose(v1);
-    }
-    if (v2.mask !== null) {
-      const newB = rep(v1.ndim, 0);
-      const newE = v1.shape.slice();
-      let bad = false;
-      for (let d2 = 0; d2 < v2.ndim; d2++) {
-        const [b, e] = v2.mask[d2];
-        const o = origin[d2];
-        const term = terms[d2];
-        const [_, tmin, tmax] = extents[d2];
-        if (b <= tmin && tmax < e) continue;
-        if (term.length !== 1) {
-          if (term.length === 0 && newE.length) newE[0] = 0;
-          else bad = true;
-        } else {
-          const [d1, s1] = term[0];
-          newB[d1] = Math.max(
-            newB[d1],
-            Math.ceil((s1 > 0 ? b - o : e - o - 1) / s1)
-          );
-          newE[d1] = Math.min(
-            newE[d1],
-            Math.floor((s1 < 0 ? b - o : e - o - 1) / s1) + 1
-          );
-        }
-      }
-      for (let d1 = 0; d1 < v1.ndim; d1++) {
-        if (newB[d1] !== 0 || newE[d1] !== v1.shape[d1]) {
-          return v2.compose(
-            _View.create(v1.shape, v1.strides, v1.offset, zip(newB, newE))
-          );
-        }
-      }
-      if (bad) return null;
-    }
-    let finalOffset = v2.offset;
-    for (let d2 = 0; d2 < v2.ndim; d2++) {
-      finalOffset += origin[d2] * v2.strides[d2];
-    }
-    return _View.create(v1.shape, strides, finalOffset, null);
-  }
-  /** Attempt to simplify this view into a smaller reshaped form. */
-  minify() {
-    const minShape = mergeDims(this.shape, this.strides, this.mask).map(
-      (x) => x[0]
-    );
-    const nv = this.reshape(minShape);
-    return nv ? nv : this;
-  }
-  /** Pad the view with zeros on each dimension. */
-  pad(arg) {
-    if (arg.length !== this.ndim || !arg.every(([b, e]) => b >= 0 && e >= 0)) {
-      throw new Error(`invalid pad ${jstr(arg)} for ${jstr(this.shape)}`);
-    }
-    if (arg.every(([b, e]) => b === 0 && e === 0)) return this;
-    const zvarg = arg.map(([b, e], i) => [-b, this.shape[i] + e]);
-    const mask = arg.map(([b, _e], i) => [b, this.shape[i] + b]);
-    return this.#unsafeResize(zvarg, mask);
-  }
-  /** Shrink the view by taking a subarray. */
-  shrink(arg) {
-    if (arg.length !== this.ndim || !arg.every(([b, e], i) => 0 <= b && b <= e && e <= this.shape[i])) {
-      throw new Error(`invalid shrink ${jstr(arg)} for ${jstr(this.shape)}`);
-    }
-    return this.#unsafeResize(arg);
-  }
-  #unsafeResize(arg, mask) {
-    const offset = this.strides.map((s, i) => s * arg[i][0]).reduce((a, b) => a + b, 0);
-    if (this.mask) {
-      const nmask = this.mask.map(([mx, my], i) => [
-        Math.max(0, Math.min(mx - arg[i][0], arg[i][1] - arg[i][0])),
-        Math.max(0, Math.min(my - arg[i][0], arg[i][1] - arg[i][0]))
-      ]);
-      mask = mask ? mask.map(([mx, my], i) => [
-        Math.max(mx, nmask[i][0]),
-        Math.min(my, nmask[i][1])
-      ]) : nmask;
-    }
-    return _View.create(
-      arg.map(([b, e]) => e - b),
-      this.strides,
-      this.offset + offset,
-      mask
-    );
-  }
-  /** Expand one or more axes with length "1" by repeating the data. */
-  expand(newShape) {
-    if (newShape.length !== this.ndim) {
-      throw new Error(
-        `Can't expand ${jstr(this.shape)} into ${jstr(newShape)}`
-      );
-    }
-    for (let i = 0; i < this.ndim; i++) {
-      if (newShape[i] !== this.shape[i] && this.shape[i] !== 1) {
-        throw new Error(
-          `Can't expand ${jstr(this.shape)} into ${jstr(newShape)}`
-        );
-      }
-    }
-    if (this.size === 0) return _View.create(newShape);
-    const mask = this.mask ? this.mask.map(
-      (m, i) => this.shape[i] === newShape[i] ? m : m[0] === 0 && m[1] === 1 ? [0, newShape[i]] : [0, 0]
-    ) : null;
-    return _View.create(newShape, this.strides, this.offset, mask);
-  }
-  /** Permute the axes of an array. */
-  permute(axis) {
-    if (!isPermutation(axis, this.ndim))
-      throw new Error(`Invalid permutation ${jstr(axis)} of len ${this.ndim}`);
-    const newShape = axis.map((a) => this.shape[a]);
-    const newStrides = axis.map((a) => this.strides[a]);
-    const newMask = this.mask ? axis.map((a) => this.mask[a]) : null;
-    return _View.create(newShape, newStrides, this.offset, newMask);
-  }
-  /** Flip (reverse) one or more axes of the view. */
-  flip(arg) {
-    if (arg.length !== this.ndim)
-      throw new Error(`Invalid flip ${jstr(arg)} for ${jstr(this.shape)}`);
-    const strides = this.strides.slice();
-    let offset = this.offset;
-    const mask = this.mask ? this.mask.slice() : null;
-    for (let i = 0; i < this.ndim; i++) {
-      const s = this.shape[i];
-      if (arg[i]) {
-        strides[i] = -strides[i];
-        offset += (s - 1) * this.strides[i];
-        if (mask) mask[i] = [s - mask[i][1], s - mask[i][0]];
-      }
-    }
-    return _View.create(this.shape, strides, offset, mask);
-  }
-  /** Reshape the view into a new shape. */
-  reshape(newShape) {
-    if (deepEqual(this.shape, newShape)) return this;
-    if (newShape.some((s) => s < 0))
-      throw new Error(`Reshape cannot have negative numbers ${jstr(newShape)}`);
-    if (this.size !== prod(newShape))
-      throw new Error(`Reshape size ${jstr(this.shape)} -> ${jstr(newShape)}`);
-    if (this.size === 0) return _View.create(newShape);
-    if (newShape.length === 0 && this.mask?.some(([b, e]) => b === e))
-      return null;
-    if (this.contiguous) return _View.create(newShape);
-    const rStrides = [];
-    const merge = mergeDims(this.shape, this.strides, this.mask);
-    let rShapeIdx = newShape.length;
-    for (let i = merge.length - 1; i >= 0; i--) {
-      let [mergedSize, newStride, realSize] = merge[i];
-      let acc = 1;
-      while (acc < mergedSize && rShapeIdx > 0) {
-        const newDim = newShape[--rShapeIdx];
-        rStrides.push(newStride * acc);
-        acc *= newDim;
-        if (acc >= realSize) newStride = 0;
-      }
-      if (acc !== mergedSize) return null;
-    }
-    const newStrides = rep(newShape.length - rStrides.length, 0).concat(
-      rStrides.reverse()
-    );
-    if (!this.mask) return _View.create(newShape, newStrides, this.offset);
-    const newMask = reshapeMask(this.mask, this.shape, newShape);
-    if (!newMask) return null;
-    let newOffset = this.offset;
-    for (let i = 0; i < this.ndim; i++)
-      newOffset += this.strides[i] * this.mask[i][0];
-    for (let i = 0; i < newShape.length; i++)
-      newOffset -= newStrides[i] * newMask[i][0];
-    return _View.create(newShape, newStrides, newOffset, newMask);
-  }
-};
-function unravel(shape, offset) {
-  let acc = 1;
-  const idxs = [];
-  for (let i = shape.length - 1; i >= 0; i--) {
-    const d = shape[i];
-    idxs.push(Math.floor(offset / acc) % d);
-    acc *= d;
-  }
-  return idxs.reverse();
-}
-function unravelAlu(shape, offset) {
-  let acc = 1;
-  const idxs = [];
-  for (let i = shape.length - 1; i >= 0; i--) {
-    const d = shape[i];
-    idxs.push(AluExp.mod(AluExp.idiv(offset, AluExp.i32(acc)), AluExp.i32(d)));
-    acc *= d;
-  }
-  return idxs.reverse();
-}
-var ShapeTracker = class _ShapeTracker {
-  constructor(views) {
-    this.views = views;
-  }
-  // Views apply left-to-right
-  /** Compose this shape tracker with another, applying after. */
-  compose(other) {
-    if (this.contiguous) return other;
-    let ret = this;
-    for (const v of other.views) {
-      ret = new _ShapeTracker(ret.views.concat(v)).simplify();
-    }
-    return ret;
-  }
-  static fromShape(shape) {
-    return new _ShapeTracker([View.create(shape)]);
-  }
-  get contiguous() {
-    return this.views.length === 1 && this.views[0].contiguous;
-  }
-  get consecutive() {
-    return this.views.length === 1 && this.views[0].mask === null && deepEqual(this.views[0].strides, defaultStrides(this.views[0].shape));
-  }
-  get lastStrides() {
-    return this.views[this.views.length - 1].strides;
-  }
-  get shape() {
-    return this.views[this.views.length - 1].shape;
-  }
-  get size() {
-    return this.views[this.views.length - 1].size;
-  }
-  toAluExp(idxs) {
-    let [iexpr, vexpr] = this.views[this.views.length - 1].toAluExp(idxs);
-    for (let i = this.views.length - 2; i >= 0; i--) {
-      const view = this.views[i].minify();
-      const exprs = view.toAluExp(unravelAlu(view.shape, iexpr));
-      iexpr = exprs[0];
-      vexpr = AluExp.mul(vexpr, exprs[1]);
-    }
-    return [iexpr.simplify(), vexpr.simplify()];
-  }
-  simplify() {
-    const views = this.views.slice();
-    while (views.length >= 2) {
-      const newView = views[views.length - 2].compose(views[views.length - 1]);
-      if (newView === null) break;
-      views.splice(views.length - 2, 2, newView);
-    }
-    return new _ShapeTracker(views);
-  }
-  pad(arg) {
-    return new _ShapeTracker(applyLast(this.views, (x) => x.pad(arg)));
-  }
-  shrink(arg) {
-    return new _ShapeTracker(applyLast(this.views, (x) => x.shrink(arg)));
-  }
-  expand(newShape) {
-    return new _ShapeTracker(applyLast(this.views, (x) => x.expand(newShape)));
-  }
-  permute(axis) {
-    return new _ShapeTracker(applyLast(this.views, (x) => x.permute(axis)));
-  }
-  flip(arg) {
-    return new _ShapeTracker(applyLast(this.views, (x) => x.flip(arg)));
-  }
-  reshape(newShape) {
-    const newView = this.views[this.views.length - 1].reshape(newShape);
-    return new _ShapeTracker(
-      newView === null ? this.views.concat(View.create(newShape)) : this.views.toSpliced(this.views.length - 1, 1, newView)
-    );
-  }
-  // Below this line are "composite" operations.
-  /** Broadcast along the given new axes, then expand the shape. */
-  broadcast(newShape, axis) {
-    let st = this;
-    if (axis.length > 0) {
-      const unsqueezed = [...st.shape];
-      for (const i of axis.toSorted()) {
-        unsqueezed.splice(i, 0, 1);
-      }
-      st = st.reshape(unsqueezed);
-    }
-    return st.expand(newShape);
-  }
-};
-function applyLast(ar, f) {
-  return ar.toSpliced(ar.length - 1, 1, f(ar[ar.length - 1]));
-}
-
-// src/tuner.ts
-var TuneDims = class {
-  st;
-  // Shape tracker including reduction axes.
-  outputSt;
-  // Shape tracker including only output axes.
-  // local: number; // TODO: Split gidx -> global and local axes during tuning.
-  groups;
-  // Reductions start here, with groups.
-  reduce;
-  // Single reduction thread.
-  unroll;
-  // Upcast along the reduce dimension.
-  upcast;
-  // Upcast along output dimension.
-  get end() {
-    return this.st.shape.length;
-  }
-  constructor(shape) {
-    this.st = ShapeTracker.fromShape(shape);
-    this.outputSt = ShapeTracker.fromShape(shape.slice(0, -1));
-    this.groups = this.st.shape.length - 1;
-    this.reduce = this.st.shape.length - 1;
-    this.unroll = this.st.shape.length;
-    this.upcast = this.st.shape.length;
-  }
-  // Place the axis at the end of the shape, so it is part of each workgroup.
-  applyLocal(axis, amount) {
-    if (axis >= this.groups) throw new Error("Cannot localize reduction axis");
-    const length = this.st.shape[axis];
-    if (length % amount !== 0)
-      throw new Error(`Localize by ${amount} on axis length ${length}`);
-    if (length !== amount) {
-      this.groups++, this.reduce++, this.unroll++, this.upcast++;
-      this.st = this.st.reshape([
-        ...this.st.shape.slice(0, axis),
-        length / amount,
-        amount,
-        ...this.st.shape.slice(axis + 1)
-      ]);
-      this.outputSt = this.outputSt.reshape([
-        ...this.outputSt.shape.slice(0, axis),
-        length / amount,
-        amount,
-        ...this.outputSt.shape.slice(axis + 1)
-      ]);
-      axis++;
-    }
-    this.st = this.st.permute([
-      ...range(axis),
-      ...range(axis + 1, this.groups),
-      axis,
-      ...range(this.groups, this.st.shape.length)
-    ]);
-    this.outputSt = this.outputSt.permute([
-      ...range(axis),
-      ...range(axis + 1, this.groups),
-      axis,
-      ...range(this.groups, this.outputSt.shape.length)
-    ]);
-  }
-  applyUpcast(axis, amount) {
-    if (axis >= this.groups)
-      throw new Error("Cannot upcast along reduction axis");
-    const length = this.st.shape[axis];
-    if (length % amount !== 0)
-      throw new Error(`Upcast by ${amount} on axis length ${length}`);
-    this.st = this.st.reshape([
-      ...this.st.shape.slice(0, axis),
-      length / amount,
-      amount,
-      ...this.st.shape.slice(axis + 1)
-    ]).permute([
-      ...range(axis + 1),
-      ...range(axis + 2, this.st.shape.length + 1),
-      axis + 1
-    ]);
-    this.outputSt = this.outputSt.reshape([
-      ...this.outputSt.shape.slice(0, axis),
-      length / amount,
-      amount,
-      ...this.outputSt.shape.slice(axis + 1)
-    ]).permute([
-      ...range(axis + 1),
-      ...range(axis + 2, this.outputSt.shape.length + 1),
-      axis + 1
-    ]);
-  }
-  applyUnroll(axis, amount) {
-    if (axis < this.groups) throw new Error("Cannot unroll non-reduce axis");
-    if (axis >= this.unroll) throw new Error("Axis already unrolled");
-    const length = this.st.shape[axis];
-    if (length % amount !== 0)
-      throw new Error(`Unroll by ${amount} on axis length ${length}`);
-    if (length === amount) {
-      this.st = this.st.permute([
-        ...range(axis),
-        ...range(axis + 1, this.upcast),
-        axis,
-        ...range(this.upcast, this.st.shape.length)
-      ]);
-      if (axis < this.reduce) this.reduce--;
-      this.unroll--;
-    } else {
-      this.st = this.st.reshape([
-        ...this.st.shape.slice(0, axis),
-        length / amount,
-        amount,
-        ...this.st.shape.slice(axis + 1)
-      ]).permute([
-        ...range(axis + 1),
-        ...range(axis + 2, this.upcast + 1),
-        // Move to just before upcast
-        axis + 1,
-        ...range(this.upcast + 1, this.st.shape.length + 1)
-      ]);
-      this.upcast++;
-    }
-  }
-};
-function tuneNullopt(kernel) {
-  const vars = {};
-  vars.gidx = AluExp.special("int32" /* Int32 */, "gidx", kernel.size);
-  if (kernel.reduction)
-    vars.ridx = AluExp.special("int32" /* Int32 */, "ridx", kernel.reduction.size);
-  return {
-    exp: kernel.exp.rewrite((exp) => {
-      if (exp.op === "GlobalView" /* GlobalView */) {
-        const gid = exp.arg[0];
-        const st = exp.arg[1];
-        return accessorGlobal(exp.dtype, gid, st, exp.src);
-      }
-    }).substitute(vars).simplify(),
-    outputIdxExp: AluExp.special("int32" /* Int32 */, "gidx", kernel.size),
-    threadCount: kernel.size,
-    size: {
-      reduce: kernel.reduction ? kernel.reduction.size : 0
-    }
-  };
-}
-function tuneWebgpu(kernel) {
-  const { exp, reduction } = kernel;
-  if (!reduction) return tuneNullopt(kernel);
-  const globalIndexes = exp.collect((exp2) => exp2.op === "GlobalIndex" /* GlobalIndex */);
-  if (globalIndexes.length > 0) {
-    if (DEBUG >= 4) console.log("Tuning: Found GlobalIndex ops, skipping opt.");
-    return tuneNullopt(kernel);
-  }
-  const globalViews = exp.collect((exp2) => exp2.op === "GlobalView" /* GlobalView */);
-  if (globalViews.length === 0) {
-    if (DEBUG >= 4) console.info("Tuning: No GlobalView ops found in kernel.");
-    return tuneNullopt(kernel);
-  }
-  const shape = globalViews[0].arg[1].shape;
-  const expectedSrc = [
-    ...unravelAlu(shape.slice(0, -1), AluVar.gidx),
-    AluVar.ridx
-  ].map((e) => e.simplify());
-  for (const gv of globalViews) {
-    if (!gv.src.length || !deepEqual(gv.src, expectedSrc)) {
-      if (DEBUG >= 4)
-        console.info("Tuning: GlobalView src[] not consistent with reduction.");
-      return tuneNullopt(kernel);
-    }
-  }
-  if (shape[shape.length - 1] !== reduction.size)
-    throw new Error("Invariant violation: shape doesn't match reduction size.");
-  const sts = globalViews.map((gv) => gv.arg[1]);
-  for (const st of sts) {
-    if (!deepEqual(st.shape, shape))
-      throw new Error("Invariant violation: GlobalView shape mismatch");
-  }
-  const dim = new TuneDims(shape);
-  const upcastedAxis = /* @__PURE__ */ new Set();
-  while (prod(dim.st.shape.slice(0, dim.groups)) >= 1024) {
-    const choices = [];
-    const composedSts = sts.map((st) => st.compose(dim.st));
-    for (let axis = 0; axis < dim.groups; axis++) {
-      for (const amount of [3, 4]) {
-        if (!upcastedAxis.has(axis) && dim.st.shape[axis] % amount === 0 && composedSts.some(
-          (st) => st.lastStrides[axis] === 0 && st.lastStrides.slice(dim.unroll).every((stride) => stride > 0)
-        )) {
-          let nonzeroStrides = 0;
-          let totalStrides = 0;
-          for (const st of composedSts) {
-            nonzeroStrides += st.lastStrides[axis] > 0 ? 1 : 0;
-            totalStrides += st.lastStrides[axis];
-          }
-          choices.push([nonzeroStrides, totalStrides, axis, amount]);
-        }
-      }
-    }
-    if (choices.length > 0) {
-      choices.sort(lexCompare);
-      dim.applyUpcast(choices[0][2], choices[0][3]);
-      upcastedAxis.add(choices[0][2]);
-    } else {
-      break;
-    }
-  }
-  if (/chrome/i.test(navigator.userAgent) && dim.reduce < dim.unroll && (prod(dim.st.shape.slice(dim.unroll)) <= 4 || dim.unroll === dim.upcast && prod(dim.st.shape.slice(dim.upcast)) < 64)) {
-    const s = dim.st.shape[dim.unroll - 1];
-    if (s <= 32) {
-      dim.applyUnroll(dim.reduce, s);
-    } else {
-      for (const splits of [4]) {
-        if (s % splits === 0) {
-          dim.applyUnroll(dim.unroll - 1, splits);
-          break;
-        }
-      }
-    }
-  }
-  for (const ax of Array.from(upcastedAxis).sort()) {
-    const s = dim.st.shape[ax];
-    for (const amount of [8, 4]) {
-      if (s % amount === 0) {
-        dim.applyLocal(ax, amount);
-        break;
-      }
-    }
-  }
-  const indices = [];
-  const addIndices = (s, exp2) => {
-    if (s.length === 0) return;
-    else if (s.length === 1) indices.push(exp2);
-    else indices.push(...unravelAlu(s, exp2));
-  };
-  if (0 < dim.groups) {
-    const s = dim.st.shape.slice(0, dim.groups);
-    addIndices(s, AluExp.special("int32" /* Int32 */, "gidx", prod(s)));
-  }
-  if (dim.groups < dim.reduce) {
-    const s = dim.st.shape.slice(dim.groups, dim.reduce);
-    addIndices(s, AluExp.special("int32" /* Int32 */, "group", prod(s)));
-  }
-  if (dim.reduce <= dim.unroll) {
-    const s = dim.st.shape.slice(dim.reduce, dim.unroll);
-    addIndices(s, AluExp.special("int32" /* Int32 */, "ridx", prod(s)));
-  }
-  if (dim.unroll < dim.upcast) {
-    const s = dim.st.shape.slice(dim.unroll, dim.upcast);
-    addIndices(s, AluVar.unroll);
-  }
-  if (dim.upcast < dim.end) {
-    const s = dim.st.shape.slice(dim.upcast);
-    addIndices(s, AluVar.upcast);
-  }
-  const newExp = exp.rewrite((exp2) => {
-    if (exp2.op === "GlobalView" /* GlobalView */) {
-      const gid = exp2.arg[0];
-      const st = exp2.arg[1];
-      return accessorGlobal(exp2.dtype, gid, st.compose(dim.st), indices);
-    }
-  });
-  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("int32" /* Int32 */, "gidx", prod(outputGidx))
-    ),
-    ...unravelAlu(outputUpcast, AluVar.upcast)
-    // Needs later substitution.
-  ]);
-  if (prod(dim.st.shape.slice(dim.groups, dim.upcast)) !== reduction.size) {
-    throw new Error(
-      `Invariant violation: reduction size ${reduction.size} does not match tuned dims ${JSON.stringify(dim.st.shape.slice(dim.groups, dim.upcast))}`
-    );
-  }
-  const size = {
-    groups: prod(dim.st.shape.slice(dim.groups, dim.reduce)),
-    reduce: prod(dim.st.shape.slice(dim.reduce, dim.unroll)),
-    unroll: prod(dim.st.shape.slice(dim.unroll, dim.upcast)),
-    upcast: prod(dim.st.shape.slice(dim.upcast))
-  };
-  return {
-    exp: newExp.simplify(),
-    outputIdxExp: outputIdxExp.simplify(),
-    threadCount: kernel.size / size.upcast * size.groups,
-    size
-  };
-}
-
-// src/backend/cpu.ts
-var CPUBackend = class {
-  type = "cpu";
-  maxArgs = Infinity;
-  #buffers;
-  #nextSlot;
-  constructor() {
-    this.#buffers = /* @__PURE__ */ new Map();
-    this.#nextSlot = 1;
-  }
-  malloc(size, initialData) {
-    const buffer = new ArrayBuffer(size);
-    if (initialData) {
-      if (initialData.byteLength !== size) {
-        throw new Error("initialData size does not match buffer size");
-      }
-      new Uint8Array(buffer).set(new Uint8Array(initialData));
-    }
-    const slot = this.#nextSlot++;
-    this.#buffers.set(slot, { buffer, 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.#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) {
-    return new Executable(kernel, void 0);
-  }
-  dispatch({ kernel }, inputs, outputs) {
-    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((exp2) => exp2.op === "GlobalIndex" /* GlobalIndex */).map((exp2) => [exp2.arg, exp2.dtype])
-    );
-    const inputArrays = inputBuffers.map((buf, i) => {
-      const dtype = usedArgs.get(i);
-      if (!dtype) return null;
-      return dtype === "float32" /* Float32 */ ? new Float32Array(buf) : new Int32Array(buf);
-    });
-    const outputArray = exp.dtype === "float32" /* Float32 */ ? new Float32Array(outputBuffers[0]) : new Int32Array(outputBuffers[0]);
-    const globals = (gidx, bufidx) => inputArrays[gidx][bufidx];
-    if (!kernel.reduction) {
-      for (let i = 0; i < kernel.size; i++) {
-        outputArray[i] = exp.evaluate({ gidx: i }, globals);
-      }
-    } else {
-      for (let i = 0; i < kernel.size; i++) {
-        let acc = kernel.reduction.identity;
-        for (let j = 0; j < kernel.reduction.size; j++) {
-          const item = exp.evaluate({ gidx: i, ridx: j }, globals);
-          acc = kernel.reduction.evaluate(acc, item);
-        }
-        outputArray[i] = kernel.reduction.fusion.evaluate({ acc });
-      }
-    }
-  }
-  #getBuffer(slot) {
-    const buffer = this.#buffers.get(slot);
-    if (!buffer) throw new SlotError(slot);
-    return buffer.buffer;
-  }
-};
-
-// src/backend.ts
-var devices = ["cpu", "webgpu"];
-var defaultBackend = "cpu";
-var initializedBackends = /* @__PURE__ */ new Map();
-initializedBackends.set("cpu", new CPUBackend());
-function setDevice(device) {
-  if (initializedBackends.has(device)) {
-    defaultBackend = device;
-  } else {
-    throw new Error(`Backend not initialized: ${device}`);
-  }
-}
-async function init(...devicesToInit) {
-  if (devicesToInit.length === 0) {
-    devicesToInit = devices;
-  }
-  const promises = [];
-  for (const device of new Set(devicesToInit)) {
-    if (!initializedBackends.has(device)) {
-      promises.push(
-        (async () => {
-          const backend = await createBackend(device);
-          if (backend) {
-            initializedBackends.set(device, backend);
-          }
-        })()
-      );
-    }
-  }
-  await Promise.all(promises);
-  return Array.from(initializedBackends.keys());
-}
-async function createBackend(device) {
-  if (device === "cpu") {
-    return new CPUBackend();
-  } 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 import("./webgpu-QNXDOQZP.js");
-    const importantLimits = [
-      "maxBufferSize",
-      "maxComputeInvocationsPerWorkgroup",
-      "maxComputeWorkgroupSizeX",
-      // All of our workgroups use X or Y.
-      "maxComputeWorkgroupSizeY",
-      "maxComputeWorkgroupSizeZ",
-      "maxComputeWorkgroupStorageSize",
-      "maxComputeWorkgroupsPerDimension",
-      // Grid size limited to 65535 due to AMD storage in u16.
-      "maxStorageBufferBindingSize",
-      "maxStorageBuffersPerShaderStage",
-      "maxStorageTexturesPerShaderStage"
-    ];
-    try {
-      const device2 = await adapter.requestDevice({
-        requiredLimits: Object.fromEntries(
-          importantLimits.map((feature) => [feature, adapter.limits[feature]])
-        )
-      });
-      return new WebGPUBackend(device2);
-    } catch (error) {
-      console.error("Unexpected error requesting WebGPU device:", error);
-      return null;
-    }
-  } else {
-    throw new Error(`Backend not found: ${device}`);
-  }
-}
-function getBackend(device) {
-  device = device ?? defaultBackend;
-  const backend = initializedBackends.get(device);
-  if (!backend) {
-    throw new Error(`${device} backend not ready, call init() first`);
-  }
-  return backend;
-}
-var Executable = class {
-  constructor(kernel, data) {
-    this.kernel = kernel;
-    this.data = data;
-  }
-};
-var SlotError = class extends Error {
-  constructor(slot) {
-    super(`Used a buffer that is invalid or already freed: ${slot}`);
-  }
-};
-
-export {
-  __export,
-  __using,
-  __callDispose,
-  DEBUG,
-  unzip2,
-  zip,
-  rep,
-  prod,
-  deepEqual,
-  partitionList,
-  range,
-  isPermutation,
-  invertPermutation,
-  toposort,
-  findPow2,
-  recursiveFlatten,
-  strip1,
-  FpHash,
-  runWithCache,
-  DType,
-  isFloatDtype,
-  AluExp,
-  AluGroup,
-  AluVar,
-  Kernel,
-  Reduction,
-  accessorGlobal,
-  accessorAluExp,
-  unravelAlu,
-  ShapeTracker,
-  tuneWebgpu,
-  devices,
-  setDevice,
-  init,
-  getBackend,
-  Executable,
-  SlotError
-};