@danielsimonjr/mathts-matrix 0.7.1 → 0.7.3

package/dist/backends/gpu/Sync.d.ts

@@ -0,0 +1,167 @@
+/**
+ * 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
+ */
+import type { GPUContext } from '@danielsimonjr/mathts-gpu';
+import type { BufferPool } from '@danielsimonjr/mathts-gpu';
+/**
+ * Synchronization strategy type
+ */
+export type SyncStrategy = 'immediate' | 'lazy' | 'double-buffer' | 'streaming';
+/**
+ * Transfer direction
+ */
+export type TransferDirection = 'cpu-to-gpu' | 'gpu-to-cpu';
+/**
+ * Transfer request
+ */
+export interface TransferRequest {
+    /** Unique ID for this request */
+    id: number;
+    /** Source buffer */
+    source: GPUBuffer | Float32Array;
+    /** Destination buffer */
+    destination: GPUBuffer | Float32Array;
+    /** Transfer direction */
+    direction: TransferDirection;
+    /** Byte offset in source */
+    sourceOffset?: number;
+    /** Byte offset in destination */
+    destOffset?: number;
+    /** Number of bytes to transfer */
+    size: number;
+    /** Priority (higher = more urgent) */
+    priority?: number;
+}
+/**
+ * Transfer result
+ */
+export 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
+ */
+export 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);
+ * ```
+ */
+export 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
+ */
+export declare function createSyncManager(context: GPUContext, bufferPool: BufferPool, strategy?: SyncStrategy): SyncManager;
+//# sourceMappingURL=Sync.d.ts.map

package/dist/backends/gpu/Sync.d.ts.map

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

package/dist/backends/gpu/builtin-shaders.d.ts

@@ -0,0 +1,178 @@
+/**
+ * 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.
+ */
+import type { ShaderManager } from '@danielsimonjr/mathts-gpu';
+export declare const BUILTIN_SHADERS: {
+    /** Matrix addition shader */
+    readonly matrixAdd: `
+    @group(0) @binding(0) var<storage, read> a: array<f32>;
+    @group(0) @binding(1) var<storage, read> b: array<f32>;
+    @group(0) @binding(2) var<storage, read_write> result: array<f32>;
+    @group(0) @binding(3) var<uniform> params: vec4<u32>; // rows, cols, _, _
+
+    @compute @workgroup_size(16, 16)
+    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+      let rows = params.x;
+      let cols = params.y;
+      let row = gid.y;
+      let col = gid.x;
+
+      if (row >= rows || col >= cols) { return; }
+
+      let idx = row * cols + col;
+      result[idx] = a[idx] + b[idx];
+    }
+  `;
+    /** Matrix subtraction shader */
+    readonly matrixSub: `
+    @group(0) @binding(0) var<storage, read> a: array<f32>;
+    @group(0) @binding(1) var<storage, read> b: array<f32>;
+    @group(0) @binding(2) var<storage, read_write> result: array<f32>;
+    @group(0) @binding(3) var<uniform> params: vec4<u32>;
+
+    @compute @workgroup_size(16, 16)
+    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+      let rows = params.x;
+      let cols = params.y;
+      let row = gid.y;
+      let col = gid.x;
+
+      if (row >= rows || col >= cols) { return; }
+
+      let idx = row * cols + col;
+      result[idx] = a[idx] - b[idx];
+    }
+  `;
+    /** Element-wise multiplication shader */
+    readonly matrixMul: `
+    @group(0) @binding(0) var<storage, read> a: array<f32>;
+    @group(0) @binding(1) var<storage, read> b: array<f32>;
+    @group(0) @binding(2) var<storage, read_write> result: array<f32>;
+    @group(0) @binding(3) var<uniform> params: vec4<u32>;
+
+    @compute @workgroup_size(16, 16)
+    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+      let rows = params.x;
+      let cols = params.y;
+      let row = gid.y;
+      let col = gid.x;
+
+      if (row >= rows || col >= cols) { return; }
+
+      let idx = row * cols + col;
+      result[idx] = a[idx] * b[idx];
+    }
+  `;
+    /** Scalar multiplication shader */
+    readonly scalarMul: `
+    @group(0) @binding(0) var<storage, read> a: array<f32>;
+    @group(0) @binding(1) var<storage, read_write> result: array<f32>;
+    @group(0) @binding(2) var<uniform> params: vec4<f32>; // scalar, length, _, _
+
+    @compute @workgroup_size(256)
+    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+      let scalar = params.x;
+      let length = u32(params.y);
+      let idx = gid.x;
+
+      if (idx >= length) { return; }
+
+      result[idx] = a[idx] * scalar;
+    }
+  `;
+    /** Matrix multiplication (naive) shader */
+    readonly matmul: `
+    @group(0) @binding(0) var<storage, read> a: array<f32>;
+    @group(0) @binding(1) var<storage, read> b: array<f32>;
+    @group(0) @binding(2) var<storage, read_write> result: array<f32>;
+    @group(0) @binding(3) var<uniform> params: vec4<u32>; // M, N, K, _
+
+    @compute @workgroup_size(16, 16)
+    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+      let M = params.x;
+      let N = params.y;
+      let K = params.z;
+      let row = gid.y;
+      let col = gid.x;
+
+      if (row >= M || col >= N) { return; }
+
+      var sum: f32 = 0.0;
+      for (var k: u32 = 0u; k < K; k = k + 1u) {
+        sum = sum + a[row * K + k] * b[k * N + col];
+      }
+
+      result[row * N + col] = sum;
+    }
+  `;
+    /** Matrix transpose shader */
+    readonly transpose: `
+    @group(0) @binding(0) var<storage, read> a: array<f32>;
+    @group(0) @binding(1) var<storage, read_write> result: array<f32>;
+    @group(0) @binding(2) var<uniform> params: vec4<u32>; // rows, cols, _, _
+
+    @compute @workgroup_size(16, 16)
+    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+      let rows = params.x;
+      let cols = params.y;
+      let row = gid.y;
+      let col = gid.x;
+
+      if (row >= rows || col >= cols) { return; }
+
+      result[col * rows + row] = a[row * cols + col];
+    }
+  `;
+    /** Sum reduction shader (first pass) */
+    readonly sumReduce: `
+    @group(0) @binding(0) var<storage, read> input: array<f32>;
+    @group(0) @binding(1) var<storage, read_write> output: array<f32>;
+    @group(0) @binding(2) var<uniform> params: vec4<u32>; // inputLength, outputLength, _, _
+
+    // NOTE: 'shared' is a RESERVED KEYWORD in WGSL — naming this workgroup
+    // array 'shared' made this shader fail to compile, which (because
+    // GPUBackend.initialize() precompiles every registered shader) poisoned
+    // backend init and silently forced ALL GPU ops onto the CPU fallback.
+    var<workgroup> sdata: array<f32, 256>;
+
+    @compute @workgroup_size(256)
+    fn main(
+      @builtin(local_invocation_id) lid: vec3<u32>,
+      @builtin(workgroup_id) wid: vec3<u32>
+    ) {
+      let inputLength = params.x;
+      let idx = wid.x * 512u + lid.x;
+
+      // Load two elements and sum
+      var sum: f32 = 0.0;
+      if (idx < inputLength) {
+        sum = input[idx];
+      }
+      if (idx + 256u < inputLength) {
+        sum = sum + input[idx + 256u];
+      }
+      sdata[lid.x] = sum;
+
+      workgroupBarrier();
+
+      // Reduce within workgroup
+      for (var s: u32 = 128u; s > 0u; s = s >> 1u) {
+        if (lid.x < s) {
+          sdata[lid.x] = sdata[lid.x] + sdata[lid.x + s];
+        }
+        workgroupBarrier();
+      }
+
+      // Write result
+      if (lid.x == 0u) {
+        output[wid.x] = sdata[0];
+      }
+    }
+  `;
+};
+/** Register every builtin matrix kernel onto a ShaderManager. */
+export declare function registerBuiltinShaders(sm: ShaderManager): void;
+//# sourceMappingURL=builtin-shaders.d.ts.map

package/dist/backends/gpu/builtin-shaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-shaders.d.ts","sourceRoot":"","sources":["../../../src/backends/gpu/builtin-shaders.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,eAAO,MAAM,eAAe;IAC1B,6BAA6B;aAC7B,SAAS,EAAE;;;;;;;;;;;;;;;;;;GAkBV;IAED,gCAAgC;aAChC,SAAS,EAAE;;;;;;;;;;;;;;;;;;GAkBV;IAED,yCAAyC;aACzC,SAAS,EAAE;;;;;;;;;;;;;;;;;;GAkBV;IAED,mCAAmC;aACnC,SAAS,EAAE;;;;;;;;;;;;;;;GAeV;IAED,2CAA2C;aAC3C,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;GAuBP;IAED,8BAA8B;aAC9B,SAAS,EAAE;;;;;;;;;;;;;;;;GAgBV;IAED,wCAAwC;aACxC,SAAS,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CV;CACO,CAAC;AAEX,iEAAiE;AACjE,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,aAAa,GAAG,IAAI,CAI9D"}

package/dist/backends/gpu/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GPU Backend Exports
+ *
+ * WebGPU infrastructure for accelerated matrix operations. The generic
+ * foundation now lives in @danielsimonjr/mathts-gpu and is re-exported here
+ * so matrix's public surface is unchanged. Matrix-domain kernels and the
+ * (unextracted) batch/sync helpers stay local.
+ */
+export { hasWebGPU, isBrowser, getGPUAdapter, detectGPUCapabilities, isGPUSuitableForMatrixOps, getRecommendedWorkgroupSize, getMaxMatrixSize, GPUContext, getGlobalGPUContext, initializeGlobalGPU, destroyGlobalGPU, getGpuDevice, resetGpuDevice, BufferPool, ShaderManager, type GPUAdapterInfo, type GPUCapabilities, type GPUContextOptions, type GPUContextStatus, type DeviceLostEvent, type BufferPoolOptions, type ShaderSource, type PipelineConfig, } from '@danielsimonjr/mathts-gpu';
+export { BUILTIN_SHADERS, registerBuiltinShaders } from './builtin-shaders.js';
+export { BatchExecutor, type BatchOperation, type BatchOperationType, type BatchResult, type BatchOptions, } from './BatchExecutor.js';
+export { SyncManager, createSyncManager, type SyncStrategy, type TransferDirection, type TransferRequest, type TransferResult, type SyncConfig, } from './Sync.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/backends/gpu/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backends/gpu/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,SAAS,EACT,SAAS,EACT,aAAa,EACb,qBAAqB,EACrB,yBAAyB,EACzB,2BAA2B,EAC3B,gBAAgB,EAChB,UAAU,EACV,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,UAAU,EACV,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,cAAc,GACpB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAG/E,OAAO,EACL,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,YAAY,GAClB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,UAAU,GAChB,MAAM,WAAW,CAAC"}

package/dist/backends/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Matrix Backend Exports
+ * @packageDocumentation
+ */
+export { BackendRegistry, backendRegistry, DEFAULT_BACKEND_HINTS } from './Backend.js';
+export type { MatrixBackend, BackendType, BackendHints } from './Backend.js';
+export { JSBackend, jsBackend } from './JSBackend.js';
+export { ParallelBackend, parallelBackend, createParallelBackend, type ParallelBackendConfig, } from './ParallelBackend.js';
+export { WASMBackend, wasmBackend, createWASMBackend, type WASMBackendConfig, } from './WASMBackend.js';
+export { GPUMatrixBackend, gpuMatrixBackend, createGPUMatrixBackend, type GPUMatrixBackendConfig, } from './GPUMatrixBackend.js';
+export { GPUBackend, getGlobalGPUBackend, initializeGlobalGPUBackend, destroyGlobalGPUBackend, type GPUBackendOptions, type GPUBackendStatus, } from './GPUBackend.js';
+export { BackendManager, backendManager, createBackendManager, DEFAULT_EXTENDED_HINTS, type ExtendedBackendHints, type OperationType, } from './BackendManager.js';
+export { detectWasmFeatures, isWasmAvailable, isSharedMemoryAvailable, isAtomicsAvailable, clearFeatureCache, getCachedFeatures, } from './wasm/index.js';
+export type { WasmFeatures } from './wasm/index.js';
+export { hasWebGPU, detectGPUCapabilities, getRecommendedWorkgroupSize, GPUContext, getGlobalGPUContext, destroyGlobalGPU, BufferPool, ShaderManager, BUILTIN_SHADERS, BatchExecutor, SyncManager, createSyncManager, } from './gpu/index.js';
+export type { GPUCapabilities, GPUContextOptions, SyncStrategy, SyncConfig } from './gpu/index.js';
+import './register-backends.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/backends/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/backends/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAEvF,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE7E,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEtD,OAAO,EACL,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,KAAK,qBAAqB,GAC3B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,KAAK,iBAAiB,GACvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,sBAAsB,GAC5B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,UAAU,EACV,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,oBAAoB,EACzB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,uBAAuB,EACvB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,OAAO,EACL,SAAS,EACT,qBAAqB,EACrB,2BAA2B,EAC3B,UAAU,EACV,mBAAmB,EACnB,gBAAgB,EAChB,UAAU,EACV,aAAa,EACb,eAAe,EACf,aAAa,EACb,WAAW,EACX,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AAExB,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAKnG,OAAO,wBAAwB,CAAC"}

package/dist/backends/register-backends.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Default backend registrations.
+ *
+ * This module is imported for side effects from both `./index.ts` and
+ * `./BackendManager.ts`. Putting the registrations here ensures they run
+ * regardless of which module the consumer imports first, and avoids a
+ * back-edge from BackendManager → index → BackendManager.
+ *
+ * Backends declared here are *registered* but not *initialized*: the WASM
+ * artifacts only load when `BackendManager.initialize()` (or a direct
+ * `.initialize()` call on the backend) runs. Importing this module is
+ * therefore cheap and safe in environments without WebAssembly (the
+ * `isAvailable()` check on each backend is the gate).
+ *
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=register-backends.d.ts.map

package/dist/backends/register-backends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-backends.d.ts","sourceRoot":"","sources":["../../src/backends/register-backends.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}

package/dist/backends/wasm/detect.d.ts

@@ -0,0 +1,58 @@
+/**
+ * WASM Feature Detection
+ *
+ * Detects available WebAssembly features in the current environment.
+ * Used to enable/disable SIMD, threads, and other optimizations.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Available WASM features
+ */
+export 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
+ */
+export declare function detectWasmFeatures(): Promise<WasmFeatures>;
+/**
+ * Synchronously check if WASM is available (basic check only)
+ */
+export declare function isWasmAvailable(): boolean;
+/**
+ * Synchronously check if SharedArrayBuffer is available
+ */
+export declare function isSharedMemoryAvailable(): boolean;
+/**
+ * Synchronously check if Atomics are available
+ */
+export declare function isAtomicsAvailable(): boolean;
+/**
+ * Clear the feature detection cache (useful for testing)
+ */
+export declare function clearFeatureCache(): void;
+/**
+ * Get cached features if available
+ */
+export declare function getCachedFeatures(): WasmFeatures | null;
+//# sourceMappingURL=detect.d.ts.map

package/dist/backends/wasm/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../src/backends/wasm/detect.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,WAAW,EAAE,OAAO,CAAC;IACrB,+BAA+B;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,kCAAkC;IAClC,YAAY,EAAE,OAAO,CAAC;IACtB,4BAA4B;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAC;IACjB,6BAA6B;IAC7B,UAAU,EAAE,OAAO,CAAC;IACpB,sBAAsB;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,8BAA8B;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,6BAA6B;IAC7B,QAAQ,EAAE,OAAO,CAAC;CACnB;AA8PD;;;;GAIG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,YAAY,CAAC,CAkDhE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,YAAY,GAAG,IAAI,CAEvD"}

package/dist/backends/wasm/fft-wasm.d.ts

@@ -0,0 +1,120 @@
+/**
+ * WASM-Accelerated FFT Operations
+ *
+ * Wraps the AssemblyScript WASM FFT exports (`fft` / `rfft` / `powerSpectrum`,
+ * `assembly/src/ops/fft.ts`, interleaved complex format) with a high-level
+ * TypeScript API. Falls back to a pure JavaScript Cooley-Tukey radix-2
+ * implementation when WASM is unavailable. (Phase 7b: the matrix loader now
+ * defaults to the AS binary; the AS `fft(data, n, inverse)` / `rfft(data, n,
+ * result)` / `powerSpectrum(data, n, result)` call shapes match the consumer
+ * exactly, so this module needed no marshalling changes.)
+ *
+ * The WASM kernels use interleaved complex arrays: [re0, im0, re1, im1, ...].
+ * This module converts between split (separate real/imag) and interleaved
+ * formats as needed.
+ *
+ * @packageDocumentation
+ */
+/**
+ * FFT result with separate real and imaginary arrays
+ */
+export interface FFTResult {
+    real: Float64Array;
+    imag: Float64Array;
+}
+/**
+ * FFT backend selection
+ */
+export type FFTBackend = 'wasm' | 'js' | 'auto';
+/**
+ * Configuration for FFT operations
+ */
+export interface FFTConfig {
+    /** Backend to use (default: 'auto') */
+    backend?: FFTBackend;
+    /** Minimum elements to use WASM (default: 64) */
+    wasmThreshold?: number;
+}
+/**
+ * Check if n is a power of 2
+ */
+export declare function isPowerOf2(n: number): boolean;
+/**
+ * Next power of 2 >= n
+ */
+export declare function nextPowerOf2(n: number): number;
+/**
+ * Pure JavaScript Cooley-Tukey radix-2 FFT
+ *
+ * Input length must be a power of 2.
+ */
+export declare function fftJS(real: Float64Array, imag: Float64Array, inverse?: boolean): FFTResult;
+/**
+ * Check if the WASM FFT backend is available
+ */
+export declare function isWasmFFTAvailable(): boolean;
+/**
+ * Compute the Fast Fourier Transform.
+ *
+ * Automatically selects WASM or JS backend based on availability and
+ * array size. Input length must be a power of 2.
+ *
+ * @param real - Real part of input signal
+ * @param imag - Imaginary part (zeros for real-only input)
+ * @param config - Backend configuration
+ * @returns FFT result with real and imaginary arrays
+ */
+export declare function fft(real: Float64Array, imag: Float64Array, config?: FFTConfig): FFTResult;
+/**
+ * Compute the Inverse Fast Fourier Transform.
+ *
+ * @param real - Real part of frequency-domain signal
+ * @param imag - Imaginary part of frequency-domain signal
+ * @param config - Backend configuration
+ * @returns Time-domain signal with real and imaginary arrays
+ */
+export declare function ifft(real: Float64Array, imag: Float64Array, config?: FFTConfig): FFTResult;
+/**
+ * Compute the real FFT (real input -> complex output).
+ *
+ * Convenience wrapper that creates a zero imaginary array.
+ *
+ * @param data - Real-valued input signal (length must be power of 2)
+ * @param config - Backend configuration
+ * @returns FFT result
+ */
+export declare function rfft(data: Float64Array, config?: FFTConfig): FFTResult;
+/**
+ * Compute the power spectrum: |X[k]|^2 for each frequency bin.
+ *
+ * @param real - Real part of FFT output
+ * @param imag - Imaginary part of FFT output
+ * @returns Power spectrum array
+ */
+export declare function powerSpectrum(real: Float64Array, imag: Float64Array): Float64Array;
+/**
+ * Compute the magnitude spectrum: |X[k]| for each frequency bin.
+ *
+ * @param real - Real part of FFT output
+ * @param imag - Imaginary part of FFT output
+ * @returns Magnitude spectrum array
+ */
+export declare function magnitudeSpectrum(real: Float64Array, imag: Float64Array): Float64Array;
+/**
+ * Compute the phase spectrum: angle(X[k]) for each frequency bin.
+ *
+ * @param real - Real part of FFT output
+ * @param imag - Imaginary part of FFT output
+ * @returns Phase spectrum array (radians)
+ */
+export declare function phaseSpectrum(real: Float64Array, imag: Float64Array): Float64Array;
+/**
+ * FFT-based convolution: conv(signal, kernel) = IFFT(FFT(signal) * FFT(kernel))
+ *
+ * @param signal - Input signal
+ * @param kernel - Convolution kernel
+ * @param config - Backend configuration
+ * @returns Convolution result (length = signal.length + kernel.length - 1)
+ */
+export declare function convolve(signal: Float64Array, kernel: Float64Array, config?: FFTConfig): Float64Array;
+//# sourceMappingURL=fft-wasm.d.ts.map

package/dist/backends/wasm/fft-wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fft-wasm.d.ts","sourceRoot":"","sources":["../../../src/backends/wasm/fft-wasm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,uCAAuC;IACvC,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB,iDAAiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAqDD;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG9C;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,GAAE,OAAe,GAAG,SAAS,CA+EjG;AAMD;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAG5C;AA2CD;;;;;;;;;;GAUG;AACH,wBAAgB,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,GAAE,SAAc,GAAG,SAAS,CAgB7F;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,GAAE,SAAc,GAAG,SAAS,CAgB9F;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,GAAE,SAAc,GAAG,SAAS,CAqC1E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,CAkClF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,CAOtF;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,CAOlF;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,EACpB,MAAM,GAAE,SAAc,GACrB,YAAY,CAkCd"}

package/dist/backends/wasm/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WASM Utilities Index
+ * @packageDocumentation
+ */
+export { detectWasmFeatures, isWasmAvailable, isSharedMemoryAvailable, isAtomicsAvailable, clearFeatureCache, getCachedFeatures, } from './detect.js';
+export type { WasmFeatures } from './detect.js';
+export { fft as wasmFFT, ifft as wasmIFFT, rfft as wasmRFFT, fftJS, convolve as wasmConvolve, powerSpectrum, magnitudeSpectrum, phaseSpectrum, isPowerOf2, nextPowerOf2, isWasmFFTAvailable, } from './fft-wasm.js';
+export type { FFTResult, FFTBackend, FFTConfig } from './fft-wasm.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/backends/wasm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backends/wasm/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,uBAAuB,EACvB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,OAAO,EACL,GAAG,IAAI,OAAO,EACd,IAAI,IAAI,QAAQ,EAChB,IAAI,IAAI,QAAQ,EAChB,KAAK,EACL,QAAQ,IAAI,YAAY,EACxB,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,YAAY,EACZ,kBAAkB,GACnB,MAAM,eAAe,CAAC;AAEvB,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC"}

package/dist/backends/wasm/integrity.d.ts

@@ -0,0 +1,18 @@
+/**
+ * WASM integrity verification - SHA-384 manifest check.
+ *
+ * The shared runtime logic (`sha384OfBuffer` / `loadWasmManifest` /
+ * `verifyWasmIntegrity`) is consolidated in
+ * `@danielsimonjr/mathts-core/internal` (`core/src/wasm-loader.ts`) so `matrix`
+ * and `functions` build on ONE copy — see docs/Architecture/duplicate-symbols.json.
+ * matrix can't import from functions (that would invert the dep edge and create a
+ * cycle), but both packages depend on core, so core/internal is a shared home
+ * reachable from both without a cycle. This module re-exports it (plus the
+ * `WasmManifest` type) to preserve the local `./integrity.js` import surface.
+ *
+ * SECURITY INVARIANT (CLAUDE.md #1): the SHA-384 hash-and-compare-before-
+ * instantiate is unchanged — it now lives in core, byte-for-byte. Guarded by
+ * matrix/tests/security/wasm-integrity.test.ts.
+ */
+export { sha384OfBuffer, loadWasmManifest, verifyWasmIntegrity, type WasmManifest, } from '@danielsimonjr/mathts-core/internal';
+//# sourceMappingURL=integrity.d.ts.map

package/dist/backends/wasm/integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity.d.ts","sourceRoot":"","sources":["../../../src/backends/wasm/integrity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,KAAK,YAAY,GAClB,MAAM,qCAAqC,CAAC"}

package/dist/backends/wasm/resolve.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Packaged `.wasm` artifact resolution.
+ *
+ * `resolvePackagedWasm` and `defaultWasmLocation` are consolidated in
+ * `@danielsimonjr/mathts-core/internal` (`core/src/wasm-loader.ts`) — shared
+ * byte-for-byte with functions (see docs/Architecture/duplicate-symbols.json).
+ * matrix can't import from functions (cycle), but both depend on core, so
+ * core/internal is a shared home reachable from both without a cycle. Each caller
+ * injects its own `import.meta.url`, so resolution stays relative to this package.
+ */
+export { resolvePackagedWasm, defaultWasmLocation } from '@danielsimonjr/mathts-core/internal';
+//# sourceMappingURL=resolve.d.ts.map

package/dist/backends/wasm/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../src/backends/wasm/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC"}