@danielsimonjr/mathts-matrix 0.7.0 → 0.7.2

package/dist/index.d.ts

@@ -1,3044 +1,21 @@
-import { MatrixDimensions } from '@danielsimonjr/mathts-core';
-export { MatrixDimensions } from '@danielsimonjr/mathts-core';
-import * as workerpool from 'workerpool';
-import { ComputePool, ComputePoolConfig } from '@danielsimonjr/mathts-parallel';
-import { GPUContextOptions, GPUCapabilities, GPUContext, BufferPool, ShaderManager } from '@danielsimonjr/mathts-gpu';
-export { BufferPool, GPUCapabilities, GPUContext, GPUContextOptions, ShaderManager, destroyGlobalGPU, detectGPUCapabilities, getGlobalGPUContext, getRecommendedWorkgroupSize, hasWebGPU } from '@danielsimonjr/mathts-gpu';
-import * as typed_function from 'typed-function';
-
 /**
- * Matrix Base Class
+ * @danielsimonjr/mathts-matrix
  *
- * Abstract base class defining the common interface for all matrix types.
- * Provides a unified API for DenseMatrix, SparseMatrix, and future implementations.
- *
- * @packageDocumentation
- */
-/**
- * Matrix dimension type, consolidated from `@danielsimonjr/mathts-core`'s
- * byte-identical copy (see docs/Architecture/duplicate-symbols.json).
- */
-
-/**
- * Matrix index for element access
- */
-interface MatrixIndex {
-    row: number;
-    col: number;
-}
-/**
- * Slice specification for submatrix extraction
- */
-interface SliceSpec {
-    rowStart?: number;
-    rowEnd?: number;
-    colStart?: number;
-    colEnd?: number;
-}
-/**
- * Matrix iterator result
- */
-interface MatrixEntry<T = number> {
-    row: number;
-    col: number;
-    value: T;
-}
-/**
- * Matrix storage format identifier
- */
-type MatrixType = 'DenseMatrix' | 'SparseMatrix' | 'DiagonalMatrix' | 'BandMatrix';
-/**
- * Abstract base class for all matrix types
- *
- * @typeParam T - The element type (default: number)
- */
-declare abstract class Matrix<T = number> {
-    /**
-     * The matrix storage format type
-     */
-    abstract readonly type: MatrixType;
-    /**
-     * Number of rows
-     */
-    abstract readonly rows: number;
-    /**
-     * Number of columns
-     */
-    abstract readonly cols: number;
-    /**
-     * Get the dimensions of the matrix
-     */
-    get size(): MatrixDimensions;
-    /**
-     * Check if the matrix is square
-     */
-    get isSquare(): boolean;
-    /**
-     * Check if the matrix is a vector (single row or column)
-     */
-    get isVector(): boolean;
-    /**
-     * Check if the matrix is a row vector
-     */
-    get isRowVector(): boolean;
-    /**
-     * Check if the matrix is a column vector
-     */
-    get isColumnVector(): boolean;
-    /**
-     * Total number of elements
-     */
-    get length(): number;
-    /**
-     * Get element at position (row, col)
-     * @param row - Row index (0-based)
-     * @param col - Column index (0-based)
-     */
-    abstract get(row: number, col: number): T;
-    /**
-     * Set element at position (row, col)
-     * @param row - Row index (0-based)
-     * @param col - Column index (0-based)
-     * @param value - Value to set
-     * @returns A new matrix with the updated value (immutable)
-     */
-    abstract set(row: number, col: number, value: T): Matrix<T>;
-    /**
-     * Get a row as a new matrix (1×n)
-     * @param index - Row index
-     */
-    abstract row(index: number): Matrix<T>;
-    /**
-     * Get a column as a new matrix (m×1)
-     * @param index - Column index
-     */
-    abstract column(index: number): Matrix<T>;
-    /**
-     * Get a submatrix (view or copy depending on implementation)
-     * @param spec - Slice specification
-     */
-    abstract slice(spec: SliceSpec): Matrix<T>;
-    /**
-     * Get the diagonal elements as a vector
-     * @param k - Diagonal offset (0 = main diagonal, positive = above, negative = below)
-     */
-    abstract diagonal(k?: number): Matrix<T>;
-    /**
-     * Matrix addition
-     */
-    abstract add(other: Matrix<T>): Matrix<T>;
-    /**
-     * Matrix subtraction
-     */
-    abstract subtract(other: Matrix<T>): Matrix<T>;
-    /**
-     * Element-wise multiplication (Hadamard product)
-     */
-    abstract multiplyElementwise(other: Matrix<T>): Matrix<T>;
-    /**
-     * Matrix multiplication
-     */
-    abstract multiply(other: Matrix<T>): Matrix<T>;
-    /**
-     * Scalar multiplication
-     */
-    abstract scale(scalar: T): Matrix<T>;
-    /**
-     * Matrix transpose
-     */
-    abstract transpose(): Matrix<T>;
-    /**
-     * Convert to nested array representation
-     */
-    abstract toArray(): T[][];
-    /**
-     * Convert to flat array (row-major order)
-     */
-    abstract toFlatArray(): T[];
-    /**
-     * Create a deep copy of the matrix
-     */
-    abstract clone(): Matrix<T>;
-    /**
-     * Iterate over all elements with their indices
-     */
-    abstract entries(): IterableIterator<MatrixEntry<T>>;
-    /**
-     * Iterate over all values (row-major order)
-     */
-    abstract values(): IterableIterator<T>;
-    /**
-     * Check if indices are within bounds
-     */
-    protected checkBounds(row: number, col: number): void;
-    /**
-     * Check if dimensions match for element-wise operations
-     */
-    protected checkDimensionsMatch(other: Matrix<T>): void;
-    /**
-     * Check if matrices can be multiplied
-     */
-    protected checkMultiplyDimensions(other: Matrix<T>): void;
-    /**
-     * Format matrix for display
-     */
-    toString(): string;
-    /**
-     * Check equality with another matrix
-     */
-    equals(other: Matrix<T>, tolerance?: number): boolean;
-}
-/**
- * Type guard to check if a value is a Matrix
- */
-declare function isMatrix<T = number>(value: unknown): value is Matrix<T>;
-
-/**
- * Dense Matrix Implementation
- *
- * Row-major dense matrix backed by Float64Array for efficient storage
- * and operations. Supports views (slices without copying) where possible.
- *
- * @packageDocumentation
- */
-
-/**
- * Dense matrix implementation using Float64Array
- *
- * Data is stored in row-major order for cache-friendly row access.
- * All operations return new matrices (immutable API).
- */
-declare class DenseMatrix extends Matrix<number> {
-    readonly type: "DenseMatrix";
-    readonly rows: number;
-    readonly cols: number;
-    /**
-     * Internal data storage (row-major Float64Array)
-     */
-    private readonly data;
-    /**
-     * Whether this matrix is a view into another matrix's data
-     */
-    private readonly isView;
-    /**
-     * Offset into data array (for views)
-     */
-    private readonly offset;
-    /**
-     * Stride between rows (for views)
-     */
-    private readonly rowStride;
-    /**
-     * Create a new DenseMatrix
-     *
-     * @param rows - Number of rows
-     * @param cols - Number of columns
-     * @param data - Optional initial data (row-major order)
-     */
-    constructor(rows: number, cols: number, data?: Float64Array | number[] | number[][], viewConfig?: {
-        isView: boolean;
-        offset: number;
-        rowStride: number;
-    });
-    /**
-     * Create a matrix from a nested array
-     */
-    static fromArray(arr: number[][]): DenseMatrix;
-    /**
-     * Create a matrix from a flat array with specified dimensions
-     */
-    static fromFlat(rows: number, cols: number, data: number[]): DenseMatrix;
-    /**
-     * Create a zero matrix
-     */
-    static zeros(rows: number, cols: number): DenseMatrix;
-    /**
-     * Create a matrix filled with ones
-     */
-    static ones(rows: number, cols: number): DenseMatrix;
-    /**
-     * Create an identity matrix
-     */
-    static identity(n: number): DenseMatrix;
-    /**
-     * Create a diagonal matrix from values
-     */
-    static diag(values: number[]): DenseMatrix;
-    /**
-     * Create a matrix filled with a constant value
-     */
-    static fill(rows: number, cols: number, value: number): DenseMatrix;
-    /**
-     * Create a matrix with random values in [0, 1)
-     */
-    static random(rows: number, cols: number): DenseMatrix;
-    /**
-     * Get element at (row, col)
-     * O(1) access time
-     */
-    get(row: number, col: number): number;
-    /**
-     * Set element at (row, col) - returns new matrix
-     */
-    set(row: number, col: number, value: number): DenseMatrix;
-    /**
-     * Get the raw Float64Array data (copy if view, reference otherwise)
-     */
-    private toFlatFloat64Array;
-    /**
-     * Get a row as a 1×n matrix (view, no copy)
-     */
-    row(index: number): DenseMatrix;
-    /**
-     * Get a column as an m×1 matrix (copy, since data is row-major)
-     */
-    column(index: number): DenseMatrix;
-    /**
-     * Get a submatrix
-     */
-    slice(spec: SliceSpec): DenseMatrix;
-    /**
-     * Get the diagonal elements
-     */
-    diagonal(k?: number): DenseMatrix;
-    /**
-     * Matrix addition
-     */
-    add(other: Matrix<number>): DenseMatrix;
-    /**
-     * Matrix subtraction
-     */
-    subtract(other: Matrix<number>): DenseMatrix;
-    /**
-     * Element-wise multiplication (Hadamard product)
-     */
-    multiplyElementwise(other: Matrix<number>): DenseMatrix;
-    /**
-     * Matrix multiplication
-     */
-    multiply(other: Matrix<number>): DenseMatrix;
-    /**
-     * Scalar multiplication
-     */
-    scale(scalar: number): DenseMatrix;
-    /**
-     * Matrix transpose
-     */
-    transpose(): DenseMatrix;
-    /**
-     * Negate all elements
-     */
-    negate(): DenseMatrix;
-    /**
-     * Sum of all elements
-     */
-    sum(): number;
-    /**
-     * Mean of all elements
-     */
-    mean(): number;
-    /**
-     * Minimum element
-     */
-    min(): number;
-    /**
-     * Maximum element
-     */
-    max(): number;
-    /**
-     * Frobenius norm (sqrt of sum of squared elements)
-     */
-    norm(): number;
-    /**
-     * Trace (sum of diagonal elements)
-     */
-    trace(): number;
-    /**
-     * Convert to nested array
-     */
-    toArray(): number[][];
-    /**
-     * Convert to flat array (row-major)
-     */
-    toFlatArray(): number[];
-    /**
-     * Get the underlying Float64Array (copy)
-     */
-    toFloat64Array(): Float64Array;
-    /**
-     * Clone the matrix
-     */
-    clone(): DenseMatrix;
-    /**
-     * Convert to sparse matrix (CSR format)
-     *
-     * This is a synchronous conversion that creates a SparseMatrix
-     * containing only the non-zero elements of this matrix.
-     *
-     * @param dropTolerance - Values below this threshold are treated as zero
-     * @returns SparseMatrix representation (typed as the `Matrix` base — the
-     *   `SparseMatrix` subtype is loaded lazily to avoid an import cycle)
-     */
-    toSparse(dropTolerance?: number): Matrix;
-    /**
-     * Iterate over entries with indices
-     */
-    entries(): IterableIterator<MatrixEntry<number>>;
-    /**
-     * Iterate over values (row-major)
-     */
-    values(): IterableIterator<number>;
-    /**
-     * Support for...of iteration (iterates over values)
-     */
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Apply a function to each element
-     */
-    map(fn: (value: number, row: number, col: number) => number): DenseMatrix;
-    /**
-     * Apply a function to each element (no return, for side effects)
-     */
-    forEach(fn: (value: number, row: number, col: number) => void): void;
-}
-/**
- * Type guard for DenseMatrix
- */
-declare function isDenseMatrix(value: unknown): value is DenseMatrix;
-
-/**
- * Sparse Matrix Implementation (CSR Format)
- *
- * Compressed Sparse Row (CSR) format sparse matrix for efficient storage
- * and operations on matrices with many zero elements.
- *
- * CSR stores:
- * - values: Non-zero values in row-major order
- * - colIndices: Column index for each non-zero value
- * - rowPointers: Index into values/colIndices where each row starts
- *
- * @packageDocumentation
- */
-
-/**
- * Sparse matrix using Compressed Sparse Row (CSR) format
- *
- * Efficient for:
- * - Row slicing and iteration
- * - Sparse matrix-vector multiplication
- * - Matrices with many zeros (typically < 10% non-zero)
- */
-declare class SparseMatrix extends Matrix<number> {
-    readonly type: "SparseMatrix";
-    readonly rows: number;
-    readonly cols: number;
-    /**
-     * Non-zero values in row-major order
-     */
-    private readonly _data;
-    /**
-     * Column indices for each non-zero value
-     */
-    private readonly _colIndices;
-    /**
-     * Row pointers: rowPointers[i] = index of first non-zero in row i
-     * rowPointers[rows] = total number of non-zeros (nnz)
-     */
-    private readonly _rowPointers;
-    /**
-     * Create a sparse matrix from CSR components
-     *
-     * @param rows - Number of rows
-     * @param cols - Number of columns
-     * @param values - Non-zero values
-     * @param colIndices - Column index for each value
-     * @param rowPointers - Row start indices
-     */
-    constructor(rows: number, cols: number, values: Float64Array | number[], colIndices: Int32Array | number[], rowPointers: Int32Array | number[]);
-    /**
-     * Create a sparse matrix from a dense matrix
-     *
-     * @param dense - Dense matrix to convert
-     * @param dropTolerance - Values below this threshold are treated as zero
-     */
-    static fromDense(dense: DenseMatrix, dropTolerance?: number): SparseMatrix;
-    /**
-     * Create a sparse matrix from coordinate (COO) format
-     *
-     * @param rows - Number of rows
-     * @param cols - Number of columns
-     * @param entries - Array of {row, col, value} entries
-     */
-    static fromCOO(rows: number, cols: number, entries: Array<{
-        row: number;
-        col: number;
-        value: number;
-    }>): SparseMatrix;
-    /**
-     * Create a zero sparse matrix
-     */
-    static zeros(rows: number, cols: number): SparseMatrix;
-    /**
-     * Create a sparse identity matrix
-     */
-    static identity(n: number): SparseMatrix;
-    /**
-     * Create a sparse diagonal matrix
-     */
-    static diag(values: number[]): SparseMatrix;
-    /**
-     * Number of non-zero elements
-     */
-    get nnz(): number;
-    /**
-     * Sparsity: fraction of zero elements
-     */
-    get sparsity(): number;
-    /**
-     * Density: fraction of non-zero elements
-     */
-    get density(): number;
-    /**
-     * Get element at (row, col) - O(log(nnz_in_row)) for sorted columns
-     */
-    get(row: number, col: number): number;
-    /**
-     * Set element at (row, col) - returns new matrix (immutable)
-     */
-    set(row: number, col: number, value: number): SparseMatrix;
-    /**
-     * Get a row as a sparse 1×n matrix
-     */
-    row(index: number): SparseMatrix;
-    /**
-     * Get a column as a sparse m×1 matrix
-     */
-    column(index: number): SparseMatrix;
-    /**
-     * Get a submatrix
-     */
-    slice(spec: SliceSpec): SparseMatrix;
-    /**
-     * Get the diagonal elements
-     */
-    diagonal(k?: number): SparseMatrix;
-    /**
-     * Sparse matrix addition
-     */
-    add(other: Matrix<number>): SparseMatrix;
-    private addSparse;
-    /**
-     * Sparse matrix subtraction
-     */
-    subtract(other: Matrix<number>): SparseMatrix;
-    /**
-     * Element-wise multiplication (Hadamard product)
-     */
-    multiplyElementwise(other: Matrix<number>): SparseMatrix;
-    /**
-     * Sparse matrix multiplication
-     */
-    multiply(other: Matrix<number>): SparseMatrix;
-    private multiplySparse;
-    /**
-     * Scalar multiplication
-     */
-    scale(scalar: number): SparseMatrix;
-    /**
-     * Sparse matrix transpose
-     */
-    transpose(): SparseMatrix;
-    /**
-     * Negate all elements
-     */
-    negate(): SparseMatrix;
-    /**
-     * Sum of all elements
-     */
-    sum(): number;
-    /**
-     * Frobenius norm
-     */
-    norm(): number;
-    /**
-     * Trace (sum of diagonal elements)
-     */
-    trace(): number;
-    /**
-     * Convert to dense matrix
-     */
-    toDense(): DenseMatrix;
-    /**
-     * Convert to nested array
-     */
-    toArray(): number[][];
-    /**
-     * Convert to flat array (row-major)
-     */
-    toFlatArray(): number[];
-    /**
-     * Clone the matrix
-     */
-    clone(): SparseMatrix;
-    /**
-     * Get the CSR components
-     */
-    getCSR(): {
-        values: Float64Array;
-        colIndices: Int32Array;
-        rowPointers: Int32Array;
-    };
-    /**
-     * Iterate over non-zero entries
-     */
-    entries(): IterableIterator<MatrixEntry<number>>;
-    /**
-     * Iterate over non-zero values
-     */
-    values(): IterableIterator<number>;
-    /**
-     * Iterate over all values (including zeros, row-major)
-     */
-    allValues(): IterableIterator<number>;
-    /**
-     * Support for...of iteration (iterates over non-zero values)
-     */
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Apply a function to each non-zero element
-     */
-    mapNonZeros(fn: (value: number, row: number, col: number) => number): SparseMatrix;
-    /**
-     * Apply a function to each element (including zeros)
-     * Warning: This may create a dense result
-     */
-    map(fn: (value: number, row: number, col: number) => number): SparseMatrix;
-}
-/**
- * Type guard for SparseMatrix
- */
-declare function isSparseMatrix(value: unknown): value is SparseMatrix;
-
-/**
- * Matrix Backend Interface
- *
- * Defines the contract for matrix operation backends.
- * Implementations include JSBackend (pure TypeScript),
- * WASMBackend (AssemblyScript), and GPUBackend (WebGPU).
- *
- * @packageDocumentation
- */
-
-/**
- * Backend type identifier
- */
-type BackendType = 'js' | 'wasm' | 'gpu' | 'parallel';
-/**
- * Backend selection hints
- */
-interface BackendHints {
-    /** Minimum size to use WASM backend */
-    wasmThreshold?: number;
-    /** Minimum size to use GPU backend */
-    gpuThreshold?: number;
-    /** Force a specific backend */
-    preferredBackend?: BackendType;
-}
-/**
- * Default backend hints
- */
-declare const DEFAULT_BACKEND_HINTS: Required<BackendHints>;
-/**
- * Abstract backend interface for matrix operations
- *
- * Each backend implements the same operations but may use different
- * underlying implementations (pure JS, WASM SIMD, WebGPU compute shaders).
- */
-interface MatrixBackend {
-    /**
-     * Backend identifier
-     */
-    readonly type: BackendType;
-    /**
-     * Whether the backend is available in the current environment
-     */
-    isAvailable(): boolean;
-    /**
-     * Initialize the backend (may be async for WASM/GPU)
-     */
-    initialize(): Promise<void>;
-    /**
-     * Matrix addition: C = A + B
-     */
-    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Matrix subtraction: C = A - B
-     */
-    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise multiplication: C = A .* B
-     */
-    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise division: C = A ./ B
-     */
-    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Scalar multiplication: C = A * s
-     */
-    scale(a: DenseMatrix, scalar: number): DenseMatrix;
-    /**
-     * Element-wise absolute value
-     */
-    abs(a: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise negation
-     */
-    negate(a: DenseMatrix): DenseMatrix;
-    /**
-     * Matrix multiplication: C = A * B
-     */
-    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Matrix transpose
-     */
-    transpose(a: DenseMatrix): DenseMatrix;
-    /**
-     * Sum of all elements (may be async for parallel backends)
-     */
-    sum(a: DenseMatrix): number | Promise<number>;
-    /**
-     * Sum along an axis (0 = columns, 1 = rows)
-     */
-    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
-    /**
-     * Frobenius norm
-     */
-    norm(a: DenseMatrix): number;
-    /**
-     * Dot product of two vectors (may be async for parallel backends)
-     */
-    dot(a: DenseMatrix, b: DenseMatrix): number | Promise<number>;
-}
-/**
- * Registry of available backends
- */
-declare class BackendRegistry {
-    private backends;
-    private initialized;
-    private hints;
-    /**
-     * Register a backend
-     */
-    register(backend: MatrixBackend): void;
-    /**
-     * Get a backend by type
-     */
-    get(type: BackendType): MatrixBackend | undefined;
-    /**
-     * Check if a backend is registered and available
-     */
-    has(type: BackendType): boolean;
-    /**
-     * Initialize a backend
-     */
-    initialize(type: BackendType): Promise<void>;
-    /**
-     * Get all available backends
-     */
-    available(): BackendType[];
-    /**
-     * Update selection hints
-     */
-    setHints(hints: BackendHints): void;
-    /**
-     * Get current hints
-     */
-    getHints(): Required<BackendHints>;
-    /**
-     * Select the best backend for a given operation size
-     */
-    selectBackend(elementCount: number): MatrixBackend;
-}
-/**
- * Global backend registry
- */
-declare const backendRegistry: BackendRegistry;
-
-/**
- * Pure TypeScript Matrix Backend
- *
- * Reference implementation of matrix operations using plain JavaScript.
- * Serves as baseline for correctness and fallback when WASM/GPU unavailable.
- *
- * @packageDocumentation
- */
-
-/**
- * Pure JavaScript matrix backend
- *
- * All operations are implemented in TypeScript without external dependencies.
- * Performance is optimized where possible but prioritizes correctness.
- */
-declare class JSBackend implements MatrixBackend {
-    readonly type: BackendType;
-    /**
-     * JS backend is always available
-     */
-    isAvailable(): boolean;
-    /**
-     * No initialization needed for JS backend
-     */
-    initialize(): Promise<void>;
-    /**
-     * Matrix addition
-     */
-    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Matrix subtraction
-     */
-    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise multiplication
-     */
-    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise division
-     */
-    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Scalar multiplication
-     */
-    scale(a: DenseMatrix, scalar: number): DenseMatrix;
-    /**
-     * Element-wise absolute value
-     */
-    abs(a: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise negation
-     */
-    negate(a: DenseMatrix): DenseMatrix;
-    /**
-     * Matrix multiplication using the naive O(n³) algorithm
-     *
-     * For larger matrices, consider using blocked/tiled multiplication
-     * or Strassen's algorithm (implemented in WASM backend).
-     */
-    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Matrix transpose
-     */
-    transpose(a: DenseMatrix): DenseMatrix;
-    /**
-     * Sum of all elements
-     */
-    sum(a: DenseMatrix): number;
-    /**
-     * Sum along an axis
-     * axis=0: sum columns (result is 1×n row vector)
-     * axis=1: sum rows (result is m×1 column vector)
-     */
-    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
-    /**
-     * Frobenius norm: sqrt(sum of squared elements)
-     */
-    norm(a: DenseMatrix): number;
-    /**
-     * Dot product of two vectors
-     *
-     * Works with row vectors (1×n) or column vectors (m×1).
-     */
-    dot(a: DenseMatrix, b: DenseMatrix): number;
-    private checkDimensionsMatch;
-    private checkMultiplyDimensions;
-}
-/**
- * Default JS backend instance
- */
-declare const jsBackend: JSBackend;
-
-/**
- * Configuration for ParallelBackend
- */
-interface ParallelBackendConfig {
-    /** Custom ComputePool instance (optional) */
-    pool?: ComputePool;
-    /** Pool configuration (if creating new pool) */
-    poolConfig?: Partial<ComputePoolConfig>;
-    /** Threshold for parallel execution (elements) */
-    parallelThreshold?: number;
-}
-/**
- * Parallel matrix backend using worker pool
- *
- * Provides parallel implementations of matrix operations for large matrices.
- * Uses automatic chunking and result aggregation for efficient parallel execution.
- *
- * @example
- * ```typescript
- * const backend = new ParallelBackend();
- * await backend.initialize();
- *
- * const result = await backend.multiply(largeMatrixA, largeMatrixB);
- * ```
- */
-declare class ParallelBackend {
-    readonly type: BackendType;
-    private pool;
-    private initialized;
-    private parallelThreshold;
-    constructor(config?: ParallelBackendConfig);
-    /**
-     * Check if parallel backend is available
-     */
-    isAvailable(): boolean;
-    /**
-     * Initialize the worker pool
-     */
-    initialize(): Promise<void>;
-    /**
-     * Check if initialized
-     */
-    isReady(): boolean;
-    /**
-     * Determine if operation should be parallelized
-     */
-    private shouldParallelize;
-    /**
-     * Parallel matrix addition
-     */
-    add(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
-    /**
-     * Parallel matrix subtraction
-     */
-    subtract(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
-    /**
-     * Parallel element-wise multiplication
-     */
-    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
-    /**
-     * Parallel element-wise division
-     */
-    divideElementwise(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
-    /**
-     * Parallel scalar multiplication
-     */
-    scale(a: DenseMatrix, scalar: number): Promise<DenseMatrix>;
-    /**
-     * Element-wise absolute value (sequential, as it's simple)
-     */
-    abs(a: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise negation
-     */
-    negate(a: DenseMatrix): DenseMatrix;
-    /**
-     * Parallel matrix multiplication
-     */
-    multiply(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
-    /**
-     * Parallel matrix transpose
-     */
-    transpose(a: DenseMatrix): Promise<DenseMatrix>;
-    /**
-     * Parallel sum of all elements
-     */
-    sum(a: DenseMatrix): Promise<number>;
-    /**
-     * Sum along an axis (sequential)
-     */
-    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
-    /**
-     * Frobenius norm (sequential)
-     */
-    norm(a: DenseMatrix): number;
-    /**
-     * Parallel dot product
-     */
-    dot(a: DenseMatrix, b: DenseMatrix): Promise<number>;
-    /**
-     * Terminate the worker pool
-     */
-    terminate(): Promise<void>;
-    /**
-     * Get pool statistics
-     */
-    getStats(): workerpool.PoolStats;
-    private checkDimensionsMatch;
-    private checkMultiplyDimensions;
-}
-/**
- * Default parallel backend instance using global compute pool
- */
-declare const parallelBackend: ParallelBackend;
-/**
- * Create a new parallel backend with custom configuration
- */
-declare function createParallelBackend(config?: ParallelBackendConfig): ParallelBackend;
-
-/**
- * WASM Feature Detection
- *
- * Detects available WebAssembly features in the current environment.
- * Used to enable/disable SIMD, threads, and other optimizations.
- *
- * @packageDocumentation
- */
-/**
- * Available WASM features
- */
-interface WasmFeatures {
-    /** Basic WebAssembly support */
-    webAssembly: boolean;
-    /** WASM SIMD (v128) support */
-    simd: boolean;
-    /** SharedArrayBuffer available */
-    sharedMemory: boolean;
-    /** Atomics API available */
-    atomics: boolean;
-    /** WASM threads (requires SharedArrayBuffer) */
-    threads: boolean;
-    /** Bulk memory operations */
-    bulkMemory: boolean;
-    /** Reference types */
-    referenceTypes: boolean;
-    /** WASM exception handling */
-    exceptions: boolean;
-    /** Tail call optimization */
-    tailCall: boolean;
-}
-/**
- * Detect all WASM features
- *
- * @returns Promise resolving to detected features
- */
-declare function detectWasmFeatures(): Promise<WasmFeatures>;
-/**
- * Synchronously check if WASM is available (basic check only)
- */
-declare function isWasmAvailable(): boolean;
-/**
- * Synchronously check if SharedArrayBuffer is available
- */
-declare function isSharedMemoryAvailable(): boolean;
-/**
- * Synchronously check if Atomics are available
- */
-declare function isAtomicsAvailable(): boolean;
-/**
- * Clear the feature detection cache (useful for testing)
- */
-declare function clearFeatureCache(): void;
-/**
- * Get cached features if available
- */
-declare function getCachedFeatures(): WasmFeatures | null;
-
-/**
- * WASM Matrix Backend (AssemblyScript)
- *
- * Implements MatrixBackend using the AssemblyScript-compiled WebAssembly
- * module (`dist/wasm/mathts-as.wasm`, ~65 KB). Falls back to JSBackend when
- * the WASM module is unavailable or for small matrices.
- *
- * ABI:
- *   The AS module exports a managed runtime (`__new` / `__pin` / `__unpin` /
- *   `__collect`) and its matrix/array functions accept managed `Float64Array`
- *   *header* pointers — NOT raw flat-memory pointers. A typed-array header is
- *   a 12-byte block at some offset that stores (buffer, buffer, byteLength).
- *
- *   To call e.g. `matrix_add(a, b, result)` from JS, we have to:
- *     1. `__new(byteLength, 1)` — allocate the data buffer (id=1 = ArrayBuffer)
- *     2. `__pin(buffer)`         — pin so it survives GC while building header
- *     3. `__new(12, 5)`          — allocate the Float64Array header (id=5)
- *     4. Write [buffer, buffer, byteLength] into the header
- *     5. Copy caller data into the buffer
- *     6. `__unpin(buffer)`       — the header now owns the buffer reference
- *
- *   The legacy artifact had no managed runtime and used a completely
- *   different ABI (camelCase exports, flat-memory raw pointers). It was
- *   retired in Phase 7b; the AssemblyScript binary is now the only WASM
- *   backend.
- *
- * Naming map (legacy backend ↔ AssemblyScript) — kept for historical reference:
- *
- *   Op                  Legacy (camelCase, flat ptrs)      AS (snake_case, header refs)
- *   ------------------  ---------------------------------  -------------------------------
- *   add                 add(aPtr,bPtr,n,resPtr)            matrix_add(a,b,result)
- *   subtract            subtract(aPtr,bPtr,n,resPtr)       matrix_sub(a,b,result)
- *   multiplyElementwise simdMulF64(aPtr,bPtr,resPtr,n)     matrix_mul_elementwise(a,b,result)
- *   divideElementwise   (none)                              matrix_div_elementwise(a,b,result)
- *   scale               simdScaleF64(aPtr,s,resPtr,n)      matrix_scale(a,scalar,result)
- *   abs                 simdAbsF64(aPtr,resPtr,n)          array_abs(a,result)
- *   negate              simdScaleF64(aPtr,-1,resPtr,n)     matrix_neg(a,result)
- *   multiply            multiplyDense(a,r,c,b,r,c,res)     matrix_multiply(a,aRows,aCols,b,bCols,result)
- *   transpose           transpose(a,r,c,res)               matrix_transpose(a,rows,cols,result)
- *   sum                 simdSumF64(aPtr,n)                 array_sum(a)
- *   norm                simdNormF64(aPtr,n)                array_norm(a)
- *   dot                 dotProduct(aPtr,bPtr,n)            array_dot(a,b)
- *
- *   AssemblyScript also exports LU / QR / Cholesky / inverse / determinant
- *   (see assembly/src/algebra/decomposition.ts); the methods below dispatch
- *   to them when present and fall back to the in-process JS implementation
- *   otherwise.
- *
- * @packageDocumentation
- */
-
-/**
- * WASM Backend configuration
- */
-interface WASMBackendConfig {
-    /** Minimum elements to use WASM (default: 100) */
-    minElements?: number;
-    /** Path to WASM file (defaults to the packaged AS artifact, `dist/wasm/mathts-as.wasm`) */
-    wasmPath?: string;
-    /** Enable SIMD code paths if the AS module exposes them (currently a no-op
-     * — AS export surface does not include `simd*` ops; kept for API stability). */
-    useSIMD?: boolean;
-}
-/**
- * WASM Backend for matrix operations (AssemblyScript path).
- *
- * This is the sole WASM backend after Phase 7b retired the legacy path; it
- * reports `type: 'wasm'` and is registered by `register-backends.ts`.
- */
-declare class WASMBackend implements MatrixBackend {
-    readonly type: BackendType;
-    private config;
-    private wasmModule;
-    private features;
-    private initPromise;
-    /** Pooled allocations — see `AsAllocCache` for rationale. */
-    private allocCache;
-    constructor(config?: WASMBackendConfig);
-    isAvailable(): boolean;
-    initialize(): Promise<void>;
-    private doInitialize;
-    /**
-     * Resolve the path to the AssemblyScript artifact (`dist/wasm/mathts-as.wasm`).
-     */
-    private resolveAsWasmPath;
-    /**
-     * Compile + instantiate the AssemblyScript WASM artifact. Each
-     * WASMBackend instance owns its own instance — this is intentional so
-     * tests and multiple backend instances can coexist in the same process.
-     */
-    private loadAsModule;
-    /**
-     * WASM is only worth its copy/alloc overhead for compute-dense ops. The 2026-07-01
-     * backend audit (`tools/benchmarks/backend-audit`) measured element-wise / transpose
-     * ops 4–6× SLOWER on WASM than JS (memory-bound; the SIMD matmul kernel is the only
-     * clear win, 9–12×). So WASM is reserved for `opKind: 'matmul'`; everything else stays
-     * on JS via each method's existing `jsBackend` fallback.
-     */
-    private shouldUseWasm;
-    getFeatures(): WasmFeatures | null;
-    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    scale(a: DenseMatrix, scalar: number): DenseMatrix;
-    abs(a: DenseMatrix): DenseMatrix;
-    negate(a: DenseMatrix): DenseMatrix;
-    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    transpose(a: DenseMatrix): DenseMatrix;
-    sum(a: DenseMatrix): number;
-    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
-    norm(a: DenseMatrix): number;
-    dot(a: DenseMatrix, b: DenseMatrix): number;
-    luDecomposition(a: DenseMatrix): Promise<{
-        lu: DenseMatrix;
-        perm: Int32Array;
-        singular: boolean;
-    }>;
-    private luDecompositionJS;
-    qrDecomposition(a: DenseMatrix): Promise<{
-        q: DenseMatrix;
-        r: DenseMatrix;
-    }>;
-    private qrDecompositionJS;
-    inverse(a: DenseMatrix): Promise<{
-        inverse: DenseMatrix;
-        singular: boolean;
-    }>;
-    private inverseJS;
-    determinantWasm(a: DenseMatrix): Promise<number>;
-    private determinantJS;
-    choleskyDecomposition(a: DenseMatrix): Promise<{
-        l: DenseMatrix;
-        positiveDefinite: boolean;
-    }>;
-    private choleskyDecompositionJS;
-    /**
-     * Update configuration
-     */
-    updateConfig(config: Partial<WASMBackendConfig>): void;
-    /**
-     * Get current configuration
-     */
-    getConfig(): Required<WASMBackendConfig>;
-}
-/**
- * Global WASM backend instance (AssemblyScript path)
- */
-declare const wasmBackend: WASMBackend;
-/**
- * Create a WASM backend (AssemblyScript path) with custom configuration
- */
-declare function createWASMBackend(config?: WASMBackendConfig): WASMBackend;
-
-/**
- * GPU Backend for Matrix Operations
- *
- * WebGPU-accelerated matrix operations for large matrices.
- */
-
-/**
- * GPU Backend status
- */
-type GPUBackendStatus = 'uninitialized' | 'initializing' | 'ready' | 'error' | 'unsupported';
-/**
- * Options for GPU backend
- */
-interface GPUBackendOptions extends GPUContextOptions {
-    /** Use global GPU context instead of creating a new one */
-    useGlobalContext?: boolean;
-    /** Buffer pool options */
-    bufferPoolOptions?: {
-        maxCacheSize?: number;
-        evictionTimeout?: number;
-    };
-    /** Threshold for using GPU (matrix size) */
-    threshold?: number;
-}
-/**
- * GPU Backend for accelerated matrix operations
- */
-declare class GPUBackend {
-    private context;
-    private bufferPool;
-    private shaderManager;
-    private _status;
-    private _capabilities;
-    private _lastError;
-    private threshold;
-    private workgroupSize;
-    private useGlobalContext;
-    constructor(options?: GPUBackendOptions);
-    /**
-     * Get the current status
-     */
-    get status(): GPUBackendStatus;
-    /**
-     * Check if backend is ready
-     */
-    get isReady(): boolean;
-    /**
-     * Get capabilities
-     */
-    get capabilities(): GPUCapabilities | null;
-    /**
-     * Get last error
-     */
-    get lastError(): Error | null;
-    /**
-     * Initialize the GPU backend
-     */
-    initialize(options?: GPUBackendOptions): Promise<boolean>;
-    /**
-     * Check if GPU should be used for the given matrix size
-     */
-    shouldUseGPU(rows: number, cols: number): boolean;
-    /**
-     * Calculate workgroup counts for a matrix
-     */
-    calculateWorkgroups(rows: number, cols: number): [number, number, number];
-    /**
-     * Get the GPU context
-     */
-    getContext(): GPUContext;
-    /**
-     * Get the buffer pool
-     */
-    getBufferPool(): BufferPool;
-    /**
-     * Get the shader manager
-     */
-    getShaderManager(): ShaderManager;
-    /**
-     * Add two matrices element-wise
-     */
-    add(a: Float32Array, b: Float32Array, rows: number, cols: number): Promise<Float32Array>;
-    /**
-     * Multiply two matrices
-     */
-    matmul(a: Float32Array, b: Float32Array, M: number, K: number, N: number): Promise<Float32Array>;
-    /**
-     * Transpose a matrix
-     */
-    transpose(a: Float32Array, rows: number, cols: number): Promise<Float32Array>;
-    /**
-     * Scale a matrix by a scalar
-     */
-    scale(a: Float32Array, scalar: number): Promise<Float32Array>;
-    /**
-     * Get backend statistics
-     */
-    getStats(): {
-        status: GPUBackendStatus;
-        capabilities: GPUCapabilities | null;
-        bufferPool: {
-            totalBuffers: number;
-            inUseBuffers: number;
-            cachedBuffers: number;
-        } | null;
-        shaders: {
-            cachedShaders: number;
-            cachedPipelines: number;
-        } | null;
-    };
-    /**
-     * Destroy the backend
-     */
-    destroy(): void;
-}
-/**
- * Get the global GPU backend
- */
-declare function getGlobalGPUBackend(): GPUBackend;
-/**
- * Initialize the global GPU backend
- */
-declare function initializeGlobalGPUBackend(options?: GPUBackendOptions): Promise<boolean>;
-/**
- * Destroy the global GPU backend
- */
-declare function destroyGlobalGPUBackend(): void;
-
-/**
- * GPU Matrix Backend Adapter
- *
- * Adapts GPUBackend to implement the MatrixBackend interface,
- * enabling seamless integration with the backend selection system.
- *
- * @packageDocumentation
- */
-
-/**
- * Configuration for GPU Matrix Backend
- */
-interface GPUMatrixBackendConfig {
-    /** Minimum elements to use GPU (default: 65536 = 256x256) */
-    minElements?: number;
-    /** Use global GPU backend instance */
-    useGlobalBackend?: boolean;
-    /** GPU backend options */
-    gpuOptions?: GPUBackendOptions;
-    /** Fall back to JS on GPU errors */
-    fallbackOnError?: boolean;
-}
-/**
- * GPU Matrix Backend
- *
- * Implements MatrixBackend interface using WebGPU compute shaders.
- * Provides significant acceleration for large matrices.
- *
- * @example
- * ```typescript
- * const gpu = new GPUMatrixBackend();
- * await gpu.initialize();
- *
- * const result = gpu.multiply(matrixA, matrixB);
- * ```
- */
-declare class GPUMatrixBackend implements MatrixBackend {
-    readonly type: BackendType;
-    private config;
-    private backend;
-    private capabilities;
-    private initPromise;
-    private _available;
-    constructor(config?: GPUMatrixBackendConfig);
-    /**
-     * Check if GPU is available in the current environment
-     */
-    isAvailable(): boolean;
-    /**
-     * Initialize the GPU backend
-     */
-    initialize(): Promise<void>;
-    private doInitialize;
-    /**
-     * Check if operation should use GPU
-     */
-    private shouldUseGPU;
-    /**
-     * Execute GPU operation with fallback
-     */
-    private executeWithFallback;
-    /**
-     * Get GPU capabilities
-     */
-    getCapabilities(): GPUCapabilities | null;
-    /**
-     * Get backend statistics
-     */
-    getStats(): ReturnType<GPUBackend['getStats']> | null;
-    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Async add operation using GPU
-     */
-    addAsync(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
-    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    scale(a: DenseMatrix, scalar: number): DenseMatrix;
-    /**
-     * Async scale operation using GPU
-     */
-    scaleAsync(a: DenseMatrix, scalar: number): Promise<DenseMatrix>;
-    abs(a: DenseMatrix): DenseMatrix;
-    negate(a: DenseMatrix): DenseMatrix;
-    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Async matrix multiplication using GPU
-     */
-    multiplyAsync(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
-    transpose(a: DenseMatrix): DenseMatrix;
-    /**
-     * Async transpose using GPU
-     */
-    transposeAsync(a: DenseMatrix): Promise<DenseMatrix>;
-    sum(a: DenseMatrix): number;
-    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
-    norm(a: DenseMatrix): number;
-    dot(a: DenseMatrix, b: DenseMatrix): number;
-    /**
-     * Update configuration
-     */
-    updateConfig(config: Partial<GPUMatrixBackendConfig>): void;
-    /**
-     * Get current configuration
-     */
-    getConfig(): Required<GPUMatrixBackendConfig>;
-    /**
-     * Destroy the backend
-     */
-    destroy(): void;
-}
-/**
- * Global GPU matrix backend instance
- */
-declare const gpuMatrixBackend: GPUMatrixBackend;
-/**
- * Create a GPU matrix backend with custom configuration
- */
-declare function createGPUMatrixBackend(config?: GPUMatrixBackendConfig): GPUMatrixBackend;
-
-/**
- * MathTS Matrix Configuration
- *
- * Centralized configuration for matrix operations, backend selection,
- * and performance tuning.
- *
- * @packageDocumentation
- */
-
-/**
- * Operation type hints for backend selection.
- *
- * Defined here rather than in `BackendManager.ts` so that `config.ts` (the
- * lower-level module) owns it — `BackendManager` already imports `config`, so
- * sourcing the type the other way round closed an import cycle.
- */
-type OperationType = 'add' | 'subtract' | 'multiply' | 'multiplyElementwise' | 'transpose' | 'scale' | 'decomposition' | 'solve' | 'fft' | 'eig' | 'svd';
-
-/**
- * Backend Manager
- *
- * Centralized management for matrix operation backends with automatic
- * selection based on matrix size, operation type, and availability.
- * Includes adaptive threshold tuning based on runtime profiling.
- *
- * @packageDocumentation
- */
-
-/**
- * Extended backend hints with operation-specific thresholds
- */
-interface ExtendedBackendHints extends BackendHints {
-    /** Specific thresholds by operation type */
-    operationThresholds?: Partial<Record<OperationType, {
-        wasm?: number;
-        gpu?: number;
-    }>>;
-    /** Enable automatic SIMD detection for WASM */
-    autoSIMD?: boolean;
-    /** Fallback to JS on backend failure */
-    fallbackOnError?: boolean;
-}
-/**
- * Default extended hints
- */
-declare const DEFAULT_EXTENDED_HINTS: Required<ExtendedBackendHints>;
-/**
- * Centralized Backend Manager
- *
- * Provides a unified interface for executing matrix operations with
- * automatic backend selection based on matrix size and operation type.
- * Features adaptive threshold tuning based on runtime profiling.
- */
-declare class BackendManager {
-    private hints;
-    private initialized;
-    private initializationPromise;
-    private adaptiveState;
-    private configUnsubscribe;
-    constructor(hints?: ExtendedBackendHints);
-    /**
-     * Sync manager state with global config
-     */
-    private syncWithConfig;
-    /**
-     * Initialize all available backends
-     */
-    initialize(): Promise<void>;
-    private doInitialize;
-    /**
-     * Update backend hints
-     */
-    setHints(hints: ExtendedBackendHints): void;
-    /**
-     * Get current hints
-     */
-    getHints(): Required<ExtendedBackendHints>;
-    /**
-     * Get the best backend for a given operation and matrix size.
-     *
-     * Selection priority:
-     *   1. Preferred backend (if explicitly set)
-     *   2. Elements > gpuThreshold -> GPU (if available)
-     *   3. Elements > wasmThreshold -> AS WASM (if loaded)
-     *   4. JS fallback
-     */
-    selectBackend(elementCount: number, operation?: OperationType): MatrixBackend;
-    /**
-     * Execute an operation with automatic backend selection
-     */
-    private executeWithFallback;
-    /**
-     * Matrix addition with auto backend selection
-     */
-    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Matrix subtraction with auto backend selection
-     */
-    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise multiplication with auto backend selection
-     */
-    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise division with auto backend selection
-     */
-    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Scalar multiplication with auto backend selection
-     */
-    scale(a: DenseMatrix, scalar: number): DenseMatrix;
-    /**
-     * Element-wise absolute value with auto backend selection
-     */
-    abs(a: DenseMatrix): DenseMatrix;
-    /**
-     * Element-wise negation with auto backend selection
-     */
-    negate(a: DenseMatrix): DenseMatrix;
-    /**
-     * Matrix multiplication with auto backend selection
-     */
-    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    /**
-     * Matrix transpose with auto backend selection
-     */
-    transpose(a: DenseMatrix): DenseMatrix;
-    /**
-     * Sum of all elements with auto backend selection
-     */
-    sum(a: DenseMatrix): Promise<number>;
-    /**
-     * Sum along axis with auto backend selection
-     */
-    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
-    /**
-     * Frobenius norm with auto backend selection
-     */
-    norm(a: DenseMatrix): number;
-    /**
-     * Dot product with auto backend selection
-     */
-    dot(a: DenseMatrix, b: DenseMatrix): Promise<number>;
-    /**
-     * Get list of available backends
-     */
-    getAvailableBackends(): BackendType[];
-    /**
-     * Check if a specific backend is available
-     */
-    hasBackend(type: BackendType): boolean;
-    /**
-     * Get current active backend for a given operation size
-     */
-    getActiveBackend(elementCount: number, operation?: OperationType): BackendType;
-    /**
-     * Force a specific backend for all operations
-     */
-    forceBackend(type: BackendType | null): void;
-    /**
-     * Record a performance sample for adaptive tuning
-     */
-    recordSample(operation: OperationType, elementCount: number, backend: BackendType, durationMs: number): void;
-    /**
-     * Adjust thresholds based on collected samples
-     */
-    private maybeAdjustThresholds;
-    /**
-     * Get current adaptive thresholds
-     */
-    getAdaptiveThresholds(): Map<OperationType, {
-        wasm: number;
-        gpu: number;
-    }>;
-    /**
-     * Reset adaptive tuning state
-     */
-    resetAdaptiveState(): void;
-    /**
-     * Get performance statistics
-     */
-    getPerformanceStats(): {
-        sampleCount: number;
-        operationStats: Map<OperationType, {
-            avgDuration: number;
-            samples: number;
-            backendUsage: Record<BackendType, number>;
-        }>;
-    };
-    /**
-     * Cleanup resources
-     */
-    destroy(): void;
-}
-/**
- * Default backend manager instance
- */
-declare const backendManager: BackendManager;
-/**
- * Create a new backend manager with custom hints
- */
-declare function createBackendManager(hints?: ExtendedBackendHints): BackendManager;
-
-/**
- * Matrix-domain WGSL kernels.
- *
- * These live in matrix — the @danielsimonjr/mathts-gpu foundation ships no
- * domain kernels. GPUBackend registers them onto a ShaderManager at init.
- */
-
-declare const BUILTIN_SHADERS: {
-    /** Matrix addition shader */
-    readonly matrixAdd: "\n    @group(0) @binding(0) var<storage, read> a: array<f32>;\n    @group(0) @binding(1) var<storage, read> b: array<f32>;\n    @group(0) @binding(2) var<storage, read_write> result: array<f32>;\n    @group(0) @binding(3) var<uniform> params: vec4<u32>; // rows, cols, _, _\n\n    @compute @workgroup_size(16, 16)\n    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n      let rows = params.x;\n      let cols = params.y;\n      let row = gid.y;\n      let col = gid.x;\n\n      if (row >= rows || col >= cols) { return; }\n\n      let idx = row * cols + col;\n      result[idx] = a[idx] + b[idx];\n    }\n  ";
-    /** Matrix subtraction shader */
-    readonly matrixSub: "\n    @group(0) @binding(0) var<storage, read> a: array<f32>;\n    @group(0) @binding(1) var<storage, read> b: array<f32>;\n    @group(0) @binding(2) var<storage, read_write> result: array<f32>;\n    @group(0) @binding(3) var<uniform> params: vec4<u32>;\n\n    @compute @workgroup_size(16, 16)\n    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n      let rows = params.x;\n      let cols = params.y;\n      let row = gid.y;\n      let col = gid.x;\n\n      if (row >= rows || col >= cols) { return; }\n\n      let idx = row * cols + col;\n      result[idx] = a[idx] - b[idx];\n    }\n  ";
-    /** Element-wise multiplication shader */
-    readonly matrixMul: "\n    @group(0) @binding(0) var<storage, read> a: array<f32>;\n    @group(0) @binding(1) var<storage, read> b: array<f32>;\n    @group(0) @binding(2) var<storage, read_write> result: array<f32>;\n    @group(0) @binding(3) var<uniform> params: vec4<u32>;\n\n    @compute @workgroup_size(16, 16)\n    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n      let rows = params.x;\n      let cols = params.y;\n      let row = gid.y;\n      let col = gid.x;\n\n      if (row >= rows || col >= cols) { return; }\n\n      let idx = row * cols + col;\n      result[idx] = a[idx] * b[idx];\n    }\n  ";
-    /** Scalar multiplication shader */
-    readonly scalarMul: "\n    @group(0) @binding(0) var<storage, read> a: array<f32>;\n    @group(0) @binding(1) var<storage, read_write> result: array<f32>;\n    @group(0) @binding(2) var<uniform> params: vec4<f32>; // scalar, length, _, _\n\n    @compute @workgroup_size(256)\n    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n      let scalar = params.x;\n      let length = u32(params.y);\n      let idx = gid.x;\n\n      if (idx >= length) { return; }\n\n      result[idx] = a[idx] * scalar;\n    }\n  ";
-    /** Matrix multiplication (naive) shader */
-    readonly matmul: "\n    @group(0) @binding(0) var<storage, read> a: array<f32>;\n    @group(0) @binding(1) var<storage, read> b: array<f32>;\n    @group(0) @binding(2) var<storage, read_write> result: array<f32>;\n    @group(0) @binding(3) var<uniform> params: vec4<u32>; // M, N, K, _\n\n    @compute @workgroup_size(16, 16)\n    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n      let M = params.x;\n      let N = params.y;\n      let K = params.z;\n      let row = gid.y;\n      let col = gid.x;\n\n      if (row >= M || col >= N) { return; }\n\n      var sum: f32 = 0.0;\n      for (var k: u32 = 0u; k < K; k = k + 1u) {\n        sum = sum + a[row * K + k] * b[k * N + col];\n      }\n\n      result[row * N + col] = sum;\n    }\n  ";
-    /** Matrix transpose shader */
-    readonly transpose: "\n    @group(0) @binding(0) var<storage, read> a: array<f32>;\n    @group(0) @binding(1) var<storage, read_write> result: array<f32>;\n    @group(0) @binding(2) var<uniform> params: vec4<u32>; // rows, cols, _, _\n\n    @compute @workgroup_size(16, 16)\n    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n      let rows = params.x;\n      let cols = params.y;\n      let row = gid.y;\n      let col = gid.x;\n\n      if (row >= rows || col >= cols) { return; }\n\n      result[col * rows + row] = a[row * cols + col];\n    }\n  ";
-    /** Sum reduction shader (first pass) */
-    readonly sumReduce: "\n    @group(0) @binding(0) var<storage, read> input: array<f32>;\n    @group(0) @binding(1) var<storage, read_write> output: array<f32>;\n    @group(0) @binding(2) var<uniform> params: vec4<u32>; // inputLength, outputLength, _, _\n\n    // NOTE: 'shared' is a RESERVED KEYWORD in WGSL — naming this workgroup\n    // array 'shared' made this shader fail to compile, which (because\n    // GPUBackend.initialize() precompiles every registered shader) poisoned\n    // backend init and silently forced ALL GPU ops onto the CPU fallback.\n    var<workgroup> sdata: array<f32, 256>;\n\n    @compute @workgroup_size(256)\n    fn main(\n      @builtin(local_invocation_id) lid: vec3<u32>,\n      @builtin(workgroup_id) wid: vec3<u32>\n    ) {\n      let inputLength = params.x;\n      let idx = wid.x * 512u + lid.x;\n\n      // Load two elements and sum\n      var sum: f32 = 0.0;\n      if (idx < inputLength) {\n        sum = input[idx];\n      }\n      if (idx + 256u < inputLength) {\n        sum = sum + input[idx + 256u];\n      }\n      sdata[lid.x] = sum;\n\n      workgroupBarrier();\n\n      // Reduce within workgroup\n      for (var s: u32 = 128u; s > 0u; s = s >> 1u) {\n        if (lid.x < s) {\n          sdata[lid.x] = sdata[lid.x] + sdata[lid.x + s];\n        }\n        workgroupBarrier();\n      }\n\n      // Write result\n      if (lid.x == 0u) {\n        output[wid.x] = sdata[0];\n      }\n    }\n  ";
-};
-
-/**
- * GPU Batch Executor
- *
- * Manages batched GPU command submission for reduced overhead.
- * Queues multiple operations and executes them together for efficiency.
- *
- * @packageDocumentation
- */
-
-/**
- * Result of batch execution
- */
-interface BatchResult {
-    /** Success status */
-    success: boolean;
-    /** Number of operations executed */
-    operationCount: number;
-    /** Execution time in milliseconds */
-    duration: number;
-    /** Error message if failed */
-    error?: string;
-}
-/**
- * Options for batch execution
- */
-interface BatchOptions {
-    /** Maximum operations per batch before auto-flush */
-    maxBatchSize?: number;
-    /** Auto-flush when batch is full */
-    autoFlush?: boolean;
-    /** Wait for GPU completion before returning */
-    waitForCompletion?: boolean;
-}
-/**
- * GPU Batch Executor
- *
- * Accumulates GPU operations and executes them in batches to reduce
- * command submission overhead. Uses command buffers efficiently.
- *
- * @example
- * ```typescript
- * const executor = new BatchExecutor(context, shaders, bufferPool);
- *
- * executor.add(a, b, output, { rows: 100, cols: 100 });
- * executor.matmul(a, b, output, { rows: 100, cols: 100, k: 100 });
- *
- * await executor.flush();
- * ```
- */
-declare class BatchExecutor {
-    private context;
-    private shaders;
-    private bufferPool;
-    private operations;
-    private options;
-    /**
-     * Create a new batch executor
-     */
-    constructor(context: GPUContext, shaders: ShaderManager, bufferPool: BufferPool, options?: BatchOptions);
-    /**
-     * Get current batch size
-     */
-    get size(): number;
-    /**
-     * Check if batch is empty
-     */
-    get isEmpty(): boolean;
-    /**
-     * Check if batch is full
-     */
-    get isFull(): boolean;
-    /**
-     * Queue an add operation
-     */
-    add(inputA: GPUBuffer, inputB: GPUBuffer, output: GPUBuffer, dimensions: {
-        rows: number;
-        cols: number;
-    }): void;
-    /**
-     * Queue a subtract operation
-     */
-    subtract(inputA: GPUBuffer, inputB: GPUBuffer, output: GPUBuffer, dimensions: {
-        rows: number;
-        cols: number;
-    }): void;
-    /**
-     * Queue an element-wise multiply operation
-     */
-    multiply(inputA: GPUBuffer, inputB: GPUBuffer, output: GPUBuffer, dimensions: {
-        rows: number;
-        cols: number;
-    }): void;
-    /**
-     * Queue a scale operation
-     */
-    scale(input: GPUBuffer, output: GPUBuffer, scalar: number, dimensions: {
-        rows: number;
-        cols: number;
-    }): void;
-    /**
-     * Queue a matrix multiplication operation
-     */
-    matmul(inputA: GPUBuffer, inputB: GPUBuffer, output: GPUBuffer, dimensions: {
-        rows: number;
-        cols: number;
-        k: number;
-    }): void;
-    /**
-     * Queue a transpose operation
-     */
-    transpose(input: GPUBuffer, output: GPUBuffer, dimensions: {
-        rows: number;
-        cols: number;
-    }): void;
-    /**
-     * Queue a sum reduction operation
-     */
-    reduceSum(input: GPUBuffer, output: GPUBuffer, dimensions: {
-        rows: number;
-        cols: number;
-    }): void;
-    /**
-     * Queue operation (internal)
-     */
-    private queueOperation;
-    /**
-     * Flush all queued operations (async)
-     */
-    flush(): Promise<BatchResult>;
-    /**
-     * Flush synchronously (fire and forget)
-     */
-    flushSync(): void;
-    /**
-     * Encode a single operation into the command encoder
-     */
-    private encodeOperation;
-    /**
-     * Get pipeline name for operation type
-     */
-    private getPipelineName;
-    /**
-     * Create params buffer for operation
-     */
-    private createParamsBuffer;
-    /**
-     * Calculate workgroup dispatch counts
-     */
-    private calculateWorkgroups;
-    /**
-     * Clear all queued operations without executing
-     */
-    clear(): void;
-    /**
-     * Get statistics about the batch executor
-     */
-    getStats(): {
-        queuedOperations: number;
-        maxBatchSize: number;
-        autoFlush: boolean;
-    };
-}
-
-/**
- * GPU-CPU Synchronization Strategy
- *
- * Implements efficient patterns for synchronizing data between
- * CPU and GPU memory. Minimizes transfer latency and enables
- * overlapping of CPU and GPU work.
- *
- * @packageDocumentation
- */
-
-/**
- * Synchronization strategy type
- */
-type SyncStrategy = 'immediate' | 'lazy' | 'double-buffer' | 'streaming';
-/**
- * Transfer direction
- */
-type TransferDirection = 'cpu-to-gpu' | 'gpu-to-cpu';
-/**
- * Transfer result
- */
-interface TransferResult {
-    /** Request ID */
-    id: number;
-    /** Success status */
-    success: boolean;
-    /** Transfer time in milliseconds */
-    duration: number;
-    /** Bytes transferred */
-    bytesTransferred: number;
-    /** Error message if failed */
-    error?: string;
-}
-/**
- * Sync configuration
- */
-interface SyncConfig {
-    /** Default strategy */
-    strategy: SyncStrategy;
-    /** Chunk size for streaming (bytes) */
-    chunkSize?: number;
-    /** Maximum pending transfers */
-    maxPendingTransfers?: number;
-    /** Auto-coalesce nearby transfers */
-    coalesceTransfers?: boolean;
-}
-/**
- * GPU-CPU Synchronization Manager
- *
- * Manages data transfer between CPU and GPU with various strategies
- * optimized for different use cases.
- *
- * @example
- * ```typescript
- * const sync = new SyncManager(context, bufferPool, {
- *   strategy: 'double-buffer',
- * });
- *
- * // Upload data to GPU
- * await sync.upload(cpuData, gpuBuffer);
- *
- * // Download results from GPU
- * const result = await sync.download(gpuBuffer);
- * ```
- */
-declare class SyncManager {
-    private context;
-    private config;
-    private pendingTransfers;
-    private nextRequestId;
-    private stagingBuffers;
-    private totalUploads;
-    private totalDownloads;
-    private totalBytesUploaded;
-    private totalBytesDownloaded;
-    constructor(context: GPUContext, _bufferPool: BufferPool, // Reserved for future pool integration
-    config?: Partial<SyncConfig>);
-    /**
-     * Upload data from CPU to GPU
-     */
-    upload(cpuData: Float32Array | Float64Array | Uint32Array | Int32Array, gpuBuffer: GPUBuffer, options?: {
-        offset?: number;
-        size?: number;
-    }): Promise<TransferResult>;
-    /**
-     * Download data from GPU to CPU
-     */
-    download(gpuBuffer: GPUBuffer, options?: {
-        offset?: number;
-        size?: number;
-    }): Promise<Float32Array>;
-    /**
-     * Download data using double-buffering for overlap
-     */
-    downloadDoubleBuffered(gpuBuffer: GPUBuffer, size: number): Promise<Float32Array>;
-    /**
-     * Stream large data in chunks
-     */
-    uploadStreaming(cpuData: Float32Array, gpuBuffer: GPUBuffer, onProgress?: (progress: number) => void): Promise<TransferResult>;
-    /**
-     * Download large data in chunks
-     */
-    downloadStreaming(gpuBuffer: GPUBuffer, totalSize: number, onProgress?: (progress: number) => void): Promise<Float32Array>;
-    /**
-     * Batch multiple transfers
-     */
-    batchTransfer(requests: Array<{
-        data: Float32Array;
-        buffer: GPUBuffer;
-        direction: TransferDirection;
-    }>): Promise<TransferResult[]>;
-    /**
-     * Create or reuse a staging buffer
-     */
-    private getOrCreateStagingBuffer;
-    /**
-     * Round up to next power of 2
-     */
-    private roundToPowerOf2;
-    /**
-     * Wait for all pending transfers to complete
-     */
-    flush(): Promise<void>;
-    /**
-     * Get synchronization statistics
-     */
-    getStats(): {
-        totalUploads: number;
-        totalDownloads: number;
-        totalBytesUploaded: number;
-        totalBytesDownloaded: number;
-        pendingTransfers: number;
-        stagingBuffersCount: number;
-        strategy: SyncStrategy;
-    };
-    /**
-     * Destroy sync manager and release resources
-     */
-    destroy(): void;
-}
-/**
- * Create a sync manager with the recommended configuration
- */
-declare function createSyncManager(context: GPUContext, bufferPool: BufferPool, strategy?: SyncStrategy): SyncManager;
-
-/**
- * Eigenvalue and Eigenvector Decomposition
- *
- * Implements eigenvalue computation using QR algorithm and
- * eigenvector extraction using inverse iteration.
- */
-/**
- * Result of eigenvalue decomposition
- */
-interface EigResult {
-    /** Eigenvalues (may be complex for non-symmetric matrices) */
-    values: Array<{
-        re: number;
-        im: number;
-    }>;
-    /**
-     * Eigenvectors as columns (each column is an eigenvector). For a real
-     * eigenvalue this is the full (real) eigenvector, unit-normalised. For a
-     * complex-conjugate eigenvalue pair this holds the REAL PART of the
-     * corresponding complex eigenvector — see {@link vectorsIm} for the
-     * imaginary part.
-     */
-    vectors: number[][];
-    /**
-     * Imaginary parts of the eigenvector columns (same shape as {@link vectors}).
-     * All-zero for real eigenvalues. For a complex-conjugate eigenvalue pair at
-     * indices `j`/`j+1`, the full complex eigenvectors are
-     * `vectors[j] + i*vectorsIm[j]` (for `values[j]`) and
-     * `vectors[j+1] - i*vectorsIm[j] === vectors[j+1] + i*vectorsIm[j+1]` (for
-     * the conjugate `values[j+1]`), each unit-normalised by the complex 2-norm
-     * `sqrt(sum(re_i^2 + im_i^2))`.
-     */
-    vectorsIm: number[][];
-    /** Whether the matrix was symmetric */
-    isSymmetric: boolean;
-}
-/**
- * Options for eigenvalue computation
- */
-interface EigOptions {
-    /** Maximum number of QR iterations */
-    maxIterations?: number;
-    /** Convergence tolerance */
-    tolerance?: number;
-    /** Whether to compute eigenvectors */
-    computeVectors?: boolean;
-}
-/**
- * Compute eigenvalues and eigenvectors of a square matrix
- * Uses QR algorithm with implicit shifts
- *
- * @param matrix - Square matrix (n x n)
- * @param options - Computation options
- * @returns Eigenvalues and eigenvectors
- */
-declare function eig(matrix: number[][] | Float64Array, options?: EigOptions): EigResult;
-/**
- * Compute only eigenvalues (faster, no eigenvector computation)
- */
-declare function eigvals(matrix: number[][] | Float64Array, options?: Omit<EigOptions, 'computeVectors'>): Array<{
-    re: number;
-    im: number;
-}>;
-/**
- * Power iteration for dominant eigenvalue
- * Faster than full eigendecomposition when only largest eigenvalue needed
- */
-declare function powerIteration(matrix: number[][], options?: {
-    maxIterations?: number;
-    tolerance?: number;
-}): {
-    value: number;
-    vector: number[];
-};
-
-/**
- * Singular Value Decomposition (SVD)
- *
- * Implements SVD using Golub-Reinsch bidiagonalization and implicit QR.
- * A = U * S * V^T where:
- *   - U: m x m orthogonal matrix (left singular vectors)
- *   - S: m x n diagonal matrix (singular values)
- *   - V: n x n orthogonal matrix (right singular vectors)
- */
-/**
- * Result of SVD decomposition
- */
-interface SVDResult {
-    /** Left singular vectors (m x m) */
-    U: number[][];
-    /** Singular values (min(m,n) values) */
-    S: number[];
-    /** Right singular vectors (n x n) */
-    V: number[][];
-    /** Rank estimate */
-    rank: number;
-}
-/**
- * Options for SVD computation
- */
-interface SVDOptions {
-    /** Maximum number of iterations */
-    maxIterations?: number;
-    /** Convergence tolerance */
-    tolerance?: number;
-    /**
-     * Complete the thin factor to a square orthonormal basis (U → m×m for tall
-     * inputs, V → n×n for wide ones), numpy `full_matrices=True` style, so the
-     * rectangular-Σ reconstruction `A = U·Σ·Vᵀ` holds. Default `false` = thin
-     * factors (the library's long-standing behavior; the option was previously
-     * accepted but ignored — B-4).
-     */
-    fullMatrices?: boolean;
-    /** Threshold for rank determination */
-    rankTolerance?: number;
-}
-declare function svd(matrix: number[][] | Float64Array, options?: SVDOptions): SVDResult;
-/**
- * Compute only singular values (faster than full SVD)
- */
-declare function singularValues(matrix: number[][] | Float64Array, options?: Omit<SVDOptions, 'fullMatrices'>): number[];
-/**
- * Compute the pseudoinverse (Moore-Penrose inverse) using SVD
- */
-declare function pinv$1(matrix: number[][], options?: SVDOptions): number[][];
-/**
- * Low-rank approximation using SVD
- * Keeps only the top r singular values
- */
-declare function lowRankApprox(matrix: number[][], r: number, options?: SVDOptions): number[][];
-/**
- * Compute condition number using SVD
- */
-declare function cond(matrix: number[][], options?: SVDOptions): number;
-/**
- * Compute matrix norm using SVD
- * Returns the spectral norm (largest singular value)
- */
-declare function norm2(matrix: number[][], options?: SVDOptions): number;
-/**
- * Compute Frobenius norm using SVD
- * Equals sqrt(sum of squared singular values)
- */
-declare function normFro(matrix: number[][]): number;
-
-/**
- * `eigWasm` / `eigvalsWasm` / `spectralRadiusWasm` — thin wrappers kept for API
- * compatibility (consumed by `tensor` and `linalg`).
- *
- * The WASM eig path was RETIRED and REMOVED (2026-07-01): the AssemblyScript Jacobi
- * (symmetric) / Hessenberg+Francis (general) kernels were scalar + async and measured
- * 0.2–0.7× of the pure-JS path, worsening with size (~5× slower at 128²) — see
- * `tools/benchmarks/decomp-audit`. Since a genuinely fast version would be a from-scratch
- * SIMD implementation (not the removed scalar code), these now simply delegate to the
- * synchronous JS `eig` / `eigvals` / `powerIteration`. The `async` signature is retained so
- * existing callers (which `await`) are unaffected.
- *
- * @packageDocumentation
- */
-
-/**
- * Eigendecomposition. Delegates to the JS {@link eig} (WASM path retired — see file header).
- */
-declare function eigWasm(matrix: number[][], options?: EigOptions): Promise<EigResult>;
-/**
- * Eigenvalues only. Delegates to the JS {@link eigvals} (WASM path retired).
- */
-declare function eigvalsWasm(matrix: number[][], options?: Omit<EigOptions, 'computeVectors'>): Promise<Array<{
-    re: number;
-    im: number;
-}>>;
-/**
- * Spectral radius (|largest eigenvalue|). Delegates to the JS {@link powerIteration}
- * (WASM path retired).
- */
-declare function spectralRadiusWasm(matrix: number[][], options?: {
-    maxIterations?: number;
-    tolerance?: number;
-}): Promise<number>;
-
-/**
- * `svdWasm` — thin wrapper kept for API compatibility (consumed by `tensor` and `linalg`).
- *
- * The WASM SVD path was RETIRED and REMOVED (2026-07-01): the AssemblyScript one-sided
- * Jacobi kernel was scalar + async and measured 0.4–0.7× of the pure-JS Golub-Reinsch
- * {@link svd}, worsening with size — see `tools/benchmarks/decomp-audit`. It now delegates
- * to the JS `svd`, truncated to the **thin / economy** form (`U` is `m×k`, `V` is `n×k`,
- * `k = min(m, n)`) so the result shape is unchanged. The `async` signature is retained so
- * existing callers (which `await`) are unaffected.
- *
- * @packageDocumentation
- */
-
-/**
- * Thin SVD. Delegates to the JS {@link svd} and truncates to the economy form
- * (WASM path retired — see file header).
- *
- * @param matrix - Input matrix (m x n) as a row-major 2D array
- * @param options - SVD options; `rankTolerance` controls the rank estimate
- * @returns thin SVD `{ U (m x k), S (k), V (n x k), rank }`
- */
-declare function svdWasm(matrix: number[][], options?: SVDOptions): Promise<SVDResult>;
-
-/**
- * Moore-Penrose Pseudoinverse (DenseMatrix primitive)
- *
- * Computes the pseudoinverse A⁺ of a DenseMatrix A via full SVD with
- * rcond·max(S) singular-value thresholding.
- *
- * Algorithm:
- *   1. Full SVD:   A = U · diag(S) · Vᵀ   (A is m×n)
- *      U: m×m orthogonal, V: n×n orthogonal, S: min(m,n) values (descending).
- *   2. Threshold:  s_inv_i = 1/s_i  if  s_i > rcond·max(S),  else 0.
- *   3. Build:      A⁺ = V · diag(s_inv) · Uᵀ   (shape: n×m).
- *
- * Satisfies all four Moore-Penrose identities within numerical precision:
- *   A · A⁺ · A  = A
- *   A⁺ · A · A⁺ = A⁺
- *   (A · A⁺)ᵀ   = A · A⁺
- *   (A⁺ · A)ᵀ   = A⁺ · A
- */
-
-interface PinvOptions {
-    /**
-     * Relative condition threshold for singular-value truncation.
-     * A singular value s_i is treated as zero when s_i ≤ rcond · max(S).
-     * Default: 1e-10.
-     */
-    rcond?: number;
-}
-/**
- * Compute the Moore-Penrose pseudoinverse of a DenseMatrix.
- *
- * @param A    - Input matrix (m × n).
- * @param opts - Optional rcond threshold (default 1e-10).
- * @returns    A⁺, the pseudoinverse of A (n × m).
- */
-declare function pinv(A: DenseMatrix, opts?: PinvOptions): DenseMatrix;
-
-/**
- * QR Decomposition (DenseMatrix primitive)
- *
- * Classical Gram-Schmidt with re-orthogonalisation. Adequate for the
- * well-conditioned matrices that arise in the tensor wrappers + the
- * `randomTensor` orthogonal-distribution code path. For pathological
- * matrices the Householder QR implemented in `WASMBackend.qrDecompositionJS`
- * is preferable, but Gram-Schmidt suffices for the current call sites.
- *
- * Two modes:
- *   - 'reduced' (thin QR): Q is (m × k), R is (k × n), k = min(m, n).
- *   - 'full'             : Q is (m × m), R is (m × n).
- *
- * In 'reduced' mode A = Q · R reconstructs A to within `1e-12`.
- * Q's columns are orthonormal (Qᵀ · Q = I_k); R is upper-triangular.
- */
-
-interface QRResult {
-    /** Orthonormal Q factor. Reduced: (m × k); full: (m × m). */
-    Q: DenseMatrix;
-    /** Upper-triangular R factor. Reduced: (k × n); full: (m × n). */
-    R: DenseMatrix;
-}
-interface QROptions {
-    /** 'reduced' (default, thin QR) or 'full'. */
-    mode?: 'reduced' | 'full';
-}
-/**
- * Compute the QR decomposition of `A` such that `A = Q · R`.
- *
- * @param A    - Input matrix (m × n, m ≥ 0, n ≥ 0).
- * @param opts - Optional mode selector (`'reduced'` thin QR or `'full'` square Q).
- */
-declare function qr(A: DenseMatrix, opts?: QROptions): QRResult;
-
-/**
- * LU Decomposition (DenseMatrix primitive)
- *
- * Doolittle's algorithm with partial (row) pivoting. Factorises a square
- * matrix A into P · A = L · U where:
- *   - L is unit lower-triangular (1s on the diagonal).
- *   - U is upper-triangular.
- *   - P is returned as a row-permutation array: P[i] is the original-row
- *     index now at position i after pivoting.
- *
- * Usage:
- *   const { L, U, P } = lu(A);
- *   // P[i] gives the original row moved to position i, so P · A = L · U.
- */
-
-interface LUResult {
-    /** Unit lower-triangular factor L. */
-    L: DenseMatrix;
-    /** Upper-triangular factor U. */
-    U: DenseMatrix;
-    /** Row permutation array of length n. P[i] is the original-row index now at position i. */
-    P: number[];
-}
-/**
- * Perform LU decomposition with partial pivoting on a square `DenseMatrix`.
- *
- * Implements Doolittle's algorithm in compact form: the working array stores
- * L below the diagonal (unit diagonal implicit) and U on and above it.
- *
- * @throws {Error} if `A` is not square.
- * @throws {Error} if `A` is singular (zero pivot encountered).
- */
-declare function lu(A: DenseMatrix): LUResult;
-/**
- * Solve the dense linear system `A · x = b` using a precomputed LU factorisation
- * (from {@link lu}), where `P · A = L · U`.
- *
- * Applies the row permutation to `b` (`(P·b)[i] = b[P[i]]`), forward-substitutes
- * the unit-lower-triangular `L`, then back-substitutes the upper-triangular `U`.
- * Each call is O(n²), so factor **once** with `lu()` and call `luSolve` repeatedly
- * to solve many right-hand sides against the same matrix — the pattern the stiff
- * Rosenbrock/RODAS ODE steps use (the iteration matrix is solved against 3–6
- * successive RHS per step).
- *
- * @param fac An `LUResult` produced by {@link lu}.
- * @param b   Right-hand side vector of length `n` (`number[]` or `Float64Array`).
- * @returns   The solution vector `x` as a `number[]` of length `n`.
- * @throws {Error} if `b.length` does not equal the factor dimension `n`.
- */
-declare function luSolve(fac: LUResult, b: ArrayLike<number>): number[];
-
-/**
- * Cholesky Decomposition (DenseMatrix primitive)
- *
- * Right-looking algorithm. Factorises a symmetric positive-definite (SPD)
- * matrix A into A = L · Lᵀ where L is lower-triangular.
- *
- * Usage:
- *   const { L } = cholesky(A);
- *   // A ≈ L · L^T  (to floating-point precision)
- */
-
-interface CholeskyResult {
-    /** Lower-triangular Cholesky factor L such that A = L · Lᵀ. */
-    L: DenseMatrix;
-}
-/**
- * Compute the Cholesky decomposition of the symmetric positive-definite
- * `DenseMatrix` A such that A = L · Lᵀ.
- *
- * @throws {Error} if `A` is not square.
- * @throws {Error} if `A` is not positive definite (non-positive diagonal pivot).
- */
-declare function cholesky(A: DenseMatrix): CholeskyResult;
-
-/**
- * Matrix Exponential — Scaling-and-Squaring with Padé-13 Approximant
- *
- * Implements Algorithm 10.20 from:
- *   Higham, N. J. (2005). "The scaling and squaring method for the matrix
- *   exponential revisited." SIAM J. Matrix Anal. Appl., 26(4), 1179–1193.
- *
- * Algorithm:
- *   1. Compute s = max(0, ceil(log2(||A||_1 / θ_13))) where θ_13 ≈ 5.372.
- *   2. Scale: B = A / 2^s.
- *   3. Compute the [13/13] Padé approximant R(B) = (U + V)^{-1} * (-U + V).
- *   4. Square s times: expm(A) = R(B)^(2^s).
- *
- * Works for any real square DenseMatrix. For large ||A||, uses scaling to
- * stay within the Padé approximant's accuracy radius.
- */
-
-interface ExpmOptions {
-    /**
-     * When true, return the result as a DenseMatrix.
-     * When false (default), work directly on the internal number[][] and
-     * return as DenseMatrix anyway — this option is reserved for future use.
-     */
-    _reserved?: never;
-}
-/**
- * Compute the matrix exponential of a square DenseMatrix.
- *
- * Uses the Padé-13 scaling-and-squaring algorithm (Higham 2005).
- * Accurate to near machine precision for general real matrices.
- *
- * @param A - Square DenseMatrix (n × n).
- * @returns expm(A) as a DenseMatrix (n × n).
- * @throws Error if A is not square.
- *
- * @example
- * // expm(0) = I
- * matrixExpm(DenseMatrix.zeros(3, 3)) // => identity 3×3
- *
- * @example
- * // expm(t*I) = e^t * I
- * const tI = DenseMatrix.fromArray([[2,0],[0,2]]);
- * matrixExpm(tI) // => [[e^2, 0], [0, e^2]]
- */
-declare function matrixExpm(A: DenseMatrix): DenseMatrix;
-
-/**
- * Matrix Logarithm — Schur-Padé inverse scaling-and-squaring (Slices 5.9a + 6.1)
- *
- * Implements the Schur-Padé algorithm based on:
- *   Higham (2008) "Functions of Matrices: Theory and Computation," Chapter 11
- *   (Algorithm 11.10).
- *
- * Algorithm (general Schur-based path, Slice 6.1):
- *   1. Schur decompose: A = Q · T · Q^T.
- *   2. Repeatedly take matrix square roots of T (Björck recurrence on upper-
- *      triangular matrices) until ||T^{1/2^k} - I||_1 < 0.25.
- *   3. Evaluate log(I + X) via 16-point Gauss-Legendre quadrature.
- *   4. Scale back by 2^k; rotate by Q: logm(A) = Q · (2^k · log(T^{1/2^k})) · Q^T.
- *
- * For the eig-based fallback (diagonalisable matrices with positive real
- * eigenvalues): logm(A) = V · diag(log(λ)) · V^{-1}.
- */
-
-interface LogmOptions {
-    /**
-     * Tolerance for the "near-identity" test.
-     * Default: 0.25 (||M - I||_1 < tol triggers Padé path).
-     */
-    nearIdentityTol?: number;
-}
-/**
- * Compute the principal matrix logarithm of a square DenseMatrix.
- *
- * Algorithm (Slice 5.9a — inverse scaling-and-squaring + Padé quadrature):
- *   1. Repeatedly take matrix square roots until ||M - I||_1 < nearIdentityTol.
- *   2. Evaluate log(I + X) = X * ∫₀¹ (I + tX)^{-1} dt via 7-pt Gauss-Legendre.
- *   3. Scale back: logm(A) = 2^k * log(A^{1/2^k}).
- *
- * Falls back to eigendecomposition if the square-root sequence diverges
- * (i.e., if the matrix has no non-positive eigenvalues and is diagonalisable).
- *
- * Limitations (deferred to Slice 5.9b):
- *   - Matrices with non-positive real eigenvalues: principal log is undefined.
- *   - Matrices with complex eigenvalues: throws.
- *   - Non-diagonalisable (defective) matrices: eig-fallback also throws.
- *   - Full Schur-based inverse-scaling-and-squaring for general non-normal
- *     matrices.
- *
- * @param A - Square DenseMatrix with positive real eigenvalues.
- * @returns logm(A) as a DenseMatrix.
- * @throws Error for matrices with non-positive or complex eigenvalues.
- *
- * @example
- * // logm(I) = 0
- * matrixLogm(DenseMatrix.eye(3)) // => zero matrix
- *
- * @example
- * // Round-trip: expm(logm(A)) ≈ A
- * const A = DenseMatrix.fromArray([[4, 1], [0, 9]]);
- * const logA = matrixLogm(A);
- * // expm(logA) ≈ A  (to machine precision for diagonalisable A)
- */
-declare function matrixLogm(A: DenseMatrix, opts?: LogmOptions): DenseMatrix;
-
-/**
- * Matrix Square Root — Hybrid approach (Slices 5.9a + 6.1)
- *
- * Computes the principal square root of a square matrix.
- *
- * Algorithm selection:
- *   1. For symmetric positive semi-definite matrices: symmetric eigendecomposition
- *      with Gram-Schmidt re-orthogonalisation (handles repeated eigenvalues).
- *   2. For general matrices: Björck-Hammarling Schur-based algorithm
- *      (Higham 2008, Algorithm 6.3):
- *        a. Schur decompose: A = Q · T · Q^T.
- *        b. Compute upper-triangular U with U^2 = T via back-substitution.
- *        c. Rotate back: sqrtm(A) = Q · U · Q^T.
- *      Falls back to Newton iteration for diagonalisable matrices when the
- *      Schur path is unsuitable (e.g. negative eigenvalues in 1×1 blocks).
- *
- * References:
- *   - Higham (2008) "Functions of Matrices" §6 (Algorithm 6.3).
- *   - Björck & Hammarling (1983) "A Schur method for the square root of a matrix."
- */
-
-interface SqrtmOptions {
-    /**
-     * Force the symmetric-eigendecomposition path even for non-SPD matrices.
-     * By default, symmetry is auto-detected.
-     */
-    assumeSymmetric?: boolean;
-}
-/**
- * Compute the principal square root of a square DenseMatrix.
- *
- * For symmetric positive semi-definite A:
- *   Uses symmetric eigendecomposition with Gram-Schmidt re-orthogonalisation.
- *
- * For general diagonalisable A with non-negative eigenvalues:
- *   Uses Newton iteration Y_{k+1} = (Y_k + A * Y_k^{-1}) / 2, falling back
- *   to the eig-based formula if Newton fails to converge.
- *
- * Slice 5.9a limitations:
- *   - Matrices with negative real eigenvalues: throws.
- *   - Matrices with complex eigenvalues: throws.
- *   - Non-diagonalisable (defective) matrices: Newton may fail + eig fallback
- *     may also fail. Full Schur-based Björck-Hammarling deferred to Slice 5.9b.
- *
- * @param A    - Square DenseMatrix (n × n).
- * @param opts - Optional flags.
- * @returns sqrtm(A), the principal square root.
- * @throws Error for matrices with negative or complex eigenvalues.
- *
- * @example
- * // sqrtm(I) = I
- * matrixSqrtm(DenseMatrix.eye(3))  // => identity 3×3
- *
- * @example
- * // sqrtm(4*I) = 2*I
- * const A = DenseMatrix.fromArray([[4,0],[0,4]]);
- * matrixSqrtm(A)  // => [[2,0],[0,2]]
- *
- * @example
- * // Round-trip: sqrtm(A)^2 ≈ A
- * const S = DenseMatrix.fromArray([[4,2],[2,3]]);
- * const R = matrixSqrtm(S);
- * // R * R ≈ S  (to machine precision for SPD matrices)
- */
-declare function matrixSqrtm(A: DenseMatrix, opts?: SqrtmOptions): DenseMatrix;
-
-/**
- * Schur Decomposition — Francis QR with double shifts (Slice 6.1)
- *
- * Computes the real Schur decomposition A = Q · T · Q^T where:
- *   - Q is orthogonal (Q^T · Q = I)
- *   - T is quasi-upper-triangular (real Schur form): diagonal blocks are
- *     1×1 (real eigenvalue) or 2×2 (complex-conjugate eigenvalue pair)
- *
- * Algorithm: Householder reduction to upper Hessenberg form followed by
- * Francis double-shift implicit QR iteration (Golub & Van Loan §7.5).
- *
- * References:
- *   Golub & Van Loan (2013) "Matrix Computations," 4th ed., §7.5.
- *   Higham (2008) "Functions of Matrices: Theory and Computation," §1.
- */
-
-interface SchurResult {
-    /** Orthogonal factor Q (Q^T · Q = I, Q · Q^T = I). */
-    Q: DenseMatrix;
-    /** Quasi-upper-triangular Schur form T (real Schur form). */
-    T: DenseMatrix;
-}
-interface SchurOptions {
-    /** Maximum QR iterations (default: 1000). */
-    maxIterations?: number;
-    /** Deflation tolerance (default: 1e-12). */
-    tolerance?: number;
-}
-/**
- * Compute the real Schur decomposition of a square matrix:
- *   A = Q · T · Q^T
- *
- * T is quasi-upper-triangular (real Schur form): 1×1 diagonal blocks for
- * real eigenvalues and 2×2 blocks for complex-conjugate pairs. Q is
- * orthogonal.
- *
- * For matrices with all real eigenvalues, T is upper triangular with
- * eigenvalues on the diagonal. For matrices with complex-conjugate eigenvalue
- * pairs, the corresponding 2×2 diagonal block has the form
- *   [[a, b], [-b, a]]  (approximately)
- * and the complex pair is  a ± bi.
- *
- * @param A - Square DenseMatrix (n × n, real entries).
- * @param opts - Optional algorithm parameters.
- * @returns { Q, T } satisfying Q · T · Q^T ≈ A.
- * @throws Error if A is not square.
- */
-declare function matrixSchur(A: DenseMatrix, opts?: SchurOptions): SchurResult;
-
-/**
- * Rank-Revealing Pivoted QR Decomposition (Businger-Golub column pivoting)
- *
- * Computes `A[:, P] = Q · R` via Householder reflections, choosing at each
- * step the remaining column of largest norm as the next pivot. This is the
- * classical column-pivoted QR (LAPACK `dgeqp3`'s algorithm, simplified —
- * exact remaining-column-norm recomputation rather than the cheaper
- * downdating formula, since these matrices are small): it guarantees
- * `|R[0,0]| ≥ |R[1,1]| ≥ … ≥ |R[k-1,k-1]|`, which makes `R`'s diagonal a
- * reliable numerical-rank indicator — unlike the plain (unpivoted)
- * Gram-Schmidt `qr()` in this directory, whose diagonal can be small for an
- * early column purely by column order, not by rank deficiency.
- *
- * Reuses the Householder helpers in `./common.js` (already exercised by
- * `svd.ts`/`schur.ts`) rather than re-deriving reflection algebra here.
- */
-
-interface QRPivotedResult {
-    /** Orthonormal Q factor (m × k, k = min(m, n)). */
-    Q: DenseMatrix;
-    /** Upper-triangular R factor (k × n) with |diag(R)| non-increasing. */
-    R: DenseMatrix;
-    /** Column permutation: `P[j]` is the original column index now at position `j`, so `A[:, P] = Q · R`. */
-    P: number[];
-    /** Numerical rank: count of `i` with `|R[i,i]| > tolerance · |R[0,0]|`. */
-    rank: number;
-}
-interface QRPivotedOptions {
-    /** Relative rank tolerance (default `1e-10`). */
-    tolerance?: number;
-}
-/**
- * Compute the column-pivoted rank-revealing QR decomposition of `A`.
- *
- * @param A    - Input matrix (m × n).
- * @param opts - Optional rank tolerance.
- */
-declare function qrPivoted(A: DenseMatrix, opts?: QRPivotedOptions): QRPivotedResult;
-
-/**
- * QR-family decompositions: LQ, RQ, QL
- *
- * Each is derived from the existing Gram-Schmidt `qr()` primitive in this
- * directory via the standard flip/transpose reductions (Golub & Van Loan,
- * *Matrix Computations*, §5.2):
- *
- *   - **LQ** (`A = L·Q`, L lower-triangular): `qr(Aᵀ)` transposed — no flips
- *     needed. If `Aᵀ = Q₁·R₁` then `A = R₁ᵀ·Q₁ᵀ`, so `L = R₁ᵀ`, `Q = Q₁ᵀ`.
- *   - **RQ** (`A = R·Q`, R upper-triangular): reverse `A`'s row order,
- *     transpose, run `qr()`, then un-flip the resulting factors.
- *   - **QL** (`A = Q·L`, L lower-triangular): reverse `A`'s column order,
- *     run `qr()`, then un-flip the resulting factors.
- *
- * All three share `qr()`'s reduced-QR convention: for an m×n input the thin
- * factor pairing is (m×k, k×n) with k = min(m, n).
- */
-
-interface LQResult {
-    /** Lower-triangular (trapezoidal) factor. m × k, k = min(m, n). */
-    L: DenseMatrix;
-    /** Orthonormal-row factor (Q · Qᵀ = I). k × n. */
-    Q: DenseMatrix;
-}
-interface RQResult {
-    /** Upper-triangular (trapezoidal) factor. m × k, k = min(m, n). */
-    R: DenseMatrix;
-    /** Orthonormal-row factor (Q · Qᵀ = I). k × n. */
-    Q: DenseMatrix;
-}
-interface QLResult {
-    /** Orthonormal-column factor (Qᵀ · Q = I). m × k, k = min(m, n). */
-    Q: DenseMatrix;
-    /** Lower-triangular (trapezoidal) factor. k × n. */
-    L: DenseMatrix;
-}
-/**
- * LQ decomposition: `A = L · Q` with `L` lower-triangular and `Q` having
- * orthonormal rows (`Q · Qᵀ = I`).
- */
-declare function lq(A: DenseMatrix): LQResult;
-/**
- * RQ decomposition: `A = R · Q` with `R` upper-triangular and `Q` having
- * orthonormal rows (`Q · Qᵀ = I`).
- */
-declare function rq(A: DenseMatrix): RQResult;
-/**
- * QL decomposition: `A = Q · L` with `Q` having orthonormal columns
- * (`Qᵀ · Q = I`) and `L` lower-triangular.
- */
-declare function ql(A: DenseMatrix): QLResult;
-
-/**
- * Condition-number ESTIMATE (Hager/Higham 1-norm power-iteration estimator)
- *
- * Estimates `‖A‖₁ · ‖A⁻¹‖₁` without ever forming `A⁻¹` explicitly — Hager's
- * algorithm (Hager 1984; Higham 1988's practical refinement) needs only the
- * ability to apply `A⁻¹` and `A⁻ᵀ` to a vector, which is done here via the
- * existing `lu()` primitive's triangular factors (forward/back substitution,
- * O(n²) per application vs. O(n³) to form `A⁻¹` or run the SVD-based exact
- * `cond()` in `svd.ts`). The result is an ESTIMATE — typically a lower bound
- * on the true `‖A⁻¹‖₁`, usually within a small constant factor — not the
- * exact value.
- */
-
-/**
- * Estimate the 1-norm condition number `‖A‖₁ · ‖A⁻¹‖₁` of a square matrix.
- *
- * This is an ESTIMATE (Hager/Higham power iteration), not the exact
- * condition number that `cond()` (in `svd.ts`) computes via a full SVD —
- * `condest` is O(n²)-per-iteration and avoids forming `A⁻¹`, at the cost of
- * being a (typically close) lower-bound estimate rather than an exact value.
- *
- * @param A - Square input matrix.
- * @param p - Only the 1-norm (`p = 1`, the default) is currently implemented.
- * @throws {Error} if `A` is not square, or `p !== 1`.
- */
-declare function condest(A: DenseMatrix, p?: number): number;
-
-/**
- * Typed Matrix Operations
- *
- * Polymorphic matrix operations using typed-function for runtime dispatch.
- * Supports operations on DenseMatrix with automatic type coercion.
- *
- * @packageDocumentation
- */
-/**
- * Create a matrix from various input types
- */
-declare const matrix: typed_function.TypedFunction;
-/**
- * Create an identity matrix
- */
-declare const identity: typed_function.TypedFunction;
-/**
- * Create a matrix of zeros
- */
-declare const zeros: typed_function.TypedFunction;
-/**
- * Create a matrix of ones
- */
-declare const ones: typed_function.TypedFunction;
-/**
- * Create a diagonal matrix
- */
-declare const diag: typed_function.TypedFunction;
-/**
- * Create a random matrix
- */
-declare const random: typed_function.TypedFunction;
-/**
- * Matrix addition - polymorphic add function
- */
-declare const add: typed_function.TypedFunction;
-/**
- * Matrix subtraction
- */
-declare const subtract: typed_function.TypedFunction;
-/**
- * Matrix multiplication (matmul)
- */
-declare const multiply: typed_function.TypedFunction;
-/**
- * Element-wise multiplication (Hadamard product)
- */
-declare const dotMultiply: typed_function.TypedFunction;
-/**
- * Matrix division (A / B where B is scalar or element-wise)
- */
-declare const divide: typed_function.TypedFunction;
-/**
- * Matrix negation
- */
-declare const unaryMinus: typed_function.TypedFunction;
-/**
- * Matrix transpose
- */
-declare const transpose: typed_function.TypedFunction;
-/**
- * Sum of all elements
- */
-declare const sum: typed_function.TypedFunction;
-/**
- * Mean of all elements
- */
-declare const mean: typed_function.TypedFunction;
-/**
- * Minimum element
- */
-declare const min: typed_function.TypedFunction;
-/**
- * Maximum element
- */
-declare const max: typed_function.TypedFunction;
-/**
- * Frobenius norm
- */
-declare const norm: typed_function.TypedFunction;
-/**
- * Matrix trace (sum of diagonal elements)
- */
-declare const trace: typed_function.TypedFunction;
-/**
- * Element-wise absolute value
- */
-declare const abs: typed_function.TypedFunction;
-/**
- * Element-wise square root
- */
-declare const sqrt: typed_function.TypedFunction;
-/**
- * Element-wise square
- */
-declare const square: typed_function.TypedFunction;
-/**
- * Element-wise exponential
- */
-declare const exp: typed_function.TypedFunction;
-/**
- * Element-wise natural logarithm
- */
-declare const log: typed_function.TypedFunction;
-/**
- * Element-wise power
- */
-declare const pow: typed_function.TypedFunction;
-/**
- * Get matrix dimensions
- */
-declare const size: typed_function.TypedFunction;
-/**
- * Get element at position
- */
-declare const subset: typed_function.TypedFunction;
-/**
- * Get row from matrix
- */
-declare const row: typed_function.TypedFunction;
-/**
- * Get column from matrix
- */
-declare const column: typed_function.TypedFunction;
-/**
- * Get diagonal from matrix
- */
-declare const diagonal: typed_function.TypedFunction;
-declare const typedMatrixOperations: {
-    matrix: typed_function.TypedFunction;
-    identity: typed_function.TypedFunction;
-    zeros: typed_function.TypedFunction;
-    ones: typed_function.TypedFunction;
-    diag: typed_function.TypedFunction;
-    random: typed_function.TypedFunction;
-    add: typed_function.TypedFunction;
-    subtract: typed_function.TypedFunction;
-    multiply: typed_function.TypedFunction;
-    dotMultiply: typed_function.TypedFunction;
-    divide: typed_function.TypedFunction;
-    unaryMinus: typed_function.TypedFunction;
-    transpose: typed_function.TypedFunction;
-    sum: typed_function.TypedFunction;
-    mean: typed_function.TypedFunction;
-    min: typed_function.TypedFunction;
-    max: typed_function.TypedFunction;
-    norm: typed_function.TypedFunction;
-    trace: typed_function.TypedFunction;
-    abs: typed_function.TypedFunction;
-    sqrt: typed_function.TypedFunction;
-    square: typed_function.TypedFunction;
-    exp: typed_function.TypedFunction;
-    log: typed_function.TypedFunction;
-    pow: typed_function.TypedFunction;
-    size: typed_function.TypedFunction;
-    subset: typed_function.TypedFunction;
-    row: typed_function.TypedFunction;
-    column: typed_function.TypedFunction;
-    diagonal: typed_function.TypedFunction;
-};
-
-/**
- * Parallel-First Matrix Operations
- *
- * AssemblyScript-friendly TypeScript implementations with typed-function
- * integration and workerpool parallel execution via @danielsimonjr/mathts-parallel.
- *
- * These operations use Float64Array flat row-major format for efficient
- * parallel processing through the ComputePool worker infrastructure.
+ * Matrix operations for MathTS with pluggable backends
+ * (JS, WASM, WebGPU) and typed-function polymorphic dispatch.
  *
  * Following the parallel-first philosophy per CLAUDE.md:
- * - Use workers for ALL matrix operations (matmul, transpose, etc.)
- * - Use workers for ALL element-wise operations on matrices
- * - Only fall back to sequential for trivial scalar operations
+ * - Sequential typed-operations.ts for DenseMatrix class operations
+ * - parallel-matrix.ts for worker pool-based Float64Array operations
+ *
+ * For Float64Array-based parallel matrix operations, use @danielsimonjr/mathts-parallel
+ * directly or import from './parallel-matrix.js'.
  *
  * @packageDocumentation
  */
-/**
- * Create a matrix from various input types - parallel-first
- */
-declare const parallelMatrix: typed_function.TypedFunction;
-/**
- * Create an identity matrix
- */
-declare const parallelIdentity: typed_function.TypedFunction;
-/**
- * Create a matrix of zeros
- */
-declare const parallelZeros: typed_function.TypedFunction;
-/**
- * Create a matrix of ones
- */
-declare const parallelOnes: typed_function.TypedFunction;
-/**
- * Create a diagonal matrix
- */
-declare const parallelDiag: typed_function.TypedFunction;
-/**
- * Create a random matrix
- */
-declare const parallelRandom: typed_function.TypedFunction;
-/**
- * Parallel matrix addition with typed-function dispatch
- */
-declare const parallelMatrixAdd: typed_function.TypedFunction;
-/**
- * Parallel matrix subtraction with typed-function dispatch
- */
-declare const parallelMatrixSubtract: typed_function.TypedFunction;
-/**
- * Parallel matrix multiplication (matmul) with typed-function dispatch
- */
-declare const parallelMatrixMultiply: typed_function.TypedFunction;
-/**
- * Element-wise multiplication (Hadamard product) - parallel execution
- */
-declare const parallelDotMultiply: typed_function.TypedFunction;
-/**
- * Parallel matrix division
- */
-declare const parallelMatrixDivide: typed_function.TypedFunction;
-/**
- * Matrix negation - parallel execution
- */
-declare const parallelUnaryMinus: typed_function.TypedFunction;
-/**
- * Matrix transpose - parallel execution
- */
-declare const parallelMatrixTranspose: typed_function.TypedFunction;
-/**
- * Parallel sum of all elements
- */
-declare const parallelMatrixSum: typed_function.TypedFunction;
-/**
- * Parallel mean of all elements
- */
-declare const parallelMatrixMean: typed_function.TypedFunction;
-/**
- * Parallel minimum element
- */
-declare const parallelMatrixMin: typed_function.TypedFunction;
-/**
- * Parallel maximum element
- */
-declare const parallelMatrixMax: typed_function.TypedFunction;
-/**
- * Parallel variance computation
- */
-declare const parallelMatrixVariance: typed_function.TypedFunction;
-/**
- * Parallel standard deviation
- */
-declare const parallelMatrixStd: typed_function.TypedFunction;
-/**
- * Parallel Frobenius norm
- */
-declare const parallelMatrixNorm: typed_function.TypedFunction;
-/**
- * Parallel dot product
- */
-declare const parallelMatrixDot: typed_function.TypedFunction;
-/**
- * Matrix trace (sum of diagonal elements)
- */
-declare const parallelMatrixTrace: typed_function.TypedFunction;
-/**
- * Parallel Euclidean distance
- */
-declare const parallelMatrixDistance: typed_function.TypedFunction;
-/**
- * Parallel element-wise absolute value
- */
-declare const parallelMatrixAbs: typed_function.TypedFunction;
-/**
- * Parallel element-wise square root
- */
-declare const parallelMatrixSqrt: typed_function.TypedFunction;
-/**
- * Parallel element-wise square
- */
-declare const parallelMatrixSquare: typed_function.TypedFunction;
-/**
- * Parallel element-wise exponential
- */
-declare const parallelMatrixExp: typed_function.TypedFunction;
-/**
- * Parallel element-wise natural logarithm
- */
-declare const parallelMatrixLog: typed_function.TypedFunction;
-/**
- * Parallel element-wise sine
- */
-declare const parallelMatrixSin: typed_function.TypedFunction;
-/**
- * Parallel element-wise cosine
- */
-declare const parallelMatrixCos: typed_function.TypedFunction;
-/**
- * Parallel element-wise tangent
- */
-declare const parallelMatrixTan: typed_function.TypedFunction;
-/**
- * Get matrix dimensions
- */
-declare const parallelMatrixSize: typed_function.TypedFunction;
-/**
- * Get element at position
- */
-declare const parallelMatrixSubset: typed_function.TypedFunction;
-/**
- * Get row from matrix
- */
-declare const parallelMatrixRow: typed_function.TypedFunction;
-/**
- * Get column from matrix
- */
-declare const parallelMatrixColumn: typed_function.TypedFunction;
-/**
- * Get diagonal from matrix
- */
-declare const parallelMatrixDiagonal: typed_function.TypedFunction;
-/**
- * Parallel matrix-vector multiplication
- */
-declare const parallelMatrixMatvec: typed_function.TypedFunction;
-/**
- * Parallel outer product
- */
-declare const parallelMatrixOuter: typed_function.TypedFunction;
-/**
- * Parallel histogram computation
- */
-declare const parallelMatrixHistogram: typed_function.TypedFunction;
-declare const parallelMatrixOperations: {
-    matrix: typed_function.TypedFunction;
-    identity: typed_function.TypedFunction;
-    zeros: typed_function.TypedFunction;
-    ones: typed_function.TypedFunction;
-    diag: typed_function.TypedFunction;
-    random: typed_function.TypedFunction;
-    add: typed_function.TypedFunction;
-    subtract: typed_function.TypedFunction;
-    multiply: typed_function.TypedFunction;
-    dotMultiply: typed_function.TypedFunction;
-    divide: typed_function.TypedFunction;
-    unaryMinus: typed_function.TypedFunction;
-    transpose: typed_function.TypedFunction;
-    sum: typed_function.TypedFunction;
-    mean: typed_function.TypedFunction;
-    min: typed_function.TypedFunction;
-    max: typed_function.TypedFunction;
-    variance: typed_function.TypedFunction;
-    std: typed_function.TypedFunction;
-    norm: typed_function.TypedFunction;
-    dot: typed_function.TypedFunction;
-    trace: typed_function.TypedFunction;
-    distance: typed_function.TypedFunction;
-    abs: typed_function.TypedFunction;
-    sqrt: typed_function.TypedFunction;
-    square: typed_function.TypedFunction;
-    exp: typed_function.TypedFunction;
-    log: typed_function.TypedFunction;
-    sin: typed_function.TypedFunction;
-    cos: typed_function.TypedFunction;
-    tan: typed_function.TypedFunction;
-    size: typed_function.TypedFunction;
-    subset: typed_function.TypedFunction;
-    row: typed_function.TypedFunction;
-    column: typed_function.TypedFunction;
-    diagonal: typed_function.TypedFunction;
-    matvec: typed_function.TypedFunction;
-    outer: typed_function.TypedFunction;
-    histogram: typed_function.TypedFunction;
-};
-/**
- * Initialize parallel matrix operations
- */
-declare function initializeParallelMatrix(): Promise<void>;
-/**
- * Terminate parallel matrix operations pool
- */
-declare function terminateParallelMatrix(): Promise<void>;
-
-export { BUILTIN_SHADERS, type BackendHints, BackendManager, BackendRegistry, type BackendType, BatchExecutor, type CholeskyResult, DEFAULT_BACKEND_HINTS, DEFAULT_EXTENDED_HINTS, DenseMatrix, type EigOptions, type EigResult, type ExpmOptions, type ExtendedBackendHints, GPUBackend, type GPUBackendOptions, type GPUBackendStatus, GPUMatrixBackend, type GPUMatrixBackendConfig, JSBackend, type LQResult, type LUResult, type LogmOptions, Matrix, type MatrixBackend, type MatrixEntry, type MatrixIndex, type MatrixType, type OperationType, ParallelBackend, type ParallelBackendConfig, type PinvOptions, type QLResult, type QROptions, type QRPivotedOptions, type QRPivotedResult, type QRResult, type RQResult, type SVDOptions, type SVDResult, type SchurOptions, type SchurResult, type SliceSpec, SparseMatrix, type SqrtmOptions, type SyncConfig, SyncManager, type SyncStrategy, WASMBackend, type WASMBackendConfig, type WasmFeatures, abs, add, backendManager, backendRegistry, cholesky, clearFeatureCache, column, cond, condest, createBackendManager, createGPUMatrixBackend, createParallelBackend, createSyncManager, createWASMBackend, destroyGlobalGPUBackend, detectWasmFeatures, diag, diagonal, divide, dotMultiply, eig, eigWasm, eigvals, eigvalsWasm, exp, getCachedFeatures, getGlobalGPUBackend, gpuMatrixBackend, identity, initializeGlobalGPUBackend, initializeParallelMatrix, isAtomicsAvailable, isDenseMatrix, isMatrix, isSharedMemoryAvailable, isSparseMatrix, isWasmAvailable, jsBackend, log, lowRankApprox, lq, lu, luSolve, matrix, matrixExpm, matrixLogm, pinv as matrixPinv, matrixSchur, matrixSqrtm, max, mean, min, multiply, norm, norm2, normFro, ones, parallelBackend, parallelDiag, parallelDotMultiply, parallelIdentity, parallelMatrix, parallelMatrixAbs, parallelMatrixAdd, parallelMatrixColumn, parallelMatrixCos, parallelMatrixDiagonal, parallelMatrixDistance, parallelMatrixDivide, parallelMatrixDot, parallelMatrixExp, parallelMatrixHistogram, parallelMatrixLog, parallelMatrixMatvec, parallelMatrixMax, parallelMatrixMean, parallelMatrixMin, parallelMatrixMultiply, parallelMatrixNorm, parallelMatrixOperations, parallelMatrixOuter, parallelMatrixRow, parallelMatrixSin, parallelMatrixSize, parallelMatrixSqrt, parallelMatrixSquare, parallelMatrixStd, parallelMatrixSubset, parallelMatrixSubtract, parallelMatrixSum, parallelMatrixTan, parallelMatrixTrace, parallelMatrixTranspose, parallelMatrixVariance, parallelOnes, parallelRandom, parallelUnaryMinus, parallelZeros, pinv$1 as pinv, pow, powerIteration, ql, qr, qrPivoted, random, row, rq, singularValues, size, spectralRadiusWasm, sqrt, square, subset, subtract, sum, svd, svdWasm, terminateParallelMatrix, trace, transpose, typedMatrixOperations, unaryMinus, wasmBackend, zeros };
+export * from './types/index.js';
+export * from './backends/index.js';
+export * from './operations/index.js';
+export * from './typed-operations.js';
+export * from './parallel-matrix.js';
+//# sourceMappingURL=index.d.ts.map