numbl 0.4.21 → 0.4.22

package/dist-browser/numbl-core/native/lapack-bridge.d.ts

@@ -1,27 +1,22 @@
 /**
- * LAPACK bridge — a module-level singleton that holds a reference to the
- * native addon when running under Node.js.
+ * LAPACK bridge: one interface for the dense linear algebra and tensor-op
+ * kernels, satisfied both by the native addon and by the pure-TypeScript
+ * implementation (ts-lapack-bridge.ts).
  *
- * In the browser the bridge is never set (stays null) and callers fall back
- * to pure-JavaScript implementations.
- *
- * Usage (CLI startup):
- *   import { setLapackBridge } from './numbl-core/native/lapack-bridge.js';
- *   setLapackBridge(require('<path-to-addon>'));
- *
- * Usage (builtin):
- *   import { getLapackBridge } from '../native/lapack-bridge.js';
- *   const bridge = getLapackBridge();
- *   if (bridge) { ... use bridge.inv(...) ... }
+ * `getLapackBridge()` always returns a complete bridge: each entry comes from
+ * the bridge installed with `setLapackBridge` (the native addon under Node,
+ * optionally a wasm accelerator in the browser) when it provides it, and from
+ * the TypeScript implementation otherwise. Call sites therefore use
+ * `getLapackBridge().X(...)` with no availability checks. Operations the
+ * TypeScript side cannot do are listed in `TS_UNSUPPORTED` in
+ * ts-lapack-bridge.ts and throw a clear error there.
  */
 /**
  * Expected native addon version. Bump this whenever the C++ addon API changes
  * (must match ADDON_VERSION in numbl_addon.cpp).
  */
-export declare const NATIVE_ADDON_EXPECTED_VERSION = 9;
+export declare const NATIVE_ADDON_EXPECTED_VERSION = 10;
 export interface LapackBridge {
-    /** Returns the native addon's version number. */
-    addonVersion?(): number;
     /**
      * Invert an n×n real matrix stored in column-major order (MATLAB/LAPACK convention).
      * @param data  Column-major Float64Array of length n*n (not modified).
@@ -29,7 +24,7 @@ export interface LapackBridge {
      * @returns     Inverted matrix as a allocFloat64Array in column-major order.
      * @throws      Error if the matrix is singular.
      */
-    inv?(data: Float64Array, n: number): Float64Array;
+    inv(data: Float64Array, n: number): Float64Array;
     /**
      * Invert an n×n complex matrix stored in column-major order (MATLAB/LAPACK convention).
      * Complex matrices are stored with separate real and imaginary parts.
@@ -39,7 +34,7 @@ export interface LapackBridge {
      * @returns       Object with {re, im} - inverted matrix parts as Float64Arrays in column-major order.
      * @throws        Error if the matrix is singular.
      */
-    invComplex?(dataRe: Float64Array, dataIm: Float64Array, n: number): {
+    invComplex(dataRe: Float64Array, dataIm: Float64Array, n: number): {
         re: Float64Array;
         im: Float64Array;
     };
@@ -53,7 +48,7 @@ export interface LapackBridge {
      * @param wantQ  false → skip dorgqr; Q will be absent from the returned object.
      * @returns      Object with R (always present) and Q (present only when wantQ=true).
      */
-    qr?(data: Float64Array, m: number, n: number, econ: boolean, wantQ: boolean): {
+    qr(data: Float64Array, m: number, n: number, econ: boolean, wantQ: boolean): {
         Q: Float64Array;
         R: Float64Array;
     };
@@ -65,7 +60,7 @@ export interface LapackBridge {
      * @param econ   true → economy/thin QR; false → full QR.
      * @returns      Object with Q, R, and jpvt (1-based permutation vector as Int32Array).
      */
-    qrPivot?(data: Float64Array, m: number, n: number, econ: boolean): {
+    qrPivot(data: Float64Array, m: number, n: number, econ: boolean): {
         Q: Float64Array;
         R: Float64Array;
         jpvt: Int32Array;
@@ -73,7 +68,7 @@ export interface LapackBridge {
     /**
      * Column-pivoted QR decomposition of an m×n complex matrix: A*P = Q*R via zgeqp3 + zungqr.
      */
-    qrPivotComplex?(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number, econ: boolean): {
+    qrPivotComplex(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number, econ: boolean): {
         QRe: Float64Array;
         QIm: Float64Array;
         RRe: Float64Array;
@@ -91,7 +86,7 @@ export interface LapackBridge {
      * @param wantQ   false → skip zungqr; Q properties will be absent from the returned object.
      * @returns       Object with RRe, RIm (always present) and QRe, QIm (present only when wantQ=true).
      */
-    qrComplex?(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number, econ: boolean, wantQ: boolean): {
+    qrComplex(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number, econ: boolean, wantQ: boolean): {
         QRe?: Float64Array;
         QIm?: Float64Array;
         RRe: Float64Array;
@@ -107,7 +102,7 @@ export interface LapackBridge {
      * @param computeUV true → compute U and V; false → compute S only.
      * @returns         Object with S (always present as vector of singular values) and optionally U and V.
      */
-    svd?(data: Float64Array, m: number, n: number, econ: boolean, computeUV: boolean): {
+    svd(data: Float64Array, m: number, n: number, econ: boolean, computeUV: boolean): {
         U?: Float64Array;
         S: Float64Array;
         V?: Float64Array;
@@ -123,7 +118,7 @@ export interface LapackBridge {
      * @param computeUV true → compute U and V; false → compute S only.
      * @returns         Object with S (real singular values) and optionally URe, UIm, VRe, VIm.
      */
-    svdComplex?(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number, econ: boolean, computeUV: boolean): {
+    svdComplex(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number, econ: boolean, computeUV: boolean): {
         S: Float64Array;
         URe?: Float64Array;
         UIm?: Float64Array;
@@ -140,7 +135,7 @@ export interface LapackBridge {
      * @param n  Number of columns in B and C.
      * @returns  C = A*B as a allocFloat64Array of length m*n in column-major order.
      */
-    matmul?(A: Float64Array, m: number, k: number, B: Float64Array, n: number): Float64Array;
+    matmul(A: Float64Array, m: number, k: number, B: Float64Array, n: number): Float64Array;
     /**
      * Complex matrix-matrix multiplication using BLAS zgemm.
      * Computes C = A * B in column-major order.
@@ -153,7 +148,7 @@ export interface LapackBridge {
      * @param n    Number of columns in B and C.
      * @returns    Object with {re, im?} — complex result as Float64Arrays.
      */
-    matmulComplex?(ARe: Float64Array, AIm: Float64Array, m: number, k: number, BRe: Float64Array, BIm: Float64Array, n: number): {
+    matmulComplex(ARe: Float64Array, AIm: Float64Array, m: number, k: number, BRe: Float64Array, BIm: Float64Array, n: number): {
         re: Float64Array;
         im?: Float64Array;
     };
@@ -170,7 +165,7 @@ export interface LapackBridge {
      * @param nrhs  Number of right-hand sides (columns of B and X).
      * @returns     X as a allocFloat64Array of length n*nrhs in column-major order.
      */
-    linsolve?(A: Float64Array, m: number, n: number, B: Float64Array, nrhs: number): Float64Array;
+    linsolve(A: Float64Array, m: number, n: number, B: Float64Array, nrhs: number): Float64Array;
     /**
      * Solve a complex linear system A * X = B.
      * Input/output are column-major Float64Arrays for real and imaginary parts.
@@ -187,7 +182,7 @@ export interface LapackBridge {
      * @param nrhs  Number of right-hand sides (columns of B and X).
      * @returns     Object with {re, im} — X as Float64Arrays of length n*nrhs in column-major order.
      */
-    linsolveComplex?(ARe: Float64Array, AIm: Float64Array, m: number, n: number, BRe: Float64Array, BIm: Float64Array, nrhs: number): {
+    linsolveComplex(ARe: Float64Array, AIm: Float64Array, m: number, n: number, BRe: Float64Array, BIm: Float64Array, nrhs: number): {
         re: Float64Array;
         im: Float64Array;
     };
@@ -201,7 +196,7 @@ export interface LapackBridge {
      * @param balance    true → balance matrix before computing (default); false → no balancing.
      * @returns          Object with wr/wi (real/imag parts of eigenvalues) and optionally VL/VR.
      */
-    eig?(data: Float64Array, n: number, computeVL: boolean, computeVR: boolean, balance: boolean): {
+    eig(data: Float64Array, n: number, computeVL: boolean, computeVR: boolean, balance: boolean): {
         wr: Float64Array;
         wi: Float64Array;
         VL?: Float64Array;
@@ -217,7 +212,7 @@ export interface LapackBridge {
      * @param computeV  true → also compute the orthonormal eigenvectors.
      * @returns         Object with w (ascending eigenvalues) and optionally V.
      */
-    eigSym?(data: Float64Array, n: number, computeV: boolean): {
+    eigSym(data: Float64Array, n: number, computeV: boolean): {
         w: Float64Array;
         V?: Float64Array;
     };
@@ -230,7 +225,7 @@ export interface LapackBridge {
      * @param computeV  true → also compute the unitary eigenvector basis.
      * @returns         Object with w (real, ascending) and optionally VRe/VIm.
      */
-    eigHerm?(dataRe: Float64Array, dataIm: Float64Array, n: number, computeV: boolean): {
+    eigHerm(dataRe: Float64Array, dataIm: Float64Array, n: number, computeV: boolean): {
         w: Float64Array;
         VRe?: Float64Array;
         VIm?: Float64Array;
@@ -245,7 +240,7 @@ export interface LapackBridge {
      * @param computeVR  true → compute right eigenvectors.
      * @returns          Object with wRe/wIm (real/imag parts of eigenvalues) and optionally VLRe/VLIm/VRRe/VRIm.
      */
-    eigComplex?(dataRe: Float64Array, dataIm: Float64Array, n: number, computeVL: boolean, computeVR: boolean): {
+    eigComplex(dataRe: Float64Array, dataIm: Float64Array, n: number, computeVL: boolean, computeVR: boolean): {
         wRe: Float64Array;
         wIm: Float64Array;
         VLRe?: Float64Array;
@@ -262,7 +257,7 @@ export interface LapackBridge {
      *   - LU: m×n Float64Array with L (unit lower) and U (upper) packed together.
      *   - ipiv: Int32Array of length min(m,n), 1-based pivot indices from dgetrf.
      */
-    lu?(data: Float64Array, m: number, n: number): {
+    lu(data: Float64Array, m: number, n: number): {
         LU: Float64Array;
         ipiv: Int32Array;
     };
@@ -276,7 +271,7 @@ export interface LapackBridge {
      *   - LURe, LUIm: m×n Float64Arrays with L (unit lower) and U (upper) packed together.
      *   - ipiv: Int32Array of length min(m,n), 1-based pivot indices from zgetrf.
      */
-    luComplex?(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number): {
+    luComplex(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number): {
         LURe: Float64Array;
         LUIm: Float64Array;
         ipiv: Int32Array;
@@ -292,7 +287,7 @@ export interface LapackBridge {
      *   - R: n×n Float64Array with the triangular factor (opposite triangle zeroed).
      *   - info: 0 if successful, >0 if not positive definite (index of failing pivot).
      */
-    chol?(data: Float64Array, n: number, upper: boolean): {
+    chol(data: Float64Array, n: number, upper: boolean): {
         R: Float64Array;
         info: number;
     };
@@ -308,7 +303,7 @@ export interface LapackBridge {
      *   - RRe, RIm: n×n Float64Arrays with the triangular factor.
      *   - info: 0 if successful, >0 if not positive definite.
      */
-    cholComplex?(dataRe: Float64Array, dataIm: Float64Array, n: number, upper: boolean): {
+    cholComplex(dataRe: Float64Array, dataIm: Float64Array, n: number, upper: boolean): {
         RRe: Float64Array;
         RIm: Float64Array;
         info: number;
@@ -329,7 +324,7 @@ export interface LapackBridge {
      *   - V?: n×n Float64Array, right generalized eigenvectors (packed, like dgeev format).
      *   - W?: n×n Float64Array, left generalized eigenvectors (packed, like dgeev format).
      */
-    qz?(dataA: Float64Array, dataB: Float64Array, n: number, computeEigvecs: boolean): {
+    qz(dataA: Float64Array, dataB: Float64Array, n: number, computeEigvecs: boolean): {
         AA: Float64Array;
         BB: Float64Array;
         Q: Float64Array;
@@ -344,48 +339,7 @@ export interface LapackBridge {
      * Complex QZ factorization (generalized Schur decomposition) of an n×n complex matrix pair.
      * Uses LAPACK zgges (and ztgevc for eigenvectors).
      */
-    /**
-     * Forward/inverse 1D FFT on real input via FFTW.
-     * Does NOT normalize for inverse — caller handles 1/n scaling.
-     * @param re      Real input data as Float64Array of length n.
-     * @param n       Transform length.
-     * @param inverse true for inverse FFT, false for forward.
-     * @returns       { re, im } Float64Arrays of length n.
-     */
-    fft1d?(re: Float64Array, n: number, inverse: boolean): {
-        re: Float64Array;
-        im: Float64Array;
-    };
-    /**
-     * Forward/inverse 1D FFT on complex input via FFTW.
-     * Does NOT normalize for inverse — caller handles 1/n scaling.
-     * @param re      Real part of input as Float64Array of length n.
-     * @param im      Imaginary part of input as Float64Array of length n.
-     * @param n       Transform length.
-     * @param inverse true for inverse FFT, false for forward.
-     * @returns       { re, im } Float64Arrays of length n.
-     */
-    fft1dComplex?(re: Float64Array, im: Float64Array, n: number, inverse: boolean): {
-        re: Float64Array;
-        im: Float64Array;
-    };
-    /**
-     * Batch FFT along a single dimension of a column-major tensor via FFTW.
-     * Transforms ALL fibers in one FFTW call using the guru split interface.
-     * Does NOT normalize for inverse — caller handles 1/n scaling.
-     * @param re      Real part of input tensor (column-major flat array).
-     * @param im      Imaginary part, or null for real input.
-     * @param shape   Tensor dimensions as a JS array of numbers.
-     * @param dim     0-based dimension to transform along.
-     * @param n       FFT length (may differ from shape[dim] for pad/truncate).
-     * @param inverse true for inverse FFT, false for forward.
-     * @returns       { re, im } Float64Arrays for the output tensor.
-     */
-    fftAlongDim?(re: Float64Array, im: Float64Array | null, shape: number[], dim: number, n: number, inverse: boolean): {
-        re: Float64Array;
-        im: Float64Array;
-    };
-    qzComplex?(dataARe: Float64Array, dataAIm: Float64Array, dataBRe: Float64Array, dataBIm: Float64Array, n: number, computeEigvecs: boolean): {
+    qzComplex(dataARe: Float64Array, dataAIm: Float64Array, dataBRe: Float64Array, dataBIm: Float64Array, n: number, computeEigvecs: boolean): {
         AARe: Float64Array;
         AAIm: Float64Array;
         BBRe: Float64Array;
@@ -403,26 +357,6 @@ export interface LapackBridge {
         WRe?: Float64Array;
         WIm?: Float64Array;
     };
-    /**
-     * Bulk fill normal random values using Marsaglia polar + xoshiro128**.
-     * State is mutated in-place. Spare is passed in/out to preserve pair caching.
-     */
-    fillRandn?(state: Uint32Array, n: number, spare: number, hasSpare: boolean): {
-        data: Float64Array;
-        spare: number;
-        hasSpare: boolean;
-    };
-    /**
-     * Unary element-wise math on a real Float64Array.
-     * op: 0=exp, 1=log, 2=log2, 3=log10, 4=sqrt, 5=abs, 6=floor, 7=ceil,
-     *     8=round, 9=trunc, 10=sin, 11=cos, 12=tan, 13=asin, 14=acos, 15=atan,
-     *     16=sinh, 17=cosh, 18=tanh, 19=sign
-     */
-    unaryElemwise?(arr: Float64Array, op: number): Float64Array;
-    /** Element-wise binary op on real Float64Arrays. op: 0=add, 1=sub, 2=mul, 3=div */
-    elemwise?(a: Float64Array, b: Float64Array, op: number): Float64Array;
-    /** Scalar-tensor element-wise op. scalarOnLeft: true → scalar op arr[i], false → arr[i] op scalar */
-    elemwiseScalar?(scalar: number, arr: Float64Array, op: number, scalarOnLeft: boolean): Float64Array;
     /**
      * Restarted GMRES solver for A*x = b (real, dense matrices only).
      * Uses BLAS dgemv for matvec and LAPACK dgetrf+dgetrs for preconditioner.
@@ -437,7 +371,7 @@ export interface LapackBridge {
      * @param x0      Initial guess (length n), or null for zeros.
      * @returns       Object with x, flag, relres, iter (Int32Array[2]), resvec.
      */
-    gmres?(A: Float64Array, n: number, b: Float64Array, restart: number, tol: number, maxit: number, M1: Float64Array | null, M2: Float64Array | null, x0: Float64Array | null): {
+    gmres(A: Float64Array, n: number, b: Float64Array, restart: number, tol: number, maxit: number, M1: Float64Array | null, M2: Float64Array | null, x0: Float64Array | null): {
         x: Float64Array;
         flag: number;
         relres: number;
@@ -447,7 +381,7 @@ export interface LapackBridge {
     /**
      * Complex restarted GMRES solver for A*x = b (split real/imag dense matrices).
      */
-    gmresComplex?(ARe: Float64Array, AIm: Float64Array, n: number, bRe: Float64Array, bIm: Float64Array, restart: number, tol: number, maxit: number, M1Re: Float64Array | null, M1Im: Float64Array | null, M2Re: Float64Array | null, M2Im: Float64Array | null, x0Re: Float64Array | null, x0Im: Float64Array | null): {
+    gmresComplex(ARe: Float64Array, AIm: Float64Array, n: number, bRe: Float64Array, bIm: Float64Array, restart: number, tol: number, maxit: number, M1Re: Float64Array | null, M1Im: Float64Array | null, M2Re: Float64Array | null, M2Im: Float64Array | null, x0Re: Float64Array | null, x0Im: Float64Array | null): {
         xRe: Float64Array;
         xIm: Float64Array;
         flag: number;
@@ -455,56 +389,103 @@ export interface LapackBridge {
         iter: Int32Array;
         resvec: Float64Array;
     };
-    /** Element-wise binary op on complex Float64Arrays. op: 0=add, 1=sub, 2=mul, 3=div */
-    elemwiseComplex?(aRe: Float64Array, aIm: Float64Array | null, bRe: Float64Array, bIm: Float64Array | null, op: number): {
-        re: Float64Array;
-        im?: Float64Array;
-    };
-    /** Complex-scalar * (real or complex) tensor element-wise op.
-     * op: 0=add, 1=sub, 2=mul, 3=div.
-     * Pass null for arrIm to treat the tensor as purely real. */
-    elemwiseComplexScalar?(scalarRe: number, scalarIm: number, arrRe: Float64Array, arrIm: Float64Array | null, op: number, scalarOnLeft: boolean): {
-        re: Float64Array;
-        im?: Float64Array;
-    };
     /** Real binary elemwise: out[i] = a[i] OP b[i]. op codes per OpRealBin. */
-    tensorOpRealBinary?(op: number, n: number, a: Float64Array, b: Float64Array, out: Float64Array): void;
+    tensorOpRealBinary(op: number, n: number, a: Float64Array, b: Float64Array, out: Float64Array): void;
     /** Real scalar-tensor binary elemwise. */
-    tensorOpRealScalarBinary?(op: number, n: number, scalar: number, arr: Float64Array, scalarOnLeft: boolean, out: Float64Array): void;
+    tensorOpRealScalarBinary(op: number, n: number, scalar: number, arr: Float64Array, scalarOnLeft: boolean, out: Float64Array): void;
     /** Complex binary elemwise (split storage). aIm/bIm may be null. */
-    tensorOpComplexBinary?(op: number, n: number, aRe: Float64Array, aIm: Float64Array | null, bRe: Float64Array, bIm: Float64Array | null, outRe: Float64Array, outIm: Float64Array): void;
+    tensorOpComplexBinary(op: number, n: number, aRe: Float64Array, aIm: Float64Array | null, bRe: Float64Array, bIm: Float64Array | null, outRe: Float64Array, outIm: Float64Array): void;
     /** Complex scalar-tensor binary elemwise. arrIm may be null. */
-    tensorOpComplexScalarBinary?(op: number, n: number, sRe: number, sIm: number, arrRe: Float64Array, arrIm: Float64Array | null, scalarOnLeft: boolean, outRe: Float64Array, outIm: Float64Array): void;
+    tensorOpComplexScalarBinary(op: number, n: number, sRe: number, sIm: number, arrRe: Float64Array, arrIm: Float64Array | null, scalarOnLeft: boolean, outRe: Float64Array, outIm: Float64Array): void;
     /** Real unary elemwise: out[i] = OP(a[i]). op codes per OpUnary. */
-    tensorOpRealUnary?(op: number, n: number, a: Float64Array, out: Float64Array): void;
+    tensorOpRealUnary(op: number, n: number, a: Float64Array, out: Float64Array): void;
     /** Complex unary elemwise (split storage). aIm may be null. ABS unsupported. */
-    tensorOpComplexUnary?(op: number, n: number, aRe: Float64Array, aIm: Float64Array | null, outRe: Float64Array, outIm: Float64Array): void;
+    tensorOpComplexUnary(op: number, n: number, aRe: Float64Array, aIm: Float64Array | null, outRe: Float64Array, outIm: Float64Array): void;
     /** Complex absolute value (real-valued output). aIm may be null. */
-    tensorOpComplexAbs?(n: number, aRe: Float64Array, aIm: Float64Array | null, out: Float64Array): void;
+    tensorOpComplexAbs(n: number, aRe: Float64Array, aIm: Float64Array | null, out: Float64Array): void;
     /** Real comparison: out[i] = (a[i] OP b[i]) ? 1 : 0. */
-    tensorOpRealComparison?(op: number, n: number, a: Float64Array, b: Float64Array, out: Float64Array): void;
+    tensorOpRealComparison(op: number, n: number, a: Float64Array, b: Float64Array, out: Float64Array): void;
     /** Real scalar-tensor comparison. */
-    tensorOpRealScalarComparison?(op: number, n: number, scalar: number, arr: Float64Array, scalarOnLeft: boolean, out: Float64Array): void;
+    tensorOpRealScalarComparison(op: number, n: number, scalar: number, arr: Float64Array, scalarOnLeft: boolean, out: Float64Array): void;
     /** Complex comparison. EQ/NE use both parts; LT/LE/GT/GE use real parts. */
-    tensorOpComplexComparison?(op: number, n: number, aRe: Float64Array, aIm: Float64Array | null, bRe: Float64Array, bIm: Float64Array | null, out: Float64Array): void;
+    tensorOpComplexComparison(op: number, n: number, aRe: Float64Array, aIm: Float64Array | null, bRe: Float64Array, bIm: Float64Array | null, out: Float64Array): void;
     /** Complex scalar-tensor comparison. */
-    tensorOpComplexScalarComparison?(op: number, n: number, sRe: number, sIm: number, arrRe: Float64Array, arrIm: Float64Array | null, scalarOnLeft: boolean, out: Float64Array): void;
+    tensorOpComplexScalarComparison(op: number, n: number, sRe: number, sIm: number, arrRe: Float64Array, arrIm: Float64Array | null, scalarOnLeft: boolean, out: Float64Array): void;
     /** Flat real reduction (output is a 1-element Float64Array). */
-    tensorOpRealFlatReduce?(op: number, n: number, a: Float64Array, out: Float64Array): void;
+    tensorOpRealFlatReduce(op: number, n: number, a: Float64Array, out: Float64Array): void;
     /** Flat complex reduction.  outIm may be null for ANY/ALL. */
-    tensorOpComplexFlatReduce?(op: number, n: number, aRe: Float64Array, aIm: Float64Array | null, outRe: Float64Array, outIm: Float64Array | null): void;
+    tensorOpComplexFlatReduce(op: number, n: number, aRe: Float64Array, aIm: Float64Array | null, outRe: Float64Array, outIm: Float64Array | null): void;
     /**
      * Real Bessel tensor op: out[i] = besselX(nu, z[i]).
      * op codes per OpBessel. scale: 0 unscaled, 1 scaled.
      */
-    tensorOpBesselReal?(op: number, nu: number, n: number, z: Float64Array, scale: number, out: Float64Array): void;
+    tensorOpBesselReal(op: number, nu: number, n: number, z: Float64Array, scale: number, out: Float64Array): void;
     /**
      * Hankel function tensor op (complex output, real input).
      * kKind: 1 → J + i*Y; 2 → J - i*Y.
      */
-    tensorOpBesselH?(kKind: number, nu: number, n: number, z: Float64Array, scale: number, outRe: Float64Array, outIm: Float64Array): void;
+    tensorOpBesselH(kKind: number, nu: number, n: number, z: Float64Array, scale: number, outRe: Float64Array, outIm: Float64Array): void;
+    /** Returns the native addon's version number. */
+    addonVersion?(): number;
     /** Dump op-code enum values as a stable string (drift detection). */
     tensorOpDumpCodes?(): string;
+    /**
+     * Forward/inverse 1D FFT on real input via FFTW.
+     * Does NOT normalize for inverse — caller handles 1/n scaling.
+     * @param re      Real input data as Float64Array of length n.
+     * @param n       Transform length.
+     * @param inverse true for inverse FFT, false for forward.
+     * @returns       { re, im } Float64Arrays of length n.
+     */
+    fft1d?(re: Float64Array, n: number, inverse: boolean): {
+        re: Float64Array;
+        im: Float64Array;
+    };
+    /**
+     * Forward/inverse 1D FFT on complex input via FFTW.
+     * Does NOT normalize for inverse — caller handles 1/n scaling.
+     * @param re      Real part of input as Float64Array of length n.
+     * @param im      Imaginary part of input as Float64Array of length n.
+     * @param n       Transform length.
+     * @param inverse true for inverse FFT, false for forward.
+     * @returns       { re, im } Float64Arrays of length n.
+     */
+    fft1dComplex?(re: Float64Array, im: Float64Array, n: number, inverse: boolean): {
+        re: Float64Array;
+        im: Float64Array;
+    };
+    /**
+     * Batch FFT along a single dimension of a column-major tensor via FFTW.
+     * Transforms ALL fibers in one FFTW call using the guru split interface.
+     * Does NOT normalize for inverse — caller handles 1/n scaling.
+     * @param re      Real part of input tensor (column-major flat array).
+     * @param im      Imaginary part, or null for real input.
+     * @param shape   Tensor dimensions as a JS array of numbers.
+     * @param dim     0-based dimension to transform along.
+     * @param n       FFT length (may differ from shape[dim] for pad/truncate).
+     * @param inverse true for inverse FFT, false for forward.
+     * @returns       { re, im } Float64Arrays for the output tensor.
+     */
+    fftAlongDim?(re: Float64Array, im: Float64Array | null, shape: number[], dim: number, n: number, inverse: boolean): {
+        re: Float64Array;
+        im: Float64Array;
+    };
+    /**
+     * Bulk fill normal random values using Marsaglia polar + xoshiro128**.
+     * State is mutated in-place. Spare is passed in/out to preserve pair caching.
+     */
+    fillRandn?(state: Uint32Array, n: number, spare: number, hasSpare: boolean): {
+        data: Float64Array;
+        spare: number;
+        hasSpare: boolean;
+    };
 }
-export declare function setLapackBridge(bridge: LapackBridge): void;
-export declare function getLapackBridge(): LapackBridge | null;
+/** Set (or clear) the sink for the one-time "bridge in use" diagnostic. */
+export declare function setBridgeLog(log: ((message: string) => void) | null): void;
+/**
+ * Install an accelerated bridge (native addon, wasm module, test stub), or
+ * clear it with null. Entries it omits fall back to TypeScript.
+ */
+export declare function setLapackBridge(bridge: Partial<LapackBridge> | null): void;
+/** The complete bridge: installed entries over the TypeScript ones. */
+export declare function getLapackBridge(): LapackBridge;

package/dist-browser/numbl-core/native/ts-lapack-bridge.d.ts

@@ -1,9 +1,8 @@
 /**
- * Pure-TypeScript LAPACK bridge — implements the LapackBridge interface using
- * the ts-lapack translations of LAPACK Fortran routines.
- *
- * This is always available (no native addon required) and is used as the
- * fallback when the native C++ addon is not loaded (e.g. in the browser).
+ * Pure-TypeScript LAPACK bridge: implements the LapackBridge interface with
+ * the ts-lapack translations of LAPACK Fortran routines and the ops-layer
+ * tensor kernels. getLapackBridge() uses it for every entry the installed
+ * (native) bridge does not provide, e.g. everything in the browser.
  */
 import type { LapackBridge } from "./lapack-bridge.js";
 export declare function getTsLapackBridge(): LapackBridge;

package/dist-browser/numbl-core/native/ts-lapack-complex.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Complex scalar helpers and ZLARFG shared by the ts-lapack complex
+ * routines (eig, Hermitian eig, QR). Split real/imag storage throughout.
+ */
+export declare const EPS = 2.220446049250313e-16;
+export declare const SAFMIN = 2.2250738585072014e-308;
+/** |Re| + |Im| (LAPACK CABS1). */
+export declare function cabs1(re: number, im: number): number;
+/** Fortran SIGN(mag, s): |mag| with the sign of s. */
+export declare function fsign(mag: number, s: number): number;
+/** Robust complex divide (a/b) via Smith's algorithm (ZLADIV). */
+export declare function cdiv(ar: number, ai: number, br: number, bi: number): [number, number];
+/** sqrt(x^2 + y^2 + z^2) without spurious over/underflow (DLAPY3). */
+export declare function dlapy3(x: number, y: number, z: number): number;
+/** DZNRM2 over x(off), x(off+incx), ... (n elements). */
+export declare function dznrm2(n: number, re: Float64Array, im: Float64Array, off: number, incx: number): number;
+/**
+ * ZLARFG: generate a complex elementary reflector H = I - tau*v*v^H with
+ * H^H * [alpha; x] = [beta; 0] and beta real. On entry re/im[off] = alpha and
+ * X is re/im[off + i*incx], i = 1..n-1; on exit re/im[off] = beta and the X
+ * part holds v(2:). Returns tau.
+ */
+export declare function zlarfg(n: number, re: Float64Array, im: Float64Array, off: number, incx: number): [number, number];

package/dist-browser/numbl-core/native/ts-lapack-qr-lu.d.ts

@@ -0,0 +1,37 @@
+/**
+ * QR and LU entry points of the ts-lapack bridge that are not plain calls
+ * into src/ts-lapack: real column-pivoted QR, and complex QR (zgeqr2/zung2r),
+ * column-pivoted QR (zlaqp2) and LU (zgetf2).
+ *
+ * The complex routines are unblocked translations that follow the LAPACK
+ * conventions (zlarfg: real diagonal of R with beta = -sign(Re(alpha))*norm;
+ * izamax pivoting by |re|+|im|) so results agree with MATLAB up to rounding.
+ */
+/**
+ * Real column-pivoted QR, A*P = Q*R (dgeqp3 + dorgqr equivalent): Householder
+ * with greedy pivoting on downdated squared column norms. jpvt is 1-based.
+ */
+export declare function qrPivotTs(data: Float64Array, m: number, n: number, econ: boolean): {
+    Q: Float64Array;
+    R: Float64Array;
+    jpvt: Int32Array;
+};
+export declare function qrComplexTs(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number, econ: boolean, wantQ: boolean): {
+    QRe?: Float64Array;
+    QIm?: Float64Array;
+    RRe: Float64Array;
+    RIm: Float64Array;
+};
+export declare function qrPivotComplexTs(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number, econ: boolean): {
+    QRe: Float64Array;
+    QIm: Float64Array;
+    RRe: Float64Array;
+    RIm: Float64Array;
+    jpvt: Int32Array;
+};
+/** zgetf2: LU with partial pivoting, L unit lower and U packed in place. */
+export declare function luComplexTs(dataRe: Float64Array, dataIm: Float64Array, m: number, n: number): {
+    LURe: Float64Array;
+    LUIm: Float64Array;
+    ipiv: Int32Array;
+};

package/dist-browser/numbl-core/native/wasm-lapack-bridge.d.ts

@@ -12,9 +12,8 @@
  *
  * Two seams are installed from one instantiated module (see
  * `installWasmLapackBridge`):
- *   1. `setLapackBridge()` — covers the *interpreter* path (opt 0), which
- *      already resolves per-op via `getEffectiveBridge` and falls back to
- *      ts-lapack for any op the bridge omits.
+ *   1. `setLapackBridge()` — covers the *interpreter* path (opt 0);
+ *      `getLapackBridge()` takes ts-lapack for any op the module omits.
  *   2. `globalThis.$matmulAccel` — the hook the JS-JIT matmul runtime
  *      snippet consults (opt 1, the browser IDE default), which otherwise
  *      runs a naive JS triple-loop that never touches the bridge.
@@ -85,9 +84,9 @@ export declare function makeWasmMatmul(exports: WasmLapackExports): MatmulFn;
 /**
  * Assemble a (partial) `LapackBridge` from an instantiated module, exposing
  * only the ops the manifest advertises. Ops the bridge omits resolve to
- * ts-lapack via `getEffectiveBridge`.
+ * ts-lapack in `getLapackBridge`.
  */
-export declare function buildLapackBridgeFromWasm(exports: WasmLapackExports, manifest: AcceleratorManifest): LapackBridge;
+export declare function buildLapackBridgeFromWasm(exports: WasmLapackExports, manifest: AcceleratorManifest): Partial<LapackBridge>;
 /**
  * Install/remove the JS-JIT matmul accelerator hook (`globalThis.$matmulAccel`)
  * that `mtoc2_tensor_mtimes_real` consults. Pass `null` to uninstall.

package/dist-browser/numbl-core/ops/dispatch.d.ts

@@ -1,11 +1,10 @@
 /**
- * Tensor-ops dispatcher: chooses native bridge or pure-TS fallback.
+ * Tensor-ops entry points: thin wrappers over the LAPACK bridge's tensorOp*
+ * kernels (native addon when installed, the TS kernels in this directory
+ * otherwise; see native/lapack-bridge.ts).
  *
- * All entry points have identical signatures across native and TS impls.
  * Caller owns input AND output memory; functions never allocate output.
- *
- * Selection happens once on first use per category and is cached
- * (the bridge identity is captured at module load via getLapackBridge()).
+ * Element-wise ops skip the bridge entirely for empty inputs.
  */
 export declare const tensorOps: {
     realBinaryElemwise(op: number, n: number, a: Float64Array, b: Float64Array, out: Float64Array): void;

package/dist-browser/numbl-core/parser/types.d.ts

@@ -313,7 +313,7 @@ export type Stmt = {
     type: "ClassDef";
     name: string;
     classAttributes: Attr[];
-    superClass: string | null;
+    superClasses: string[];
     members: ClassMember[];
     span: Span;
 } | {
@@ -322,26 +322,6 @@ export type Stmt = {
     directive: string;
     args: string[];
     span: Span;
-} | {
-    /** Synthetic stmt produced by an executor-registered AST
-     *  transformer (e.g. the C-JIT chain pass). Wraps a contiguous
-     *  run of original stmts so a specialized executor can claim
-     *  them as a unit; the interpreter falls back to executing
-     *  `subStmts` in order when the executor isn't registered or
-     *  declines.
-     *
-     *  Never produced by the parser. */
-    type: "Synth";
-    /** Identifies the executor that this synth node was built for
-     *  (e.g. `"c-jit-chain"`). The matching executor reads `data`. */
-    tag: string;
-    /** Original adjacent stmts, in source order. Used by the
-     *  interpreter fallback. */
-    subStmts: Stmt[];
-    /** Executor-specific pre-computed analysis. Opaque to the
-     *  interpreter. */
-    data: unknown;
-    span: Span;
 };
 export interface AbstractSyntaxTree {
     body: Stmt[];

package/{dist-lib/numbl-core/runtime → dist-browser/numbl-core/plotting}/axisCommand.d.ts

@@ -19,8 +19,8 @@
  * `lim = axis(ax)` carry no setting argument; the runtime detects them via
  * the `false` return value and computes the limits separately.
  */
-import type { RuntimeValue } from "./types.js";
-import type { PlotInstruction } from "../../graphics/types.js";
+import type { RuntimeValue } from "../runtime/types.js";
+import type { PlotInstruction } from "./types.js";
 /**
  * Process an `axis(...)` call, pushing instructions onto `instructions`.
  *

package/dist-browser/{graphics → numbl-core/plotting}/axisLimits.d.ts

@@ -3,8 +3,8 @@
  *
  * This is the source of truth for the query form `lim = axis`: the numbl
  * runtime reduces its accumulated plot instructions into an `AxesState` and
- * asks this module for the limit vector. It is deliberately rendering-free
- * (no canvas, no DOM) so numbl-core can import it.
+ * asks this module for the limit vector. It is rendering-free (no canvas, no
+ * DOM); the renderer in src/graphics/ uses it too.
  *
  * For an axis with an explicit limit, that limit is returned verbatim (a
  * `null` bound falls back to the data-derived bound). For a fully automatic
@@ -13,11 +13,23 @@
  * what is drawn.
  */
 import type { AxesState } from "./figuresReducer.js";
+type Extent = {
+    min: number;
+    max: number;
+};
 /** Does this axes hold any 3-D content (so limits are a 6-vector)? */
 export declare function axesIs3D(axes: AxesState): boolean;
+/** Raw data extents (no padding) across every renderable trace type.
+ *  Non-finite values are ignored; an empty axis has min > max. */
+export declare function dataExtents(axes: Partial<AxesState>): {
+    x: Extent;
+    y: Extent;
+    z: Extent;
+};
 /**
  * Compute the limit vector for `lim = axis`.
  * Returns 4 elements `[xmin xmax ymin ymax]` for a 2-D view, or 6 elements
  * `[xmin xmax ymin ymax zmin zmax]` when the axes holds 3-D content.
  */
 export declare function computeAxisLimits(axes: AxesState): number[];
+export {};