@danielsimonjr/mathts-matrix 0.2.2 → 0.3.1

package/dist/index.d.ts

@@ -1,4 +1,8 @@
+/// <reference types="@webgpu/types" />
+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';
 
 /**
@@ -854,96 +858,6 @@ declare class JSBackend implements MatrixBackend {
  */
 declare const jsBackend: JSBackend;
 
-/**
- * Stub type declarations for workerpool.
- * The actual workerpool package ships raw .ts sources without pre-built .d.ts files.
- * This stub prevents TypeScript from diving into the raw source during type-checking.
- */
-declare module 'workerpool' {
-  export interface ExecOptions<T = unknown> {
-    on?: (payload: unknown) => void;
-    transfer?: Transferable[];
-    metadata?: T;
-  }
-
-  export interface PoolStats {
-    totalWorkers: number;
-    busyWorkers: number;
-    idleWorkers: number;
-    pendingTasks: number;
-    activeTasks: number;
-  }
-
-  export interface PoolOptions {
-    minWorkers?: number | 'max';
-    maxWorkers?: number;
-    maxQueueSize?: number;
-    workerType?: 'auto' | 'web' | 'process' | 'thread';
-    queueStrategy?: 'fifo' | 'lifo';
-    script?: string;
-    workerTerminateTimeout?: number;
-    forkArgs?: string[];
-    forkOpts?: Record<string, unknown>;
-    workerOpts?: Record<string, unknown>;
-    workerThreadOpts?: Record<string, unknown>;
-    emitStdStreams?: boolean;
-    onCreateWorker?: (arg: Record<string, unknown>) => Record<string, unknown> | void;
-    onTerminateWorker?: (arg: Record<string, unknown>) => void;
-    debugPortStart?: number;
-  }
-
-  export interface WorkerpoolPromise<T> extends Promise<T> {
-    readonly resolved: boolean;
-    readonly rejected: boolean;
-    readonly pending: boolean;
-    cancel(): this;
-    timeout(delay: number): this;
-  }
-
-  export type WorkerProxy<T extends Record<string, (...args: unknown[]) => unknown>> = {
-    [K in keyof T]: (...args: Parameters<T[K]>) => WorkerpoolPromise<ReturnType<T[K]>>;
-  };
-
-  export class Pool {
-    constructor(script?: string | PoolOptions, options?: PoolOptions);
-    exec<T>(
-      method: string | ((...args: unknown[]) => T),
-      params?: unknown[],
-      options?: ExecOptions
-    ): WorkerpoolPromise<T>;
-    proxy<T extends Record<string, (...args: unknown[]) => unknown>>(): Promise<WorkerProxy<T>>;
-    stats(): PoolStats;
-    terminate(force?: boolean, timeout?: number): Promise<void>;
-  }
-
-  export interface TransferDescriptor<T = unknown> {
-    message: T;
-    transfer: Transferable[];
-  }
-
-  export class Transfer<T = unknown> {
-    message: T;
-    transfer: Transferable[];
-    constructor(message: T, transfer: Transferable[]);
-  }
-
-  export class CancellationError extends Error {}
-  export class TimeoutError extends Error {}
-  export class TerminateError extends Error {}
-
-  export function pool(script?: string | PoolOptions, options?: PoolOptions): Pool;
-
-  export function worker(
-    methods?: Record<string, (...args: unknown[]) => unknown>,
-    options?: {
-      onTerminate?: (code: number | undefined) => void | PromiseLike<void>;
-      abortListenerTimeout?: number;
-    }
-  ): void;
-
-  export function workerEmit(payload: unknown): void;
-}
-
 /**
  * Configuration for ParallelBackend
  */
@@ -1050,7 +964,7 @@ declare class ParallelBackend {
     /**
      * Get pool statistics
      */
-    getStats(): undefined;
+    getStats(): workerpool.PoolStats;
     private checkDimensionsMatch;
     private checkMultiplyDimensions;
 }
@@ -1276,118 +1190,51 @@ declare const wasmBackend: WASMBackend;
 declare function createWASMBackend(config?: WASMBackendConfig): WASMBackend;
 
 /**
- * WebGPU Detection and Capability Checking
- *
- * Provides runtime detection of WebGPU support and adapter capabilities.
- */
-/**
- * WebGPU adapter information
- */
-interface GPUAdapterInfo {
-    /** Adapter vendor */
-    vendor: string;
-    /** Adapter architecture */
-    architecture: string;
-    /** Device description */
-    device: string;
-    /** Driver description */
-    description: string;
-}
-/**
- * WebGPU capability information
- */
-interface GPUCapabilities {
-    /** Whether WebGPU is supported */
-    supported: boolean;
-    /** Adapter information if available */
-    adapterInfo: GPUAdapterInfo | null;
-    /** Maximum buffer size in bytes */
-    maxBufferSize: number;
-    /** Maximum compute workgroup size */
-    maxWorkgroupSize: [number, number, number];
-    /** Maximum storage buffer binding size */
-    maxStorageBufferBindingSize: number;
-    /** Maximum compute invocations per workgroup */
-    maxComputeInvocationsPerWorkgroup: number;
-    /** Maximum workgroups per dimension */
-    maxComputeWorkgroupsPerDimension: number;
-    /** Whether the adapter is a fallback/software adapter */
-    isFallbackAdapter: boolean;
-    /** Supported features */
-    features: string[];
-}
-/**
- * Check if WebGPU is available in the current environment
- */
-declare function hasWebGPU(): boolean;
-/**
- * Detect WebGPU capabilities
- * @param preferHighPerformance - Whether to prefer high-performance GPU
- */
-declare function detectGPUCapabilities(preferHighPerformance?: boolean): Promise<GPUCapabilities>;
-/**
- * Recommended workgroup size based on GPU capabilities
- */
-declare function getRecommendedWorkgroupSize(capabilities: GPUCapabilities): [number, number, number];
-
-/**
- * WebGPU Context Management
+ * GPU Backend for Matrix Operations
  *
- * Manages WebGPU device, queue, and command encoding.
+ * WebGPU-accelerated matrix operations for large matrices.
  */
 
 /**
- * Options for GPUContext initialization
- */
-interface GPUContextOptions {
-    /** Prefer high-performance GPU */
-    preferHighPerformance?: boolean;
-    /** Required features for the device */
-    requiredFeatures?: GPUFeatureName[];
-    /** Required limits for the device */
-    requiredLimits?: Record<string, number>;
-    /** Label for debugging */
-    label?: string;
-}
-/**
- * Status of the GPU context
+ * GPU Backend status
  */
-type GPUContextStatus = 'uninitialized' | 'initializing' | 'ready' | 'error' | 'lost';
+type GPUBackendStatus = 'uninitialized' | 'initializing' | 'ready' | 'error' | 'unsupported';
 /**
- * Event emitted when device is lost
+ * Options for GPU backend
  */
-interface DeviceLostEvent {
-    reason: GPUDeviceLostReason;
-    message: string;
+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 Context manages the lifecycle of WebGPU resources
+ * GPU Backend for accelerated matrix operations
  */
-declare class GPUContext {
-    private adapter;
-    private device;
+declare class GPUBackend {
+    private context;
+    private bufferPool;
+    private shaderManager;
     private _status;
     private _capabilities;
     private _lastError;
-    private deviceLostCallbacks;
-    private label;
-    constructor(options?: GPUContextOptions);
+    private threshold;
+    private workgroupSize;
+    private useGlobalContext;
+    constructor(options?: GPUBackendOptions);
     /**
      * Get the current status
      */
-    get status(): GPUContextStatus;
+    get status(): GPUBackendStatus;
     /**
-     * Check if context is ready
+     * Check if backend is ready
      */
     get isReady(): boolean;
-    /**
-     * Get the GPU device (throws if not initialized)
-     */
-    getDevice(): GPUDevice;
-    /**
-     * Get the GPU queue
-     */
-    getQueue(): GPUQueue;
     /**
      * Get capabilities
      */
@@ -1397,256 +1244,447 @@ declare class GPUContext {
      */
     get lastError(): Error | null;
     /**
-     * Initialize the GPU context
-     */
-    initialize(options?: GPUContextOptions): Promise<boolean>;
-    /**
-     * Register callback for device lost event
-     */
-    onDeviceLost(callback: (event: DeviceLostEvent) => void): void;
-    /**
-     * Create a command encoder
-     */
-    createCommandEncoder(label?: string): GPUCommandEncoder;
-    /**
-     * Create a buffer
+     * Initialize the GPU backend
      */
-    createBuffer(size: number, usage: GPUBufferUsageFlags, label?: string, mappedAtCreation?: boolean): GPUBuffer;
+    initialize(options?: GPUBackendOptions): Promise<boolean>;
     /**
-     * Create a storage buffer for compute operations
+     * Check if GPU should be used for the given matrix size
      */
-    createStorageBuffer(size: number, label?: string, readable?: boolean, writable?: boolean): GPUBuffer;
+    shouldUseGPU(rows: number, cols: number): boolean;
     /**
-     * Create a staging buffer for reading back data
+     * Calculate workgroup counts for a matrix
      */
-    createStagingBuffer(size: number, label?: string): GPUBuffer;
+    calculateWorkgroups(rows: number, cols: number): [number, number, number];
     /**
-     * Create a compute pipeline
+     * Get the GPU context
      */
-    createComputePipeline(shaderModule: GPUShaderModule, entryPoint: string, layout?: GPUPipelineLayout | 'auto', label?: string): GPUComputePipeline;
+    getContext(): GPUContext;
     /**
-     * Create a shader module from WGSL source
+     * Get the buffer pool
      */
-    createShaderModule(code: string, label?: string): GPUShaderModule;
+    getBufferPool(): BufferPool;
     /**
-     * Create a bind group
+     * Get the shader manager
      */
-    createBindGroup(layout: GPUBindGroupLayout, entries: GPUBindGroupEntry[], label?: string): GPUBindGroup;
+    getShaderManager(): ShaderManager;
     /**
-     * Submit commands to the GPU queue
+     * Add two matrices element-wise
      */
-    submitCommands(commandBuffers: GPUCommandBuffer[]): void;
+    add(a: Float32Array, b: Float32Array, rows: number, cols: number): Promise<Float32Array>;
     /**
-     * Write data to a buffer
+     * Multiply two matrices
      */
-    writeBuffer(buffer: GPUBuffer, data: ArrayBufferView | ArrayBuffer | SharedArrayBuffer, bufferOffset?: number, dataOffset?: number, size?: number): void;
+    matmul(a: Float32Array, b: Float32Array, M: number, K: number, N: number): Promise<Float32Array>;
     /**
-     * Read data from a buffer (async)
+     * Transpose a matrix
      */
-    readBuffer(buffer: GPUBuffer, offset?: number, size?: number): Promise<ArrayBuffer>;
+    transpose(a: Float32Array, rows: number, cols: number): Promise<Float32Array>;
     /**
-     * Dispatch a compute shader
+     * Scale a matrix by a scalar
      */
-    dispatchCompute(pipeline: GPUComputePipeline, bindGroups: GPUBindGroup[], workgroupCounts: [number, number, number]): void;
+    scale(a: Float32Array, scalar: number): Promise<Float32Array>;
     /**
-     * Wait for all GPU operations to complete
+     * Get backend statistics
      */
-    waitForCompletion(): Promise<void>;
+    getStats(): {
+        status: GPUBackendStatus;
+        capabilities: GPUCapabilities | null;
+        bufferPool: {
+            totalBuffers: number;
+            inUseBuffers: number;
+            cachedBuffers: number;
+        } | null;
+        shaders: {
+            cachedShaders: number;
+            cachedPipelines: number;
+        } | null;
+    };
     /**
-     * Destroy the context and release resources
+     * Destroy the backend
      */
     destroy(): void;
 }
 /**
- * Get the global GPU context
+ * Get the global GPU backend
+ */
+declare function getGlobalGPUBackend(): GPUBackend;
+/**
+ * Initialize the global GPU backend
  */
-declare function getGlobalGPUContext(): GPUContext;
+declare function initializeGlobalGPUBackend(options?: GPUBackendOptions): Promise<boolean>;
 /**
- * Destroy the global GPU context
+ * Destroy the global GPU backend
  */
-declare function destroyGlobalGPU(): void;
+declare function destroyGlobalGPUBackend(): void;
 
 /**
- * GPU Buffer Pool
+ * GPU Matrix Backend Adapter
+ *
+ * Adapts GPUBackend to implement the MatrixBackend interface,
+ * enabling seamless integration with the backend selection system.
  *
- * Manages GPU buffer allocation, deallocation, and reuse.
- * Reduces allocation overhead by recycling buffers.
+ * @packageDocumentation
  */
 
 /**
- * Options for buffer pool
- */
-interface BufferPoolOptions {
-    /** Maximum total memory to cache (bytes) */
-    maxCacheSize?: number;
-    /** Time after which unused buffers are evicted (ms) */
-    evictionTimeout?: number;
-    /** Whether to enable automatic eviction */
-    autoEvict?: boolean;
-    /** Interval for automatic eviction (ms) */
-    evictionInterval?: number;
+ * 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 Buffer Pool for efficient buffer management
+ * 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 BufferPool {
-    private context;
-    private buffers;
-    private maxCacheSize;
-    private evictionTimeout;
-    private evictionTimer;
-    private currentCacheSize;
-    constructor(context: GPUContext, options?: BufferPoolOptions);
-    /**
-     * Generate a key for buffer categorization
-     */
-    private getBufferKey;
+declare class GPUMatrixBackend implements MatrixBackend {
+    readonly type: BackendType;
+    private config;
+    private backend;
+    private capabilities;
+    private initPromise;
+    private _available;
+    constructor(config?: GPUMatrixBackendConfig);
     /**
-     * Round up to nearest power of 2
+     * Check if GPU is available in the current environment
      */
-    private roundUpToPowerOf2;
+    isAvailable(): boolean;
     /**
-     * Acquire a buffer from the pool or create a new one
+     * Initialize the GPU backend
      */
-    acquire(size: number, usage: GPUBufferUsageFlags, label?: string): GPUBuffer;
+    initialize(): Promise<void>;
+    private doInitialize;
     /**
-     * Release a buffer back to the pool
+     * Check if operation should use GPU
      */
-    release(buffer: GPUBuffer): void;
+    private shouldUseGPU;
     /**
-     * Create a storage buffer from the pool
+     * Execute GPU operation with fallback
      */
-    acquireStorageBuffer(size: number, label?: string, readable?: boolean, writable?: boolean): GPUBuffer;
+    private executeWithFallback;
     /**
-     * Create a staging buffer from the pool
+     * Get GPU capabilities
      */
-    acquireStagingBuffer(size: number, label?: string): GPUBuffer;
+    getCapabilities(): GPUCapabilities | null;
     /**
-     * Create a uniform buffer from the pool
+     * Get backend statistics
      */
-    acquireUniformBuffer(size: number, label?: string): GPUBuffer;
+    getStats(): ReturnType<GPUBackend['getStats']> | null;
+    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
     /**
-     * Evict old unused buffers
+     * Async add operation using GPU
      */
-    evictOldBuffers(): void;
+    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;
     /**
-     * Force eviction to reduce cache to target size
+     * Async scale operation using GPU
      */
-    evictToSize(targetSize: number): void;
+    scaleAsync(a: DenseMatrix, scalar: number): Promise<DenseMatrix>;
+    abs(a: DenseMatrix): DenseMatrix;
+    negate(a: DenseMatrix): DenseMatrix;
+    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
     /**
-     * Start automatic eviction timer
+     * Async matrix multiplication using GPU
      */
-    startAutoEviction(interval: number): void;
+    multiplyAsync(a: DenseMatrix, b: DenseMatrix): Promise<DenseMatrix>;
+    transpose(a: DenseMatrix): DenseMatrix;
     /**
-     * Stop automatic eviction timer
+     * Async transpose using GPU
      */
-    stopAutoEviction(): void;
+    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;
     /**
-     * Get pool statistics
+     * Update configuration
      */
-    getStats(): {
-        totalBuffers: number;
-        inUseBuffers: number;
-        cachedBuffers: number;
-        currentCacheSize: number;
-        maxCacheSize: number;
-    };
+    updateConfig(config: Partial<GPUMatrixBackendConfig>): void;
     /**
-     * Clear all buffers and reset pool
+     * Get current configuration
      */
-    clear(): void;
+    getConfig(): Required<GPUMatrixBackendConfig>;
     /**
-     * Destroy the pool
+     * Destroy the backend
      */
     destroy(): void;
 }
-
 /**
- * GPU Shader Manager
- *
- * Manages WGSL shader loading, compilation, and caching.
+ * Global GPU matrix backend instance
+ */
+declare const gpuMatrixBackend: GPUMatrixBackend;
+/**
+ * Create a GPU matrix backend with custom configuration
  */
+declare function createGPUMatrixBackend(config?: GPUMatrixBackendConfig): GPUMatrixBackend;
 
 /**
- * Built-in shader library
+ * MathTS Matrix Configuration
+ *
+ * Centralized configuration for matrix operations, backend selection,
+ * and performance tuning.
+ *
+ * @packageDocumentation
  */
-declare const BUILTIN_SHADERS: {
-    /** Matrix addition shader */
-    matrixAdd: string;
-    /** Matrix subtraction shader */
-    matrixSub: string;
-    /** Element-wise multiplication shader */
-    matrixMul: string;
-    /** Scalar multiplication shader */
-    scalarMul: string;
-    /** Matrix multiplication (naive) shader */
-    matmul: string;
-    /** Matrix transpose shader */
-    transpose: string;
-    /** Sum reduction shader (first pass) */
-    sumReduce: string;
-};
+
 /**
- * Shader Manager for compiling and caching GPU shaders
+ * 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.
  */
-declare class ShaderManager {
-    private context;
-    private cache;
-    constructor(context: GPUContext);
-    /**
-     * Get or compile a shader module
-     */
-    getShaderModule(name: string, code: string): GPUShaderModule;
-    /**
-     * Get a builtin shader module
-     */
-    getBuiltinShader(name: keyof typeof BUILTIN_SHADERS): GPUShaderModule;
-    /**
-     * Get or create a compute pipeline
-     */
-    getPipeline(shaderName: string, entryPoint: string, code?: string, layout?: GPUPipelineLayout | 'auto'): GPUComputePipeline;
-    /**
-     * Get a builtin compute pipeline
-     */
-    getBuiltinPipeline(name: keyof typeof BUILTIN_SHADERS, entryPoint?: string): GPUComputePipeline;
-    /**
-     * Precompile all builtin shaders
-     */
-    precompileBuiltins(): void;
-    /**
-     * Clear shader cache
-     */
-    clearCache(): void;
-    /**
-     * Get cache statistics
-     */
-    getStats(): {
-        cachedShaders: number;
-        cachedPipelines: number;
-    };
-}
+type OperationType = 'add' | 'subtract' | 'multiply' | 'multiplyElementwise' | 'transpose' | 'scale' | 'decomposition' | 'solve' | 'fft' | 'eig' | 'svd';
 
 /**
- * GPU Batch Executor
+ * Backend Manager
  *
- * Manages batched GPU command submission for reduced overhead.
- * Queues multiple operations and executes them together for efficiency.
+ * 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
  */
 
 /**
- * Result of batch execution
+ * Extended backend hints with operation-specific thresholds
  */
-interface BatchResult {
-    /** Success status */
-    success: boolean;
-    /** Number of operations executed */
-    operationCount: number;
-    /** Execution time in milliseconds */
-    duration: number;
-    /** Error message if failed */
-    error?: string;
+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
@@ -1934,457 +1972,6 @@ declare class SyncManager {
  */
 declare function createSyncManager(context: GPUContext, bufferPool: BufferPool, strategy?: SyncStrategy): SyncManager;
 
-/**
- * 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;
-
 /**
  * Eigenvalue and Eigenvector Decomposition
  *
@@ -3304,4 +2891,4 @@ declare function initializeParallelMatrix(): Promise<void>;
  */
 declare function terminateParallelMatrix(): Promise<void>;
 
-export { BUILTIN_SHADERS, type BackendHints, BackendManager, BackendRegistry, type BackendType, BatchExecutor, BufferPool, type CholeskyResult, DEFAULT_BACKEND_HINTS, DEFAULT_EXTENDED_HINTS, DenseMatrix, type EigOptions, type EigResult, type ExpmOptions, type ExtendedBackendHints, GPUBackend, type GPUBackendOptions, type GPUBackendStatus, type GPUCapabilities, GPUContext, type GPUContextOptions, GPUMatrixBackend, type GPUMatrixBackendConfig, JSBackend, type LUResult, type LogmOptions, Matrix, type MatrixBackend, type MatrixDimensions, type MatrixEntry, type MatrixIndex, type MatrixType, type OperationType, ParallelBackend, type ParallelBackendConfig, type PinvOptions, type QROptions, type QRResult, type SVDOptions, type SVDResult, type SchurOptions, type SchurResult, ShaderManager, type SliceSpec, SparseMatrix, type SqrtmOptions, type SyncConfig, SyncManager, type SyncStrategy, WASMBackend, type WASMBackendConfig, type WasmFeatures, abs, add, backendManager, backendRegistry, cholesky, clearFeatureCache, column, cond, createBackendManager, createGPUMatrixBackend, createParallelBackend, createSyncManager, createWASMBackend, destroyGlobalGPU, destroyGlobalGPUBackend, detectGPUCapabilities, detectWasmFeatures, diag, diagonal, divide, dotMultiply, eig, eigWasm, eigvals, eigvalsWasm, exp, getCachedFeatures, getGlobalGPUBackend, getGlobalGPUContext, getRecommendedWorkgroupSize, gpuMatrixBackend, hasWebGPU, identity, initializeGlobalGPUBackend, initializeParallelMatrix, isAtomicsAvailable, isDenseMatrix, isMatrix, isSharedMemoryAvailable, isSparseMatrix, isWasmAvailable, jsBackend, log, lowRankApprox, lu, 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, qr, random, row, singularValues, size, spectralRadiusWasm, sqrt, square, subset, subtract, sum, svd, svdWasm, terminateParallelMatrix, trace, transpose, typedMatrixOperations, unaryMinus, wasmBackend, zeros };
+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 LUResult, type LogmOptions, Matrix, type MatrixBackend, type MatrixDimensions, type MatrixEntry, type MatrixIndex, type MatrixType, type OperationType, ParallelBackend, type ParallelBackendConfig, type PinvOptions, type QROptions, type QRResult, 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, 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, lu, 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, qr, random, row, singularValues, size, spectralRadiusWasm, sqrt, square, subset, subtract, sum, svd, svdWasm, terminateParallelMatrix, trace, transpose, typedMatrixOperations, unaryMinus, wasmBackend, zeros };