@danielsimonjr/mathts-tensor 0.2.24 → 0.2.26

package/dist/index.js

@@ -1,2563 +1,1886 @@
-// src/Tensor.ts
-import { DenseMatrix, backendManager } from "@danielsimonjr/mathts-matrix";
-var Tensor = class _Tensor {
-  shape;
-  data;
-  /** Optional per-axis Index labels. When set, enables `contract`, `replaceIndex`, `axisOf`. */
-  axisLabels;
-  constructor(shape, data, axisLabels) {
-    if (data.length !== _Tensor.sizeOf(shape)) {
-      throw new Error(
-        `Tensor: data length ${data.length} does not match shape [${shape}] (size ${_Tensor.sizeOf(shape)})`
-      );
-    }
-    if (axisLabels !== void 0 && axisLabels.length !== shape.length) {
-      throw new Error(
-        `Tensor: axisLabels length ${axisLabels.length} does not match rank ${shape.length}`
-      );
-    }
-    this.shape = shape;
-    this.data = data;
-    if (axisLabels !== void 0) {
-      this.axisLabels = [...axisLabels];
-    }
-  }
-  static sizeOf(shape) {
-    return shape.reduce((a, b) => a * b, 1);
-  }
-  static rowMajorStrides(shape) {
-    const strides = new Array(shape.length);
-    let acc = 1;
-    for (let k = shape.length - 1; k >= 0; k--) {
-      strides[k] = acc;
-      acc *= shape[k];
-    }
-    return strides;
-  }
-  static fromNested(data, shape) {
-    const size = _Tensor.sizeOf(shape);
-    const out = new Float64Array(size);
-    let cursor = 0;
-    const walk = (node, depth) => {
-      if (depth === shape.length) {
-        if (typeof node !== "number") {
-          throw new Error(`Tensor.fromNested: expected a number at depth ${depth}`);
-        }
-        out[cursor++] = node;
-        return;
-      }
-      if (!Array.isArray(node) || node.length !== shape[depth]) {
-        throw new Error(`Tensor.fromNested: shape mismatch at depth ${depth}`);
-      }
-      for (const child of node) walk(child, depth + 1);
-    };
-    walk(data, 0);
-    if (cursor !== size) throw new Error(`Tensor.fromNested: filled ${cursor} of ${size}`);
-    return new _Tensor([...shape], out);
-  }
-  static identity(n) {
-    const out = new Float64Array(n * n);
-    for (let i = 0; i < n; i++) out[i * n + i] = 1;
-    return new _Tensor([n, n], out);
-  }
-  toNested() {
-    if (this.shape.length === 0) return this.data[0];
-    const strides = _Tensor.rowMajorStrides(this.shape);
-    const build = (depth, offset) => {
-      if (depth === this.shape.length - 1) {
-        const row = [];
-        for (let i = 0; i < this.shape[depth]; i++) row.push(this.data[offset + i]);
-        return row;
-      }
-      const out = [];
-      for (let i = 0; i < this.shape[depth]; i++) {
-        out.push(build(depth + 1, offset + i * strides[depth]));
-      }
-      return out;
-    };
-    return build(0, 0);
-  }
-  /**
-   * Build a rank-2 Tensor from a native DenseMatrix. Bridges the tensor and
-   * matrix packages so matrix data can flow into rank-N / autodiff code.
-   */
-  static fromDenseMatrix(m) {
-    const nested = m.toArray();
-    const rows = nested.length;
-    const cols = rows > 0 ? nested[0].length : 0;
-    return _Tensor.fromNested(nested, [rows, cols]);
-  }
-  /**
-   * Convert a rank-2 Tensor to a native DenseMatrix. Throws for any other rank.
-   */
-  toDenseMatrix() {
-    if (this.shape.length !== 2) {
-      throw new Error(
-        `Tensor.toDenseMatrix: expected a rank-2 tensor, got rank ${this.shape.length}`
-      );
-    }
-    return DenseMatrix.fromArray(this.toNested());
-  }
-  sameShape(other) {
-    return this.shape.length === other.shape.length && this.shape.every((v, i) => v === other.shape[i]);
-  }
-  elementwise(other, op, f) {
-    if (!this.sameShape(other)) {
-      throw new Error(`Tensor.${op}: shape mismatch [${this.shape}] vs [${other.shape}]`);
-    }
-    const out = new Float64Array(this.data.length);
-    for (let i = 0; i < this.data.length; i++) out[i] = f(this.data[i], other.data[i]);
-    return new _Tensor(this.shape, out);
-  }
-  add(other) {
-    if (typeof other === "number") {
-      const out = new Float64Array(this.data.length);
-      for (let i = 0; i < this.data.length; i++) out[i] = this.data[i] + other;
-      return new _Tensor(this.shape, out, this.axisLabels);
-    }
-    if (this.sameShape(other)) {
-      return this.elementwise(other, "add", (x, y) => x + y);
-    }
-    return _Tensor.broadcastOp(this, other, "add", (x, y) => x + y);
-  }
-  sub(other) {
-    if (typeof other === "number") {
-      const out = new Float64Array(this.data.length);
-      for (let i = 0; i < this.data.length; i++) out[i] = this.data[i] - other;
-      return new _Tensor(this.shape, out, this.axisLabels);
-    }
-    if (this.sameShape(other)) {
-      return this.elementwise(other, "sub", (x, y) => x - y);
-    }
-    return _Tensor.broadcastOp(this, other, "sub", (x, y) => x - y);
-  }
-  mul(other) {
-    if (typeof other === "number") {
-      return this.scale(other);
-    }
-    if (this.sameShape(other)) {
-      return this.elementwise(other, "mul", (x, y) => x * y);
-    }
-    return _Tensor.broadcastOp(this, other, "mul", (x, y) => x * y);
-  }
-  scale(k) {
-    const out = new Float64Array(this.data.length);
-    for (let i = 0; i < this.data.length; i++) out[i] = this.data[i] * k;
-    return new _Tensor(this.shape, out);
-  }
-  normInf() {
-    let max = 0;
-    for (let i = 0; i < this.data.length; i++) {
-      const a = Math.abs(this.data[i]);
-      if (a > max) max = a;
-    }
-    return max;
-  }
-  // -------------------------------------------------------------------------
-  // Broadcasting support
-  // -------------------------------------------------------------------------
-  /**
-   * Compute the broadcast output shape of two shapes following NumPy rules:
-   * right-align the two shapes; a dimension of 1 broadcasts against any size;
-   * missing leading axes are treated as length-1.
-   * Throws with message including both shape arrays on incompatibility.
-   */
-  static broadcastShape(a, b) {
-    const rank = Math.max(a.length, b.length);
-    const out = new Array(rank);
-    for (let i = 0; i < rank; i++) {
-      const ai = a.length - rank + i;
-      const bi = b.length - rank + i;
-      const da = ai >= 0 ? a[ai] : 1;
-      const db = bi >= 0 ? b[bi] : 1;
-      if (da === db) {
-        out[i] = da;
-      } else if (da === 1) {
-        out[i] = db;
-      } else if (db === 1) {
-        out[i] = da;
-      } else {
-        throw new Error(
-          `shapes [${a}] and [${b}] cannot be broadcast: dimension mismatch ${da} vs ${db} at axis ${i} of the aligned shape`
-        );
-      }
-    }
-    return out;
-  }
-  /**
-   * Apply a binary elementwise op with NumPy-style broadcasting.
-   * Both tensors are read via virtual broadcast indices — no data is copied
-   * until the output is written.
-   */
-  static broadcastOp(a, b, _opName, f) {
-    const outShape = _Tensor.broadcastShape(a.shape, b.shape);
-    const rank = outShape.length;
-    const outSize = _Tensor.sizeOf(outShape);
-    const aStrides = _Tensor.rowMajorStrides(a.shape);
-    const bStrides = _Tensor.rowMajorStrides(b.shape);
-    const aRankOffset = rank - a.shape.length;
-    const bRankOffset = rank - b.shape.length;
-    const aEffStrides = new Array(rank).fill(0);
-    const bEffStrides = new Array(rank).fill(0);
-    for (let i = 0; i < rank; i++) {
-      const ai = i - aRankOffset;
-      if (ai >= 0 && a.shape[ai] !== 1) {
-        aEffStrides[i] = aStrides[ai];
-      }
-      const bi = i - bRankOffset;
-      if (bi >= 0 && b.shape[bi] !== 1) {
-        bEffStrides[i] = bStrides[bi];
-      }
-    }
-    const out = new Float64Array(outSize);
-    const coords = new Array(rank).fill(0);
-    for (let n = 0; n < outSize; n++) {
-      let aFlat = 0;
-      let bFlat = 0;
-      for (let k = 0; k < rank; k++) {
-        aFlat += coords[k] * aEffStrides[k];
-        bFlat += coords[k] * bEffStrides[k];
-      }
-      out[n] = f(a.data[aFlat], b.data[bFlat]);
-      for (let k = rank - 1; k >= 0; k--) {
-        if (++coords[k] < outShape[k]) break;
-        coords[k] = 0;
-      }
-    }
-    return new _Tensor(outShape, out);
-  }
-  // -------------------------------------------------------------------------
-  // Reduction helpers
-  // -------------------------------------------------------------------------
-  /**
-   * Generic strided reduction over a set of axes.
-   *
-   * `init` is the neutral element; `combine` folds one new value into the
-   * accumulator; `finalise` (optional) post-processes the accumulator once
-   * all elements have been visited.
-   */
-  reduceAxes(axes, keepDims, init, combine, finalise) {
-    const rank = this.shape.length;
-    const axisSet = new Set(axes);
-    for (const ax of axes) {
-      if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
-        throw new Error(`Tensor.reduce: axis ${ax} out of range for rank-${rank} tensor`);
-      }
-    }
-    const outShape = [];
-    for (let k = 0; k < rank; k++) {
-      if (axisSet.has(k)) {
-        if (keepDims) outShape.push(1);
-      } else {
-        outShape.push(this.shape[k]);
-      }
-    }
-    const reduceCount = axes.reduce((prod, ax) => prod * this.shape[ax], 1);
-    const outSize = _Tensor.sizeOf(outShape);
-    const out = new Float64Array(outSize).fill(init);
-    const outStrides = _Tensor.rowMajorStrides(outShape.length > 0 ? outShape : [1]);
-    const inCoords = new Array(rank).fill(0);
-    const inSize = this.data.length;
-    for (let n = 0; n < inSize; n++) {
-      let outFlat = 0;
-      let outDim = 0;
-      for (let k = 0; k < rank; k++) {
-        if (axisSet.has(k)) {
-          if (keepDims) {
-            outDim++;
-          }
-        } else {
-          outFlat += inCoords[k] * outStrides[outDim];
-          outDim++;
-        }
-      }
-      out[outFlat] = combine(out[outFlat], this.data[n]);
-      for (let k = rank - 1; k >= 0; k--) {
-        if (++inCoords[k] < this.shape[k]) break;
-        inCoords[k] = 0;
-      }
-    }
-    if (finalise !== void 0) {
-      for (let i = 0; i < out.length; i++) {
-        out[i] = finalise(out[i], reduceCount);
-      }
-    }
-    let resultLabels;
-    if (!keepDims && this.axisLabels !== void 0) {
-      const surviving = [];
-      for (let k = 0; k < rank; k++) {
-        if (!axisSet.has(k)) {
-          surviving.push(this.axisLabels[k]);
-        }
-      }
-      if (surviving.length === outShape.length) {
-        resultLabels = surviving;
-      }
-    }
-    return new _Tensor(outShape, out, resultLabels);
-  }
-  // -------------------------------------------------------------------------
-  // Public reductions
-  // -------------------------------------------------------------------------
-  /**
-   * Sum elements along the given axis/axes (or all axes if omitted).
-   * `keepDims: true` preserves reduced axes as length-1.
-   */
-  sum(axis, opts) {
-    const axes = this.resolveAxes(axis);
-    const keepDims = opts?.keepDims ?? false;
-    return this.reduceAxes(axes, keepDims, 0, (acc, v) => acc + v);
-  }
-  /**
-   * Arithmetic mean along the given axis/axes (or all axes if omitted).
-   */
-  mean(axis, opts) {
-    const axes = this.resolveAxes(axis);
-    const keepDims = opts?.keepDims ?? false;
-    return this.reduceAxes(
-      axes,
-      keepDims,
-      0,
-      (acc, v) => acc + v,
-      (acc, count) => acc / count
-    );
-  }
-  /**
-   * Element-wise maximum along the given axis/axes (or all axes if omitted).
-   * NaN propagates (matches NumPy default behaviour).
-   */
-  max(axis, opts) {
-    const axes = this.resolveAxes(axis);
-    const keepDims = opts?.keepDims ?? false;
-    return this.reduceAxes(
-      axes,
-      keepDims,
-      -Infinity,
-      (acc, v) => isNaN(v) ? v : isNaN(acc) ? acc : Math.max(acc, v)
-    );
-  }
-  /**
-   * Element-wise minimum along the given axis/axes (or all axes if omitted).
-   * NaN propagates (matches NumPy default behaviour).
-   */
-  min(axis, opts) {
-    const axes = this.resolveAxes(axis);
-    const keepDims = opts?.keepDims ?? false;
-    return this.reduceAxes(
-      axes,
-      keepDims,
-      Infinity,
-      (acc, v) => isNaN(v) ? v : isNaN(acc) ? acc : Math.min(acc, v)
-    );
-  }
-  /**
-   * Product of elements along the given axis/axes (or all axes if omitted).
-   */
-  prod(axis, opts) {
-    const axes = this.resolveAxes(axis);
-    const keepDims = opts?.keepDims ?? false;
-    return this.reduceAxes(axes, keepDims, 1, (acc, v) => acc * v);
-  }
-  /**
-   * p-norm of the tensor.
-   *
-   * - `p = 2` (default): Euclidean / Frobenius norm — `sqrt(sum x_i^2)`.
-   * - `p = 'fro'`: alias for p=2 (Frobenius).
-   * - `p = 'inf'`: max of absolute values.
-   * - `p = '-inf'`: min of absolute values.
-   * - numeric p: `(sum |x_i|^p)^(1/p)`.
-   *
-   * When `axis` is given, the norm is computed along that single axis and the
-   * result has rank reduced by 1 (or stays the same with `keepDims`).
-   * When `axis` is omitted, the norm is computed over all elements.
-   */
-  norm(opts) {
-    const p = opts?.p ?? 2;
-    const keepDims = opts?.keepDims ?? false;
-    const axes = opts?.axis !== void 0 ? [opts.axis] : this.resolveAxes(void 0);
-    if (p === "fro" || p === 2) {
-      const sqSum = this.reduceAxes(axes, keepDims, 0, (acc, v) => acc + v * v);
-      const sqrtData = new Float64Array(sqSum.data.length);
-      for (let i = 0; i < sqSum.data.length; i++) sqrtData[i] = Math.sqrt(sqSum.data[i]);
-      return new _Tensor(sqSum.shape, sqrtData, sqSum.axisLabels);
-    }
-    if (p === "inf") {
-      return this.reduceAxes(axes, keepDims, 0, (acc, v) => Math.max(acc, Math.abs(v)));
-    }
-    if (p === "-inf") {
-      return this.reduceAxes(axes, keepDims, Infinity, (acc, v) => Math.min(acc, Math.abs(v)));
-    }
-    const pNum = p;
-    const powSum = this.reduceAxes(
-      axes,
-      keepDims,
-      0,
-      (acc, v) => acc + Math.pow(Math.abs(v), pNum)
-    );
-    const invP = 1 / pNum;
-    const result = new Float64Array(powSum.data.length);
-    for (let i = 0; i < powSum.data.length; i++) result[i] = Math.pow(powSum.data[i], invP);
-    return new _Tensor(powSum.shape, result, powSum.axisLabels);
-  }
-  /**
-   * Generalised dot product (NumPy `tensordot`) over explicitly specified axis pairs.
-   *
-   * `axes[i] = [a, b]` contracts axis `a` of `this` with axis `b` of `other`.
-   * The result shape is `this`'s non-contracted axes followed by `other`'s
-   * non-contracted axes (NumPy convention).
-   *
-   * Delegates to `Tensor.einsum` under the hood.
-   */
-  tensordot(other, axes) {
-    const selfRank = this.shape.length;
-    const otherRank = other.shape.length;
-    const selfContracted = /* @__PURE__ */ new Set();
-    const otherContracted = /* @__PURE__ */ new Set();
-    for (const [a, b] of axes) {
-      if (!Number.isInteger(a) || a < 0 || a >= selfRank) {
-        throw new Error(`Tensor.tensordot: axis ${a} of 'this' (rank ${selfRank}) is out of range`);
-      }
-      if (!Number.isInteger(b) || b < 0 || b >= otherRank) {
-        throw new Error(
-          `Tensor.tensordot: axis ${b} of 'other' (rank ${otherRank}) is out of range`
-        );
-      }
-      if (selfContracted.has(a)) {
-        throw new Error(`Tensor.tensordot: duplicate axis ${a} in self contraction list`);
-      }
-      if (otherContracted.has(b)) {
-        throw new Error(`Tensor.tensordot: duplicate axis ${b} in other contraction list`);
-      }
-      if (this.shape[a] !== other.shape[b]) {
-        throw new Error(
-          `Tensor.tensordot: dimension mismatch on contracted axes: this.shape[${a}]=${this.shape[a]} vs other.shape[${b}]=${other.shape[b]}`
-        );
-      }
-      selfContracted.add(a);
-      otherContracted.add(b);
-    }
-    const contractions = axes.map(([a, b]) => ({
-      pair: [
-        [0, a],
-        [1, b]
-      ]
-    }));
-    const free = [];
-    for (let si = 0; si < selfRank; si++) {
-      if (!selfContracted.has(si)) {
-        free.push({ operand: 0, axis: si });
-      }
-    }
-    for (let oi = 0; oi < otherRank; oi++) {
-      if (!otherContracted.has(oi)) {
-        free.push({ operand: 1, axis: oi });
-      }
-    }
-    const spec = { contractions, free };
-    const result = _Tensor.einsum(spec, this, other);
-    let resultLabels;
-    if (this.axisLabels !== void 0 || other.axisLabels !== void 0) {
-      if (this.axisLabels !== void 0 && other.axisLabels !== void 0) {
-        resultLabels = [];
-        for (let si = 0; si < selfRank; si++) {
-          if (!selfContracted.has(si)) {
-            resultLabels.push(this.axisLabels[si]);
-          }
-        }
-        for (let oi = 0; oi < otherRank; oi++) {
-          if (!otherContracted.has(oi)) {
-            resultLabels.push(other.axisLabels[oi]);
-          }
-        }
-      }
-    }
-    return new _Tensor([...result.shape], result.data, resultLabels);
-  }
-  /**
-   * Normalise an `axis` argument into a sorted list of axis indices.
-   * `undefined` ⇒ all axes (reduce everything to a rank-0 scalar).
-   */
-  resolveAxes(axis) {
-    if (axis === void 0) {
-      return Array.from({ length: this.shape.length }, (_, i) => i);
-    }
-    if (typeof axis === "number") {
-      return [axis];
-    }
-    return [...axis];
-  }
-  static forEachIndex(shape, visit) {
-    if (shape.length === 0) {
-      visit([]);
-      return;
-    }
-    const idx2 = new Array(shape.length).fill(0);
-    const total = _Tensor.sizeOf(shape);
-    for (let n = 0; n < total; n++) {
-      visit(idx2);
-      for (let k = shape.length - 1; k >= 0; k--) {
-        if (++idx2[k] < shape[k]) break;
-        idx2[k] = 0;
-      }
-    }
-  }
-  static flatIndex(idx2, strides) {
-    let f = 0;
-    for (let k = 0; k < idx2.length; k++) f += idx2[k] * strides[k];
-    return f;
-  }
-  reshape(shape) {
-    if (_Tensor.sizeOf(shape) !== this.data.length) {
-      throw new Error(`Tensor.reshape: size mismatch [${this.shape}] -> [${shape}]`);
-    }
-    return new _Tensor([...shape], this.data.slice());
-  }
-  transpose(perm) {
-    const rank = this.shape.length;
-    const p = perm ?? Array.from({ length: rank }, (_, i) => rank - 1 - i);
-    if (p.length !== rank)
-      throw new Error(`Tensor.transpose: perm length ${p.length} != rank ${rank}`);
-    const outShape = p.map((axis) => this.shape[axis]);
-    const inStrides = _Tensor.rowMajorStrides(this.shape);
-    const outStrides = _Tensor.rowMajorStrides(outShape);
-    const out = new Float64Array(this.data.length);
-    _Tensor.forEachIndex(outShape, (outIdx) => {
-      const inIdx = new Array(rank);
-      for (let k = 0; k < rank; k++) inIdx[p[k]] = outIdx[k];
-      out[_Tensor.flatIndex(outIdx, outStrides)] = this.data[_Tensor.flatIndex(inIdx, inStrides)];
-    });
-    return new _Tensor(outShape, out);
-  }
-  matMul(other) {
-    if (this.shape.length !== 2 || other.shape.length !== 2) {
-      throw new Error(`Tensor.matMul: both operands must be rank-2`);
-    }
-    const [m, k] = this.shape;
-    const [k2, n] = other.shape;
-    if (k !== k2) throw new Error(`Tensor.matMul: inner dimension mismatch ${k} != ${k2}`);
-    const c = backendManager.multiply(
-      new DenseMatrix(m, k, this.data),
-      new DenseMatrix(k, n, other.data)
-    );
-    return new _Tensor([m, n], c.toFloat64Array());
-  }
-  static einsum(spec, ...operands) {
-    const inStrides = operands.map((o) => _Tensor.rowMajorStrides(o.shape));
-    const freeSizes = spec.free.map((fa) => operands[fa.operand].shape[fa.axis]);
-    const contractSizes = spec.contractions.map((c) => {
-      const [[oa, axa], [ob, axb]] = c.pair;
-      const sa = operands[oa]?.shape[axa];
-      const sb = operands[ob]?.shape[axb];
-      if (sa === void 0 || sb === void 0 || sa !== sb) {
-        throw new Error(`Tensor.einsum: contraction pair size mismatch`);
-      }
-      return sa;
-    });
-    const outStrides = _Tensor.rowMajorStrides(freeSizes);
-    const out = new Float64Array(_Tensor.sizeOf(freeSizes));
-    for (let o = 0; o < operands.length; o++) {
-      if (operands[o].shape.length === 0) continue;
-      const covered = /* @__PURE__ */ new Set();
-      spec.free.forEach((fa) => {
-        if (fa.operand === o) covered.add(fa.axis);
-      });
-      spec.contractions.forEach((c) => {
-        const [[oa, axa], [ob, axb]] = c.pair;
-        if (oa === o) covered.add(axa);
-        if (ob === o) covered.add(axb);
-      });
-      if (covered.size !== operands[o].shape.length) {
-        throw new Error(`Tensor.einsum: operand ${o} has axes not referenced by the spec`);
-      }
-    }
-    const operandFlatIndex = (opIndex, freeVals, contractVals) => {
-      const idx2 = new Array(operands[opIndex].shape.length).fill(0);
-      spec.free.forEach((fa, v) => {
-        if (fa.operand === opIndex) idx2[fa.axis] = freeVals[v];
-      });
-      spec.contractions.forEach((c, v) => {
-        const [[oa, axa], [ob, axb]] = c.pair;
-        if (oa === opIndex) idx2[axa] = contractVals[v];
-        if (ob === opIndex) idx2[axb] = contractVals[v];
-      });
-      return _Tensor.flatIndex(idx2, inStrides[opIndex]);
-    };
-    _Tensor.forEachIndex(freeSizes, (freeVals) => {
-      let acc = 0;
-      _Tensor.forEachIndex(contractSizes, (contractVals) => {
-        let product = 1;
-        for (let o = 0; o < operands.length; o++) {
-          product *= operands[o].data[operandFlatIndex(o, freeVals, contractVals)];
-        }
-        acc += product;
-      });
-      out[_Tensor.flatIndex(freeVals, outStrides)] = acc;
-    });
-    return new _Tensor(freeSizes, out);
-  }
-  // -------------------------------------------------------------------------
-  // Named-index API (opt-in via axisLabels)
-  // -------------------------------------------------------------------------
-  /**
-   * Return the axis position (0-based) of a labelled index.
-   * Throws if the index is not found in `axisLabels`.
-   */
-  axisOf(index) {
-    if (this.axisLabels === void 0) {
-      throw new Error("Tensor.axisOf: this tensor has no axisLabels");
-    }
-    const pos = this.axisLabels.findIndex((lbl) => lbl.matches(index));
-    if (pos === -1) {
-      throw new Error(`Tensor.axisOf: index ${index.toString()} not found in axisLabels`);
-    }
-    return pos;
-  }
-  /**
-   * Return a new Tensor with the same data and shape but with `oldIndex`
-   * swapped for `newIndex` in `axisLabels`.
-   * Throws if `oldIndex` is not found.
-   */
-  replaceIndex(oldIndex, newIndex) {
-    if (this.axisLabels === void 0) {
-      throw new Error("Tensor.replaceIndex: this tensor has no axisLabels");
-    }
-    const pos = this.axisLabels.findIndex((lbl) => lbl.matches(oldIndex));
-    if (pos === -1) {
-      throw new Error(`Tensor.replaceIndex: index ${oldIndex.toString()} not found in axisLabels`);
-    }
-    const newLabels = [...this.axisLabels];
-    newLabels[pos] = newIndex;
-    return new _Tensor([...this.shape], this.data.slice(), newLabels);
-  }
-  /**
-   * Contract this tensor with `other` over every shared index (matched by
-   * `Index.matches`). Both operands must carry `axisLabels`.
-   *
-   * The result tensor carries the non-shared axes from `this` followed by
-   * the non-shared axes from `other` as its `axisLabels`.
-   *
-   * Throws:
-   * - If either operand lacks `axisLabels`.
-   * - If there are no shared indices (use `einsum` or an explicit outer product).
-   * - If a shared index has mismatched dimensions on the two operands.
-   */
-  contract(other) {
-    if (this.axisLabels === void 0 || other.axisLabels === void 0) {
-      throw new Error("Tensor.contract requires axisLabels on both operands");
-    }
-    const sharedPairs = [];
-    for (let si = 0; si < this.axisLabels.length; si++) {
-      for (let oi = 0; oi < other.axisLabels.length; oi++) {
-        if (this.axisLabels[si].matches(other.axisLabels[oi])) {
-          sharedPairs.push({ selfAxis: si, otherAxis: oi });
-          break;
-        }
-      }
-    }
-    if (sharedPairs.length === 0) {
-      throw new Error(
-        "Tensor.contract: no shared indices to contract; use einsum or an explicit outer product"
-      );
-    }
-    for (const { selfAxis, otherAxis } of sharedPairs) {
-      const dSelf = this.shape[selfAxis];
-      const dOther = other.shape[otherAxis];
-      if (dSelf !== dOther) {
-        throw new Error(
-          `Tensor.contract: shared index ${this.axisLabels[selfAxis].toString()} has dimension ${dSelf} on 'this' but ${dOther} on 'other'`
-        );
-      }
-    }
-    const sharedSelfAxes = new Set(sharedPairs.map((p) => p.selfAxis));
-    const sharedOtherAxes = new Set(sharedPairs.map((p) => p.otherAxis));
-    let letterCount = 0;
-    const selfLetters = new Array(this.shape.length).fill(-1);
-    const otherLetters = new Array(other.shape.length).fill(-1);
-    for (const { selfAxis, otherAxis } of sharedPairs) {
-      const letter = letterCount++;
-      selfLetters[selfAxis] = letter;
-      otherLetters[otherAxis] = letter;
-    }
-    for (let si = 0; si < this.shape.length; si++) {
-      if (!sharedSelfAxes.has(si)) {
-        selfLetters[si] = letterCount++;
-      }
-    }
-    for (let oi = 0; oi < other.shape.length; oi++) {
-      if (!sharedOtherAxes.has(oi)) {
-        otherLetters[oi] = letterCount++;
-      }
-    }
-    const contractions = sharedPairs.map(
-      ({ selfAxis, otherAxis }) => ({
-        pair: [
-          [0, selfAxis],
-          [1, otherAxis]
-        ]
-      })
-    );
-    const free = [];
-    for (let si = 0; si < this.shape.length; si++) {
-      if (!sharedSelfAxes.has(si)) {
-        free.push({ operand: 0, axis: si });
-      }
-    }
-    for (let oi = 0; oi < other.shape.length; oi++) {
-      if (!sharedOtherAxes.has(oi)) {
-        free.push({ operand: 1, axis: oi });
-      }
-    }
-    const spec = { contractions, free };
-    const result = _Tensor.einsum(spec, this, other);
-    const resultLabels = [];
-    for (let si = 0; si < this.axisLabels.length; si++) {
-      if (!sharedSelfAxes.has(si)) {
-        resultLabels.push(this.axisLabels[si]);
-      }
-    }
-    for (let oi = 0; oi < other.axisLabels.length; oi++) {
-      if (!sharedOtherAxes.has(oi)) {
-        resultLabels.push(other.axisLabels[oi]);
-      }
-    }
-    return new _Tensor([...result.shape], result.data, resultLabels);
-  }
+import { boxMuller, mulberry32, rowMajorStrides } from "@danielsimonjr/mathts-core";
+import { DenseMatrix, backendManager, cholesky, eig, eigWasm, lu, qr, svd, svdWasm } from "@danielsimonjr/mathts-matrix";
+//#region src/Tensor.ts
+var Tensor = class Tensor {
+	shape;
+	data;
+	axisLabels;
+	constructor(shape, data, axisLabels) {
+		if (data.length !== Tensor.sizeOf(shape)) throw new Error(`Tensor: data length ${data.length} does not match shape [${shape}] (size ${Tensor.sizeOf(shape)})`);
+		if (axisLabels !== void 0 && axisLabels.length !== shape.length) throw new Error(`Tensor: axisLabels length ${axisLabels.length} does not match rank ${shape.length}`);
+		this.shape = shape;
+		this.data = data;
+		if (axisLabels !== void 0) this.axisLabels = [...axisLabels];
+	}
+	static sizeOf(shape) {
+		return shape.reduce((a, b) => a * b, 1);
+	}
+	static rowMajorStrides(shape) {
+		return rowMajorStrides(shape);
+	}
+	static fromNested(data, shape) {
+		const size = Tensor.sizeOf(shape);
+		const out = new Float64Array(size);
+		let cursor = 0;
+		const walk = (node, depth) => {
+			if (depth === shape.length) {
+				if (typeof node !== "number") throw new Error(`Tensor.fromNested: expected a number at depth ${depth}`);
+				out[cursor++] = node;
+				return;
+			}
+			if (!Array.isArray(node) || node.length !== shape[depth]) throw new Error(`Tensor.fromNested: shape mismatch at depth ${depth}`);
+			for (const child of node) walk(child, depth + 1);
+		};
+		walk(data, 0);
+		if (cursor !== size) throw new Error(`Tensor.fromNested: filled ${cursor} of ${size}`);
+		return new Tensor([...shape], out);
+	}
+	static identity(n) {
+		const out = new Float64Array(n * n);
+		for (let i = 0; i < n; i++) out[i * n + i] = 1;
+		return new Tensor([n, n], out);
+	}
+	toNested() {
+		if (this.shape.length === 0) return this.data[0];
+		const strides = Tensor.rowMajorStrides(this.shape);
+		const build = (depth, offset) => {
+			if (depth === this.shape.length - 1) {
+				const row = [];
+				for (let i = 0; i < this.shape[depth]; i++) row.push(this.data[offset + i]);
+				return row;
+			}
+			const out = [];
+			for (let i = 0; i < this.shape[depth]; i++) out.push(build(depth + 1, offset + i * strides[depth]));
+			return out;
+		};
+		return build(0, 0);
+	}
+	static fromDenseMatrix(m) {
+		const nested = m.toArray();
+		const rows = nested.length;
+		const cols = rows > 0 ? nested[0].length : 0;
+		return Tensor.fromNested(nested, [rows, cols]);
+	}
+	toDenseMatrix() {
+		if (this.shape.length !== 2) throw new Error(`Tensor.toDenseMatrix: expected a rank-2 tensor, got rank ${this.shape.length}`);
+		return DenseMatrix.fromArray(this.toNested());
+	}
+	sameShape(other) {
+		return this.shape.length === other.shape.length && this.shape.every((v, i) => v === other.shape[i]);
+	}
+	elementwise(other, op, f) {
+		if (!this.sameShape(other)) throw new Error(`Tensor.${op}: shape mismatch [${this.shape}] vs [${other.shape}]`);
+		const out = new Float64Array(this.data.length);
+		for (let i = 0; i < this.data.length; i++) out[i] = f(this.data[i], other.data[i]);
+		return new Tensor(this.shape, out);
+	}
+	add(other) {
+		if (typeof other === "number") {
+			const out = new Float64Array(this.data.length);
+			for (let i = 0; i < this.data.length; i++) out[i] = this.data[i] + other;
+			return new Tensor(this.shape, out, this.axisLabels);
+		}
+		if (this.sameShape(other)) return this.elementwise(other, "add", (x, y) => x + y);
+		return Tensor.broadcastOp(this, other, "add", (x, y) => x + y);
+	}
+	sub(other) {
+		if (typeof other === "number") {
+			const out = new Float64Array(this.data.length);
+			for (let i = 0; i < this.data.length; i++) out[i] = this.data[i] - other;
+			return new Tensor(this.shape, out, this.axisLabels);
+		}
+		if (this.sameShape(other)) return this.elementwise(other, "sub", (x, y) => x - y);
+		return Tensor.broadcastOp(this, other, "sub", (x, y) => x - y);
+	}
+	mul(other) {
+		if (typeof other === "number") return this.scale(other);
+		if (this.sameShape(other)) return this.elementwise(other, "mul", (x, y) => x * y);
+		return Tensor.broadcastOp(this, other, "mul", (x, y) => x * y);
+	}
+	scale(k) {
+		const out = new Float64Array(this.data.length);
+		for (let i = 0; i < this.data.length; i++) out[i] = this.data[i] * k;
+		return new Tensor(this.shape, out);
+	}
+	normInf() {
+		let max = 0;
+		for (let i = 0; i < this.data.length; i++) {
+			const a = Math.abs(this.data[i]);
+			if (a > max) max = a;
+		}
+		return max;
+	}
+	static broadcastShape(a, b) {
+		const rank = Math.max(a.length, b.length);
+		const out = new Array(rank);
+		for (let i = 0; i < rank; i++) {
+			const ai = a.length - rank + i;
+			const bi = b.length - rank + i;
+			const da = ai >= 0 ? a[ai] : 1;
+			const db = bi >= 0 ? b[bi] : 1;
+			if (da === db) out[i] = da;
+			else if (da === 1) out[i] = db;
+			else if (db === 1) out[i] = da;
+			else throw new Error(`shapes [${a}] and [${b}] cannot be broadcast: dimension mismatch ${da} vs ${db} at axis ${i} of the aligned shape`);
+		}
+		return out;
+	}
+	static broadcastOp(a, b, _opName, f) {
+		const outShape = Tensor.broadcastShape(a.shape, b.shape);
+		const rank = outShape.length;
+		const outSize = Tensor.sizeOf(outShape);
+		const aStrides = Tensor.rowMajorStrides(a.shape);
+		const bStrides = Tensor.rowMajorStrides(b.shape);
+		const aRankOffset = rank - a.shape.length;
+		const bRankOffset = rank - b.shape.length;
+		const aEffStrides = new Array(rank).fill(0);
+		const bEffStrides = new Array(rank).fill(0);
+		for (let i = 0; i < rank; i++) {
+			const ai = i - aRankOffset;
+			if (ai >= 0 && a.shape[ai] !== 1) aEffStrides[i] = aStrides[ai];
+			const bi = i - bRankOffset;
+			if (bi >= 0 && b.shape[bi] !== 1) bEffStrides[i] = bStrides[bi];
+		}
+		const out = new Float64Array(outSize);
+		const coords = new Array(rank).fill(0);
+		for (let n = 0; n < outSize; n++) {
+			let aFlat = 0;
+			let bFlat = 0;
+			for (let k = 0; k < rank; k++) {
+				aFlat += coords[k] * aEffStrides[k];
+				bFlat += coords[k] * bEffStrides[k];
+			}
+			out[n] = f(a.data[aFlat], b.data[bFlat]);
+			for (let k = rank - 1; k >= 0; k--) {
+				if (++coords[k] < outShape[k]) break;
+				coords[k] = 0;
+			}
+		}
+		return new Tensor(outShape, out);
+	}
+	reduceAxes(axes, keepDims, init, combine, finalise) {
+		const rank = this.shape.length;
+		const axisSet = new Set(axes);
+		for (const ax of axes) if (!Number.isInteger(ax) || ax < 0 || ax >= rank) throw new Error(`Tensor.reduce: axis ${ax} out of range for rank-${rank} tensor`);
+		const outShape = [];
+		for (let k = 0; k < rank; k++) if (axisSet.has(k)) {
+			if (keepDims) outShape.push(1);
+		} else outShape.push(this.shape[k]);
+		const reduceCount = axes.reduce((prod, ax) => prod * this.shape[ax], 1);
+		const outSize = Tensor.sizeOf(outShape);
+		const out = new Float64Array(outSize).fill(init);
+		const outStrides = Tensor.rowMajorStrides(outShape.length > 0 ? outShape : [1]);
+		const inCoords = new Array(rank).fill(0);
+		const inSize = this.data.length;
+		for (let n = 0; n < inSize; n++) {
+			let outFlat = 0;
+			let outDim = 0;
+			for (let k = 0; k < rank; k++) if (axisSet.has(k)) {
+				if (keepDims) outDim++;
+			} else {
+				outFlat += inCoords[k] * outStrides[outDim];
+				outDim++;
+			}
+			out[outFlat] = combine(out[outFlat], this.data[n]);
+			for (let k = rank - 1; k >= 0; k--) {
+				if (++inCoords[k] < this.shape[k]) break;
+				inCoords[k] = 0;
+			}
+		}
+		if (finalise !== void 0) for (let i = 0; i < out.length; i++) out[i] = finalise(out[i], reduceCount);
+		let resultLabels;
+		if (!keepDims && this.axisLabels !== void 0) {
+			const surviving = [];
+			for (let k = 0; k < rank; k++) if (!axisSet.has(k)) surviving.push(this.axisLabels[k]);
+			if (surviving.length === outShape.length) resultLabels = surviving;
+		}
+		return new Tensor(outShape, out, resultLabels);
+	}
+	sum(axis, opts) {
+		const axes = this.resolveAxes(axis);
+		const keepDims = opts?.keepDims ?? false;
+		return this.reduceAxes(axes, keepDims, 0, (acc, v) => acc + v);
+	}
+	mean(axis, opts) {
+		const axes = this.resolveAxes(axis);
+		const keepDims = opts?.keepDims ?? false;
+		return this.reduceAxes(axes, keepDims, 0, (acc, v) => acc + v, (acc, count) => acc / count);
+	}
+	max(axis, opts) {
+		return this.extremum(axis, opts, -Infinity, Math.max);
+	}
+	min(axis, opts) {
+		return this.extremum(axis, opts, Infinity, Math.min);
+	}
+	extremum(axis, opts, init, pick) {
+		const axes = this.resolveAxes(axis);
+		const keepDims = opts?.keepDims ?? false;
+		return this.reduceAxes(axes, keepDims, init, (acc, v) => isNaN(v) ? v : isNaN(acc) ? acc : pick(acc, v));
+	}
+	prod(axis, opts) {
+		const axes = this.resolveAxes(axis);
+		const keepDims = opts?.keepDims ?? false;
+		return this.reduceAxes(axes, keepDims, 1, (acc, v) => acc * v);
+	}
+	norm(opts) {
+		const p = opts?.p ?? 2;
+		const keepDims = opts?.keepDims ?? false;
+		const axes = opts?.axis !== void 0 ? [opts.axis] : this.resolveAxes(void 0);
+		if (p === "fro" || p === 2) {
+			const sqSum = this.reduceAxes(axes, keepDims, 0, (acc, v) => acc + v * v);
+			const sqrtData = new Float64Array(sqSum.data.length);
+			for (let i = 0; i < sqSum.data.length; i++) sqrtData[i] = Math.sqrt(sqSum.data[i]);
+			return new Tensor(sqSum.shape, sqrtData, sqSum.axisLabels);
+		}
+		if (p === "inf") return this.reduceAxes(axes, keepDims, 0, (acc, v) => Math.max(acc, Math.abs(v)));
+		if (p === "-inf") return this.reduceAxes(axes, keepDims, Infinity, (acc, v) => Math.min(acc, Math.abs(v)));
+		const pNum = p;
+		const powSum = this.reduceAxes(axes, keepDims, 0, (acc, v) => acc + Math.pow(Math.abs(v), pNum));
+		const invP = 1 / pNum;
+		const result = new Float64Array(powSum.data.length);
+		for (let i = 0; i < powSum.data.length; i++) result[i] = Math.pow(powSum.data[i], invP);
+		return new Tensor(powSum.shape, result, powSum.axisLabels);
+	}
+	tensordot(other, axes) {
+		const selfRank = this.shape.length;
+		const otherRank = other.shape.length;
+		const selfContracted = /* @__PURE__ */ new Set();
+		const otherContracted = /* @__PURE__ */ new Set();
+		for (const [a, b] of axes) {
+			if (!Number.isInteger(a) || a < 0 || a >= selfRank) throw new Error(`Tensor.tensordot: axis ${a} of 'this' (rank ${selfRank}) is out of range`);
+			if (!Number.isInteger(b) || b < 0 || b >= otherRank) throw new Error(`Tensor.tensordot: axis ${b} of 'other' (rank ${otherRank}) is out of range`);
+			if (selfContracted.has(a)) throw new Error(`Tensor.tensordot: duplicate axis ${a} in self contraction list`);
+			if (otherContracted.has(b)) throw new Error(`Tensor.tensordot: duplicate axis ${b} in other contraction list`);
+			if (this.shape[a] !== other.shape[b]) throw new Error(`Tensor.tensordot: dimension mismatch on contracted axes: this.shape[${a}]=${this.shape[a]} vs other.shape[${b}]=${other.shape[b]}`);
+			selfContracted.add(a);
+			otherContracted.add(b);
+		}
+		const contractions = axes.map(([a, b]) => ({ pair: [[0, a], [1, b]] }));
+		const free = [];
+		for (let si = 0; si < selfRank; si++) if (!selfContracted.has(si)) free.push({
+			operand: 0,
+			axis: si
+		});
+		for (let oi = 0; oi < otherRank; oi++) if (!otherContracted.has(oi)) free.push({
+			operand: 1,
+			axis: oi
+		});
+		const spec = {
+			contractions,
+			free
+		};
+		const result = Tensor.einsum(spec, this, other);
+		let resultLabels;
+		if (this.axisLabels !== void 0 || other.axisLabels !== void 0) {
+			if (this.axisLabels !== void 0 && other.axisLabels !== void 0) {
+				resultLabels = [];
+				for (let si = 0; si < selfRank; si++) if (!selfContracted.has(si)) resultLabels.push(this.axisLabels[si]);
+				for (let oi = 0; oi < otherRank; oi++) if (!otherContracted.has(oi)) resultLabels.push(other.axisLabels[oi]);
+			}
+		}
+		return new Tensor([...result.shape], result.data, resultLabels);
+	}
+	resolveAxes(axis) {
+		if (axis === void 0) return Array.from({ length: this.shape.length }, (_, i) => i);
+		if (typeof axis === "number") return [axis];
+		return [...axis];
+	}
+	static forEachIndex(shape, visit) {
+		if (shape.length === 0) {
+			visit([]);
+			return;
+		}
+		const idx = new Array(shape.length).fill(0);
+		const total = Tensor.sizeOf(shape);
+		for (let n = 0; n < total; n++) {
+			visit(idx);
+			for (let k = shape.length - 1; k >= 0; k--) {
+				if (++idx[k] < shape[k]) break;
+				idx[k] = 0;
+			}
+		}
+	}
+	static flatIndex(idx, strides) {
+		let f = 0;
+		for (let k = 0; k < idx.length; k++) f += idx[k] * strides[k];
+		return f;
+	}
+	reshape(shape) {
+		if (Tensor.sizeOf(shape) !== this.data.length) throw new Error(`Tensor.reshape: size mismatch [${this.shape}] -> [${shape}]`);
+		return new Tensor([...shape], this.data.slice());
+	}
+	transpose(perm) {
+		const rank = this.shape.length;
+		const p = perm ?? Array.from({ length: rank }, (_, i) => rank - 1 - i);
+		if (p.length !== rank) throw new Error(`Tensor.transpose: perm length ${p.length} != rank ${rank}`);
+		const outShape = p.map((axis) => this.shape[axis]);
+		const inStrides = Tensor.rowMajorStrides(this.shape);
+		const outStrides = Tensor.rowMajorStrides(outShape);
+		const out = new Float64Array(this.data.length);
+		Tensor.forEachIndex(outShape, (outIdx) => {
+			const inIdx = new Array(rank);
+			for (let k = 0; k < rank; k++) inIdx[p[k]] = outIdx[k];
+			out[Tensor.flatIndex(outIdx, outStrides)] = this.data[Tensor.flatIndex(inIdx, inStrides)];
+		});
+		return new Tensor(outShape, out);
+	}
+	matMul(other) {
+		if (this.shape.length !== 2 || other.shape.length !== 2) throw new Error(`Tensor.matMul: both operands must be rank-2`);
+		const [m, k] = this.shape;
+		const [k2, n] = other.shape;
+		if (k !== k2) throw new Error(`Tensor.matMul: inner dimension mismatch ${k} != ${k2}`);
+		const c = backendManager.multiply(new DenseMatrix(m, k, this.data), new DenseMatrix(k, n, other.data));
+		return new Tensor([m, n], c.toFloat64Array());
+	}
+	static einsum(spec, ...operands) {
+		const inStrides = operands.map((o) => Tensor.rowMajorStrides(o.shape));
+		const freeSizes = spec.free.map((fa) => operands[fa.operand].shape[fa.axis]);
+		const contractSizes = spec.contractions.map((c) => {
+			const [[oa, axa], [ob, axb]] = c.pair;
+			const sa = operands[oa]?.shape[axa];
+			const sb = operands[ob]?.shape[axb];
+			if (sa === void 0 || sb === void 0 || sa !== sb) throw new Error(`Tensor.einsum: contraction pair size mismatch`);
+			return sa;
+		});
+		const outStrides = Tensor.rowMajorStrides(freeSizes);
+		const out = new Float64Array(Tensor.sizeOf(freeSizes));
+		for (let o = 0; o < operands.length; o++) {
+			if (operands[o].shape.length === 0) continue;
+			const covered = /* @__PURE__ */ new Set();
+			spec.free.forEach((fa) => {
+				if (fa.operand === o) covered.add(fa.axis);
+			});
+			spec.contractions.forEach((c) => {
+				const [[oa, axa], [ob, axb]] = c.pair;
+				if (oa === o) covered.add(axa);
+				if (ob === o) covered.add(axb);
+			});
+			if (covered.size !== operands[o].shape.length) throw new Error(`Tensor.einsum: operand ${o} has axes not referenced by the spec`);
+		}
+		const operandFlatIndex = (opIndex, freeVals, contractVals) => {
+			const idx = new Array(operands[opIndex].shape.length).fill(0);
+			spec.free.forEach((fa, v) => {
+				if (fa.operand === opIndex) idx[fa.axis] = freeVals[v];
+			});
+			spec.contractions.forEach((c, v) => {
+				const [[oa, axa], [ob, axb]] = c.pair;
+				if (oa === opIndex) idx[axa] = contractVals[v];
+				if (ob === opIndex) idx[axb] = contractVals[v];
+			});
+			return Tensor.flatIndex(idx, inStrides[opIndex]);
+		};
+		Tensor.forEachIndex(freeSizes, (freeVals) => {
+			let acc = 0;
+			Tensor.forEachIndex(contractSizes, (contractVals) => {
+				let product = 1;
+				for (let o = 0; o < operands.length; o++) product *= operands[o].data[operandFlatIndex(o, freeVals, contractVals)];
+				acc += product;
+			});
+			out[Tensor.flatIndex(freeVals, outStrides)] = acc;
+		});
+		return new Tensor(freeSizes, out);
+	}
+	axisOf(index) {
+		return this.axisPosition(index, "axisOf");
+	}
+	replaceIndex(oldIndex, newIndex) {
+		const pos = this.axisPosition(oldIndex, "replaceIndex");
+		const newLabels = [...this.axisLabels];
+		newLabels[pos] = newIndex;
+		return new Tensor([...this.shape], this.data.slice(), newLabels);
+	}
+	axisPosition(index, op) {
+		if (this.axisLabels === void 0) throw new Error(`Tensor.${op}: this tensor has no axisLabels`);
+		const pos = this.axisLabels.findIndex((lbl) => lbl.matches(index));
+		if (pos === -1) throw new Error(`Tensor.${op}: index ${index.toString()} not found in axisLabels`);
+		return pos;
+	}
+	contract(other) {
+		if (this.axisLabels === void 0 || other.axisLabels === void 0) throw new Error("Tensor.contract requires axisLabels on both operands");
+		const sharedPairs = [];
+		for (let si = 0; si < this.axisLabels.length; si++) for (let oi = 0; oi < other.axisLabels.length; oi++) if (this.axisLabels[si].matches(other.axisLabels[oi])) {
+			sharedPairs.push({
+				selfAxis: si,
+				otherAxis: oi
+			});
+			break;
+		}
+		if (sharedPairs.length === 0) throw new Error("Tensor.contract: no shared indices to contract; use einsum or an explicit outer product");
+		for (const { selfAxis, otherAxis } of sharedPairs) {
+			const dSelf = this.shape[selfAxis];
+			const dOther = other.shape[otherAxis];
+			if (dSelf !== dOther) throw new Error(`Tensor.contract: shared index ${this.axisLabels[selfAxis].toString()} has dimension ${dSelf} on 'this' but ${dOther} on 'other'`);
+		}
+		const sharedSelfAxes = new Set(sharedPairs.map((p) => p.selfAxis));
+		const sharedOtherAxes = new Set(sharedPairs.map((p) => p.otherAxis));
+		let letterCount = 0;
+		const selfLetters = new Array(this.shape.length).fill(-1);
+		const otherLetters = new Array(other.shape.length).fill(-1);
+		for (const { selfAxis, otherAxis } of sharedPairs) {
+			const letter = letterCount++;
+			selfLetters[selfAxis] = letter;
+			otherLetters[otherAxis] = letter;
+		}
+		for (let si = 0; si < this.shape.length; si++) if (!sharedSelfAxes.has(si)) selfLetters[si] = letterCount++;
+		for (let oi = 0; oi < other.shape.length; oi++) if (!sharedOtherAxes.has(oi)) otherLetters[oi] = letterCount++;
+		const contractions = sharedPairs.map(({ selfAxis, otherAxis }) => ({ pair: [[0, selfAxis], [1, otherAxis]] }));
+		const free = [];
+		for (let si = 0; si < this.shape.length; si++) if (!sharedSelfAxes.has(si)) free.push({
+			operand: 0,
+			axis: si
+		});
+		for (let oi = 0; oi < other.shape.length; oi++) if (!sharedOtherAxes.has(oi)) free.push({
+			operand: 1,
+			axis: oi
+		});
+		const spec = {
+			contractions,
+			free
+		};
+		const result = Tensor.einsum(spec, this, other);
+		const resultLabels = [];
+		for (let si = 0; si < this.axisLabels.length; si++) if (!sharedSelfAxes.has(si)) resultLabels.push(this.axisLabels[si]);
+		for (let oi = 0; oi < other.axisLabels.length; oi++) if (!sharedOtherAxes.has(oi)) resultLabels.push(other.axisLabels[oi]);
+		return new Tensor([...result.shape], result.data, resultLabels);
+	}
 };
-
-// src/named-index.ts
-var Index = class _Index {
-  id;
-  dim;
-  name;
-  tags;
-  primeLevel;
-  constructor(dim, opts) {
-    if (!Number.isInteger(dim) || dim < 1) {
-      throw new Error(`Index: dim must be a positive integer, got ${dim}`);
-    }
-    this.id = Symbol(opts?.name ?? "");
-    this.dim = dim;
-    this.name = opts?.name;
-    this.tags = opts?.tags ? [...opts.tags] : [];
-    this.primeLevel = opts?.primeLevel ?? 0;
-  }
-  /**
-   * Internal constructor used by mutating-style methods that need to share the
-   * same `id` with a different primeLevel / tags. Not exposed publicly.
-   */
-  static _from(id, dim, name, tags, primeLevel) {
-    const ix = Object.create(_Index.prototype);
-    ix.id = id;
-    ix.dim = dim;
-    ix.name = name;
-    ix.tags = [...tags];
-    ix.primeLevel = primeLevel;
-    return ix;
-  }
-  /**
-   * Return a new Index with `primeLevel` incremented by `by` (default 1).
-   */
-  prime(by = 1) {
-    if (!Number.isInteger(by) || by < 1) {
-      throw new Error(`Index.prime: 'by' must be a positive integer, got ${by}`);
-    }
-    return _Index._from(this.id, this.dim, this.name, this.tags, this.primeLevel + by);
-  }
-  /**
-   * Return a new Index with `primeLevel` reset to 0.
-   */
-  noprime() {
-    return _Index._from(this.id, this.dim, this.name, this.tags, 0);
-  }
-  /**
-   * Return a new Index with `tag` added to its tag list (no-op if already present).
-   */
-  addTag(tag) {
-    if (this.tags.includes(tag)) return this;
-    return _Index._from(this.id, this.dim, this.name, [...this.tags, tag], this.primeLevel);
-  }
-  /**
-   * Return a new Index with `tag` removed from its tag list (no-op if absent).
-   */
-  removeTag(tag) {
-    const next = this.tags.filter((t) => t !== tag);
-    if (next.length === this.tags.length) return this;
-    return _Index._from(this.id, this.dim, this.name, next, this.primeLevel);
-  }
-  /**
-   * True if `tag` is in this index's tag list.
-   */
-  hasTag(tag) {
-    return this.tags.includes(tag);
-  }
-  /**
-   * Two indices match iff they share the same `id` AND the same `primeLevel`.
-   * Dimension is NOT used for matching — it is validated at contraction time.
-   */
-  matches(other) {
-    return this.id === other.id && this.primeLevel === other.primeLevel;
-  }
-  toString() {
-    const primeStr = this.primeLevel > 0 ? `'`.repeat(this.primeLevel) : "";
-    const nameStr = this.name ?? this.id.toString();
-    const tagStr = this.tags.length > 0 ? ` [${this.tags.join(",")}]` : "";
-    return `Index(${nameStr}${primeStr}, dim=${this.dim}${tagStr})`;
-  }
+//#endregion
+//#region src/named-index.ts
+var Index = class Index {
+	id;
+	dim;
+	name;
+	tags;
+	primeLevel;
+	constructor(dim, opts) {
+		if (!Number.isInteger(dim) || dim < 1) throw new Error(`Index: dim must be a positive integer, got ${dim}`);
+		this.id = Symbol(opts?.name ?? "");
+		this.dim = dim;
+		this.name = opts?.name;
+		this.tags = opts?.tags ? [...opts.tags] : [];
+		this.primeLevel = opts?.primeLevel ?? 0;
+	}
+	static _from(id, dim, name, tags, primeLevel) {
+		const ix = Object.create(Index.prototype);
+		ix.id = id;
+		ix.dim = dim;
+		ix.name = name;
+		ix.tags = [...tags];
+		ix.primeLevel = primeLevel;
+		return ix;
+	}
+	prime(by = 1) {
+		if (!Number.isInteger(by) || by < 1) throw new Error(`Index.prime: 'by' must be a positive integer, got ${by}`);
+		return Index._from(this.id, this.dim, this.name, this.tags, this.primeLevel + by);
+	}
+	noprime() {
+		return Index._from(this.id, this.dim, this.name, this.tags, 0);
+	}
+	addTag(tag) {
+		if (this.tags.includes(tag)) return this;
+		return Index._from(this.id, this.dim, this.name, [...this.tags, tag], this.primeLevel);
+	}
+	removeTag(tag) {
+		const next = this.tags.filter((t) => t !== tag);
+		if (next.length === this.tags.length) return this;
+		return Index._from(this.id, this.dim, this.name, next, this.primeLevel);
+	}
+	hasTag(tag) {
+		return this.tags.includes(tag);
+	}
+	matches(other) {
+		return this.id === other.id && this.primeLevel === other.primeLevel;
+	}
+	toString() {
+		const primeStr = this.primeLevel > 0 ? `'`.repeat(this.primeLevel) : "";
+		const nameStr = this.name ?? this.id.toString();
+		const tagStr = this.tags.length > 0 ? ` [${this.tags.join(",")}]` : "";
+		return `Index(${nameStr}${primeStr}, dim=${this.dim}${tagStr})`;
+	}
 };
 function idx(dim, name, opts) {
-  return new Index(dim, { name, ...opts });
+	return new Index(dim, {
+		name,
+		...opts
+	});
 }
-
-// src/operations/svd.ts
-import { svd, svdWasm } from "@danielsimonjr/mathts-matrix";
+//#endregion
+//#region src/operations/reshape-axes.ts
+function reshapeByRowAxes(t, rowAxes, messages) {
+	const rank = t.shape.length;
+	for (const ax of rowAxes) if (!Number.isInteger(ax) || ax < 0 || ax >= rank) throw new RangeError(messages.badAxis(ax, rank));
+	const rowSet = new Set(rowAxes);
+	const colAxes = [];
+	for (let i = 0; i < rank; i++) if (!rowSet.has(i)) colAxes.push(i);
+	if (colAxes.length === 0) throw new Error(messages.noColAxis);
+	if (rowAxes.length === 0) throw new Error(messages.noRowAxis);
+	const rowDims = rowAxes.map((ax) => t.shape[ax]);
+	const colDims = colAxes.map((ax) => t.shape[ax]);
+	const numRows = rowDims.reduce((a, b) => a * b, 1);
+	const numCols = colDims.reduce((a, b) => a * b, 1);
+	const perm = [...rowAxes, ...colAxes];
+	const permuted = t.transpose(perm);
+	return {
+		permuted,
+		rowDims,
+		colDims,
+		numRows,
+		numCols,
+		matrix: Array.from({ length: numRows }, (_, i) => Array.from({ length: numCols }, (_, j) => permuted.data[i * numCols + j]))
+	};
+}
+//#endregion
+//#region src/operations/svd.ts
 function prepareSvdMatrix(t, rowAxes) {
-  const rank = t.shape.length;
-  for (const ax of rowAxes) {
-    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
-      throw new RangeError(
-        `tensorSvd: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
-      );
-    }
-  }
-  const rowSet = new Set(rowAxes);
-  const colAxes = [];
-  for (let i = 0; i < rank; i++) {
-    if (!rowSet.has(i)) colAxes.push(i);
-  }
-  if (colAxes.length === 0) {
-    throw new Error("tensorSvd: rowAxes covers all axes \u2014 at least one axis must remain for V");
-  }
-  if (rowAxes.length === 0) {
-    throw new Error("tensorSvd: rowAxes is empty \u2014 at least one axis must be assigned to U");
-  }
-  const perm = [...rowAxes, ...colAxes];
-  const permuted = t.transpose(perm);
-  const rowDims = rowAxes.map((ax) => t.shape[ax]);
-  const colDims = colAxes.map((ax) => t.shape[ax]);
-  const numRows = rowDims.reduce((a, b) => a * b, 1);
-  const numCols = colDims.reduce((a, b) => a * b, 1);
-  const matrix = Array.from(
-    { length: numRows },
-    (_, i) => Array.from({ length: numCols }, (_2, j) => permuted.data[i * numCols + j])
-  );
-  return { matrix, rowDims, colDims, numRows, numCols };
+	const { matrix, rowDims, colDims, numRows, numCols } = reshapeByRowAxes(t, rowAxes, {
+		badAxis: (ax, rank) => `tensorSvd: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`,
+		noColAxis: "tensorSvd: rowAxes covers all axes — at least one axis must remain for V",
+		noRowAxis: "tensorSvd: rowAxes is empty — at least one axis must be assigned to U"
+	});
+	return {
+		matrix,
+		rowDims,
+		colDims,
+		numRows,
+		numCols
+	};
 }
 function finishSvd(result, prep, opts) {
-  const { rowDims, colDims, numRows, numCols } = prep;
-  const { U: fullU, S: allS, V: fullV } = result;
-  const cutoff = opts?.cutoff ?? 0;
-  const maxdim = opts?.maxdim;
-  let k = allS.filter((s) => s >= cutoff).length;
-  if (maxdim !== void 0) {
-    k = Math.min(k, maxdim);
-  }
-  k = Math.min(k, allS.length);
-  let truncationError = 0;
-  for (let i = k; i < allS.length; i++) {
-    truncationError += allS[i] * allS[i];
-  }
-  const truncatedDim = k;
-  const uData = new Float64Array(numRows * k);
-  for (let i = 0; i < numRows; i++) {
-    for (let j = 0; j < k; j++) {
-      uData[i * k + j] = fullU[i][j];
-    }
-  }
-  const uTensor = new Tensor([...rowDims, k], uData);
-  const vData = new Float64Array(k * numCols);
-  for (let j = 0; j < k; j++) {
-    for (let i = 0; i < numCols; i++) {
-      vData[j * numCols + i] = fullV[i][j];
-    }
-  }
-  const vTensor = new Tensor([k, ...colDims], vData);
-  const sData = new Float64Array(k);
-  for (let j = 0; j < k; j++) {
-    sData[j] = allS[j];
-  }
-  const sTensor = new Tensor([k], sData);
-  return {
-    U: uTensor,
-    S: sTensor,
-    V: vTensor,
-    truncatedDim,
-    truncationError
-  };
+	const { rowDims, colDims, numRows, numCols } = prep;
+	const { U: fullU, S: allS, V: fullV } = result;
+	const cutoff = opts?.cutoff ?? 0;
+	const maxdim = opts?.maxdim;
+	let k = allS.filter((s) => s >= cutoff).length;
+	if (maxdim !== void 0) k = Math.min(k, maxdim);
+	k = Math.min(k, allS.length);
+	let truncationError = 0;
+	for (let i = k; i < allS.length; i++) truncationError += allS[i] * allS[i];
+	const truncatedDim = k;
+	const uData = new Float64Array(numRows * k);
+	for (let i = 0; i < numRows; i++) for (let j = 0; j < k; j++) uData[i * k + j] = fullU[i][j];
+	const uTensor = new Tensor([...rowDims, k], uData);
+	const vData = new Float64Array(k * numCols);
+	for (let j = 0; j < k; j++) for (let i = 0; i < numCols; i++) vData[j * numCols + i] = fullV[i][j];
+	const vTensor = new Tensor([k, ...colDims], vData);
+	const sData = new Float64Array(k);
+	for (let j = 0; j < k; j++) sData[j] = allS[j];
+	return {
+		U: uTensor,
+		S: new Tensor([k], sData),
+		V: vTensor,
+		truncatedDim,
+		truncationError
+	};
 }
 function tensorSvd(t, rowAxes, opts) {
-  const prep = prepareSvdMatrix(t, rowAxes);
-  return finishSvd(svd(prep.matrix, { tolerance: 1e-12 }), prep, opts);
+	const prep = prepareSvdMatrix(t, rowAxes);
+	return finishSvd(svd(prep.matrix, { tolerance: 1e-12 }), prep, opts);
 }
 async function tensorSvdWasm(t, rowAxes, opts) {
-  const prep = prepareSvdMatrix(t, rowAxes);
-  return finishSvd(await svdWasm(prep.matrix, { tolerance: 1e-12 }), prep, opts);
-}
-
-// src/operations/random.ts
-import { DenseMatrix as DenseMatrix2, qr as matrixQr } from "@danielsimonjr/mathts-matrix";
-function makeMulberry32(seed) {
-  let s = seed | 0;
-  return () => {
-    s = s + 1831565813 | 0;
-    let z = s;
-    z = Math.imul(z ^ z >>> 15, z | 1);
-    z ^= z + Math.imul(z ^ z >>> 7, z | 61);
-    z = (z ^ z >>> 14) >>> 0;
-    return z / 4294967296;
-  };
-}
-function boxMuller(u1, u2) {
-  const clamped = u1 === 0 ? Number.EPSILON : u1;
-  const r = Math.sqrt(-2 * Math.log(clamped));
-  const theta = 2 * Math.PI * u2;
-  return [r * Math.cos(theta), r * Math.sin(theta)];
+	const prep = prepareSvdMatrix(t, rowAxes);
+	return finishSvd(await svdWasm(prep.matrix, { tolerance: 1e-12 }), prep, opts);
 }
+//#endregion
+//#region src/operations/random.ts
 function thinQViaMatrixQr(data, rows, cols) {
-  const matA = new DenseMatrix2(rows, cols, data);
-  const { Q: matQ } = matrixQr(matA, { mode: "reduced" });
-  return matQ.toFloat64Array();
+	const matA = new DenseMatrix(rows, cols, data);
+	const { Q: matQ } = qr(matA, { mode: "reduced" });
+	return matQ.toFloat64Array();
 }
 function randomTensor(shape, opts) {
-  const distribution = opts?.distribution ?? "uniform";
-  const axisLabels = opts?.axisLabels;
-  const size = shape.reduce((acc, d) => acc * d, 1);
-  const rng = opts?.seed !== void 0 ? makeMulberry32(opts.seed) : () => Math.random();
-  if (distribution === "orthogonal") {
-    if (shape.length !== 2) {
-      throw new Error("randomTensor: 'orthogonal' distribution requires a rank-2 shape");
-    }
-    const [rows, cols] = shape;
-    const totalNormal = rows * cols;
-    const normalData = new Float64Array(totalNormal);
-    let idx2 = 0;
-    while (idx2 < totalNormal - 1) {
-      const [z0, z1] = boxMuller(rng(), rng());
-      normalData[idx2++] = z0;
-      normalData[idx2++] = z1;
-    }
-    if (idx2 < totalNormal) {
-      const [z0] = boxMuller(rng(), rng());
-      normalData[idx2] = z0;
-    }
-    const qCols = Math.min(rows, cols);
-    const qData = thinQViaMatrixQr(normalData, rows, qCols);
-    const outShape = [rows, qCols];
-    return new Tensor(outShape, qData, axisLabels);
-  }
-  const data = new Float64Array(size);
-  if (distribution === "uniform") {
-    for (let i = 0; i < size; i++) {
-      data[i] = rng();
-    }
-  } else if (distribution === "normal") {
-    let i = 0;
-    while (i < size - 1) {
-      const [z0, z1] = boxMuller(rng(), rng());
-      data[i++] = z0;
-      data[i++] = z1;
-    }
-    if (i < size) {
-      const [z0] = boxMuller(rng(), rng());
-      data[i] = z0;
-    }
-  } else {
-    const _exhaustive = distribution;
-    throw new Error(`randomTensor: unknown distribution '${String(_exhaustive)}'`);
-  }
-  return new Tensor([...shape], data, axisLabels);
+	const distribution = opts?.distribution ?? "uniform";
+	const axisLabels = opts?.axisLabels;
+	const size = shape.reduce((acc, d) => acc * d, 1);
+	const rng = opts?.seed !== void 0 ? mulberry32(opts.seed) : () => Math.random();
+	if (distribution === "orthogonal") {
+		if (shape.length !== 2) throw new Error("randomTensor: 'orthogonal' distribution requires a rank-2 shape");
+		const [rows, cols] = shape;
+		const totalNormal = rows * cols;
+		const normalData = new Float64Array(totalNormal);
+		let idx = 0;
+		while (idx < totalNormal - 1) {
+			const [z0, z1] = boxMuller(rng(), rng());
+			normalData[idx++] = z0;
+			normalData[idx++] = z1;
+		}
+		if (idx < totalNormal) {
+			const [z0] = boxMuller(rng(), rng());
+			normalData[idx] = z0;
+		}
+		const qCols = Math.min(rows, cols);
+		const qData = thinQViaMatrixQr(normalData, rows, qCols);
+		return new Tensor([rows, qCols], qData, axisLabels);
+	}
+	const data = new Float64Array(size);
+	if (distribution === "uniform") for (let i = 0; i < size; i++) data[i] = rng();
+	else if (distribution === "normal") {
+		let i = 0;
+		while (i < size - 1) {
+			const [z0, z1] = boxMuller(rng(), rng());
+			data[i++] = z0;
+			data[i++] = z1;
+		}
+		if (i < size) {
+			const [z0] = boxMuller(rng(), rng());
+			data[i] = z0;
+		}
+	} else throw new Error(`randomTensor: unknown distribution '${String(distribution)}'`);
+	return new Tensor([...shape], data, axisLabels);
 }
-
-// src/contraction-sequence.ts
+//#endregion
+//#region src/contraction-sequence.ts
 function pairwise(a, b) {
-  const aIsShared = new Array(a.indices.length).fill(false);
-  const bIsShared = new Array(b.indices.length).fill(false);
-  let dShared = 1;
-  for (let i = 0; i < a.indices.length; i++) {
-    for (let j = 0; j < b.indices.length; j++) {
-      if (bIsShared[j]) continue;
-      if (a.indices[i].matches(b.indices[j])) {
-        aIsShared[i] = true;
-        bIsShared[j] = true;
-        dShared *= a.indices[i].dim;
-        break;
-      }
-    }
-  }
-  let dFreeLeft = 1;
-  const free = [];
-  for (let i = 0; i < a.indices.length; i++) {
-    if (!aIsShared[i]) {
-      dFreeLeft *= a.indices[i].dim;
-      free.push(a.indices[i]);
-    }
-  }
-  let dFreeRight = 1;
-  for (let j = 0; j < b.indices.length; j++) {
-    if (!bIsShared[j]) {
-      dFreeRight *= b.indices[j].dim;
-      free.push(b.indices[j]);
-    }
-  }
-  const cost = dShared * dFreeLeft * dFreeRight;
-  const resultSize = dFreeLeft * dFreeRight;
-  return { cost, resultShape: { indices: free }, resultSize };
+	const aIsShared = new Array(a.indices.length).fill(false);
+	const bIsShared = new Array(b.indices.length).fill(false);
+	let dShared = 1;
+	for (let i = 0; i < a.indices.length; i++) for (let j = 0; j < b.indices.length; j++) {
+		if (bIsShared[j]) continue;
+		if (a.indices[i].matches(b.indices[j])) {
+			aIsShared[i] = true;
+			bIsShared[j] = true;
+			dShared *= a.indices[i].dim;
+			break;
+		}
+	}
+	let dFreeLeft = 1;
+	const free = [];
+	for (let i = 0; i < a.indices.length; i++) if (!aIsShared[i]) {
+		dFreeLeft *= a.indices[i].dim;
+		free.push(a.indices[i]);
+	}
+	let dFreeRight = 1;
+	for (let j = 0; j < b.indices.length; j++) if (!bIsShared[j]) {
+		dFreeRight *= b.indices[j].dim;
+		free.push(b.indices[j]);
+	}
+	const cost = dShared * dFreeLeft * dFreeRight;
+	const resultSize = dFreeLeft * dFreeRight;
+	return {
+		cost,
+		resultShape: { indices: free },
+		resultSize
+	};
 }
 function netShape(shapes) {
-  const seen = [];
-  for (const sh of shapes) {
-    for (const ix of sh.indices) {
-      let found = false;
-      for (const entry of seen) {
-        if (entry.index.matches(ix)) {
-          entry.count++;
-          found = true;
-          break;
-        }
-      }
-      if (!found) seen.push({ index: ix, count: 1 });
-    }
-  }
-  return { indices: seen.filter((e) => e.count === 1).map((e) => e.index) };
+	const seen = [];
+	for (const sh of shapes) for (const ix of sh.indices) {
+		let found = false;
+		for (const entry of seen) if (entry.index.matches(ix)) {
+			entry.count++;
+			found = true;
+			break;
+		}
+		if (!found) seen.push({
+			index: ix,
+			count: 1
+		});
+	}
+	return { indices: seen.filter((e) => e.count === 1).map((e) => e.index) };
 }
 function extractShapes(tensors) {
-  const shapes = [];
-  for (let i = 0; i < tensors.length; i++) {
-    const t = tensors[i];
-    if (t.axisLabels === void 0) {
-      throw new Error(`contractNetwork: tensor at index ${i} lacks axisLabels`);
-    }
-    shapes.push({ indices: t.axisLabels });
-  }
-  return shapes;
+	const shapes = [];
+	for (let i = 0; i < tensors.length; i++) {
+		const t = tensors[i];
+		if (t.axisLabels === void 0) throw new Error(`contractNetwork: tensor at index ${i} lacks axisLabels`);
+		shapes.push({ indices: t.axisLabels });
+	}
+	return shapes;
 }
 function buildCanonicalTable(shapes) {
-  const keyByIndex = [];
-  const dimsByKey = [];
-  const globalCount = [];
-  const perInputMaskLo = [];
-  const perInputMaskHi = [];
-  const lookupOrInsert = (ix) => {
-    for (const entry of keyByIndex) {
-      if (entry.index.matches(ix)) return entry.key;
-    }
-    const newKey = dimsByKey.length;
-    dimsByKey.push(ix.dim);
-    globalCount.push(0);
-    keyByIndex.push({ index: ix, key: newKey });
-    return newKey;
-  };
-  for (const sh of shapes) {
-    let maskLo = 0;
-    let maskHi = 0;
-    for (const ix of sh.indices) {
-      const key = lookupOrInsert(ix);
-      if (key < 30) {
-        maskLo |= 1 << key;
-      } else {
-        maskHi |= 1 << key - 30;
-      }
-      globalCount[key]++;
-    }
-    perInputMaskLo.push(maskLo);
-    perInputMaskHi.push(maskHi);
-  }
-  const xorSafe = globalCount.every((c) => c <= 2);
-  return {
-    dimsByKey,
-    perInputMaskLo,
-    perInputMaskHi,
-    xorSafe,
-    uniqueIndexCount: dimsByKey.length
-  };
+	const keyByIndex = [];
+	const dimsByKey = [];
+	const globalCount = [];
+	const perInputMaskLo = [];
+	const perInputMaskHi = [];
+	const lookupOrInsert = (ix) => {
+		for (const entry of keyByIndex) if (entry.index.matches(ix)) return entry.key;
+		const newKey = dimsByKey.length;
+		dimsByKey.push(ix.dim);
+		globalCount.push(0);
+		keyByIndex.push({
+			index: ix,
+			key: newKey
+		});
+		return newKey;
+	};
+	for (const sh of shapes) {
+		let maskLo = 0;
+		let maskHi = 0;
+		for (const ix of sh.indices) {
+			const key = lookupOrInsert(ix);
+			if (key < 30) maskLo |= 1 << key;
+			else maskHi |= 1 << key - 30;
+			globalCount[key]++;
+		}
+		perInputMaskLo.push(maskLo);
+		perInputMaskHi.push(maskHi);
+	}
+	return {
+		dimsByKey,
+		perInputMaskLo,
+		perInputMaskHi,
+		xorSafe: globalCount.every((c) => c <= 2),
+		uniqueIndexCount: dimsByKey.length
+	};
 }
 function solveExact(shapes, maxIntermediateSize) {
-  const N = shapes.length;
-  if (N > 30) {
-    throw new Error(
-      `contractNetwork (exact): N=${N} exceeds bitmask cap of 30; use algorithm: 'greedy'`
-    );
-  }
-  const table = buildCanonicalTable(shapes);
-  if (!table.xorSafe || table.uniqueIndexCount > 60) {
-    return solveExactSlow(shapes, maxIntermediateSize);
-  }
-  const dims = table.dimsByKey;
-  const dp = new Array(1 << N);
-  const maskLoOf = new Int32Array(1 << N);
-  const maskHiOf = new Int32Array(1 << N);
-  for (let i = 0; i < N; i++) {
-    const single = 1 << i;
-    dp[single] = { cost: 0, split: null };
-    maskLoOf[single] = table.perInputMaskLo[i];
-    maskHiOf[single] = table.perInputMaskHi[i];
-  }
-  const full = (1 << N) - 1;
-  const masksByPopcount = [];
-  for (let k = 0; k <= N; k++) masksByPopcount.push([]);
-  for (let mask = 1; mask <= full; mask++) {
-    let pc = 0;
-    for (let m = mask; m > 0; m &= m - 1) pc++;
-    masksByPopcount[pc].push(mask);
-  }
-  for (let pc = 2; pc <= N; pc++) {
-    const buckets = masksByPopcount[pc];
-    for (let bi = 0; bi < buckets.length; bi++) {
-      const mask = buckets[bi];
-      let bestCost = Infinity;
-      let bestS1 = -1;
-      let bestS2 = -1;
-      let bestMaskLo = 0;
-      let bestMaskHi = 0;
-      for (let sub = mask - 1 & mask; sub > 0; sub = sub - 1 & mask) {
-        const comp = mask ^ sub;
-        if (sub > comp) continue;
-        const left = dp[sub];
-        const right = dp[comp];
-        if (!left || !right) continue;
-        const lLo = maskLoOf[sub];
-        const lHi = maskHiOf[sub];
-        const rLo = maskLoOf[comp];
-        const rHi = maskHiOf[comp];
-        const sharedLo = lLo & rLo;
-        const sharedHi = lHi & rHi;
-        const leftOnlyLo = lLo & ~rLo;
-        const leftOnlyHi = lHi & ~rHi;
-        const rightOnlyLo = rLo & ~lLo;
-        const rightOnlyHi = rHi & ~lHi;
-        let dShared = 1;
-        let m1 = sharedLo;
-        while (m1 !== 0) {
-          const lsb = m1 & -m1;
-          dShared *= dims[31 - Math.clz32(lsb)];
-          m1 ^= lsb;
-        }
-        let m2 = sharedHi;
-        while (m2 !== 0) {
-          const lsb = m2 & -m2;
-          dShared *= dims[30 + 31 - Math.clz32(lsb)];
-          m2 ^= lsb;
-        }
-        let dFreeLeft = 1;
-        m1 = leftOnlyLo;
-        while (m1 !== 0) {
-          const lsb = m1 & -m1;
-          dFreeLeft *= dims[31 - Math.clz32(lsb)];
-          m1 ^= lsb;
-        }
-        m2 = leftOnlyHi;
-        while (m2 !== 0) {
-          const lsb = m2 & -m2;
-          dFreeLeft *= dims[30 + 31 - Math.clz32(lsb)];
-          m2 ^= lsb;
-        }
-        let dFreeRight = 1;
-        m1 = rightOnlyLo;
-        while (m1 !== 0) {
-          const lsb = m1 & -m1;
-          dFreeRight *= dims[31 - Math.clz32(lsb)];
-          m1 ^= lsb;
-        }
-        m2 = rightOnlyHi;
-        while (m2 !== 0) {
-          const lsb = m2 & -m2;
-          dFreeRight *= dims[30 + 31 - Math.clz32(lsb)];
-          m2 ^= lsb;
-        }
-        const stepCost = dShared * dFreeLeft * dFreeRight;
-        const stepResultSize = dFreeLeft * dFreeRight;
-        if (stepResultSize > maxIntermediateSize) continue;
-        const total = left.cost + right.cost + stepCost;
-        const better = total < bestCost || total === bestCost && (sub < bestS1 || sub === bestS1 && comp < bestS2);
-        if (better) {
-          bestCost = total;
-          bestS1 = sub;
-          bestS2 = comp;
-          bestMaskLo = lLo ^ rLo;
-          bestMaskHi = lHi ^ rHi;
-        }
-      }
-      if (bestS1 !== -1) {
-        dp[mask] = { cost: bestCost, split: [bestS1, bestS2] };
-        maskLoOf[mask] = bestMaskLo;
-        maskHiOf[mask] = bestMaskHi;
-      }
-    }
-  }
-  const root = dp[full];
-  if (!root) return null;
-  const steps = [];
-  const slotFor = /* @__PURE__ */ new Map();
-  for (let i = 0; i < N; i++) slotFor.set(1 << i, i);
-  let nextSlot = N;
-  const stepFor = (s1, s2) => {
-    const lLo = maskLoOf[s1];
-    const lHi = maskHiOf[s1];
-    const rLo = maskLoOf[s2];
-    const rHi = maskHiOf[s2];
-    const sharedLo = lLo & rLo;
-    const sharedHi = lHi & rHi;
-    const leftOnlyLo = lLo & ~rLo;
-    const leftOnlyHi = lHi & ~rHi;
-    const rightOnlyLo = rLo & ~lLo;
-    const rightOnlyHi = rHi & ~lHi;
-    let dShared = 1;
-    for (let m = sharedLo; m !== 0; ) {
-      const lsb = m & -m;
-      dShared *= dims[31 - Math.clz32(lsb)];
-      m ^= lsb;
-    }
-    for (let m = sharedHi; m !== 0; ) {
-      const lsb = m & -m;
-      dShared *= dims[30 + 31 - Math.clz32(lsb)];
-      m ^= lsb;
-    }
-    let dFL = 1;
-    for (let m = leftOnlyLo; m !== 0; ) {
-      const lsb = m & -m;
-      dFL *= dims[31 - Math.clz32(lsb)];
-      m ^= lsb;
-    }
-    for (let m = leftOnlyHi; m !== 0; ) {
-      const lsb = m & -m;
-      dFL *= dims[30 + 31 - Math.clz32(lsb)];
-      m ^= lsb;
-    }
-    let dFR = 1;
-    for (let m = rightOnlyLo; m !== 0; ) {
-      const lsb = m & -m;
-      dFR *= dims[31 - Math.clz32(lsb)];
-      m ^= lsb;
-    }
-    for (let m = rightOnlyHi; m !== 0; ) {
-      const lsb = m & -m;
-      dFR *= dims[30 + 31 - Math.clz32(lsb)];
-      m ^= lsb;
-    }
-    return { cost: dShared * dFL * dFR, resultSize: dFL * dFR };
-  };
-  const stack2 = [{ mask: full, visited: false }];
-  while (stack2.length > 0) {
-    const frame = stack2[stack2.length - 1];
-    if (frame.visited) {
-      stack2.pop();
-      if (slotFor.has(frame.mask)) continue;
-      const entry2 = dp[frame.mask];
-      const [s12, s22] = entry2.split;
-      const step = stepFor(s12, s22);
-      const slot1 = slotFor.get(s12);
-      const slot2 = slotFor.get(s22);
-      const orderedPair = slot1 <= slot2 ? [slot1, slot2] : [slot2, slot1];
-      steps.push({ pair: orderedPair, cost: step.cost, resultSize: step.resultSize });
-      slotFor.set(frame.mask, nextSlot++);
-      continue;
-    }
-    frame.visited = true;
-    if (slotFor.has(frame.mask)) continue;
-    const entry = dp[frame.mask];
-    if (!entry.split) continue;
-    const [s1, s2] = entry.split;
-    stack2.push({ mask: s2, visited: false });
-    stack2.push({ mask: s1, visited: false });
-  }
-  return { steps };
+	const N = shapes.length;
+	if (N > 30) throw new Error(`contractNetwork (exact): N=${N} exceeds bitmask cap of 30; use algorithm: 'greedy'`);
+	const table = buildCanonicalTable(shapes);
+	if (!table.xorSafe || table.uniqueIndexCount > 60) return solveExactSlow(shapes, maxIntermediateSize);
+	const dims = table.dimsByKey;
+	const dp = new Array(1 << N);
+	const maskLoOf = new Int32Array(1 << N);
+	const maskHiOf = new Int32Array(1 << N);
+	for (let i = 0; i < N; i++) {
+		const single = 1 << i;
+		dp[single] = {
+			cost: 0,
+			split: null
+		};
+		maskLoOf[single] = table.perInputMaskLo[i];
+		maskHiOf[single] = table.perInputMaskHi[i];
+	}
+	const full = (1 << N) - 1;
+	const masksByPopcount = [];
+	for (let k = 0; k <= N; k++) masksByPopcount.push([]);
+	for (let mask = 1; mask <= full; mask++) {
+		let pc = 0;
+		for (let m = mask; m > 0; m &= m - 1) pc++;
+		masksByPopcount[pc].push(mask);
+	}
+	for (let pc = 2; pc <= N; pc++) {
+		const buckets = masksByPopcount[pc];
+		for (let bi = 0; bi < buckets.length; bi++) {
+			const mask = buckets[bi];
+			let bestCost = Infinity;
+			let bestS1 = -1;
+			let bestS2 = -1;
+			let bestMaskLo = 0;
+			let bestMaskHi = 0;
+			for (let sub = mask - 1 & mask; sub > 0; sub = sub - 1 & mask) {
+				const comp = mask ^ sub;
+				if (sub > comp) continue;
+				const left = dp[sub];
+				const right = dp[comp];
+				if (!left || !right) continue;
+				const lLo = maskLoOf[sub];
+				const lHi = maskHiOf[sub];
+				const rLo = maskLoOf[comp];
+				const rHi = maskHiOf[comp];
+				const sharedLo = lLo & rLo;
+				const sharedHi = lHi & rHi;
+				const leftOnlyLo = lLo & ~rLo;
+				const leftOnlyHi = lHi & ~rHi;
+				const rightOnlyLo = rLo & ~lLo;
+				const rightOnlyHi = rHi & ~lHi;
+				let dShared = 1;
+				let m1 = sharedLo;
+				while (m1 !== 0) {
+					const lsb = m1 & -m1;
+					dShared *= dims[31 - Math.clz32(lsb)];
+					m1 ^= lsb;
+				}
+				let m2 = sharedHi;
+				while (m2 !== 0) {
+					const lsb = m2 & -m2;
+					dShared *= dims[61 - Math.clz32(lsb)];
+					m2 ^= lsb;
+				}
+				let dFreeLeft = 1;
+				m1 = leftOnlyLo;
+				while (m1 !== 0) {
+					const lsb = m1 & -m1;
+					dFreeLeft *= dims[31 - Math.clz32(lsb)];
+					m1 ^= lsb;
+				}
+				m2 = leftOnlyHi;
+				while (m2 !== 0) {
+					const lsb = m2 & -m2;
+					dFreeLeft *= dims[61 - Math.clz32(lsb)];
+					m2 ^= lsb;
+				}
+				let dFreeRight = 1;
+				m1 = rightOnlyLo;
+				while (m1 !== 0) {
+					const lsb = m1 & -m1;
+					dFreeRight *= dims[31 - Math.clz32(lsb)];
+					m1 ^= lsb;
+				}
+				m2 = rightOnlyHi;
+				while (m2 !== 0) {
+					const lsb = m2 & -m2;
+					dFreeRight *= dims[61 - Math.clz32(lsb)];
+					m2 ^= lsb;
+				}
+				const stepCost = dShared * dFreeLeft * dFreeRight;
+				if (dFreeLeft * dFreeRight > maxIntermediateSize) continue;
+				const total = left.cost + right.cost + stepCost;
+				if (total < bestCost || total === bestCost && (sub < bestS1 || sub === bestS1 && comp < bestS2)) {
+					bestCost = total;
+					bestS1 = sub;
+					bestS2 = comp;
+					bestMaskLo = lLo ^ rLo;
+					bestMaskHi = lHi ^ rHi;
+				}
+			}
+			if (bestS1 !== -1) {
+				dp[mask] = {
+					cost: bestCost,
+					split: [bestS1, bestS2]
+				};
+				maskLoOf[mask] = bestMaskLo;
+				maskHiOf[mask] = bestMaskHi;
+			}
+		}
+	}
+	if (!dp[full]) return null;
+	const steps = [];
+	const slotFor = /* @__PURE__ */ new Map();
+	for (let i = 0; i < N; i++) slotFor.set(1 << i, i);
+	let nextSlot = N;
+	const stepFor = (s1, s2) => {
+		const lLo = maskLoOf[s1];
+		const lHi = maskHiOf[s1];
+		const rLo = maskLoOf[s2];
+		const rHi = maskHiOf[s2];
+		const sharedLo = lLo & rLo;
+		const sharedHi = lHi & rHi;
+		const leftOnlyLo = lLo & ~rLo;
+		const leftOnlyHi = lHi & ~rHi;
+		const rightOnlyLo = rLo & ~lLo;
+		const rightOnlyHi = rHi & ~lHi;
+		let dShared = 1;
+		for (let m = sharedLo; m !== 0;) {
+			const lsb = m & -m;
+			dShared *= dims[31 - Math.clz32(lsb)];
+			m ^= lsb;
+		}
+		for (let m = sharedHi; m !== 0;) {
+			const lsb = m & -m;
+			dShared *= dims[61 - Math.clz32(lsb)];
+			m ^= lsb;
+		}
+		let dFL = 1;
+		for (let m = leftOnlyLo; m !== 0;) {
+			const lsb = m & -m;
+			dFL *= dims[31 - Math.clz32(lsb)];
+			m ^= lsb;
+		}
+		for (let m = leftOnlyHi; m !== 0;) {
+			const lsb = m & -m;
+			dFL *= dims[61 - Math.clz32(lsb)];
+			m ^= lsb;
+		}
+		let dFR = 1;
+		for (let m = rightOnlyLo; m !== 0;) {
+			const lsb = m & -m;
+			dFR *= dims[31 - Math.clz32(lsb)];
+			m ^= lsb;
+		}
+		for (let m = rightOnlyHi; m !== 0;) {
+			const lsb = m & -m;
+			dFR *= dims[61 - Math.clz32(lsb)];
+			m ^= lsb;
+		}
+		return {
+			cost: dShared * dFL * dFR,
+			resultSize: dFL * dFR
+		};
+	};
+	const stack = [{
+		mask: full,
+		visited: false
+	}];
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		if (frame.visited) {
+			stack.pop();
+			if (slotFor.has(frame.mask)) continue;
+			const [s1, s2] = dp[frame.mask].split;
+			const step = stepFor(s1, s2);
+			const slot1 = slotFor.get(s1);
+			const slot2 = slotFor.get(s2);
+			const orderedPair = slot1 <= slot2 ? [slot1, slot2] : [slot2, slot1];
+			steps.push({
+				pair: orderedPair,
+				cost: step.cost,
+				resultSize: step.resultSize
+			});
+			slotFor.set(frame.mask, nextSlot++);
+			continue;
+		}
+		frame.visited = true;
+		if (slotFor.has(frame.mask)) continue;
+		const entry = dp[frame.mask];
+		if (!entry.split) continue;
+		const [s1, s2] = entry.split;
+		stack.push({
+			mask: s2,
+			visited: false
+		});
+		stack.push({
+			mask: s1,
+			visited: false
+		});
+	}
+	return { steps };
 }
 function solveExactSlow(shapes, maxIntermediateSize) {
-  const N = shapes.length;
-  const dp = /* @__PURE__ */ new Map();
-  for (let i = 0; i < N; i++) {
-    dp.set(1 << i, { cost: 0, split: null, shape: shapes[i] });
-  }
-  const full = (1 << N) - 1;
-  const masksByPopcount = [];
-  for (let k = 0; k <= N; k++) masksByPopcount.push([]);
-  for (let mask = 1; mask <= full; mask++) {
-    let pc = 0;
-    for (let m = mask; m > 0; m &= m - 1) pc++;
-    masksByPopcount[pc].push(mask);
-  }
-  for (let pc = 2; pc <= N; pc++) {
-    for (const mask of masksByPopcount[pc]) {
-      let best = null;
-      for (let sub = mask - 1 & mask; sub > 0; sub = sub - 1 & mask) {
-        const comp = mask ^ sub;
-        if (sub > comp) continue;
-        const left = dp.get(sub);
-        const right = dp.get(comp);
-        if (!left || !right) continue;
-        const step = pairwise(left.shape, right.shape);
-        if (step.resultSize > maxIntermediateSize) continue;
-        const total = left.cost + right.cost + step.cost;
-        if (best === null || total < best.cost || total === best.cost && tieBreakBetter(sub, comp, best.split)) {
-          best = { cost: total, split: [sub, comp], shape: step.resultShape };
-        }
-      }
-      if (best !== null) {
-        dp.set(mask, { cost: best.cost, split: best.split, shape: best.shape });
-      }
-    }
-  }
-  const root = dp.get(full);
-  if (!root) return null;
-  const steps = [];
-  const slotFor = /* @__PURE__ */ new Map();
-  for (let i = 0; i < N; i++) slotFor.set(1 << i, i);
-  let nextSlot = N;
-  const stack2 = [{ mask: full, visited: false }];
-  while (stack2.length > 0) {
-    const frame = stack2[stack2.length - 1];
-    if (frame.visited) {
-      stack2.pop();
-      if (slotFor.has(frame.mask)) continue;
-      const entry2 = dp.get(frame.mask);
-      const [s12, s22] = entry2.split;
-      const left = dp.get(s12);
-      const right = dp.get(s22);
-      const step = pairwise(left.shape, right.shape);
-      const slot1 = slotFor.get(s12);
-      const slot2 = slotFor.get(s22);
-      const orderedPair = slot1 <= slot2 ? [slot1, slot2] : [slot2, slot1];
-      steps.push({ pair: orderedPair, cost: step.cost, resultSize: step.resultSize });
-      slotFor.set(frame.mask, nextSlot++);
-      continue;
-    }
-    frame.visited = true;
-    if (slotFor.has(frame.mask)) continue;
-    const entry = dp.get(frame.mask);
-    if (!entry.split) continue;
-    const [s1, s2] = entry.split;
-    stack2.push({ mask: s2, visited: false });
-    stack2.push({ mask: s1, visited: false });
-  }
-  return { steps };
+	const N = shapes.length;
+	const dp = /* @__PURE__ */ new Map();
+	for (let i = 0; i < N; i++) dp.set(1 << i, {
+		cost: 0,
+		split: null,
+		shape: shapes[i]
+	});
+	const full = (1 << N) - 1;
+	const masksByPopcount = [];
+	for (let k = 0; k <= N; k++) masksByPopcount.push([]);
+	for (let mask = 1; mask <= full; mask++) {
+		let pc = 0;
+		for (let m = mask; m > 0; m &= m - 1) pc++;
+		masksByPopcount[pc].push(mask);
+	}
+	for (let pc = 2; pc <= N; pc++) for (const mask of masksByPopcount[pc]) {
+		let best = null;
+		for (let sub = mask - 1 & mask; sub > 0; sub = sub - 1 & mask) {
+			const comp = mask ^ sub;
+			if (sub > comp) continue;
+			const left = dp.get(sub);
+			const right = dp.get(comp);
+			if (!left || !right) continue;
+			const step = pairwise(left.shape, right.shape);
+			if (step.resultSize > maxIntermediateSize) continue;
+			const total = left.cost + right.cost + step.cost;
+			if (best === null || total < best.cost || total === best.cost && tieBreakBetter(sub, comp, best.split)) best = {
+				cost: total,
+				split: [sub, comp],
+				shape: step.resultShape
+			};
+		}
+		if (best !== null) dp.set(mask, {
+			cost: best.cost,
+			split: best.split,
+			shape: best.shape
+		});
+	}
+	if (!dp.get(full)) return null;
+	const steps = [];
+	const slotFor = /* @__PURE__ */ new Map();
+	for (let i = 0; i < N; i++) slotFor.set(1 << i, i);
+	let nextSlot = N;
+	const stack = [{
+		mask: full,
+		visited: false
+	}];
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		if (frame.visited) {
+			stack.pop();
+			if (slotFor.has(frame.mask)) continue;
+			const [s1, s2] = dp.get(frame.mask).split;
+			const left = dp.get(s1);
+			const right = dp.get(s2);
+			const step = pairwise(left.shape, right.shape);
+			const slot1 = slotFor.get(s1);
+			const slot2 = slotFor.get(s2);
+			const orderedPair = slot1 <= slot2 ? [slot1, slot2] : [slot2, slot1];
+			steps.push({
+				pair: orderedPair,
+				cost: step.cost,
+				resultSize: step.resultSize
+			});
+			slotFor.set(frame.mask, nextSlot++);
+			continue;
+		}
+		frame.visited = true;
+		if (slotFor.has(frame.mask)) continue;
+		const entry = dp.get(frame.mask);
+		if (!entry.split) continue;
+		const [s1, s2] = entry.split;
+		stack.push({
+			mask: s2,
+			visited: false
+		});
+		stack.push({
+			mask: s1,
+			visited: false
+		});
+	}
+	return { steps };
 }
 function tieBreakBetter(a, b, prev) {
-  if (!prev) return true;
-  if (a < prev[0]) return true;
-  if (a > prev[0]) return false;
-  return b < prev[1];
+	if (!prev) return true;
+	if (a < prev[0]) return true;
+	if (a > prev[0]) return false;
+	return b < prev[1];
 }
 function solveGreedy(shapes, maxIntermediateSize) {
-  const N = shapes.length;
-  const working = [];
-  for (let i = 0; i < N; i++) working.push({ slot: i, shape: shapes[i] });
-  let nextSlot = N;
-  const steps = [];
-  while (working.length > 1) {
-    let bestI = -1;
-    let bestJ = -1;
-    let bestCost = Infinity;
-    let bestStep = null;
-    let bestSharedCount = -1;
-    for (let i = 0; i < working.length; i++) {
-      for (let j = i + 1; j < working.length; j++) {
-        const step = pairwise(working[i].shape, working[j].shape);
-        if (step.resultSize > maxIntermediateSize) continue;
-        let shared = 0;
-        for (const ix of working[i].shape.indices) {
-          for (const jx of working[j].shape.indices) {
-            if (ix.matches(jx)) {
-              shared++;
-              break;
-            }
-          }
-        }
-        const isBetter = step.cost < bestCost || step.cost === bestCost && shared > bestSharedCount || step.cost === bestCost && shared === bestSharedCount && (i < bestI || i === bestI && j < bestJ);
-        if (isBetter) {
-          bestI = i;
-          bestJ = j;
-          bestCost = step.cost;
-          bestStep = step;
-          bestSharedCount = shared;
-        }
-      }
-    }
-    if (bestStep === null || bestI === -1) {
-      return null;
-    }
-    const slotI = working[bestI].slot;
-    const slotJ = working[bestJ].slot;
-    const orderedPair = slotI <= slotJ ? [slotI, slotJ] : [slotJ, slotI];
-    steps.push({ pair: orderedPair, cost: bestStep.cost, resultSize: bestStep.resultSize });
-    working.splice(bestJ, 1);
-    working.splice(bestI, 1);
-    working.push({ slot: nextSlot++, shape: bestStep.resultShape });
-  }
-  return { steps };
+	const N = shapes.length;
+	const working = [];
+	for (let i = 0; i < N; i++) working.push({
+		slot: i,
+		shape: shapes[i]
+	});
+	let nextSlot = N;
+	const steps = [];
+	while (working.length > 1) {
+		let bestI = -1;
+		let bestJ = -1;
+		let bestCost = Infinity;
+		let bestStep = null;
+		let bestSharedCount = -1;
+		for (let i = 0; i < working.length; i++) for (let j = i + 1; j < working.length; j++) {
+			const step = pairwise(working[i].shape, working[j].shape);
+			if (step.resultSize > maxIntermediateSize) continue;
+			let shared = 0;
+			for (const ix of working[i].shape.indices) for (const jx of working[j].shape.indices) if (ix.matches(jx)) {
+				shared++;
+				break;
+			}
+			if (step.cost < bestCost || step.cost === bestCost && shared > bestSharedCount || step.cost === bestCost && shared === bestSharedCount && (i < bestI || i === bestI && j < bestJ)) {
+				bestI = i;
+				bestJ = j;
+				bestCost = step.cost;
+				bestStep = step;
+				bestSharedCount = shared;
+			}
+		}
+		if (bestStep === null || bestI === -1) return null;
+		const slotI = working[bestI].slot;
+		const slotJ = working[bestJ].slot;
+		const orderedPair = slotI <= slotJ ? [slotI, slotJ] : [slotJ, slotI];
+		steps.push({
+			pair: orderedPair,
+			cost: bestStep.cost,
+			resultSize: bestStep.resultSize
+		});
+		working.splice(bestJ, 1);
+		working.splice(bestI, 1);
+		working.push({
+			slot: nextSlot++,
+			shape: bestStep.resultShape
+		});
+	}
+	return { steps };
 }
 function executePlan(inputs, plan) {
-  const slots = /* @__PURE__ */ new Map();
-  for (let i = 0; i < inputs.length; i++) slots.set(i, inputs[i]);
-  let nextSlot = inputs.length;
-  const intermediateSizes = [];
-  for (const step of plan) {
-    const [i, j] = step.pair;
-    const a = slots.get(i);
-    const b = slots.get(j);
-    if (!a || !b) {
-      throw new Error(
-        `contractNetwork: plan references unknown virtual slot (${i}, ${j}); plan is corrupted`
-      );
-    }
-    const out = a.contract(b);
-    intermediateSizes.push(out.data.length);
-    slots.set(nextSlot++, out);
-  }
-  const finalSlot = nextSlot - 1;
-  const result = slots.get(finalSlot);
-  if (!result) throw new Error("contractNetwork: empty plan produced no result");
-  return { result, intermediateSizes };
+	const slots = /* @__PURE__ */ new Map();
+	for (let i = 0; i < inputs.length; i++) slots.set(i, inputs[i]);
+	let nextSlot = inputs.length;
+	const intermediateSizes = [];
+	for (const step of plan) {
+		const [i, j] = step.pair;
+		const a = slots.get(i);
+		const b = slots.get(j);
+		if (!a || !b) throw new Error(`contractNetwork: plan references unknown virtual slot (${i}, ${j}); plan is corrupted`);
+		const out = a.contract(b);
+		intermediateSizes.push(out.data.length);
+		slots.set(nextSlot++, out);
+	}
+	const finalSlot = nextSlot - 1;
+	const result = slots.get(finalSlot);
+	if (!result) throw new Error("contractNetwork: empty plan produced no result");
+	return {
+		result,
+		intermediateSizes
+	};
 }
 function contractNetwork(tensors, opts) {
-  if (tensors.length === 0) {
-    throw new Error("contractNetwork: tensors array is empty");
-  }
-  if (tensors.length === 1) {
-    return {
-      result: tensors[0],
-      contractionOrder: [],
-      totalFlops: 0,
-      intermediateSizes: []
-    };
-  }
-  const shapes = extractShapes(tensors);
-  const maxIntermediateSize = opts?.maxIntermediateSize ?? 2 ** 31;
-  const algorithmRaw = opts?.algorithm ?? "auto";
-  const N = tensors.length;
-  const algorithm = algorithmRaw === "auto" ? N <= 16 ? "exact" : "greedy" : algorithmRaw;
-  const planResult = algorithm === "exact" ? solveExact(shapes, maxIntermediateSize) : solveGreedy(shapes, maxIntermediateSize);
-  if (planResult === null) {
-    throw new Error(
-      `contractNetwork: no valid contraction order found under maxIntermediateSize=${maxIntermediateSize}`
-    );
-  }
-  void netShape(shapes);
-  const { result, intermediateSizes } = executePlan(tensors, planResult.steps);
-  const contractionOrder = planResult.steps.map((s) => s.pair);
-  const totalFlops = planResult.steps.reduce((acc, s) => acc + s.cost, 0);
-  return {
-    result,
-    contractionOrder,
-    totalFlops,
-    intermediateSizes
-  };
+	if (tensors.length === 0) throw new Error("contractNetwork: tensors array is empty");
+	if (tensors.length === 1) return {
+		result: tensors[0],
+		contractionOrder: [],
+		totalFlops: 0,
+		intermediateSizes: []
+	};
+	const shapes = extractShapes(tensors);
+	const maxIntermediateSize = opts?.maxIntermediateSize ?? 2 ** 31;
+	const algorithmRaw = opts?.algorithm ?? "auto";
+	const N = tensors.length;
+	const planResult = (algorithmRaw === "auto" ? N <= 16 ? "exact" : "greedy" : algorithmRaw) === "exact" ? solveExact(shapes, maxIntermediateSize) : solveGreedy(shapes, maxIntermediateSize);
+	if (planResult === null) throw new Error(`contractNetwork: no valid contraction order found under maxIntermediateSize=${maxIntermediateSize}`);
+	netShape(shapes);
+	const { result, intermediateSizes } = executePlan(tensors, planResult.steps);
+	return {
+		result,
+		contractionOrder: planResult.steps.map((s) => s.pair),
+		totalFlops: planResult.steps.reduce((acc, s) => acc + s.cost, 0),
+		intermediateSizes
+	};
 }
-
-// src/operations/qr.ts
-import { DenseMatrix as DenseMatrix3, qr as matrixQR } from "@danielsimonjr/mathts-matrix";
+//#endregion
+//#region src/operations/qr.ts
 function tensorQr(t, rowAxes, opts) {
-  const rank = t.shape.length;
-  const mode = opts?.mode ?? "reduced";
-  for (const ax of rowAxes) {
-    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
-      throw new RangeError(
-        `tensorQr: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
-      );
-    }
-  }
-  const rowSet = new Set(rowAxes);
-  if (rowSet.size !== rowAxes.length) {
-    throw new Error("tensorQr: rowAxes contains duplicate axes");
-  }
-  const colAxes = [];
-  for (let i = 0; i < rank; i++) {
-    if (!rowSet.has(i)) colAxes.push(i);
-  }
-  if (colAxes.length === 0) {
-    throw new Error("tensorQr: rowAxes covers all axes \u2014 at least one axis must remain for R");
-  }
-  if (rowAxes.length === 0) {
-    throw new Error("tensorQr: rowAxes is empty \u2014 at least one axis must be assigned to Q");
-  }
-  const perm = [...rowAxes, ...colAxes];
-  const permuted = t.transpose(perm);
-  const rowDims = rowAxes.map((ax) => t.shape[ax]);
-  const colDims = colAxes.map((ax) => t.shape[ax]);
-  const numRows = rowDims.reduce((a, b) => a * b, 1);
-  const numCols = colDims.reduce((a, b) => a * b, 1);
-  const mat = new DenseMatrix3(numRows, numCols, permuted.data.slice());
-  const { Q: qMat, R: rMat } = matrixQR(mat, { mode });
-  const qCols = qMat.cols;
-  const rRows = rMat.rows;
-  const qData = qMat.toFloat64Array();
-  const rData = rMat.toFloat64Array();
-  let qLabels;
-  let rLabels;
-  if (t.axisLabels !== void 0) {
-    const joiningDim = qCols;
-    const joiningIndex = new Index(joiningDim, {
-      name: opts?.joiningIndexName ?? "qr"
-    });
-    const rowLabels = rowAxes.map((ax) => t.axisLabels[ax]);
-    const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
-    qLabels = [...rowLabels, joiningIndex];
-    rLabels = [joiningIndex, ...colLabels];
-  }
-  const qTensor = new Tensor([...rowDims, qCols], qData, qLabels);
-  const rTensor = new Tensor([rRows, ...colDims], rData, rLabels);
-  return { Q: qTensor, R: rTensor };
+	const rank = t.shape.length;
+	const mode = opts?.mode ?? "reduced";
+	for (const ax of rowAxes) if (!Number.isInteger(ax) || ax < 0 || ax >= rank) throw new RangeError(`tensorQr: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`);
+	const rowSet = new Set(rowAxes);
+	if (rowSet.size !== rowAxes.length) throw new Error("tensorQr: rowAxes contains duplicate axes");
+	const colAxes = [];
+	for (let i = 0; i < rank; i++) if (!rowSet.has(i)) colAxes.push(i);
+	if (colAxes.length === 0) throw new Error("tensorQr: rowAxes covers all axes — at least one axis must remain for R");
+	if (rowAxes.length === 0) throw new Error("tensorQr: rowAxes is empty — at least one axis must be assigned to Q");
+	const perm = [...rowAxes, ...colAxes];
+	const permuted = t.transpose(perm);
+	const rowDims = rowAxes.map((ax) => t.shape[ax]);
+	const colDims = colAxes.map((ax) => t.shape[ax]);
+	const numRows = rowDims.reduce((a, b) => a * b, 1);
+	const numCols = colDims.reduce((a, b) => a * b, 1);
+	const mat = new DenseMatrix(numRows, numCols, permuted.data.slice());
+	const { Q: qMat, R: rMat } = qr(mat, { mode });
+	const qCols = qMat.cols;
+	const rRows = rMat.rows;
+	const qData = qMat.toFloat64Array();
+	const rData = rMat.toFloat64Array();
+	let qLabels;
+	let rLabels;
+	if (t.axisLabels !== void 0) {
+		const joiningIndex = new Index(qCols, { name: opts?.joiningIndexName ?? "qr" });
+		const rowLabels = rowAxes.map((ax) => t.axisLabels[ax]);
+		const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
+		qLabels = [...rowLabels, joiningIndex];
+		rLabels = [joiningIndex, ...colLabels];
+	}
+	return {
+		Q: new Tensor([...rowDims, qCols], qData, qLabels),
+		R: new Tensor([rRows, ...colDims], rData, rLabels)
+	};
 }
-
-// src/operations/lu.ts
-import { DenseMatrix as DenseMatrix4 } from "@danielsimonjr/mathts-matrix";
-import { lu as matrixLU } from "@danielsimonjr/mathts-matrix";
+//#endregion
+//#region src/operations/lu.ts
 function tensorLU(t, rowAxes, opts) {
-  const rank = t.shape.length;
-  for (const ax of rowAxes) {
-    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
-      throw new RangeError(
-        `tensorLU: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
-      );
-    }
-  }
-  const rowSet = new Set(rowAxes);
-  if (rowSet.size !== rowAxes.length) {
-    throw new Error("tensorLU: rowAxes contains duplicate axes");
-  }
-  const colAxes = [];
-  for (let i = 0; i < rank; i++) {
-    if (!rowSet.has(i)) colAxes.push(i);
-  }
-  if (colAxes.length === 0) {
-    throw new Error("tensorLU: rowAxes covers all axes \u2014 at least one axis must remain for U");
-  }
-  if (rowAxes.length === 0) {
-    throw new Error("tensorLU: rowAxes is empty \u2014 at least one axis must be assigned to L");
-  }
-  const rowDims = rowAxes.map((ax) => t.shape[ax]);
-  const colDims = colAxes.map((ax) => t.shape[ax]);
-  const numRows = rowDims.reduce((a, b) => a * b, 1);
-  const numCols = colDims.reduce((a, b) => a * b, 1);
-  if (numRows !== numCols) {
-    throw new Error(
-      `tensorLU: reshaped matrix must be square (got ${numRows}\xD7${numCols}); LU decomposition requires equal row and column dimensions`
-    );
-  }
-  const perm = [...rowAxes, ...colAxes];
-  const permuted = t.transpose(perm);
-  const n = numRows;
-  const matA = new DenseMatrix4(n, n, new Float64Array(permuted.data));
-  const { L: matL, U: matU, P: matP } = matrixLU(matA);
-  const P = new Int32Array(matP);
-  let parity = 1;
-  const visited = new Uint8Array(n);
-  for (let i = 0; i < n; i++) {
-    if (visited[i] || P[i] === i) {
-      visited[i] = 1;
-      continue;
-    }
-    let cycleLen = 0;
-    let j = i;
-    while (!visited[j]) {
-      visited[j] = 1;
-      j = P[j];
-      cycleLen++;
-    }
-    if ((cycleLen - 1) % 2 !== 0) {
-      parity = parity === 1 ? -1 : 1;
-    }
-  }
-  const lData = matL.toFloat64Array();
-  const uData = matU.toFloat64Array();
-  let lLabels;
-  let uLabels;
-  if (t.axisLabels !== void 0) {
-    const joiningIndex = new Index(n, {
-      name: opts?.joiningIndexName ?? "lu"
-    });
-    const rowLabels = rowAxes.map((ax) => t.axisLabels[ax]);
-    const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
-    lLabels = [...rowLabels, joiningIndex];
-    uLabels = [joiningIndex, ...colLabels];
-  }
-  const L = new Tensor([...rowDims, n], lData, lLabels);
-  const U = new Tensor([n, ...colDims], uData, uLabels);
-  return { L, U, P, parity };
+	const rank = t.shape.length;
+	for (const ax of rowAxes) if (!Number.isInteger(ax) || ax < 0 || ax >= rank) throw new RangeError(`tensorLU: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`);
+	const rowSet = new Set(rowAxes);
+	if (rowSet.size !== rowAxes.length) throw new Error("tensorLU: rowAxes contains duplicate axes");
+	const colAxes = [];
+	for (let i = 0; i < rank; i++) if (!rowSet.has(i)) colAxes.push(i);
+	if (colAxes.length === 0) throw new Error("tensorLU: rowAxes covers all axes — at least one axis must remain for U");
+	if (rowAxes.length === 0) throw new Error("tensorLU: rowAxes is empty — at least one axis must be assigned to L");
+	const rowDims = rowAxes.map((ax) => t.shape[ax]);
+	const colDims = colAxes.map((ax) => t.shape[ax]);
+	const numRows = rowDims.reduce((a, b) => a * b, 1);
+	const numCols = colDims.reduce((a, b) => a * b, 1);
+	if (numRows !== numCols) throw new Error(`tensorLU: reshaped matrix must be square (got ${numRows}×${numCols}); LU decomposition requires equal row and column dimensions`);
+	const perm = [...rowAxes, ...colAxes];
+	const permuted = t.transpose(perm);
+	const n = numRows;
+	const matA = new DenseMatrix(n, n, new Float64Array(permuted.data));
+	const { L: matL, U: matU, P: matP } = lu(matA);
+	const P = new Int32Array(matP);
+	let parity = 1;
+	const visited = new Uint8Array(n);
+	for (let i = 0; i < n; i++) {
+		if (visited[i] || P[i] === i) {
+			visited[i] = 1;
+			continue;
+		}
+		let cycleLen = 0;
+		let j = i;
+		while (!visited[j]) {
+			visited[j] = 1;
+			j = P[j];
+			cycleLen++;
+		}
+		if ((cycleLen - 1) % 2 !== 0) parity = parity === 1 ? -1 : 1;
+	}
+	const lData = matL.toFloat64Array();
+	const uData = matU.toFloat64Array();
+	let lLabels;
+	let uLabels;
+	if (t.axisLabels !== void 0) {
+		const joiningIndex = new Index(n, { name: opts?.joiningIndexName ?? "lu" });
+		const rowLabels = rowAxes.map((ax) => t.axisLabels[ax]);
+		const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
+		lLabels = [...rowLabels, joiningIndex];
+		uLabels = [joiningIndex, ...colLabels];
+	}
+	return {
+		L: new Tensor([...rowDims, n], lData, lLabels),
+		U: new Tensor([n, ...colDims], uData, uLabels),
+		P,
+		parity
+	};
 }
-
-// src/operations/cholesky.ts
-import { DenseMatrix as DenseMatrix5 } from "@danielsimonjr/mathts-matrix";
-import { cholesky as matrixCholesky } from "@danielsimonjr/mathts-matrix";
+//#endregion
+//#region src/operations/cholesky.ts
 function transposeSquare(data, n) {
-  const out = new Float64Array(n * n);
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j < n; j++) {
-      out[j * n + i] = data[i * n + j];
-    }
-  }
-  return out;
+	const out = new Float64Array(n * n);
+	for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) out[j * n + i] = data[i * n + j];
+	return out;
 }
 function tensorCholesky(t, rowAxes, opts) {
-  const rank = t.shape.length;
-  const lower = opts?.lower ?? true;
-  for (const ax of rowAxes) {
-    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
-      throw new RangeError(
-        `tensorCholesky: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
-      );
-    }
-  }
-  const rowSet = new Set(rowAxes);
-  if (rowSet.size !== rowAxes.length) {
-    throw new Error("tensorCholesky: rowAxes contains duplicate axes");
-  }
-  const colAxes = [];
-  for (let i = 0; i < rank; i++) {
-    if (!rowSet.has(i)) colAxes.push(i);
-  }
-  if (colAxes.length === 0) {
-    throw new Error(
-      "tensorCholesky: rowAxes covers all axes \u2014 at least one axis must remain for the column factor"
-    );
-  }
-  if (rowAxes.length === 0) {
-    throw new Error("tensorCholesky: rowAxes is empty \u2014 at least one axis must be assigned");
-  }
-  const rowDims = rowAxes.map((ax) => t.shape[ax]);
-  const colDims = colAxes.map((ax) => t.shape[ax]);
-  const numRows = rowDims.reduce((a, b) => a * b, 1);
-  const numCols = colDims.reduce((a, b) => a * b, 1);
-  if (numRows !== numCols) {
-    throw new Error(`tensorCholesky: reshaped matrix must be square (got ${numRows}\xD7${numCols})`);
-  }
-  const perm = [...rowAxes, ...colAxes];
-  const permuted = t.transpose(perm);
-  const n = numRows;
-  let lData;
-  try {
-    const matA = new DenseMatrix5(n, n, new Float64Array(permuted.data));
-    const { L: matL } = matrixCholesky(matA);
-    lData = matL.toFloat64Array();
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(msg.replace(/^cholesky:/, "tensorCholesky:"), { cause: err });
-  }
-  const factorData = lower ? lData : transposeSquare(lData, n);
-  let factorLabels;
-  if (t.axisLabels !== void 0) {
-    const joiningIndex = new Index(n, {
-      name: opts?.joiningIndexName ?? "cholesky"
-    });
-    const rowLabels = rowAxes.map((ax) => t.axisLabels[ax]);
-    const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
-    if (lower) {
-      factorLabels = [...rowLabels, joiningIndex];
-    } else {
-      factorLabels = [joiningIndex, ...colLabels];
-    }
-  }
-  const factorShape = lower ? [...rowDims, n] : [n, ...colDims];
-  const factor = new Tensor(factorShape, factorData, factorLabels);
-  return { L: factor };
+	const rank = t.shape.length;
+	const lower = opts?.lower ?? true;
+	for (const ax of rowAxes) if (!Number.isInteger(ax) || ax < 0 || ax >= rank) throw new RangeError(`tensorCholesky: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`);
+	const rowSet = new Set(rowAxes);
+	if (rowSet.size !== rowAxes.length) throw new Error("tensorCholesky: rowAxes contains duplicate axes");
+	const colAxes = [];
+	for (let i = 0; i < rank; i++) if (!rowSet.has(i)) colAxes.push(i);
+	if (colAxes.length === 0) throw new Error("tensorCholesky: rowAxes covers all axes — at least one axis must remain for the column factor");
+	if (rowAxes.length === 0) throw new Error("tensorCholesky: rowAxes is empty — at least one axis must be assigned");
+	const rowDims = rowAxes.map((ax) => t.shape[ax]);
+	const colDims = colAxes.map((ax) => t.shape[ax]);
+	const numRows = rowDims.reduce((a, b) => a * b, 1);
+	const numCols = colDims.reduce((a, b) => a * b, 1);
+	if (numRows !== numCols) throw new Error(`tensorCholesky: reshaped matrix must be square (got ${numRows}×${numCols})`);
+	const perm = [...rowAxes, ...colAxes];
+	const permuted = t.transpose(perm);
+	const n = numRows;
+	let lData;
+	try {
+		const matA = new DenseMatrix(n, n, new Float64Array(permuted.data));
+		const { L: matL } = cholesky(matA);
+		lData = matL.toFloat64Array();
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		throw new Error(msg.replace(/^cholesky:/, "tensorCholesky:"), { cause: err });
+	}
+	const factorData = lower ? lData : transposeSquare(lData, n);
+	let factorLabels;
+	if (t.axisLabels !== void 0) {
+		const joiningIndex = new Index(n, { name: opts?.joiningIndexName ?? "cholesky" });
+		const rowLabels = rowAxes.map((ax) => t.axisLabels[ax]);
+		const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
+		if (lower) factorLabels = [...rowLabels, joiningIndex];
+		else factorLabels = [joiningIndex, ...colLabels];
+	}
+	return { L: new Tensor(lower ? [...rowDims, n] : [n, ...colDims], factorData, factorLabels) };
 }
-
-// src/operations/eig.ts
-import { eig as matrixEig, eigWasm } from "@danielsimonjr/mathts-matrix";
+//#endregion
+//#region src/operations/eig.ts
 function prepareEigMatrix(t, rowAxes, symmetricHint) {
-  const rank = t.shape.length;
-  for (const ax of rowAxes) {
-    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
-      throw new RangeError(
-        `tensorEig: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
-      );
-    }
-  }
-  const rowSet = new Set(rowAxes);
-  if (rowSet.size !== rowAxes.length) {
-    throw new Error("tensorEig: rowAxes contains duplicate axes");
-  }
-  const colAxes = [];
-  for (let i = 0; i < rank; i++) {
-    if (!rowSet.has(i)) colAxes.push(i);
-  }
-  if (colAxes.length === 0) {
-    throw new Error("tensorEig: rowAxes covers all axes \u2014 at least one axis must remain");
-  }
-  if (rowAxes.length === 0) {
-    throw new Error("tensorEig: rowAxes is empty \u2014 at least one axis must be assigned");
-  }
-  const rowDims = rowAxes.map((ax) => t.shape[ax]);
-  const colDims = colAxes.map((ax) => t.shape[ax]);
-  const numRows = rowDims.reduce((a, b) => a * b, 1);
-  const numCols = colDims.reduce((a, b) => a * b, 1);
-  if (numRows !== numCols) {
-    throw new Error(`tensorEig: reshaped matrix must be square (got ${numRows}\xD7${numCols})`);
-  }
-  const perm = [...rowAxes, ...colAxes];
-  const permuted = t.transpose(perm);
-  const n = numRows;
-  const matrix2D = Array.from(
-    { length: n },
-    (_, i) => Array.from({ length: n }, (_2, j) => permuted.data[i * n + j])
-  );
-  if (symmetricHint) {
-    for (let i = 0; i < n; i++) {
-      for (let j = i + 1; j < n; j++) {
-        const avg = (matrix2D[i][j] + matrix2D[j][i]) / 2;
-        matrix2D[i][j] = avg;
-        matrix2D[j][i] = avg;
-      }
-    }
-  }
-  return { matrix2D, n };
+	const rank = t.shape.length;
+	for (const ax of rowAxes) if (!Number.isInteger(ax) || ax < 0 || ax >= rank) throw new RangeError(`tensorEig: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`);
+	if (new Set(rowAxes).size !== rowAxes.length) throw new Error("tensorEig: rowAxes contains duplicate axes");
+	const { numRows, numCols, matrix } = reshapeByRowAxes(t, rowAxes, {
+		badAxis: (ax, rank) => `tensorEig: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`,
+		noColAxis: "tensorEig: rowAxes covers all axes — at least one axis must remain",
+		noRowAxis: "tensorEig: rowAxes is empty — at least one axis must be assigned"
+	});
+	if (numRows !== numCols) throw new Error(`tensorEig: reshaped matrix must be square (got ${numRows}×${numCols})`);
+	const n = numRows;
+	const matrix2D = matrix;
+	if (symmetricHint) for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+		const avg = (matrix2D[i][j] + matrix2D[j][i]) / 2;
+		matrix2D[i][j] = avg;
+		matrix2D[j][i] = avg;
+	}
+	return {
+		matrix2D,
+		n
+	};
 }
 function finishEig(eigResult, n, computeVectors, symmetricHint) {
-  const { values, vectors } = eigResult;
-  const reData = new Float64Array(n);
-  const imData = new Float64Array(n);
-  let anyImaginary = false;
-  for (let i = 0; i < n; i++) {
-    reData[i] = values[i].re;
-    imData[i] = values[i].im;
-    if (values[i].im !== 0) anyImaginary = true;
-  }
-  const eigenvalues = new Tensor([n], reData);
-  const result = { eigenvalues };
-  if (anyImaginary && !symmetricHint) {
-    result.eigenvaluesImaginary = new Tensor([n], imData);
-  }
-  if (computeVectors) {
-    const vData = new Float64Array(n * n);
-    for (let i = 0; i < n; i++) {
-      const v = vectors[i];
-      for (let r = 0; r < n; r++) {
-        vData[r * n + i] = v[r];
-      }
-    }
-    result.eigenvectors = new Tensor([n, n], vData);
-  }
-  return result;
+	const { values, vectors } = eigResult;
+	const reData = new Float64Array(n);
+	const imData = new Float64Array(n);
+	let anyImaginary = false;
+	for (let i = 0; i < n; i++) {
+		reData[i] = values[i].re;
+		imData[i] = values[i].im;
+		if (values[i].im !== 0) anyImaginary = true;
+	}
+	const result = { eigenvalues: new Tensor([n], reData) };
+	if (anyImaginary && !symmetricHint) result.eigenvaluesImaginary = new Tensor([n], imData);
+	if (computeVectors) {
+		const vData = new Float64Array(n * n);
+		for (let i = 0; i < n; i++) {
+			const v = vectors[i];
+			for (let r = 0; r < n; r++) vData[r * n + i] = v[r];
+		}
+		result.eigenvectors = new Tensor([n, n], vData);
+	}
+	return result;
 }
 function tensorEig(t, rowAxes, opts) {
-  const computeVectors = opts?.computeVectors ?? true;
-  const symmetricHint = opts?.symmetric ?? false;
-  const { matrix2D, n } = prepareEigMatrix(t, rowAxes, symmetricHint);
-  return finishEig(matrixEig(matrix2D, { computeVectors }), n, computeVectors, symmetricHint);
+	const computeVectors = opts?.computeVectors ?? true;
+	const symmetricHint = opts?.symmetric ?? false;
+	const { matrix2D, n } = prepareEigMatrix(t, rowAxes, symmetricHint);
+	return finishEig(eig(matrix2D, { computeVectors }), n, computeVectors, symmetricHint);
 }
 async function tensorEigWasm(t, rowAxes, opts) {
-  const computeVectors = opts?.computeVectors ?? true;
-  const symmetricHint = opts?.symmetric ?? false;
-  const { matrix2D, n } = prepareEigMatrix(t, rowAxes, symmetricHint);
-  return finishEig(await eigWasm(matrix2D, { computeVectors }), n, computeVectors, symmetricHint);
+	const computeVectors = opts?.computeVectors ?? true;
+	const symmetricHint = opts?.symmetric ?? false;
+	const { matrix2D, n } = prepareEigMatrix(t, rowAxes, symmetricHint);
+	return finishEig(await eigWasm(matrix2D, { computeVectors }), n, computeVectors, symmetricHint);
 }
-
-// src/operations/pinv.ts
-import { svd as svd2 } from "@danielsimonjr/mathts-matrix";
+//#endregion
+//#region src/operations/pinv.ts
 function tensorPinv(t, rowAxes, opts) {
-  const rcond = opts?.rcond ?? 1e-10;
-  const rank = t.shape.length;
-  const resolvedRowAxes = rowAxes.map((ax) => {
-    if (typeof ax === "number") {
-      return ax;
-    }
-    if (t.axisLabels === void 0) {
-      throw new Error("tensorPinv: received Index in rowAxes but tensor has no axisLabels");
-    }
-    const pos = t.axisLabels.findIndex((lbl) => lbl.matches(ax));
-    if (pos === -1) {
-      throw new Error(
-        `tensorPinv: Index "${ax.name ?? ax.id.toString()}" not found in tensor axisLabels`
-      );
-    }
-    return pos;
-  });
-  for (const ax of resolvedRowAxes) {
-    if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
-      throw new RangeError(
-        `tensorPinv: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`
-      );
-    }
-  }
-  const rowSet = new Set(resolvedRowAxes);
-  if (rowSet.size !== resolvedRowAxes.length) {
-    throw new Error("tensorPinv: rowAxes contains duplicate axes");
-  }
-  const colAxes = [];
-  for (let i = 0; i < rank; i++) {
-    if (!rowSet.has(i)) colAxes.push(i);
-  }
-  if (colAxes.length === 0) {
-    throw new Error("tensorPinv: rowAxes covers all axes \u2014 at least one col axis is required");
-  }
-  if (resolvedRowAxes.length === 0) {
-    throw new Error("tensorPinv: rowAxes is empty \u2014 at least one row axis is required");
-  }
-  const perm = [...resolvedRowAxes, ...colAxes];
-  const permuted = t.transpose(perm);
-  const rowDims = resolvedRowAxes.map((ax) => t.shape[ax]);
-  const colDims = colAxes.map((ax) => t.shape[ax]);
-  const numRows = rowDims.reduce((a, b) => a * b, 1);
-  const numCols = colDims.reduce((a, b) => a * b, 1);
-  const matrix2D = Array.from(
-    { length: numRows },
-    (_, i) => Array.from({ length: numCols }, (_2, j) => permuted.data[i * numCols + j])
-  );
-  const { U, S, V } = svd2(matrix2D, { tolerance: 1e-12 });
-  const maxS = S.length > 0 ? S[0] : 0;
-  const Sinv = S.map((s) => s > rcond * maxS ? 1 / s : 0);
-  const k = S.length;
-  const pinvData = new Float64Array(numCols * numRows);
-  for (let i = 0; i < numCols; i++) {
-    for (let j = 0; j < numRows; j++) {
-      let sum = 0;
-      for (let l = 0; l < k; l++) {
-        sum += V[i][l] * Sinv[l] * U[j][l];
-      }
-      pinvData[i * numRows + j] = sum;
-    }
-  }
-  const outShape = [...colDims, ...rowDims];
-  let outLabels;
-  if (t.axisLabels !== void 0) {
-    const rowLabels = resolvedRowAxes.map((ax) => t.axisLabels[ax]);
-    const colLabels = colAxes.map((ax) => t.axisLabels[ax]);
-    outLabels = [...colLabels, ...rowLabels];
-  }
-  return new Tensor(outShape, pinvData, outLabels);
+	const rcond = opts?.rcond ?? 1e-10;
+	const rank = t.shape.length;
+	const resolvedRowAxes = rowAxes.map((ax) => {
+		if (typeof ax === "number") return ax;
+		if (t.axisLabels === void 0) throw new Error("tensorPinv: received Index in rowAxes but tensor has no axisLabels");
+		const pos = t.axisLabels.findIndex((lbl) => lbl.matches(ax));
+		if (pos === -1) throw new Error(`tensorPinv: Index "${ax.name ?? ax.id.toString()}" not found in tensor axisLabels`);
+		return pos;
+	});
+	for (const ax of resolvedRowAxes) if (!Number.isInteger(ax) || ax < 0 || ax >= rank) throw new RangeError(`tensorPinv: rowAxes contains invalid axis ${ax} for tensor of rank ${rank}`);
+	const rowSet = new Set(resolvedRowAxes);
+	if (rowSet.size !== resolvedRowAxes.length) throw new Error("tensorPinv: rowAxes contains duplicate axes");
+	const colAxes = [];
+	for (let i = 0; i < rank; i++) if (!rowSet.has(i)) colAxes.push(i);
+	if (colAxes.length === 0) throw new Error("tensorPinv: rowAxes covers all axes — at least one col axis is required");
+	if (resolvedRowAxes.length === 0) throw new Error("tensorPinv: rowAxes is empty — at least one row axis is required");
+	const perm = [...resolvedRowAxes, ...colAxes];
+	const permuted = t.transpose(perm);
+	const rowDims = resolvedRowAxes.map((ax) => t.shape[ax]);
+	const colDims = colAxes.map((ax) => t.shape[ax]);
+	const numRows = rowDims.reduce((a, b) => a * b, 1);
+	const numCols = colDims.reduce((a, b) => a * b, 1);
+	const matrix2D = Array.from({ length: numRows }, (_, i) => Array.from({ length: numCols }, (_, j) => permuted.data[i * numCols + j]));
+	const { U, S, V } = svd(matrix2D, { tolerance: 1e-12 });
+	const maxS = S.length > 0 ? S[0] : 0;
+	const Sinv = S.map((s) => s > rcond * maxS ? 1 / s : 0);
+	const k = S.length;
+	const pinvData = new Float64Array(numCols * numRows);
+	for (let i = 0; i < numCols; i++) for (let j = 0; j < numRows; j++) {
+		let sum = 0;
+		for (let l = 0; l < k; l++) sum += V[i][l] * Sinv[l] * U[j][l];
+		pinvData[i * numRows + j] = sum;
+	}
+	const outShape = [...colDims, ...rowDims];
+	let outLabels;
+	if (t.axisLabels !== void 0) {
+		const rowLabels = resolvedRowAxes.map((ax) => t.axisLabels[ax]);
+		outLabels = [...colAxes.map((ax) => t.axisLabels[ax]), ...rowLabels];
+	}
+	return new Tensor(outShape, pinvData, outLabels);
 }
-
-// src/operations/solve.ts
-import { DenseMatrix as DenseMatrix6 } from "@danielsimonjr/mathts-matrix";
-import { lu as matrixLU2 } from "@danielsimonjr/mathts-matrix";
+//#endregion
+//#region src/operations/solve.ts
 function resolveAxes(axes, t, label) {
-  return axes.map((ax) => {
-    if (typeof ax === "number") return ax;
-    if (t.axisLabels === void 0) {
-      throw new Error(`${label}: received Index in axes but tensor has no axisLabels`);
-    }
-    const pos = t.axisLabels.findIndex((lbl) => lbl.id === ax.id);
-    if (pos === -1) {
-      throw new Error(
-        `${label}: Index "${ax.name ?? ax.id.toString()}" not found in tensor axisLabels`
-      );
-    }
-    return pos;
-  });
+	return axes.map((ax) => {
+		if (typeof ax === "number") return ax;
+		if (t.axisLabels === void 0) throw new Error(`${label}: received Index in axes but tensor has no axisLabels`);
+		const pos = t.axisLabels.findIndex((lbl) => lbl.id === ax.id);
+		if (pos === -1) throw new Error(`${label}: Index "${ax.name ?? ax.id.toString()}" not found in tensor axisLabels`);
+		return pos;
+	});
 }
 function forwardSub(L, Pb, n, nRHS) {
-  const y = new Float64Array(n * nRHS);
-  for (let i = 0; i < n; i++) {
-    for (let r = 0; r < nRHS; r++) {
-      let sum = Pb[i * nRHS + r];
-      for (let j = 0; j < i; j++) {
-        sum -= L[i * n + j] * y[j * nRHS + r];
-      }
-      y[i * nRHS + r] = sum;
-    }
-  }
-  return y;
+	const y = new Float64Array(n * nRHS);
+	for (let i = 0; i < n; i++) for (let r = 0; r < nRHS; r++) {
+		let sum = Pb[i * nRHS + r];
+		for (let j = 0; j < i; j++) sum -= L[i * n + j] * y[j * nRHS + r];
+		y[i * nRHS + r] = sum;
+	}
+	return y;
 }
 function backSub(U, y, n, nRHS) {
-  const x = new Float64Array(n * nRHS);
-  for (let i = n - 1; i >= 0; i--) {
-    for (let r = 0; r < nRHS; r++) {
-      let sum = y[i * nRHS + r];
-      for (let j = i + 1; j < n; j++) {
-        sum -= U[i * n + j] * x[j * nRHS + r];
-      }
-      x[i * nRHS + r] = sum / U[i * n + i];
-    }
-  }
-  return x;
+	const x = new Float64Array(n * nRHS);
+	for (let i = n - 1; i >= 0; i--) for (let r = 0; r < nRHS; r++) {
+		let sum = y[i * nRHS + r];
+		for (let j = i + 1; j < n; j++) sum -= U[i * n + j] * x[j * nRHS + r];
+		x[i * nRHS + r] = sum / U[i * n + i];
+	}
+	return x;
 }
 function tensorSolve(A, b, opts) {
-  const rankA = A.shape.length;
-  const rankB = b.shape.length;
-  let rowAxesA;
-  if (opts?.rowAxesA !== void 0) {
-    rowAxesA = resolveAxes(opts.rowAxesA, A, "tensorSolve(A)");
-  } else if (A.axisLabels !== void 0 && b.axisLabels !== void 0) {
-    rowAxesA = [];
-    for (let i = 0; i < rankA; i++) {
-      const lbl = A.axisLabels[i];
-      if (b.axisLabels.some((blbl) => blbl.id === lbl.id)) {
-        rowAxesA.push(i);
-      }
-    }
-    if (rowAxesA.length === 0) {
-      const half = Math.ceil(rankA / 2);
-      rowAxesA = Array.from({ length: half }, (_, i) => i);
-    }
-  } else {
-    const half = Math.ceil(rankA / 2);
-    rowAxesA = Array.from({ length: half }, (_, i) => i);
-  }
-  let rowAxesB;
-  if (opts?.rowAxesB !== void 0) {
-    rowAxesB = resolveAxes(opts.rowAxesB, b, "tensorSolve(b)");
-  } else if (A.axisLabels !== void 0 && b.axisLabels !== void 0) {
-    const aRowIds = new Set(rowAxesA.map((ax) => A.axisLabels[ax].id));
-    rowAxesB = [];
-    for (let i = 0; i < rankB; i++) {
-      if (aRowIds.has(b.axisLabels[i].id)) {
-        rowAxesB.push(i);
-      }
-    }
-    if (rowAxesB.length === 0) {
-      rowAxesB = [0];
-    }
-  } else {
-    rowAxesB = [0];
-  }
-  for (const ax of rowAxesA) {
-    if (!Number.isInteger(ax) || ax < 0 || ax >= rankA) {
-      throw new RangeError(
-        `tensorSolve: rowAxesA contains invalid axis ${ax} for tensor A of rank ${rankA}`
-      );
-    }
-  }
-  const rowSetA = new Set(rowAxesA);
-  if (rowSetA.size !== rowAxesA.length) {
-    throw new Error("tensorSolve: rowAxesA contains duplicate axes");
-  }
-  for (const ax of rowAxesB) {
-    if (!Number.isInteger(ax) || ax < 0 || ax >= rankB) {
-      throw new RangeError(
-        `tensorSolve: rowAxesB contains invalid axis ${ax} for tensor b of rank ${rankB}`
-      );
-    }
-  }
-  const rowSetB = new Set(rowAxesB);
-  if (rowSetB.size !== rowAxesB.length) {
-    throw new Error("tensorSolve: rowAxesB contains duplicate axes");
-  }
-  const colAxesA = [];
-  for (let i = 0; i < rankA; i++) {
-    if (!rowSetA.has(i)) colAxesA.push(i);
-  }
-  const colAxesB = [];
-  for (let i = 0; i < rankB; i++) {
-    if (!rowSetB.has(i)) colAxesB.push(i);
-  }
-  const rowDimsA = rowAxesA.map((ax) => A.shape[ax]);
-  const colDimsA = colAxesA.map((ax) => A.shape[ax]);
-  const rowDimsB = rowAxesB.map((ax) => b.shape[ax]);
-  const colDimsB = colAxesB.map((ax) => b.shape[ax]);
-  const numRowsA = rowDimsA.reduce((a, v) => a * v, 1);
-  const numColsA = colDimsA.reduce((a, v) => a * v, 1);
-  const numRowsB = rowDimsB.reduce((a, v) => a * v, 1);
-  const numColsB = colDimsB.length > 0 ? colDimsB.reduce((a, v) => a * v, 1) : 1;
-  if (numRowsA !== numColsA) {
-    throw new Error(
-      `tensorSolve: reshaped A must be square (got ${numRowsA}\xD7${numColsA}); non-square systems are not supported \u2014 use tensorPinv for least-squares`
-    );
-  }
-  const n = numRowsA;
-  if (numRowsB !== n) {
-    throw new Error(
-      `tensorSolve: b's contracting dimension (${numRowsB}) does not match A's dimension (${n})`
-    );
-  }
-  const permA = [...rowAxesA, ...colAxesA];
-  const permutedA = A.transpose(permA);
-  const matA = new DenseMatrix6(n, n, new Float64Array(permutedA.data));
-  const { L, U, P } = matrixLU2(matA);
-  const lFlat = L.toFloat64Array();
-  const uFlat = U.toFloat64Array();
-  const permB = [...rowAxesB, ...colAxesB];
-  const permutedB = b.transpose(permB);
-  const bFlat = permutedB.data;
-  const Pb = new Float64Array(n * numColsB);
-  for (let i = 0; i < n; i++) {
-    for (let r = 0; r < numColsB; r++) {
-      Pb[i * numColsB + r] = bFlat[P[i] * numColsB + r];
-    }
-  }
-  const y = forwardSub(lFlat, Pb, n, numColsB);
-  const xFlat = backSub(uFlat, y, n, numColsB);
-  const outShape = [...colDimsA, ...colDimsB];
-  const finalShape = outShape.length > 0 ? outShape : [n];
-  let outLabels;
-  if (A.axisLabels !== void 0 || b.axisLabels !== void 0) {
-    const aColLabels = A.axisLabels ? colAxesA.map((ax) => A.axisLabels[ax]) : [];
-    const bColLabels = b.axisLabels ? colAxesB.map((ax) => b.axisLabels[ax]) : [];
-    if (aColLabels.length + bColLabels.length === finalShape.length) {
-      outLabels = [...aColLabels, ...bColLabels];
-    }
-  }
-  const xTensor = new Tensor(finalShape, xFlat, outLabels?.length ? outLabels : void 0);
-  return { x: xTensor };
+	const rankA = A.shape.length;
+	const rankB = b.shape.length;
+	let rowAxesA;
+	if (opts?.rowAxesA !== void 0) rowAxesA = resolveAxes(opts.rowAxesA, A, "tensorSolve(A)");
+	else if (A.axisLabels !== void 0 && b.axisLabels !== void 0) {
+		rowAxesA = [];
+		for (let i = 0; i < rankA; i++) {
+			const lbl = A.axisLabels[i];
+			if (b.axisLabels.some((blbl) => blbl.id === lbl.id)) rowAxesA.push(i);
+		}
+		if (rowAxesA.length === 0) {
+			const half = Math.ceil(rankA / 2);
+			rowAxesA = Array.from({ length: half }, (_, i) => i);
+		}
+	} else {
+		const half = Math.ceil(rankA / 2);
+		rowAxesA = Array.from({ length: half }, (_, i) => i);
+	}
+	let rowAxesB;
+	if (opts?.rowAxesB !== void 0) rowAxesB = resolveAxes(opts.rowAxesB, b, "tensorSolve(b)");
+	else if (A.axisLabels !== void 0 && b.axisLabels !== void 0) {
+		const aRowIds = new Set(rowAxesA.map((ax) => A.axisLabels[ax].id));
+		rowAxesB = [];
+		for (let i = 0; i < rankB; i++) if (aRowIds.has(b.axisLabels[i].id)) rowAxesB.push(i);
+		if (rowAxesB.length === 0) rowAxesB = [0];
+	} else rowAxesB = [0];
+	for (const ax of rowAxesA) if (!Number.isInteger(ax) || ax < 0 || ax >= rankA) throw new RangeError(`tensorSolve: rowAxesA contains invalid axis ${ax} for tensor A of rank ${rankA}`);
+	const rowSetA = new Set(rowAxesA);
+	if (rowSetA.size !== rowAxesA.length) throw new Error("tensorSolve: rowAxesA contains duplicate axes");
+	for (const ax of rowAxesB) if (!Number.isInteger(ax) || ax < 0 || ax >= rankB) throw new RangeError(`tensorSolve: rowAxesB contains invalid axis ${ax} for tensor b of rank ${rankB}`);
+	const rowSetB = new Set(rowAxesB);
+	if (rowSetB.size !== rowAxesB.length) throw new Error("tensorSolve: rowAxesB contains duplicate axes");
+	const colAxesA = [];
+	for (let i = 0; i < rankA; i++) if (!rowSetA.has(i)) colAxesA.push(i);
+	const colAxesB = [];
+	for (let i = 0; i < rankB; i++) if (!rowSetB.has(i)) colAxesB.push(i);
+	const rowDimsA = rowAxesA.map((ax) => A.shape[ax]);
+	const colDimsA = colAxesA.map((ax) => A.shape[ax]);
+	const rowDimsB = rowAxesB.map((ax) => b.shape[ax]);
+	const colDimsB = colAxesB.map((ax) => b.shape[ax]);
+	const numRowsA = rowDimsA.reduce((a, v) => a * v, 1);
+	const numColsA = colDimsA.reduce((a, v) => a * v, 1);
+	const numRowsB = rowDimsB.reduce((a, v) => a * v, 1);
+	const numColsB = colDimsB.length > 0 ? colDimsB.reduce((a, v) => a * v, 1) : 1;
+	if (numRowsA !== numColsA) throw new Error(`tensorSolve: reshaped A must be square (got ${numRowsA}×${numColsA}); non-square systems are not supported — use tensorPinv for least-squares`);
+	const n = numRowsA;
+	if (numRowsB !== n) throw new Error(`tensorSolve: b's contracting dimension (${numRowsB}) does not match A's dimension (${n})`);
+	const permA = [...rowAxesA, ...colAxesA];
+	const permutedA = A.transpose(permA);
+	const matA = new DenseMatrix(n, n, new Float64Array(permutedA.data));
+	const { L, U, P } = lu(matA);
+	const lFlat = L.toFloat64Array();
+	const uFlat = U.toFloat64Array();
+	const permB = [...rowAxesB, ...colAxesB];
+	const bFlat = b.transpose(permB).data;
+	const Pb = new Float64Array(n * numColsB);
+	for (let i = 0; i < n; i++) for (let r = 0; r < numColsB; r++) Pb[i * numColsB + r] = bFlat[P[i] * numColsB + r];
+	const xFlat = backSub(uFlat, forwardSub(lFlat, Pb, n, numColsB), n, numColsB);
+	const outShape = [...colDimsA, ...colDimsB];
+	const finalShape = outShape.length > 0 ? outShape : [n];
+	let outLabels;
+	if (A.axisLabels !== void 0 || b.axisLabels !== void 0) {
+		const aColLabels = A.axisLabels ? colAxesA.map((ax) => A.axisLabels[ax]) : [];
+		const bColLabels = b.axisLabels ? colAxesB.map((ax) => b.axisLabels[ax]) : [];
+		if (aColLabels.length + bColLabels.length === finalShape.length) outLabels = [...aColLabels, ...bColLabels];
+	}
+	return { x: new Tensor(finalShape, xFlat, outLabels?.length ? outLabels : void 0) };
 }
-
-// src/operations/kron.ts
+//#endregion
+//#region src/operations/kron.ts
 function tensorKron(a, b, opts) {
-  const separator = opts?.separator ?? "_X_";
-  let aShape = [...a.shape];
-  let bShape = [...b.shape];
-  let aLabels = a.axisLabels ? [...a.axisLabels] : void 0;
-  let bLabels = b.axisLabels ? [...b.axisLabels] : void 0;
-  const rankA = aShape.length;
-  const rankB = bShape.length;
-  const outRank = Math.max(rankA, rankB);
-  if (rankA < outRank) {
-    const pad2 = outRank - rankA;
-    aShape = [...new Array(pad2).fill(1), ...aShape];
-    if (aLabels !== void 0) {
-      const padLabels = Array.from(
-        { length: pad2 },
-        (_, i) => new Index(1, { name: `kron_pad_a_${i}` })
-      );
-      aLabels = [...padLabels, ...aLabels];
-    }
-  }
-  if (rankB < outRank) {
-    const pad2 = outRank - rankB;
-    bShape = [...new Array(pad2).fill(1), ...bShape];
-    if (bLabels !== void 0) {
-      const padLabels = Array.from(
-        { length: pad2 },
-        (_, i) => new Index(1, { name: `kron_pad_b_${i}` })
-      );
-      bLabels = [...padLabels, ...bLabels];
-    }
-  }
-  const outShape = aShape.map((d, k) => d * bShape[k]);
-  const outSize = outShape.reduce((acc, d) => acc * d, 1);
-  const outStrides = Tensor.rowMajorStrides(outShape);
-  const aData = a.data;
-  const bData = b.data;
-  const aOrigStrides = Tensor.rowMajorStrides(aShape.slice(outRank - rankA));
-  const bOrigStrides = Tensor.rowMajorStrides(bShape.slice(outRank - rankB));
-  const result = new Float64Array(outSize);
-  const outIdx = new Array(outRank).fill(0);
-  for (let flatOut = 0; flatOut < outSize; flatOut++) {
-    {
-      let rem = flatOut;
-      for (let k = 0; k < outRank; k++) {
-        outIdx[k] = Math.floor(rem / outStrides[k]);
-        rem -= outIdx[k] * outStrides[k];
-      }
-    }
-    let flatA = 0;
-    let flatB = 0;
-    for (let k = 0; k < outRank; k++) {
-      const aIdx = Math.floor(outIdx[k] / bShape[k]);
-      const bIdx = outIdx[k] % bShape[k];
-      const aPadded = outRank - rankA;
-      const bPadded = outRank - rankB;
-      if (k >= aPadded) {
-        flatA += aIdx * aOrigStrides[k - aPadded];
-      }
-      if (k >= bPadded) {
-        flatB += bIdx * bOrigStrides[k - bPadded];
-      }
-    }
-    result[flatOut] = aData[flatA] * bData[flatB];
-  }
-  let outLabels;
-  if (aLabels !== void 0 && bLabels !== void 0) {
-    outLabels = aLabels.map((al, k) => {
-      const bl = bLabels[k];
-      const aName = al.name ?? `a${k}`;
-      const bName = bl.name ?? `b${k}`;
-      const outDim = outShape[k];
-      return new Index(outDim, { name: `${aName}${separator}${bName}` });
-    });
-  }
-  return new Tensor(outShape, result, outLabels);
+	const separator = opts?.separator ?? "_X_";
+	let aShape = [...a.shape];
+	let bShape = [...b.shape];
+	let aLabels = a.axisLabels ? [...a.axisLabels] : void 0;
+	let bLabels = b.axisLabels ? [...b.axisLabels] : void 0;
+	const rankA = aShape.length;
+	const rankB = bShape.length;
+	const outRank = Math.max(rankA, rankB);
+	if (rankA < outRank) {
+		const pad = outRank - rankA;
+		aShape = [...new Array(pad).fill(1), ...aShape];
+		if (aLabels !== void 0) aLabels = [...Array.from({ length: pad }, (_, i) => new Index(1, { name: `kron_pad_a_${i}` })), ...aLabels];
+	}
+	if (rankB < outRank) {
+		const pad = outRank - rankB;
+		bShape = [...new Array(pad).fill(1), ...bShape];
+		if (bLabels !== void 0) bLabels = [...Array.from({ length: pad }, (_, i) => new Index(1, { name: `kron_pad_b_${i}` })), ...bLabels];
+	}
+	const outShape = aShape.map((d, k) => d * bShape[k]);
+	const outSize = outShape.reduce((acc, d) => acc * d, 1);
+	const outStrides = Tensor.rowMajorStrides(outShape);
+	const aData = a.data;
+	const bData = b.data;
+	const aOrigStrides = Tensor.rowMajorStrides(aShape.slice(outRank - rankA));
+	const bOrigStrides = Tensor.rowMajorStrides(bShape.slice(outRank - rankB));
+	const result = new Float64Array(outSize);
+	const outIdx = new Array(outRank).fill(0);
+	for (let flatOut = 0; flatOut < outSize; flatOut++) {
+		{
+			let rem = flatOut;
+			for (let k = 0; k < outRank; k++) {
+				outIdx[k] = Math.floor(rem / outStrides[k]);
+				rem -= outIdx[k] * outStrides[k];
+			}
+		}
+		let flatA = 0;
+		let flatB = 0;
+		for (let k = 0; k < outRank; k++) {
+			const aIdx = Math.floor(outIdx[k] / bShape[k]);
+			const bIdx = outIdx[k] % bShape[k];
+			const aPadded = outRank - rankA;
+			const bPadded = outRank - rankB;
+			if (k >= aPadded) flatA += aIdx * aOrigStrides[k - aPadded];
+			if (k >= bPadded) flatB += bIdx * bOrigStrides[k - bPadded];
+		}
+		result[flatOut] = aData[flatA] * bData[flatB];
+	}
+	let outLabels;
+	if (aLabels !== void 0 && bLabels !== void 0) outLabels = aLabels.map((al, k) => {
+		const bl = bLabels[k];
+		const aName = al.name ?? `a${k}`;
+		const bName = bl.name ?? `b${k}`;
+		const outDim = outShape[k];
+		return new Index(outDim, { name: `${aName}${separator}${bName}` });
+	});
+	return new Tensor(outShape, result, outLabels);
 }
-
-// src/operations/slice.ts
+//#endregion
+//#region src/operations/slice.ts
 function slice(t, ranges) {
-  const rank = t.shape.length;
-  if (ranges.length !== rank) {
-    throw new Error(`slice: ranges length ${ranges.length} does not match tensor rank ${rank}`);
-  }
-  const resolved = ranges.map((r, axis) => {
-    const dim = t.shape[axis];
-    const step = r?.step ?? 1;
-    if (!Number.isInteger(step) || step < 1) {
-      throw new RangeError(`slice: step must be a positive integer (axis ${axis}), got ${step}`);
-    }
-    let start = r?.start ?? 0;
-    let stop = r?.stop ?? dim;
-    if (start < 0) start = dim + start;
-    if (stop < 0) stop = dim + stop;
-    if (start < 0 || start > dim) {
-      throw new RangeError(
-        `slice: start ${r?.start} is out of range for axis ${axis} with dim ${dim}`
-      );
-    }
-    stop = Math.max(0, Math.min(stop, dim));
-    return { start, stop, step };
-  });
-  const outShape = resolved.map(
-    ({ start, stop, step }) => start >= stop ? 0 : Math.ceil((stop - start) / step)
-  );
-  const outSize = outShape.reduce((a, b) => a * b, 1);
-  const outData = new Float64Array(outSize);
-  if (outSize > 0) {
-    const inStrides = Tensor.rowMajorStrides(t.shape);
-    const outStrides = Tensor.rowMajorStrides(outShape);
-    const outIdx = new Array(rank).fill(0);
-    for (let flatOut = 0; flatOut < outSize; flatOut++) {
-      let rem = flatOut;
-      for (let k = 0; k < rank; k++) {
-        outIdx[k] = Math.floor(rem / outStrides[k]);
-        rem -= outIdx[k] * outStrides[k];
-      }
-      let flatIn = 0;
-      for (let k = 0; k < rank; k++) {
-        const inK = resolved[k].start + outIdx[k] * resolved[k].step;
-        flatIn += inK * inStrides[k];
-      }
-      outData[flatOut] = t.data[flatIn];
-    }
-  }
-  let outLabels;
-  if (t.axisLabels !== void 0) {
-    outLabels = t.axisLabels.map((lbl, k) => {
-      const newDim = outShape[k];
-      return new Index(Math.max(1, newDim), { name: lbl.name, tags: [...lbl.tags] });
-    });
-  }
-  return new Tensor(outShape, outData, outLabels);
+	const rank = t.shape.length;
+	if (ranges.length !== rank) throw new Error(`slice: ranges length ${ranges.length} does not match tensor rank ${rank}`);
+	const resolved = ranges.map((r, axis) => {
+		const dim = t.shape[axis];
+		const step = r?.step ?? 1;
+		if (!Number.isInteger(step) || step < 1) throw new RangeError(`slice: step must be a positive integer (axis ${axis}), got ${step}`);
+		let start = r?.start ?? 0;
+		let stop = r?.stop ?? dim;
+		if (start < 0) start = dim + start;
+		if (stop < 0) stop = dim + stop;
+		if (start < 0 || start > dim) throw new RangeError(`slice: start ${r?.start} is out of range for axis ${axis} with dim ${dim}`);
+		stop = Math.max(0, Math.min(stop, dim));
+		return {
+			start,
+			stop,
+			step
+		};
+	});
+	const outShape = resolved.map(({ start, stop, step }) => start >= stop ? 0 : Math.ceil((stop - start) / step));
+	const outSize = outShape.reduce((a, b) => a * b, 1);
+	const outData = new Float64Array(outSize);
+	if (outSize > 0) {
+		const inStrides = Tensor.rowMajorStrides(t.shape);
+		const outStrides = Tensor.rowMajorStrides(outShape);
+		const outIdx = new Array(rank).fill(0);
+		for (let flatOut = 0; flatOut < outSize; flatOut++) {
+			let rem = flatOut;
+			for (let k = 0; k < rank; k++) {
+				outIdx[k] = Math.floor(rem / outStrides[k]);
+				rem -= outIdx[k] * outStrides[k];
+			}
+			let flatIn = 0;
+			for (let k = 0; k < rank; k++) {
+				const inK = resolved[k].start + outIdx[k] * resolved[k].step;
+				flatIn += inK * inStrides[k];
+			}
+			outData[flatOut] = t.data[flatIn];
+		}
+	}
+	let outLabels;
+	if (t.axisLabels !== void 0) outLabels = t.axisLabels.map((lbl, k) => {
+		const newDim = outShape[k];
+		return new Index(Math.max(1, newDim), {
+			name: lbl.name,
+			tags: [...lbl.tags]
+		});
+	});
+	return new Tensor(outShape, outData, outLabels);
 }
-
-// src/operations/gather.ts
+//#endregion
+//#region src/operations/gather.ts
 function gather(t, axis, indices) {
-  const rank = t.shape.length;
-  const ax = axis < 0 ? rank + axis : axis;
-  if (ax < 0 || ax >= rank) {
-    throw new Error(`gather: axis ${axis} is out of range for rank ${rank}`);
-  }
-  const dimAx = t.shape[ax];
-  for (let i = 0; i < indices.length; i++) {
-    if (!Number.isInteger(indices[i]) || indices[i] < 0 || indices[i] >= dimAx) {
-      throw new RangeError(
-        `gather: index ${indices[i]} at position ${i} is out of range [0, ${dimAx}) for axis ${ax}`
-      );
-    }
-  }
-  const outShape = [...t.shape];
-  outShape[ax] = indices.length;
-  const outSize = outShape.reduce((a, b) => a * b, 1);
-  const outData = new Float64Array(outSize);
-  if (outSize > 0) {
-    const inStrides = Tensor.rowMajorStrides(t.shape);
-    const outStrides = Tensor.rowMajorStrides(outShape);
-    const outIdx = new Array(rank).fill(0);
-    for (let flatOut = 0; flatOut < outSize; flatOut++) {
-      let rem = flatOut;
-      for (let k = 0; k < rank; k++) {
-        outIdx[k] = Math.floor(rem / outStrides[k]);
-        rem -= outIdx[k] * outStrides[k];
-      }
-      let flatIn = 0;
-      for (let k = 0; k < rank; k++) {
-        const inK = k === ax ? indices[outIdx[k]] : outIdx[k];
-        flatIn += inK * inStrides[k];
-      }
-      outData[flatOut] = t.data[flatIn];
-    }
-  }
-  let outLabels;
-  if (t.axisLabels !== void 0) {
-    outLabels = t.axisLabels.map((lbl, k) => {
-      if (k === ax) {
-        return lbl.prime();
-      }
-      return lbl;
-    });
-  }
-  return new Tensor(outShape, outData, outLabels);
+	const rank = t.shape.length;
+	const ax = axis < 0 ? rank + axis : axis;
+	if (ax < 0 || ax >= rank) throw new Error(`gather: axis ${axis} is out of range for rank ${rank}`);
+	const dimAx = t.shape[ax];
+	for (let i = 0; i < indices.length; i++) if (!Number.isInteger(indices[i]) || indices[i] < 0 || indices[i] >= dimAx) throw new RangeError(`gather: index ${indices[i]} at position ${i} is out of range [0, ${dimAx}) for axis ${ax}`);
+	const outShape = [...t.shape];
+	outShape[ax] = indices.length;
+	const outSize = outShape.reduce((a, b) => a * b, 1);
+	const outData = new Float64Array(outSize);
+	if (outSize > 0) {
+		const inStrides = Tensor.rowMajorStrides(t.shape);
+		const outStrides = Tensor.rowMajorStrides(outShape);
+		const outIdx = new Array(rank).fill(0);
+		for (let flatOut = 0; flatOut < outSize; flatOut++) {
+			let rem = flatOut;
+			for (let k = 0; k < rank; k++) {
+				outIdx[k] = Math.floor(rem / outStrides[k]);
+				rem -= outIdx[k] * outStrides[k];
+			}
+			let flatIn = 0;
+			for (let k = 0; k < rank; k++) {
+				const inK = k === ax ? indices[outIdx[k]] : outIdx[k];
+				flatIn += inK * inStrides[k];
+			}
+			outData[flatOut] = t.data[flatIn];
+		}
+	}
+	let outLabels;
+	if (t.axisLabels !== void 0) outLabels = t.axisLabels.map((lbl, k) => {
+		if (k === ax) return lbl.prime();
+		return lbl;
+	});
+	return new Tensor(outShape, outData, outLabels);
 }
-
-// src/operations/stack.ts
+//#endregion
+//#region src/operations/stack.ts
 function stack(tensors, axis, opts) {
-  if (tensors.length === 0) {
-    throw new Error("stack: tensors array must be non-empty");
-  }
-  const first = tensors[0];
-  const inRank = first.shape.length;
-  const outRank = inRank + 1;
-  const ax = axis < 0 ? outRank + axis : axis;
-  if (ax < 0 || ax > inRank) {
-    throw new Error(`stack: axis ${axis} is out of range for output rank ${outRank}`);
-  }
-  for (let t = 1; t < tensors.length; t++) {
-    const s = tensors[t].shape;
-    if (s.length !== inRank) {
-      throw new Error(
-        `stack: tensors[${t}] has rank ${s.length} but tensors[0] has rank ${inRank}`
-      );
-    }
-    for (let k = 0; k < inRank; k++) {
-      if (s[k] !== first.shape[k]) {
-        throw new Error(
-          `stack: shape mismatch at axis ${k}: tensors[${t}].shape[${k}]=${s[k]} vs tensors[0].shape[${k}]=${first.shape[k]}`
-        );
-      }
-    }
-  }
-  const outShape = [];
-  for (let k = 0; k < ax; k++) outShape.push(first.shape[k]);
-  outShape.push(tensors.length);
-  for (let k = ax; k < inRank; k++) outShape.push(first.shape[k]);
-  const outSize = outShape.reduce((a, b) => a * b, 1);
-  const outData = new Float64Array(outSize);
-  const outStrides = Tensor.rowMajorStrides(outShape);
-  const inStrides = Tensor.rowMajorStrides(first.shape);
-  for (let ti = 0; ti < tensors.length; ti++) {
-    const inData = tensors[ti].data;
-    const inSize = first.shape.reduce((a, b) => a * b, 1);
-    const inIdx = new Array(inRank).fill(0);
-    for (let flatIn = 0; flatIn < inSize; flatIn++) {
-      let rem = flatIn;
-      for (let k = 0; k < inRank; k++) {
-        inIdx[k] = Math.floor(rem / inStrides[k]);
-        rem -= inIdx[k] * inStrides[k];
-      }
-      let flatOut = 0;
-      for (let k = 0; k < ax; k++) flatOut += inIdx[k] * outStrides[k];
-      flatOut += ti * outStrides[ax];
-      for (let k = ax; k < inRank; k++) flatOut += inIdx[k] * outStrides[k + 1];
-      outData[flatOut] = inData[flatIn];
-    }
-  }
-  let outLabels;
-  if (first.axisLabels !== void 0) {
-    const newLabel = opts?.newAxisLabel ?? new Index(tensors.length, { name: void 0 });
-    const labels = [];
-    for (let k = 0; k < ax; k++) labels.push(first.axisLabels[k]);
-    labels.push(newLabel);
-    for (let k = ax; k < inRank; k++) labels.push(first.axisLabels[k]);
-    outLabels = labels;
-  } else if (opts?.newAxisLabel !== void 0) {
-  }
-  return new Tensor(outShape, outData, outLabels);
+	if (tensors.length === 0) throw new Error("stack: tensors array must be non-empty");
+	const first = tensors[0];
+	const inRank = first.shape.length;
+	const outRank = inRank + 1;
+	const ax = axis < 0 ? outRank + axis : axis;
+	if (ax < 0 || ax > inRank) throw new Error(`stack: axis ${axis} is out of range for output rank ${outRank}`);
+	for (let t = 1; t < tensors.length; t++) {
+		const s = tensors[t].shape;
+		if (s.length !== inRank) throw new Error(`stack: tensors[${t}] has rank ${s.length} but tensors[0] has rank ${inRank}`);
+		for (let k = 0; k < inRank; k++) if (s[k] !== first.shape[k]) throw new Error(`stack: shape mismatch at axis ${k}: tensors[${t}].shape[${k}]=${s[k]} vs tensors[0].shape[${k}]=${first.shape[k]}`);
+	}
+	const outShape = [];
+	for (let k = 0; k < ax; k++) outShape.push(first.shape[k]);
+	outShape.push(tensors.length);
+	for (let k = ax; k < inRank; k++) outShape.push(first.shape[k]);
+	const outSize = outShape.reduce((a, b) => a * b, 1);
+	const outData = new Float64Array(outSize);
+	const outStrides = Tensor.rowMajorStrides(outShape);
+	const inStrides = Tensor.rowMajorStrides(first.shape);
+	for (let ti = 0; ti < tensors.length; ti++) {
+		const inData = tensors[ti].data;
+		const inSize = first.shape.reduce((a, b) => a * b, 1);
+		const inIdx = new Array(inRank).fill(0);
+		for (let flatIn = 0; flatIn < inSize; flatIn++) {
+			let rem = flatIn;
+			for (let k = 0; k < inRank; k++) {
+				inIdx[k] = Math.floor(rem / inStrides[k]);
+				rem -= inIdx[k] * inStrides[k];
+			}
+			let flatOut = 0;
+			for (let k = 0; k < ax; k++) flatOut += inIdx[k] * outStrides[k];
+			flatOut += ti * outStrides[ax];
+			for (let k = ax; k < inRank; k++) flatOut += inIdx[k] * outStrides[k + 1];
+			outData[flatOut] = inData[flatIn];
+		}
+	}
+	let outLabels;
+	if (first.axisLabels !== void 0) {
+		const newLabel = opts?.newAxisLabel ?? new Index(tensors.length, { name: void 0 });
+		const labels = [];
+		for (let k = 0; k < ax; k++) labels.push(first.axisLabels[k]);
+		labels.push(newLabel);
+		for (let k = ax; k < inRank; k++) labels.push(first.axisLabels[k]);
+		outLabels = labels;
+	} else if (opts?.newAxisLabel !== void 0) {}
+	return new Tensor(outShape, outData, outLabels);
 }
-
-// src/operations/concatenate.ts
+//#endregion
+//#region src/operations/concatenate.ts
 function concatenate(tensors, axis) {
-  if (tensors.length === 0) {
-    throw new Error("concatenate: tensors array must be non-empty");
-  }
-  const first = tensors[0];
-  const rank = first.shape.length;
-  const ax = axis < 0 ? rank + axis : axis;
-  if (ax < 0 || ax >= rank) {
-    throw new Error(`concatenate: axis ${axis} is out of range for rank ${rank}`);
-  }
-  for (let t = 1; t < tensors.length; t++) {
-    const s = tensors[t].shape;
-    if (s.length !== rank) {
-      throw new Error(
-        `concatenate: tensors[${t}] has rank ${s.length} but tensors[0] has rank ${rank}`
-      );
-    }
-    for (let k = 0; k < rank; k++) {
-      if (k !== ax && s[k] !== first.shape[k]) {
-        throw new Error(
-          `concatenate: shape mismatch on non-join axis ${k}: tensors[${t}].shape[${k}]=${s[k]} vs tensors[0].shape[${k}]=${first.shape[k]}`
-        );
-      }
-    }
-  }
-  const joinDim = tensors.reduce((sum, t) => sum + t.shape[ax], 0);
-  const outShape = [...first.shape];
-  outShape[ax] = joinDim;
-  const outSize = outShape.reduce((a, b) => a * b, 1);
-  const outData = new Float64Array(outSize);
-  const outStrides = Tensor.rowMajorStrides(outShape);
-  let joinOffset = 0;
-  for (let ti = 0; ti < tensors.length; ti++) {
-    const t = tensors[ti];
-    const inShape = t.shape;
-    const inSize = inShape.reduce((a, b) => a * b, 1);
-    const inStrides = Tensor.rowMajorStrides(inShape);
-    const inIdx = new Array(rank).fill(0);
-    for (let flatIn = 0; flatIn < inSize; flatIn++) {
-      let rem = flatIn;
-      for (let k = 0; k < rank; k++) {
-        inIdx[k] = Math.floor(rem / inStrides[k]);
-        rem -= inIdx[k] * inStrides[k];
-      }
-      let flatOut = 0;
-      for (let k = 0; k < rank; k++) {
-        const outK = k === ax ? inIdx[k] + joinOffset : inIdx[k];
-        flatOut += outK * outStrides[k];
-      }
-      outData[flatOut] = t.data[flatIn];
-    }
-    joinOffset += inShape[ax];
-  }
-  let outLabels;
-  if (first.axisLabels !== void 0) {
-    outLabels = first.axisLabels.map((lbl, k) => {
-      if (k === ax) {
-        return new Index(joinDim, { name: lbl.name, tags: [...lbl.tags] });
-      }
-      return lbl;
-    });
-  }
-  return new Tensor(outShape, outData, outLabels);
+	if (tensors.length === 0) throw new Error("concatenate: tensors array must be non-empty");
+	const first = tensors[0];
+	const rank = first.shape.length;
+	const ax = axis < 0 ? rank + axis : axis;
+	if (ax < 0 || ax >= rank) throw new Error(`concatenate: axis ${axis} is out of range for rank ${rank}`);
+	for (let t = 1; t < tensors.length; t++) {
+		const s = tensors[t].shape;
+		if (s.length !== rank) throw new Error(`concatenate: tensors[${t}] has rank ${s.length} but tensors[0] has rank ${rank}`);
+		for (let k = 0; k < rank; k++) if (k !== ax && s[k] !== first.shape[k]) throw new Error(`concatenate: shape mismatch on non-join axis ${k}: tensors[${t}].shape[${k}]=${s[k]} vs tensors[0].shape[${k}]=${first.shape[k]}`);
+	}
+	const joinDim = tensors.reduce((sum, t) => sum + t.shape[ax], 0);
+	const outShape = [...first.shape];
+	outShape[ax] = joinDim;
+	const outSize = outShape.reduce((a, b) => a * b, 1);
+	const outData = new Float64Array(outSize);
+	const outStrides = Tensor.rowMajorStrides(outShape);
+	let joinOffset = 0;
+	for (let ti = 0; ti < tensors.length; ti++) {
+		const t = tensors[ti];
+		const inShape = t.shape;
+		const inSize = inShape.reduce((a, b) => a * b, 1);
+		const inStrides = Tensor.rowMajorStrides(inShape);
+		const inIdx = new Array(rank).fill(0);
+		for (let flatIn = 0; flatIn < inSize; flatIn++) {
+			let rem = flatIn;
+			for (let k = 0; k < rank; k++) {
+				inIdx[k] = Math.floor(rem / inStrides[k]);
+				rem -= inIdx[k] * inStrides[k];
+			}
+			let flatOut = 0;
+			for (let k = 0; k < rank; k++) {
+				const outK = k === ax ? inIdx[k] + joinOffset : inIdx[k];
+				flatOut += outK * outStrides[k];
+			}
+			outData[flatOut] = t.data[flatIn];
+		}
+		joinOffset += inShape[ax];
+	}
+	let outLabels;
+	if (first.axisLabels !== void 0) outLabels = first.axisLabels.map((lbl, k) => {
+		if (k === ax) return new Index(joinDim, {
+			name: lbl.name,
+			tags: [...lbl.tags]
+		});
+		return lbl;
+	});
+	return new Tensor(outShape, outData, outLabels);
 }
-
-// src/operations/scatter.ts
+//#endregion
+//#region src/operations/scatter.ts
 function scatter(t, axis, indices, updates, opts) {
-  const rank = t.shape.length;
-  const reduce = opts?.reduce ?? "overwrite";
-  const ax = axis < 0 ? rank + axis : axis;
-  if (ax < 0 || ax >= rank) {
-    throw new Error(`scatter: axis ${axis} is out of range for rank ${rank}`);
-  }
-  const dimAx = t.shape[ax];
-  for (let i = 0; i < indices.length; i++) {
-    if (!Number.isInteger(indices[i]) || indices[i] < 0 || indices[i] >= dimAx) {
-      throw new RangeError(
-        `scatter: index ${indices[i]} at position ${i} is out of range [0, ${dimAx}) for axis ${ax}`
-      );
-    }
-  }
-  if (updates.shape.length !== rank) {
-    throw new Error(
-      `scatter: updates rank ${updates.shape.length} does not match tensor rank ${rank}`
-    );
-  }
-  for (let k = 0; k < rank; k++) {
-    if (k === ax) {
-      if (updates.shape[k] !== indices.length) {
-        throw new Error(
-          `scatter: updates.shape[${k}] = ${updates.shape[k]} but indices.length = ${indices.length}`
-        );
-      }
-    } else {
-      if (updates.shape[k] !== t.shape[k]) {
-        throw new Error(
-          `scatter: updates.shape[${k}] = ${updates.shape[k]} does not match t.shape[${k}] = ${t.shape[k]}`
-        );
-      }
-    }
-  }
-  const outData = new Float64Array(t.data);
-  if (indices.length > 0) {
-    const inStrides = Tensor.rowMajorStrides(t.shape);
-    const updStrides = Tensor.rowMajorStrides(updates.shape);
-    const updSize = updates.shape.reduce((a, b) => a * b, 1);
-    const updIdx = new Array(rank).fill(0);
-    for (let flatUpd = 0; flatUpd < updSize; flatUpd++) {
-      let rem = flatUpd;
-      for (let k = 0; k < rank; k++) {
-        updIdx[k] = Math.floor(rem / updStrides[k]);
-        rem -= updIdx[k] * updStrides[k];
-      }
-      const targetAxIdx = indices[updIdx[ax]];
-      let flatOut = 0;
-      for (let k = 0; k < rank; k++) {
-        const idxK = k === ax ? targetAxIdx : updIdx[k];
-        flatOut += idxK * inStrides[k];
-      }
-      if (reduce === "add") {
-        outData[flatOut] += updates.data[flatUpd];
-      } else {
-        outData[flatOut] = updates.data[flatUpd];
-      }
-    }
-  }
-  let outLabels;
-  if (t.axisLabels !== void 0) {
-    outLabels = [...t.axisLabels];
-  }
-  return new Tensor([...t.shape], outData, outLabels);
+	const rank = t.shape.length;
+	const reduce = opts?.reduce ?? "overwrite";
+	const ax = axis < 0 ? rank + axis : axis;
+	if (ax < 0 || ax >= rank) throw new Error(`scatter: axis ${axis} is out of range for rank ${rank}`);
+	const dimAx = t.shape[ax];
+	for (let i = 0; i < indices.length; i++) if (!Number.isInteger(indices[i]) || indices[i] < 0 || indices[i] >= dimAx) throw new RangeError(`scatter: index ${indices[i]} at position ${i} is out of range [0, ${dimAx}) for axis ${ax}`);
+	if (updates.shape.length !== rank) throw new Error(`scatter: updates rank ${updates.shape.length} does not match tensor rank ${rank}`);
+	for (let k = 0; k < rank; k++) if (k === ax) {
+		if (updates.shape[k] !== indices.length) throw new Error(`scatter: updates.shape[${k}] = ${updates.shape[k]} but indices.length = ${indices.length}`);
+	} else if (updates.shape[k] !== t.shape[k]) throw new Error(`scatter: updates.shape[${k}] = ${updates.shape[k]} does not match t.shape[${k}] = ${t.shape[k]}`);
+	const outData = new Float64Array(t.data);
+	if (indices.length > 0) {
+		const inStrides = Tensor.rowMajorStrides(t.shape);
+		const updStrides = Tensor.rowMajorStrides(updates.shape);
+		const updSize = updates.shape.reduce((a, b) => a * b, 1);
+		const updIdx = new Array(rank).fill(0);
+		for (let flatUpd = 0; flatUpd < updSize; flatUpd++) {
+			let rem = flatUpd;
+			for (let k = 0; k < rank; k++) {
+				updIdx[k] = Math.floor(rem / updStrides[k]);
+				rem -= updIdx[k] * updStrides[k];
+			}
+			const targetAxIdx = indices[updIdx[ax]];
+			let flatOut = 0;
+			for (let k = 0; k < rank; k++) {
+				const idxK = k === ax ? targetAxIdx : updIdx[k];
+				flatOut += idxK * inStrides[k];
+			}
+			if (reduce === "add") outData[flatOut] += updates.data[flatUpd];
+			else outData[flatOut] = updates.data[flatUpd];
+		}
+	}
+	let outLabels;
+	if (t.axisLabels !== void 0) outLabels = [...t.axisLabels];
+	return new Tensor([...t.shape], outData, outLabels);
 }
-
-// src/operations/pad.ts
+//#endregion
+//#region src/operations/pad.ts
 function pad(t, padWidths, opts) {
-  const rank = t.shape.length;
-  const mode = opts?.mode ?? "constant";
-  const fillValue = opts?.constantValue ?? 0;
-  if (padWidths.length !== rank) {
-    throw new Error(`pad: padWidths length ${padWidths.length} does not match tensor rank ${rank}`);
-  }
-  for (let k = 0; k < rank; k++) {
-    const [before, after] = padWidths[k];
-    if (!Number.isInteger(before) || before < 0) {
-      throw new Error(`pad: padWidths[${k}][0] must be a non-negative integer, got ${before}`);
-    }
-    if (!Number.isInteger(after) || after < 0) {
-      throw new Error(`pad: padWidths[${k}][1] must be a non-negative integer, got ${after}`);
-    }
-    if (mode === "reflect") {
-      const dim = t.shape[k];
-      if (before >= dim || after >= dim) {
-        throw new Error(
-          `pad: reflect mode requires pad amounts < axis size; axis ${k} has size ${dim} but pad is [${before}, ${after}]`
-        );
-      }
-    }
-  }
-  const outShape = t.shape.map((d, k) => d + padWidths[k][0] + padWidths[k][1]);
-  const outSize = outShape.reduce((a, b) => a * b, 1);
-  const outData = new Float64Array(outSize);
-  if (mode === "constant") {
-    if (fillValue !== 0) outData.fill(fillValue);
-  }
-  const inStrides = Tensor.rowMajorStrides(t.shape);
-  const outStrides = Tensor.rowMajorStrides(outShape);
-  const outIdx = new Array(rank).fill(0);
-  for (let flatOut = 0; flatOut < outSize; flatOut++) {
-    let rem = flatOut;
-    for (let k = 0; k < rank; k++) {
-      outIdx[k] = Math.floor(rem / outStrides[k]);
-      rem -= outIdx[k] * outStrides[k];
-    }
-    let inBounds = true;
-    let flatIn = 0;
-    for (let k = 0; k < rank; k++) {
-      const before = padWidths[k][0];
-      const dim = t.shape[k];
-      const oIdx = outIdx[k];
-      let iIdx;
-      if (oIdx < before) {
-        if (mode === "constant") {
-          inBounds = false;
-          break;
-        } else if (mode === "edge") {
-          iIdx = 0;
-        } else {
-          iIdx = before - oIdx;
-        }
-      } else if (oIdx >= before + dim) {
-        if (mode === "constant") {
-          inBounds = false;
-          break;
-        } else if (mode === "edge") {
-          iIdx = dim - 1;
-        } else {
-          const dist = oIdx - (before + dim - 1);
-          iIdx = dim - 1 - dist;
-        }
-      } else {
-        iIdx = oIdx - before;
-      }
-      flatIn += iIdx * inStrides[k];
-    }
-    if (inBounds) {
-      outData[flatOut] = t.data[flatIn];
-    }
-  }
-  let outLabels;
-  if (t.axisLabels !== void 0) {
-    outLabels = [...t.axisLabels];
-  }
-  return new Tensor(outShape, outData, outLabels);
+	const rank = t.shape.length;
+	const mode = opts?.mode ?? "constant";
+	const fillValue = opts?.constantValue ?? 0;
+	if (padWidths.length !== rank) throw new Error(`pad: padWidths length ${padWidths.length} does not match tensor rank ${rank}`);
+	for (let k = 0; k < rank; k++) {
+		const [before, after] = padWidths[k];
+		if (!Number.isInteger(before) || before < 0) throw new Error(`pad: padWidths[${k}][0] must be a non-negative integer, got ${before}`);
+		if (!Number.isInteger(after) || after < 0) throw new Error(`pad: padWidths[${k}][1] must be a non-negative integer, got ${after}`);
+		if (mode === "reflect") {
+			const dim = t.shape[k];
+			if (before >= dim || after >= dim) throw new Error(`pad: reflect mode requires pad amounts < axis size; axis ${k} has size ${dim} but pad is [${before}, ${after}]`);
+		}
+	}
+	const outShape = t.shape.map((d, k) => d + padWidths[k][0] + padWidths[k][1]);
+	const outSize = outShape.reduce((a, b) => a * b, 1);
+	const outData = new Float64Array(outSize);
+	if (mode === "constant") {
+		if (fillValue !== 0) outData.fill(fillValue);
+	}
+	const inStrides = Tensor.rowMajorStrides(t.shape);
+	const outStrides = Tensor.rowMajorStrides(outShape);
+	const outIdx = new Array(rank).fill(0);
+	for (let flatOut = 0; flatOut < outSize; flatOut++) {
+		let rem = flatOut;
+		for (let k = 0; k < rank; k++) {
+			outIdx[k] = Math.floor(rem / outStrides[k]);
+			rem -= outIdx[k] * outStrides[k];
+		}
+		let inBounds = true;
+		let flatIn = 0;
+		for (let k = 0; k < rank; k++) {
+			const before = padWidths[k][0];
+			const dim = t.shape[k];
+			const oIdx = outIdx[k];
+			let iIdx;
+			if (oIdx < before) {
+				if (mode === "constant") {
+					inBounds = false;
+					break;
+				} else if (mode === "edge") iIdx = 0;
+				else iIdx = before - oIdx;
+			} else if (oIdx >= before + dim) {
+				if (mode === "constant") {
+					inBounds = false;
+					break;
+				} else if (mode === "edge") iIdx = dim - 1;
+				else {
+					const dist = oIdx - (before + dim - 1);
+					iIdx = dim - 1 - dist;
+				}
+			} else iIdx = oIdx - before;
+			flatIn += iIdx * inStrides[k];
+		}
+		if (inBounds) outData[flatOut] = t.data[flatIn];
+	}
+	let outLabels;
+	if (t.axisLabels !== void 0) outLabels = [...t.axisLabels];
+	return new Tensor(outShape, outData, outLabels);
 }
-
-// src/operations/roll.ts
+//#endregion
+//#region src/operations/roll.ts
 function roll(t, shifts, axes) {
-  const rank = t.shape.length;
-  const totalSize = t.shape.reduce((a, b) => a * b, 1);
-  if (axes === void 0) {
-    if (Array.isArray(shifts)) {
-      throw new Error("roll: when axes is omitted, shifts must be a single number");
-    }
-    const shift = shifts;
-    const outData2 = new Float64Array(totalSize);
-    const n = totalSize;
-    for (let i = 0; i < n; i++) {
-      const srcIdx = ((i - shift) % n + n) % n;
-      outData2[i] = t.data[srcIdx];
-    }
-    let outLabels2;
-    if (t.axisLabels !== void 0) outLabels2 = [...t.axisLabels];
-    return new Tensor([...t.shape], outData2, outLabels2);
-  }
-  const shiftArr = Array.isArray(shifts) ? [...shifts] : [shifts];
-  if (shiftArr.length !== axes.length) {
-    throw new Error(
-      `roll: shifts length ${shiftArr.length} does not match axes length ${axes.length}`
-    );
-  }
-  const normAxes = axes.map((ax) => {
-    const a = ax < 0 ? rank + ax : ax;
-    if (a < 0 || a >= rank) {
-      throw new Error(`roll: axis ${ax} is out of range for rank ${rank}`);
-    }
-    return a;
-  });
-  const axisShift = new Array(rank).fill(0);
-  for (let i = 0; i < normAxes.length; i++) {
-    axisShift[normAxes[i]] = shiftArr[i];
-  }
-  const outData = new Float64Array(totalSize);
-  const inStrides = Tensor.rowMajorStrides(t.shape);
-  const outStrides = Tensor.rowMajorStrides(t.shape);
-  const outIdx = new Array(rank).fill(0);
-  for (let flatOut = 0; flatOut < totalSize; flatOut++) {
-    let rem = flatOut;
-    for (let k = 0; k < rank; k++) {
-      outIdx[k] = Math.floor(rem / outStrides[k]);
-      rem -= outIdx[k] * outStrides[k];
-    }
-    let flatIn = 0;
-    for (let k = 0; k < rank; k++) {
-      const dim = t.shape[k];
-      const srcK = ((outIdx[k] - axisShift[k]) % dim + dim) % dim;
-      flatIn += srcK * inStrides[k];
-    }
-    outData[flatOut] = t.data[flatIn];
-  }
-  let outLabels;
-  if (t.axisLabels !== void 0) outLabels = [...t.axisLabels];
-  return new Tensor([...t.shape], outData, outLabels);
+	const rank = t.shape.length;
+	const totalSize = t.shape.reduce((a, b) => a * b, 1);
+	if (axes === void 0) {
+		if (Array.isArray(shifts)) throw new Error("roll: when axes is omitted, shifts must be a single number");
+		const shift = shifts;
+		const outData = new Float64Array(totalSize);
+		const n = totalSize;
+		for (let i = 0; i < n; i++) {
+			const srcIdx = ((i - shift) % n + n) % n;
+			outData[i] = t.data[srcIdx];
+		}
+		let outLabels;
+		if (t.axisLabels !== void 0) outLabels = [...t.axisLabels];
+		return new Tensor([...t.shape], outData, outLabels);
+	}
+	const shiftArr = Array.isArray(shifts) ? [...shifts] : [shifts];
+	if (shiftArr.length !== axes.length) throw new Error(`roll: shifts length ${shiftArr.length} does not match axes length ${axes.length}`);
+	const normAxes = axes.map((ax) => {
+		const a = ax < 0 ? rank + ax : ax;
+		if (a < 0 || a >= rank) throw new Error(`roll: axis ${ax} is out of range for rank ${rank}`);
+		return a;
+	});
+	const axisShift = new Array(rank).fill(0);
+	for (let i = 0; i < normAxes.length; i++) axisShift[normAxes[i]] = shiftArr[i];
+	const outData = new Float64Array(totalSize);
+	const inStrides = Tensor.rowMajorStrides(t.shape);
+	const outStrides = Tensor.rowMajorStrides(t.shape);
+	const outIdx = new Array(rank).fill(0);
+	for (let flatOut = 0; flatOut < totalSize; flatOut++) {
+		let rem = flatOut;
+		for (let k = 0; k < rank; k++) {
+			outIdx[k] = Math.floor(rem / outStrides[k]);
+			rem -= outIdx[k] * outStrides[k];
+		}
+		let flatIn = 0;
+		for (let k = 0; k < rank; k++) {
+			const dim = t.shape[k];
+			const srcK = ((outIdx[k] - axisShift[k]) % dim + dim) % dim;
+			flatIn += srcK * inStrides[k];
+		}
+		outData[flatOut] = t.data[flatIn];
+	}
+	let outLabels;
+	if (t.axisLabels !== void 0) outLabels = [...t.axisLabels];
+	return new Tensor([...t.shape], outData, outLabels);
 }
-
-// src/operations/flip.ts
+//#endregion
+//#region src/operations/flip.ts
 function flip(t, axes) {
-  const rank = t.shape.length;
-  const totalSize = t.shape.reduce((a, b) => a * b, 1);
-  const normAxesSet = /* @__PURE__ */ new Set();
-  for (const ax of axes) {
-    const a = ax < 0 ? rank + ax : ax;
-    if (a < 0 || a >= rank) {
-      throw new Error(`flip: axis ${ax} is out of range for rank ${rank}`);
-    }
-    normAxesSet.add(a);
-  }
-  const flipSet = normAxesSet;
-  const outData = new Float64Array(totalSize);
-  const inStrides = Tensor.rowMajorStrides(t.shape);
-  const outStrides = Tensor.rowMajorStrides(t.shape);
-  const outIdx = new Array(rank).fill(0);
-  for (let flatOut = 0; flatOut < totalSize; flatOut++) {
-    let rem = flatOut;
-    for (let k = 0; k < rank; k++) {
-      outIdx[k] = Math.floor(rem / outStrides[k]);
-      rem -= outIdx[k] * outStrides[k];
-    }
-    let flatIn = 0;
-    for (let k = 0; k < rank; k++) {
-      const iIdx = flipSet.has(k) ? t.shape[k] - 1 - outIdx[k] : outIdx[k];
-      flatIn += iIdx * inStrides[k];
-    }
-    outData[flatOut] = t.data[flatIn];
-  }
-  let outLabels;
-  if (t.axisLabels !== void 0) outLabels = [...t.axisLabels];
-  return new Tensor([...t.shape], outData, outLabels);
+	const rank = t.shape.length;
+	const totalSize = t.shape.reduce((a, b) => a * b, 1);
+	const normAxesSet = /* @__PURE__ */ new Set();
+	for (const ax of axes) {
+		const a = ax < 0 ? rank + ax : ax;
+		if (a < 0 || a >= rank) throw new Error(`flip: axis ${ax} is out of range for rank ${rank}`);
+		normAxesSet.add(a);
+	}
+	const flipSet = normAxesSet;
+	const outData = new Float64Array(totalSize);
+	const inStrides = Tensor.rowMajorStrides(t.shape);
+	const outStrides = Tensor.rowMajorStrides(t.shape);
+	const outIdx = new Array(rank).fill(0);
+	for (let flatOut = 0; flatOut < totalSize; flatOut++) {
+		let rem = flatOut;
+		for (let k = 0; k < rank; k++) {
+			outIdx[k] = Math.floor(rem / outStrides[k]);
+			rem -= outIdx[k] * outStrides[k];
+		}
+		let flatIn = 0;
+		for (let k = 0; k < rank; k++) {
+			const iIdx = flipSet.has(k) ? t.shape[k] - 1 - outIdx[k] : outIdx[k];
+			flatIn += iIdx * inStrides[k];
+		}
+		outData[flatOut] = t.data[flatIn];
+	}
+	let outLabels;
+	if (t.axisLabels !== void 0) outLabels = [...t.axisLabels];
+	return new Tensor([...t.shape], outData, outLabels);
 }
-export {
-  Index,
-  Tensor,
-  concatenate,
-  contractNetwork,
-  flip,
-  gather,
-  idx,
-  pad,
-  randomTensor,
-  roll,
-  scatter,
-  slice,
-  stack,
-  tensorCholesky,
-  tensorEig,
-  tensorEigWasm,
-  tensorKron,
-  tensorLU,
-  tensorPinv,
-  tensorQr,
-  tensorSolve,
-  tensorSvd,
-  tensorSvdWasm
-};
+//#endregion
+export { Index, Tensor, concatenate, contractNetwork, flip, gather, idx, pad, randomTensor, roll, scatter, slice, stack, tensorCholesky, tensorEig, tensorEigWasm, tensorKron, tensorLU, tensorPinv, tensorQr, tensorSolve, tensorSvd, tensorSvdWasm };