@danielsimonjr/mathts-autograd 0.3.13 → 0.3.15

package/dist/reverse-grad.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reverse-mode AD via tape. Returns the value and the vector-Jacobian product
+ * (gradient = ∂(cotangent · value) / ∂x). gradient.shape = x.shape.
+ *
+ * Default cotangent: ones-like(value) — required for scalar outputs, useful
+ * for VJP defaults. For non-scalar value, cotangent's shape must match value.shape.
+ */
+import { Tensor } from '@danielsimonjr/mathts-tensor';
+/**
+ * Computes the value of `fn` at `x` and the vector-Jacobian product with reverse-mode AD.
+ *
+ * `fn` receives a TapedTensor in place of `x`. It must return a result of TapedTensor operations on that argument.
+ *
+ * @param fn - Function to differentiate.
+ * @param x - Point at which to evaluate `fn`.
+ * @param cotangent - Seed for the backward pass. Its shape must match the value shape. The default is all ones.
+ * @returns The value of `fn(x)`, and the gradient of `cotangent · value` with respect to `x`, with the shape of `x`.
+ * @throws Error if `fn` does not return a TapedTensor.
+ * @throws Error if the `cotangent` shape does not match the value shape.
+ */
+export declare function reverseGrad(fn: (x: Tensor) => Tensor, x: Tensor, cotangent?: Tensor): {
+    value: Tensor;
+    gradient: Tensor;
+};
+//# sourceMappingURL=reverse-grad.d.ts.map

package/dist/reverse-grad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-grad.d.ts","sourceRoot":"","sources":["../src/reverse-grad.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAGtD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACzB,CAAC,EAAE,MAAM,EACT,SAAS,CAAC,EAAE,MAAM,GACjB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAyCrC"}

package/dist/tape.d.ts

@@ -0,0 +1,444 @@
+/**
+ * Tape — records the sequence of ops during a forward pass so we can
+ * replay them in reverse to compute the vector-Jacobian product.
+ *
+ * Each TapedTensor wraps a primal Tensor + a tape-node id. Ops on
+ * TapedTensors record their backward closures into a shared Tape.
+ * After the forward pass, calling Tape.backward(outputGrad) walks the
+ * tape in reverse, accumulating gradients into each input slot.
+ *
+ * v0.1.0 supports the same ops as DualTensor: add, sub, mul, scale.
+ * v0.2.0 adds: contract (named-index), matmul (batched rank-N).
+ */
+import { Tensor, Index } from '@danielsimonjr/mathts-tensor';
+type BackwardFn = (outputGrad: Float64Array) => void;
+/**
+ * Records the operations of a forward pass so that `backward` can replay them in reverse.
+ *
+ * `allocate` gives inputs negative ids. `record` gives operations non-negative ids.
+ * Each id owns a gradient slot. `backward` writes `outputGrad` into the output slot: it replaces the
+ * value in that slot. `backward` adds gradients into the input and intermediate slots.
+ * `backward` does not clear the input and intermediate slots. A second call adds to the gradients of the
+ * first call in those slots.
+ */
+export declare class Tape {
+    private nodes;
+    private inputGradSlots;
+    private nextOpId;
+    private nextInputId;
+    /** Allocate a fresh id for an input or intermediate. */
+    allocate(size: number): {
+        id: number;
+        gradSlot: Float64Array;
+    };
+    record(inputIds: ReadonlyArray<number>, outputSize: number, backward: BackwardFn): {
+        id: number;
+        gradSlot: Float64Array;
+    };
+    /** Seed the final output's gradient slot, then replay in reverse. */
+    backward(outputId: number, outputGrad: Float64Array): void;
+    getInputGrad(id: number): Float64Array | undefined;
+}
+/**
+ * Wraps tensor values with a tape id, so that each operation records its backward step on the tape.
+ *
+ * The `data` getter returns the primal values, so tensor ops that read `.data` accept a TapedTensor.
+ * The `id` names the gradient slot of this tensor on the tape.
+ * The optional per-axis Index labels enable `contract`.
+ */
+export declare class TapedTensor {
+    readonly shape: ReadonlyArray<number>;
+    readonly primal: Float64Array;
+    readonly tape: Tape;
+    readonly id: number;
+    /**
+     * Optional per-axis Index labels. When set, enables `contract`.
+     * Must have the same length as `shape` when present.
+     */
+    readonly axisLabels?: ReadonlyArray<Index>;
+    constructor(shape: ReadonlyArray<number>, primal: Float64Array, tape: Tape, id: number, axisLabels?: ReadonlyArray<Index>);
+    /**
+     * S5 fix: existing engine ops (e.g. lower, pderiv, contract) reach into
+     * `.data`. The getter returns the primal so those ops still work when a
+     * TapedTensor flows through them as a structurally-compatible Tensor.
+     * (AD-aware ops branch on `'tape' in arg` before reaching here.)
+     */
+    get data(): Float64Array;
+    static fromTensorAsInput(t: Tensor, tape: Tape): TapedTensor;
+    toPrimalTensor(): Tensor;
+    /**
+     * Reconstruct the Tensor primal with the given axisLabels (used internally
+     * when the primal was computed from an op that produces labelled output).
+     */
+    private toPrimalTensorWith;
+    add(other: TapedTensor): TapedTensor;
+    sub(other: TapedTensor): TapedTensor;
+    /**
+     * Elementwise division: this / other.
+     *
+     * Adjoints (quotient rule):
+     *   dA = dY / b
+     *   dB = −dY · a / b²
+     *
+     * The alias case (a.divide(a)) is handled explicitly: the combined gradient
+     * is dA + dB = dY/a − dY·a/a² = dY/a − dY/a = 0. This is correct since
+     * a/a = 1 everywhere and d(1)/da = 0.
+     */
+    divide(other: TapedTensor): TapedTensor;
+    mul(other: TapedTensor): TapedTensor;
+    scale(k: number): TapedTensor;
+    /**
+     * Reverse-mode AD over `Tensor.contract`.
+     *
+     * Both operands must carry `axisLabels`; the resulting TapedTensor inherits
+     * the contracted-output axisLabels (non-shared axis concatenation).
+     *
+     * Adjoint derivation (T-notation):
+     *   Let Y = A.contract(B)  (contraction over shared indices S).
+     *   dA = dY.contract(B')  where B' = B with its free axes re-labelled to
+     *        match the shared positions in A. Equivalently: for each element of A,
+     *        dA[...a_free, ...s] = Σ_{...b_free} dY[...a_free, ...b_free] · B[...s, ...b_free]
+     *   dB = A'.contract(dY)  symmetrically.
+     *
+     * Implementation: because `Tensor.contract` matches by Index identity, we
+     * build the backward contraction by re-labelling the free axes of dY with
+     * the Index objects from the other operand — so `Tensor.contract` automatically
+     * finds the right shared axes.
+     */
+    contract(other: TapedTensor): TapedTensor;
+    /**
+     * Reverse-mode AD over batched matmul.
+     *
+     * Accepts operands of rank ≥ 2. Convention: trailing 2 axes are the matrix
+     * dims (rows × cols); all leading axes are batch dims (must be broadcast-
+     * compatible). For rank-2 inputs this is classical matrix multiplication.
+     *
+     * Adjoint derivation (classical matrix calc, extended to batched):
+     *   Y = A @ B  (A: ...×m×k, B: ...×k×n  →  Y: ...×m×n)
+     *   dA = dY @ Bᵀ       (dA: ...×m×k)
+     *   dB = Aᵀ @ dY       (dB: ...×k×n)
+     *
+     * Implemented via `Tensor.einsum` with a dynamically-built spec:
+     *   forward:  '...ik,...kj->...ij'
+     *   dA:       '...ij,...kj->...ik'   (contract dY with B on j)
+     *   dB:       '...ki,...kj->...ij'   (contract A on k with dY on k)
+     */
+    matmul(other: TapedTensor): TapedTensor;
+    private checkSameShape;
+    /**
+     * Sum elements along the given axis/axes (or all axes if omitted).
+     *
+     * Adjoint: dX[...] = dY[reduced(idx)] broadcast back to input shape.
+     * Each input element receives the output-gradient entry from its reduced
+     * counterpart (the non-reduced coordinates select the dY element; the
+     * reduced coordinates are collapsed to 0 in the keepDims=false case).
+     */
+    sum(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): TapedTensor;
+    /**
+     * Arithmetic mean along the given axis/axes (or all axes if omitted).
+     *
+     * Adjoint: dX[...] = dY[reduced(idx)] / N, broadcast back to input shape.
+     * N = product of reduced-axis dimensions.
+     */
+    mean(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): TapedTensor;
+    /**
+     * Product of elements along the given axis/axes (or all axes if omitted).
+     *
+     * Adjoint: dX_i = dY * (prod_over_axes(x) / x_i) per element.
+     *
+     * Zero-element corners:
+     * - Exactly one x_i = 0 in the reduced group: d/dx_i = product of all others
+     *   (which is the full product / x_i evaluated via alternate product),
+     *   and d/dx_j = 0 for all j ≠ i where x_j ≠ 0.
+     * - Two or more zeros in the reduced group: gradient is 0 everywhere for that
+     *   group (because changing any single zero cannot change a product that is
+     *   zero due to another zero).
+     *
+     * Implementation: uses prefix/suffix products to handle zeros robustly.
+     */
+    prod(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): TapedTensor;
+    /**
+     * Maximum value along the given axis/axes (or all axes if omitted).
+     *
+     * Adjoint: dY is scattered to the argmax position(s).
+     * Tie-breaking: "first-wins" — the gradient flows to the first (smallest
+     * flat-index) element among those that attain the maximum.
+     */
+    max(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): TapedTensor;
+    /**
+     * Minimum value along the given axis/axes (or all axes if omitted).
+     *
+     * Adjoint: dY is scattered to the argmin position(s).
+     * Tie-breaking: "first-wins" — gradient flows to the first (smallest
+     * flat-index) element that attains the minimum.
+     */
+    min(axis?: number | ReadonlyArray<number>, opts?: {
+        keepDims?: boolean;
+    }): TapedTensor;
+    /**
+     * p-norm of the tensor.
+     *
+     * Supported p values: 1, 2, 'fro', 'inf'. Default p = 2.
+     * When `opts.axis` is given, reduces along that axis; otherwise reduces all axes.
+     *
+     * Adjoints:
+     * - p=2 / p='fro': dX = dY · x / ‖x‖₂  (Frobenius is the 2-norm of the flattened tensor)
+     * - p=1:           dX = dY · sign(x)  (subgradient = 0 at exact zero)
+     * - p='inf':       dX scattered to the element(s) of max absolute value;
+     *                  tie-breaking: first-wins. Sign of the scattered gradient
+     *                  matches sign(x_max).
+     */
+    norm(opts?: {
+        p?: 1 | 2 | 'fro' | 'inf';
+        axis?: number;
+        keepDims?: boolean;
+    }): TapedTensor;
+    /**
+     * Elementwise natural logarithm.
+     *
+     * Adjoint: dX = dY / x
+     */
+    log(): TapedTensor;
+    /**
+     * Elementwise exponential.
+     *
+     * Adjoint: dX = dY · y  where y = exp(x). Primal output is cached.
+     */
+    exp(): TapedTensor;
+    /**
+     * Elementwise sine.
+     *
+     * Adjoint: dX = dY · cos(x)
+     */
+    sin(): TapedTensor;
+    /**
+     * Elementwise cosine.
+     *
+     * Adjoint: dX = −dY · sin(x)
+     */
+    cos(): TapedTensor;
+    /**
+     * Elementwise tangent.
+     *
+     * Adjoint: dX = dY / cos²(x)  (= dY · sec²(x))
+     */
+    tan(): TapedTensor;
+    /**
+     * Elementwise square root.
+     *
+     * Adjoint: dX = dY / (2·y)  where y = sqrt(x). Primal output is cached.
+     */
+    sqrt(): TapedTensor;
+    /**
+     * Elementwise square (x²).
+     *
+     * Adjoint: dX = dY · 2x
+     */
+    square(): TapedTensor;
+    /**
+     * Elementwise power: x^k.
+     *
+     * `k` may be a fixed `number` (constant exponent) or a `TapedTensor`
+     * (variable exponent, both inputs on the tape).
+     *
+     * Adjoints, for y = a^b:
+     *   - fixed exponent k:   dA = dY · k · a^(k−1)
+     *   - variable exponent:  dA = dY · b · a^(b−1),   dB = dY · a^b · ln(a)
+     *   - aliased a^a:         dA = dY · a^a · (ln a + 1)
+     *
+     * The dB term needs ln(a); for a ≤ 0 it is mathematically undefined and
+     * yields NaN/−Inf, honestly signalling non-differentiability w.r.t. the
+     * exponent rather than masking it.
+     */
+    pow(k: number | TapedTensor): TapedTensor;
+    /**
+     * Elementwise reciprocal: 1 / x.
+     *
+     * Adjoint: dX = −dY / x²
+     */
+    reciprocal(): TapedTensor;
+    /**
+     * Elementwise absolute value: |x|.
+     *
+     * Adjoint: dX = dY · sign(x)
+     * Subgradient at exact zero is defined as 0 (rather than undefined).
+     */
+    abs(): TapedTensor;
+    /**
+     * Build a reverse-mode node for an elementwise unary op.
+     * @param primalFn forward value y = f(x)
+     * @param localGrad local derivative dy/dx, given x and the computed y
+     */
+    private _unaryElementwise;
+    /** Hyperbolic sine. Adjoint: dX = dY · cosh(x). */
+    sinh(): TapedTensor;
+    /** Hyperbolic cosine. Adjoint: dX = dY · sinh(x). */
+    cosh(): TapedTensor;
+    /** Hyperbolic tangent. Adjoint: dX = dY · (1 − tanh²(x)) = dY · (1 − y²). */
+    tanh(): TapedTensor;
+    /** Arcsine. Adjoint: dX = dY / √(1 − x²). */
+    asin(): TapedTensor;
+    /** Arccosine. Adjoint: dX = −dY / √(1 − x²). */
+    acos(): TapedTensor;
+    /** Arctangent. Adjoint: dX = dY / (1 + x²). */
+    atan(): TapedTensor;
+    /** Inverse hyperbolic sine. Adjoint: dX = dY / √(x² + 1). */
+    asinh(): TapedTensor;
+    /** Inverse hyperbolic cosine (x ≥ 1). Adjoint: dX = dY / √(x² − 1). */
+    acosh(): TapedTensor;
+    /** Inverse hyperbolic tangent (|x| < 1). Adjoint: dX = dY / (1 − x²). */
+    atanh(): TapedTensor;
+    /** Base-2 logarithm. Adjoint: dX = dY / (x · ln2). */
+    log2(): TapedTensor;
+    /** Base-10 logarithm. Adjoint: dX = dY / (x · ln10). */
+    log10(): TapedTensor;
+    /** log(1 + x) (accurate near 0). Adjoint: dX = dY / (1 + x). */
+    log1p(): TapedTensor;
+    /** exp(x) − 1 (accurate near 0). Adjoint: dX = dY · eˣ = dY · (y + 1). */
+    expm1(): TapedTensor;
+    /** Cube root. Adjoint: dX = dY / (3 · y²) where y = x^(1/3) (→∞ at x = 0). */
+    cbrt(): TapedTensor;
+    /** Sign of x (−1/0/+1). Adjoint: 0 almost everywhere. */
+    sign(): TapedTensor;
+    /**
+     * Two-argument arctangent: atan2(this, other), with this = y, other = x.
+     *
+     * Adjoints (a = this, b = other, d = a² + b²):
+     *   dA = dY · b / d
+     *   dB = −dY · a / d
+     *
+     * The aliased case atan2(a, a) is locally constant (±π/4 or ±3π/4), so its
+     * gradient is 0 — produced naturally by contributing nothing when aliased
+     * (dA + dB = dY · (b − a)/d = 0 at a = b).
+     */
+    atan2(other: TapedTensor): TapedTensor;
+    /**
+     * Reverse-mode AD over `Tensor.tensordot`.
+     *
+     * `axes[i] = [a, b]` contracts axis `a` of `this` with axis `b` of `other`.
+     * The result shape is `this`'s non-contracted axes (in original order)
+     * followed by `other`'s non-contracted axes (in original order).
+     *
+     * Adjoint derivation (NumPy/PyTorch tensordot backward, see Townsend 2016 §6,
+     * and the canonical PyTorch implementation `TensorDotBackward0` in
+     * `torch/csrc/autograd/generated/Functions.cpp`):
+     *
+     *   Z = tensordot(A, B, axes)
+     *   dA = tensordot(dZ, B, [axes_of_dZ_corresponding_to_B's_free, B's_free])
+     *        then permute back into A's original axis order.
+     *   dB = tensordot(A, dZ, [A's_free, axes_of_dZ_corresponding_to_A's_free])
+     *        then permute back into B's original axis order.
+     *
+     * The axis-permutation bookkeeping is the trickiest part: Tensor.tensordot
+     * produces output axes in the order [A's free axes (original A order),
+     * B's free axes (original B order)] — and after the backward contractions
+     * the survivors come out in B's original (resp. A's original) axis order
+     * for the contracted side, which then needs to be permuted into pair order
+     * (so axis k of the contracted block matches the kth pair) and finally
+     * scattered back into A's (resp. B's) full original axis order.
+     *
+     * For the rank-2 × rank-2 single-axis case (i.e. ordinary matmul A·B with
+     * axes = [[1, 0]]), this reduces to dA = dZ · Bᵀ, dB = Aᵀ · dZ — the same
+     * adjoint as `TapedTensor.matmul`.
+     */
+    tensordot(other: TapedTensor, axes: ReadonlyArray<readonly [number, number]>): TapedTensor;
+    /**
+     * Reverse-mode AD over the full SVD of a rank-2 matrix.
+     *
+     * Forward: `A = U · diag(S) · Vt`, where for input shape [m, n], k = min(m, n):
+     *   - U  has shape [m, k]
+     *   - S  has shape [k]
+     *   - Vt has shape [k, n]    (Vt is V^T in the standard A = U Σ V^T convention,
+     *                              i.e. its rows are right-singular-vector components)
+     *
+     * Returned TapedTensors share a single backward closure. When backward()
+     * runs, it pulls dU, dS, dV from each output's gradient slot, assembles
+     * dA, and writes to the input's gradient slot.
+     *
+     * Adjoint (real, distinct nonzero singular values, m = n square case;
+     * extended to rectangular below). Derived directly from the forward
+     * Jacobian; equivalent to PyTorch's `svd_backward`
+     * (`aten/src/ATen/native/BatchLinearAlgebra.cpp`) and Townsend (2016)
+     * "Differentiating the Singular Value Decomposition" §3:
+     *
+     *   Let α = skew(U^T · dU),  β = skew(V^T · dV)        (k×k, antisymmetric)
+     *   Build C (k×k):
+     *     C[i,i] = dS[i]
+     *     C[i,j] = (α[i,j] + β[i,j]) / (s_j − s_i)
+     *            + (α[i,j] − β[i,j]) / (s_j + s_i)         for i ≠ j
+     *   dA_in = U · C · V^T                                 (m×n in-subspace part)
+     *
+     * Rectangular correction (when m > k, i.e. m > n):
+     *   dA += (I − U U^T) · dU · diag(1/s) · V^T
+     * Rectangular correction (when n > k, i.e. n > m):
+     *   dA += U · diag(1/s) · dV^T · (I − V V^T)
+     *
+     * Regularisation at repeated/near-zero singular values (PyTorch-equivalent
+     * subgradient choice): the (i,j) entry of C is masked to 0 whenever
+     * `|s_j − s_i| < REL_TOL · max(|s|)` (the "difference" denominator) or
+     * `|s_j + s_i| < REL_TOL · max(|s|)` (the "sum" denominator, only relevant
+     * when both are ~0). REL_TOL = 1e-10. This makes the gradient a subgradient
+     * at exact degeneracy — finite, but not the unique true derivative (which
+     * does not exist at degeneracies). The rectangular correction also masks
+     * 1/s_i when |s_i| < REL_TOL · max(|s|).
+     *
+     * Throws if input is not rank-2. For rank > 2 inputs the user should
+     * reshape first.
+     */
+    svd(): {
+        U: TapedTensor;
+        S: TapedTensor;
+        V: TapedTensor;
+    };
+    /**
+     * Reverse-mode AD over the eigendecomposition of a rank-2 matrix.
+     *
+     * Symmetric path (`symmetric: true`):
+     *   Forward: `A = U · diag(Λ) · U^T` for symmetric A (n×n).
+     *   Adjoint (Magnus & Neudecker 1999 §10.6.6; PyTorch `linalg_eigh_backward`):
+     *     F[i,j] = 1 / (λ_j − λ_i)   for i ≠ j, 0 otherwise (with degeneracy mask)
+     *     dA_raw = U · (diag(dΛ) + F ∘ (U^T · dU)) · U^T
+     *     dA     = (dA_raw + dA_raw^T) / 2          (symmetrise)
+     *
+     * Non-symmetric path (`symmetric: false`):
+     *   Forward: `A = V · diag(λ) · V^{-1}` (V columns are right eigenvectors).
+     *   Adjoint (Magnus & Neudecker 1999 §10.6 / Giles 2008 §3.2 / Townsend 2016 §4;
+     *   cross-check: PyTorch `linalg_eig_backward`):
+     *     E[i,j] = 1 / (λ_j − λ_i)  for i ≠ j, 0 otherwise (with degeneracy mask)
+     *     dA = V^{-T} · ( E ∘ (V^T · dV) + diag(dλ) ) · V^T
+     *
+     *   Restrictions (all enforced — throw a clear error otherwise):
+     *   1. Eigenvalues must be real. The underlying matrix-eig primitive returns
+     *      placeholder eigenvectors (not actual complex vectors) when complex
+     *      eigenvalues arise, so the adjoint formula cannot be evaluated. Real-
+     *      Schur differentiation would require complex arithmetic infrastructure
+     *      throughout the Tape/TapedTensor stack, which is out of scope.
+     *   2. A must be diagonalisable (non-defective). The adjoint assumes V is
+     *      invertible; defective inputs have algebraic > geometric multiplicity
+     *      so V is rank-deficient. Detected by cond_∞(V) > 1e14.
+     *
+     * Regularisation at repeated eigenvalues (subgradient choice): mask
+     * F/E[i,j] = 0 when `|λ_i − λ_j| < REL_TOL · max(|λ|)`. REL_TOL = 1e-10.
+     *
+     * Throws if input is not rank-2 or square, if `symmetric` is missing, or
+     * (non-symmetric path) on complex eigenvalues / defective input.
+     */
+    eig(opts: {
+        symmetric: boolean;
+    }): {
+        eigvals: TapedTensor;
+        eigvecs: TapedTensor;
+    };
+    private _eigSymmetric;
+    private _eigGeneral;
+}
+export {};
+//# sourceMappingURL=tape.d.ts.map

package/dist/tape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tape.d.ts","sourceRoot":"","sources":["../src/tape.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-autograd",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "description": "Forward + reverse-mode automatic differentiation for MathTS rank-N Tensor",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -19,26 +19,26 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts --format esm --clean && tsc -p tsconfig.dts.json",
     "dev": "tsup src/index.ts --format esm --dts --watch",
-    "test": "vitest run",
+    "test": "bun test --isolate --timeout 30000",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "bun test --isolate --timeout 30000 --coverage",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint src --fix",
     "clean": "rm -rf dist",
     "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
   },
   "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.14.0",
-    "@danielsimonjr/mathts-tensor": "^0.2.19"
+    "@danielsimonjr/mathts-core": "^0.15.4",
+    "@danielsimonjr/mathts-tensor": "^0.2.21"
   },
   "devDependencies": {
-    "@types/node": "^25.5.2",
+    "@types/node": "^26.4.0",
     "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.5"
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
   },
   "publishConfig": {
     "access": "public"