@danielsimonjr/mathts-matrix 0.2.2 → 0.3.1

package/dist/index.js

@@ -2954,572 +2954,18 @@ function createWASMBackend(config) {
 // src/backends/GPUMatrixBackend.ts
 init_DenseMatrix();
 
-// src/backends/gpu/detect.ts
-var NO_WEBGPU_CAPABILITIES = {
-  supported: false,
-  adapterInfo: null,
-  maxBufferSize: 0,
-  maxWorkgroupSize: [0, 0, 0],
-  maxStorageBufferBindingSize: 0,
-  maxComputeInvocationsPerWorkgroup: 0,
-  maxComputeWorkgroupsPerDimension: 0,
-  isFallbackAdapter: false,
-  features: []
-};
-function hasWebGPU() {
-  if (typeof navigator === "undefined") {
-    return false;
-  }
-  return "gpu" in navigator;
-}
-async function getGPUAdapter(options) {
-  if (!hasWebGPU()) {
-    return null;
-  }
-  try {
-    const gpu = navigator.gpu;
-    const adapter = await gpu.requestAdapter(options);
-    return adapter;
-  } catch {
-    return null;
-  }
-}
-async function detectGPUCapabilities(preferHighPerformance = true) {
-  if (!hasWebGPU()) {
-    return NO_WEBGPU_CAPABILITIES;
-  }
-  try {
-    const gpu = navigator.gpu;
-    const adapter = await gpu.requestAdapter({
-      powerPreference: preferHighPerformance ? "high-performance" : "low-power"
-    });
-    if (!adapter) {
-      return NO_WEBGPU_CAPABILITIES;
-    }
-    const info = adapter.info || {};
-    const adapterInfo = {
-      vendor: info.vendor || "unknown",
-      architecture: info.architecture || "unknown",
-      device: info.device || "unknown",
-      description: info.description || "unknown"
-    };
-    const limits = adapter.limits;
-    const features = Array.from(adapter.features);
-    return {
-      supported: true,
-      adapterInfo,
-      maxBufferSize: limits.maxBufferSize,
-      maxWorkgroupSize: [
-        limits.maxComputeWorkgroupSizeX,
-        limits.maxComputeWorkgroupSizeY,
-        limits.maxComputeWorkgroupSizeZ
-      ],
-      maxStorageBufferBindingSize: limits.maxStorageBufferBindingSize,
-      maxComputeInvocationsPerWorkgroup: limits.maxComputeInvocationsPerWorkgroup,
-      maxComputeWorkgroupsPerDimension: limits.maxComputeWorkgroupsPerDimension,
-      isFallbackAdapter: adapter.isFallbackAdapter ?? false,
-      features
-    };
-  } catch {
-    return NO_WEBGPU_CAPABILITIES;
-  }
-}
-function getRecommendedWorkgroupSize(capabilities) {
-  if (!capabilities.supported) {
-    return [1, 1, 1];
-  }
-  const preferred = [16, 16, 1];
-  const maxX = capabilities.maxWorkgroupSize[0];
-  const maxY = capabilities.maxWorkgroupSize[1];
-  const maxTotal = capabilities.maxComputeInvocationsPerWorkgroup;
-  let x = Math.min(preferred[0], maxX);
-  let y = Math.min(preferred[1], maxY);
-  while (x * y > maxTotal) {
-    if (x > y) {
-      x = Math.floor(x / 2);
-    } else {
-      y = Math.floor(y / 2);
-    }
-  }
-  return [x, y, 1];
-}
-
-// src/backends/gpu/GPUContext.ts
-var GPUContext = class {
-  adapter = null;
-  device = null;
-  _status = "uninitialized";
-  _capabilities = null;
-  _lastError = null;
-  deviceLostCallbacks = [];
-  label;
-  constructor(options = {}) {
-    this.label = options.label || "MathTS-GPUContext";
-  }
-  /**
-   * Get the current status
-   */
-  get status() {
-    return this._status;
-  }
-  /**
-   * Check if context is ready
-   */
-  get isReady() {
-    return this._status === "ready" && this.device !== null;
-  }
-  /**
-   * Get the GPU device (throws if not initialized)
-   */
-  getDevice() {
-    if (!this.device) {
-      throw new Error("GPUContext not initialized. Call initialize() first.");
-    }
-    return this.device;
-  }
-  /**
-   * Get the GPU queue
-   */
-  getQueue() {
-    return this.getDevice().queue;
-  }
-  /**
-   * Get capabilities
-   */
-  get capabilities() {
-    return this._capabilities;
-  }
-  /**
-   * Get last error
-   */
-  get lastError() {
-    return this._lastError;
-  }
-  /**
-   * Initialize the GPU context
-   */
-  async initialize(options = {}) {
-    if (this._status === "ready") {
-      return true;
-    }
-    if (this._status === "initializing") {
-      throw new Error("Already initializing");
-    }
-    this._status = "initializing";
-    try {
-      if (!hasWebGPU()) {
-        throw new Error("WebGPU is not supported in this environment");
-      }
-      this._capabilities = await detectGPUCapabilities(options.preferHighPerformance ?? true);
-      if (!this._capabilities.supported) {
-        throw new Error("WebGPU adapter not available");
-      }
-      this.adapter = await getGPUAdapter({
-        powerPreference: options.preferHighPerformance ? "high-performance" : "low-power"
-      });
-      if (!this.adapter) {
-        throw new Error("Failed to get GPU adapter");
-      }
-      const deviceDescriptor = {
-        label: this.label,
-        requiredFeatures: options.requiredFeatures || [],
-        requiredLimits: options.requiredLimits || {}
-      };
-      this.device = await this.adapter.requestDevice(deviceDescriptor);
-      if (!this.device) {
-        throw new Error("Failed to get GPU device");
-      }
-      this.device.lost.then((info) => {
-        this._status = "lost";
-        const event = {
-          reason: info.reason,
-          message: info.message
-        };
-        this.deviceLostCallbacks.forEach((cb) => cb(event));
-      });
-      this.device.onuncapturederror = (event) => {
-        console.error("GPU uncaptured error:", event.error);
-        this._lastError = new Error(`GPU Error: ${event.error.message}`);
-      };
-      this._status = "ready";
-      return true;
-    } catch (error) {
-      this._status = "error";
-      this._lastError = error;
-      return false;
-    }
-  }
-  /**
-   * Register callback for device lost event
-   */
-  onDeviceLost(callback) {
-    this.deviceLostCallbacks.push(callback);
-  }
-  /**
-   * Create a command encoder
-   */
-  createCommandEncoder(label) {
-    return this.getDevice().createCommandEncoder({
-      label: label || `${this.label}-CommandEncoder`
-    });
-  }
-  /**
-   * Create a buffer
-   */
-  createBuffer(size2, usage, label, mappedAtCreation = false) {
-    return this.getDevice().createBuffer({
-      label: label || `${this.label}-Buffer`,
-      size: size2,
-      usage,
-      mappedAtCreation
-    });
-  }
-  /**
-   * Create a storage buffer for compute operations
-   */
-  createStorageBuffer(size2, label, readable = true, writable = true) {
-    let usage = GPUBufferUsage.STORAGE;
-    if (readable) {
-      usage |= GPUBufferUsage.COPY_SRC;
-    }
-    if (writable) {
-      usage |= GPUBufferUsage.COPY_DST;
-    }
-    return this.createBuffer(size2, usage, label);
-  }
-  /**
-   * Create a staging buffer for reading back data
-   */
-  createStagingBuffer(size2, label) {
-    return this.createBuffer(size2, GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST, label);
-  }
-  /**
-   * Create a compute pipeline
-   */
-  createComputePipeline(shaderModule, entryPoint, layout, label) {
-    return this.getDevice().createComputePipeline({
-      label: label || `${this.label}-ComputePipeline`,
-      layout: layout || "auto",
-      compute: {
-        module: shaderModule,
-        entryPoint
-      }
-    });
-  }
-  /**
-   * Create a shader module from WGSL source
-   */
-  createShaderModule(code, label) {
-    return this.getDevice().createShaderModule({
-      label: label || `${this.label}-ShaderModule`,
-      code
-    });
-  }
-  /**
-   * Create a bind group
-   */
-  createBindGroup(layout, entries, label) {
-    return this.getDevice().createBindGroup({
-      label: label || `${this.label}-BindGroup`,
-      layout,
-      entries
-    });
-  }
-  /**
-   * Submit commands to the GPU queue
-   */
-  submitCommands(commandBuffers) {
-    this.getQueue().submit(commandBuffers);
-  }
-  /**
-   * Write data to a buffer
-   */
-  writeBuffer(buffer, data, bufferOffset = 0, dataOffset, size2) {
-    this.getQueue().writeBuffer(buffer, bufferOffset, data, dataOffset, size2);
-  }
-  /**
-   * Read data from a buffer (async)
-   */
-  async readBuffer(buffer, offset = 0, size2) {
-    const readSize = size2 ?? buffer.size - offset;
-    const stagingBuffer = this.createStagingBuffer(readSize);
-    const encoder = this.createCommandEncoder();
-    encoder.copyBufferToBuffer(buffer, offset, stagingBuffer, 0, readSize);
-    this.submitCommands([encoder.finish()]);
-    await stagingBuffer.mapAsync(GPUMapMode.READ);
-    const data = stagingBuffer.getMappedRange().slice(0);
-    stagingBuffer.unmap();
-    stagingBuffer.destroy();
-    return data;
-  }
-  /**
-   * Dispatch a compute shader
-   */
-  dispatchCompute(pipeline, bindGroups, workgroupCounts) {
-    const encoder = this.createCommandEncoder();
-    const pass = encoder.beginComputePass();
-    pass.setPipeline(pipeline);
-    bindGroups.forEach((bg, i) => pass.setBindGroup(i, bg));
-    pass.dispatchWorkgroups(...workgroupCounts);
-    pass.end();
-    this.submitCommands([encoder.finish()]);
-  }
-  /**
-   * Wait for all GPU operations to complete
-   */
-  async waitForCompletion() {
-    await this.getQueue().onSubmittedWorkDone();
-  }
-  /**
-   * Destroy the context and release resources
-   */
-  destroy() {
-    if (this.device) {
-      this.device.destroy();
-      this.device = null;
-    }
-    this.adapter = null;
-    this._status = "uninitialized";
-    this._capabilities = null;
-    this.deviceLostCallbacks = [];
-  }
-};
-var globalContext = null;
-function getGlobalGPUContext() {
-  if (!globalContext) {
-    globalContext = new GPUContext({ label: "MathTS-Global" });
-  }
-  return globalContext;
-}
-function destroyGlobalGPU() {
-  if (globalContext) {
-    globalContext.destroy();
-    globalContext = null;
-  }
-}
-
-// src/backends/gpu/BufferPool.ts
-var DEFAULT_MAX_CACHE_SIZE = 512 * 1024 * 1024;
-var DEFAULT_EVICTION_TIMEOUT = 3e4;
-var DEFAULT_EVICTION_INTERVAL = 1e4;
-var BufferPool = class {
-  context;
-  buffers = /* @__PURE__ */ new Map();
-  maxCacheSize;
-  evictionTimeout;
-  evictionTimer = null;
-  currentCacheSize = 0;
-  constructor(context, options = {}) {
-    this.context = context;
-    this.maxCacheSize = options.maxCacheSize ?? DEFAULT_MAX_CACHE_SIZE;
-    this.evictionTimeout = options.evictionTimeout ?? DEFAULT_EVICTION_TIMEOUT;
-    if (options.autoEvict !== false) {
-      this.startAutoEviction(options.evictionInterval ?? DEFAULT_EVICTION_INTERVAL);
-    }
-  }
-  /**
-   * Generate a key for buffer categorization
-   */
-  getBufferKey(size2, usage) {
-    const roundedSize = this.roundUpToPowerOf2(size2);
-    return `${roundedSize}_${usage}`;
-  }
-  /**
-   * Round up to nearest power of 2
-   */
-  roundUpToPowerOf2(n) {
-    if (n <= 0) return 1;
-    let power = 1;
-    while (power < n && power < Number.MAX_SAFE_INTEGER) {
-      power *= 2;
-    }
-    return power;
-  }
-  /**
-   * Acquire a buffer from the pool or create a new one
-   */
-  acquire(size2, usage, label) {
-    const key = this.getBufferKey(size2, usage);
-    const entries = this.buffers.get(key);
-    if (entries) {
-      for (const entry2 of entries) {
-        if (!entry2.inUse && entry2.size >= size2) {
-          entry2.inUse = true;
-          entry2.lastUsed = Date.now();
-          entry2.label = label;
-          return entry2.buffer;
-        }
-      }
-    }
-    const roundedSize = this.roundUpToPowerOf2(size2);
-    const buffer = this.context.createBuffer(roundedSize, usage, label);
-    const entry = {
-      buffer,
-      size: roundedSize,
-      usage,
-      inUse: true,
-      lastUsed: Date.now(),
-      label
-    };
-    if (!this.buffers.has(key)) {
-      this.buffers.set(key, []);
-    }
-    this.buffers.get(key).push(entry);
-    this.currentCacheSize += roundedSize;
-    if (this.currentCacheSize > this.maxCacheSize) {
-      this.evictOldBuffers();
-    }
-    return buffer;
-  }
-  /**
-   * Release a buffer back to the pool
-   */
-  release(buffer) {
-    for (const entries of this.buffers.values()) {
-      for (const entry of entries) {
-        if (entry.buffer === buffer) {
-          entry.inUse = false;
-          entry.lastUsed = Date.now();
-          return;
-        }
-      }
-    }
-  }
-  /**
-   * Create a storage buffer from the pool
-   */
-  acquireStorageBuffer(size2, label, readable = true, writable = true) {
-    let usage = GPUBufferUsage.STORAGE;
-    if (readable) {
-      usage |= GPUBufferUsage.COPY_SRC;
-    }
-    if (writable) {
-      usage |= GPUBufferUsage.COPY_DST;
-    }
-    return this.acquire(size2, usage, label);
-  }
-  /**
-   * Create a staging buffer from the pool
-   */
-  acquireStagingBuffer(size2, label) {
-    return this.acquire(size2, GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST, label);
-  }
-  /**
-   * Create a uniform buffer from the pool
-   */
-  acquireUniformBuffer(size2, label) {
-    return this.acquire(size2, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, label);
-  }
-  /**
-   * Evict old unused buffers
-   */
-  evictOldBuffers() {
-    const now = Date.now();
-    const timeout = this.evictionTimeout;
-    for (const [key, entries] of this.buffers.entries()) {
-      const remaining = [];
-      for (const entry of entries) {
-        if (!entry.inUse && now - entry.lastUsed > timeout) {
-          entry.buffer.destroy();
-          this.currentCacheSize -= entry.size;
-        } else {
-          remaining.push(entry);
-        }
-      }
-      if (remaining.length === 0) {
-        this.buffers.delete(key);
-      } else {
-        this.buffers.set(key, remaining);
-      }
-    }
-  }
-  /**
-   * Force eviction to reduce cache to target size
-   */
-  evictToSize(targetSize) {
-    if (this.currentCacheSize <= targetSize) {
-      return;
-    }
-    const allEntries = [];
-    for (const [key, entries] of this.buffers.entries()) {
-      entries.forEach((entry, index) => {
-        if (!entry.inUse) {
-          allEntries.push({ key, entry, index });
-        }
-      });
-    }
-    allEntries.sort((a, b) => a.entry.lastUsed - b.entry.lastUsed);
-    for (const { key, entry, index } of allEntries) {
-      if (this.currentCacheSize <= targetSize) {
-        break;
-      }
-      const entries = this.buffers.get(key);
-      entry.buffer.destroy();
-      this.currentCacheSize -= entry.size;
-      entries.splice(index, 1);
-      if (entries.length === 0) {
-        this.buffers.delete(key);
-      }
-    }
-  }
-  /**
-   * Start automatic eviction timer
-   */
-  startAutoEviction(interval) {
-    this.stopAutoEviction();
-    this.evictionTimer = setInterval(() => {
-      this.evictOldBuffers();
-    }, interval);
-  }
-  /**
-   * Stop automatic eviction timer
-   */
-  stopAutoEviction() {
-    if (this.evictionTimer) {
-      clearInterval(this.evictionTimer);
-      this.evictionTimer = null;
-    }
-  }
-  /**
-   * Get pool statistics
-   */
-  getStats() {
-    let totalBuffers = 0;
-    let inUseBuffers = 0;
-    for (const entries of this.buffers.values()) {
-      totalBuffers += entries.length;
-      inUseBuffers += entries.filter((e) => e.inUse).length;
-    }
-    return {
-      totalBuffers,
-      inUseBuffers,
-      cachedBuffers: totalBuffers - inUseBuffers,
-      currentCacheSize: this.currentCacheSize,
-      maxCacheSize: this.maxCacheSize
-    };
-  }
-  /**
-   * Clear all buffers and reset pool
-   */
-  clear() {
-    this.stopAutoEviction();
-    for (const entries of this.buffers.values()) {
-      for (const entry of entries) {
-        entry.buffer.destroy();
-      }
-    }
-    this.buffers.clear();
-    this.currentCacheSize = 0;
-  }
-  /**
-   * Destroy the pool
-   */
-  destroy() {
-    this.clear();
-  }
-};
+// src/backends/GPUBackend.ts
+import {
+  GPUContext,
+  getGlobalGPUContext,
+  BufferPool,
+  ShaderManager,
+  hasWebGPU,
+  detectGPUCapabilities,
+  getRecommendedWorkgroupSize
+} from "@danielsimonjr/mathts-gpu";
 
-// src/backends/gpu/ShaderManager.ts
+// src/backends/gpu/builtin-shaders.ts
 var BUILTIN_SHADERS = {
   /** Matrix addition shader */
   matrixAdd: `
@@ -3647,7 +3093,11 @@ var BUILTIN_SHADERS = {
     @group(0) @binding(1) var<storage, read_write> output: array<f32>;
     @group(0) @binding(2) var<uniform> params: vec4<u32>; // inputLength, outputLength, _, _
 
-    var<workgroup> shared: array<f32, 256>;
+    // NOTE: 'shared' is a RESERVED KEYWORD in WGSL \u2014 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(
@@ -3665,2172 +3115,2103 @@ var BUILTIN_SHADERS = {
       if (idx + 256u < inputLength) {
         sum = sum + input[idx + 256u];
       }
-      shared[lid.x] = sum;
+      sdata[lid.x] = sum;
 
       workgroupBarrier();
 
       // Reduce within workgroup
       for (var s: u32 = 128u; s > 0u; s = s >> 1u) {
         if (lid.x < s) {
-          shared[lid.x] = shared[lid.x] + shared[lid.x + s];
+          sdata[lid.x] = sdata[lid.x] + sdata[lid.x + s];
         }
         workgroupBarrier();
       }
 
       // Write result
       if (lid.x == 0u) {
-        output[wid.x] = shared[0];
+        output[wid.x] = sdata[0];
       }
     }
   `
 };
-var ShaderManager = class {
-  context;
-  cache = /* @__PURE__ */ new Map();
-  constructor(context) {
-    this.context = context;
-  }
-  /**
-   * Get or compile a shader module
-   */
-  getShaderModule(name, code) {
-    let entry = this.cache.get(name);
-    if (entry) {
-      return entry.module;
-    }
-    const module = this.context.createShaderModule(code, name);
-    entry = {
-      module,
-      pipelines: /* @__PURE__ */ new Map(),
-      createdAt: Date.now()
-    };
-    this.cache.set(name, entry);
-    return module;
+function registerBuiltinShaders(sm) {
+  for (const [name, code] of Object.entries(BUILTIN_SHADERS)) {
+    sm.registerShader(name, code);
   }
-  /**
-   * Get a builtin shader module
-   */
-  getBuiltinShader(name) {
-    const code = BUILTIN_SHADERS[name];
-    if (!code) {
-      throw new Error(`Unknown builtin shader: ${name}`);
-    }
-    return this.getShaderModule(`builtin:${name}`, code);
-  }
-  /**
-   * Get or create a compute pipeline
-   */
-  getPipeline(shaderName, entryPoint, code, layout) {
-    const pipelineKey = `${shaderName}:${entryPoint}`;
-    let entry = this.cache.get(shaderName);
-    if (entry) {
-      const pipeline2 = entry.pipelines.get(pipelineKey);
-      if (pipeline2) {
-        return pipeline2;
-      }
-    } else if (code) {
-      this.getShaderModule(shaderName, code);
-      entry = this.cache.get(shaderName);
-    } else {
-      throw new Error(`Shader not found: ${shaderName}`);
-    }
-    const pipeline = this.context.createComputePipeline(
-      entry.module,
-      entryPoint,
-      layout,
-      pipelineKey
-    );
-    entry.pipelines.set(pipelineKey, pipeline);
-    return pipeline;
+}
+
+// src/backends/GPUBackend.ts
+var DEFAULT_THRESHOLD = 256;
+var GPUBackend = class {
+  context = null;
+  bufferPool = null;
+  shaderManager = null;
+  _status = "uninitialized";
+  _capabilities = null;
+  _lastError = null;
+  threshold;
+  workgroupSize = [16, 16, 1];
+  useGlobalContext;
+  constructor(options = {}) {
+    this.threshold = options.threshold ?? DEFAULT_THRESHOLD;
+    this.useGlobalContext = options.useGlobalContext ?? true;
   }
   /**
-   * Get a builtin compute pipeline
+   * Get the current status
    */
-  getBuiltinPipeline(name, entryPoint = "main") {
-    const shaderName = `builtin:${name}`;
-    const code = BUILTIN_SHADERS[name];
-    return this.getPipeline(shaderName, entryPoint, code);
+  get status() {
+    return this._status;
   }
   /**
-   * Precompile all builtin shaders
+   * Check if backend is ready
    */
-  precompileBuiltins() {
-    for (const name of Object.keys(BUILTIN_SHADERS)) {
-      this.getBuiltinShader(name);
-      this.getBuiltinPipeline(name);
-    }
+  get isReady() {
+    return this._status === "ready";
   }
   /**
-   * Clear shader cache
+   * Get capabilities
    */
-  clearCache() {
-    this.cache.clear();
+  get capabilities() {
+    return this._capabilities;
   }
   /**
-   * Get cache statistics
+   * Get last error
    */
-  getStats() {
-    let cachedShaders = 0;
-    let cachedPipelines = 0;
-    for (const entry of this.cache.values()) {
-      cachedShaders++;
-      cachedPipelines += entry.pipelines.size;
-    }
-    return { cachedShaders, cachedPipelines };
+  get lastError() {
+    return this._lastError;
   }
-};
-
-// src/backends/gpu/BatchExecutor.ts
-var BatchExecutor = class {
-  context;
-  shaders;
-  bufferPool;
-  operations = [];
-  options;
   /**
-   * Create a new batch executor
+   * Initialize the GPU backend
    */
-  constructor(context, shaders, bufferPool, options = {}) {
-    this.context = context;
-    this.shaders = shaders;
-    this.bufferPool = bufferPool;
-    this.options = {
-      maxBatchSize: options.maxBatchSize ?? 100,
-      autoFlush: options.autoFlush ?? true,
-      waitForCompletion: options.waitForCompletion ?? true
-    };
+  async initialize(options = {}) {
+    if (this._status === "ready") {
+      return true;
+    }
+    if (this._status === "initializing") {
+      throw new Error("Already initializing");
+    }
+    this._status = "initializing";
+    try {
+      if (!hasWebGPU()) {
+        this._status = "unsupported";
+        this._lastError = new Error("WebGPU is not supported");
+        return false;
+      }
+      this._capabilities = await detectGPUCapabilities(options.preferHighPerformance ?? true);
+      if (!this._capabilities.supported) {
+        this._status = "unsupported";
+        this._lastError = new Error("WebGPU adapter not available");
+        return false;
+      }
+      if (this.useGlobalContext) {
+        this.context = getGlobalGPUContext();
+      } else {
+        this.context = new GPUContext({ label: "GPUBackend" });
+      }
+      const success = await this.context.initialize(options);
+      if (!success) {
+        this._status = "error";
+        this._lastError = this.context.lastError;
+        return false;
+      }
+      this.bufferPool = new BufferPool(this.context, options.bufferPoolOptions);
+      this.shaderManager = new ShaderManager(this.context);
+      registerBuiltinShaders(this.shaderManager);
+      this.shaderManager.precompileRegistered();
+      this.workgroupSize = getRecommendedWorkgroupSize(this._capabilities);
+      this._status = "ready";
+      return true;
+    } catch (error) {
+      this._status = "error";
+      this._lastError = error;
+      return false;
+    }
   }
   /**
-   * Get current batch size
+   * Check if GPU should be used for the given matrix size
    */
-  get size() {
-    return this.operations.length;
+  shouldUseGPU(rows, cols) {
+    if (!this.isReady) {
+      return false;
+    }
+    return rows >= this.threshold || cols >= this.threshold;
   }
   /**
-   * Check if batch is empty
+   * Calculate workgroup counts for a matrix
    */
-  get isEmpty() {
-    return this.operations.length === 0;
+  calculateWorkgroups(rows, cols) {
+    const [wgX, wgY] = this.workgroupSize;
+    return [Math.ceil(cols / wgX), Math.ceil(rows / wgY), 1];
   }
   /**
-   * Check if batch is full
+   * Get the GPU context
    */
-  get isFull() {
-    return this.operations.length >= this.options.maxBatchSize;
+  getContext() {
+    if (!this.context || !this.isReady) {
+      throw new Error("GPUBackend not initialized");
+    }
+    return this.context;
   }
   /**
-   * Queue an add operation
+   * Get the buffer pool
    */
-  add(inputA, inputB, output, dimensions) {
-    this.queueOperation({
-      type: "add",
-      inputA,
-      inputB,
-      output,
-      dimensions
-    });
+  getBufferPool() {
+    if (!this.bufferPool || !this.isReady) {
+      throw new Error("GPUBackend not initialized");
+    }
+    return this.bufferPool;
   }
   /**
-   * Queue a subtract operation
+   * Get the shader manager
    */
-  subtract(inputA, inputB, output, dimensions) {
-    this.queueOperation({
-      type: "subtract",
-      inputA,
-      inputB,
-      output,
-      dimensions
-    });
+  getShaderManager() {
+    if (!this.shaderManager || !this.isReady) {
+      throw new Error("GPUBackend not initialized");
+    }
+    return this.shaderManager;
   }
   /**
-   * Queue an element-wise multiply operation
+   * Add two matrices element-wise
    */
-  multiply(inputA, inputB, output, dimensions) {
-    this.queueOperation({
-      type: "multiply",
-      inputA,
-      inputB,
-      output,
-      dimensions
-    });
+  async add(a, b, rows, cols) {
+    const ctx = this.getContext();
+    const pool = this.getBufferPool();
+    const shaders = this.getShaderManager();
+    const size2 = rows * cols * 4;
+    const bufferA = pool.acquireStorageBuffer(size2, "matrix-a", true, true);
+    const bufferB = pool.acquireStorageBuffer(size2, "matrix-b", true, true);
+    const bufferResult = pool.acquireStorageBuffer(size2, "matrix-result", true, false);
+    const bufferParams = pool.acquireUniformBuffer(16, "params");
+    ctx.writeBuffer(bufferA, a);
+    ctx.writeBuffer(bufferB, b);
+    ctx.writeBuffer(bufferParams, new Uint32Array([rows, cols, 0, 0]));
+    const pipeline = shaders.getRegisteredPipeline("matrixAdd");
+    const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
+      { binding: 0, resource: { buffer: bufferA } },
+      { binding: 1, resource: { buffer: bufferB } },
+      { binding: 2, resource: { buffer: bufferResult } },
+      { binding: 3, resource: { buffer: bufferParams } }
+    ]);
+    ctx.dispatchCompute(pipeline, [bindGroup], this.calculateWorkgroups(rows, cols));
+    const resultData = await ctx.readBuffer(bufferResult);
+    pool.release(bufferA);
+    pool.release(bufferB);
+    pool.release(bufferResult);
+    pool.release(bufferParams);
+    return new Float32Array(resultData);
   }
   /**
-   * Queue a scale operation
+   * Multiply two matrices
    */
-  scale(input, output, scalar, dimensions) {
-    this.queueOperation({
-      type: "scale",
-      inputA: input,
-      output,
-      dimensions,
-      scalar
-    });
+  async matmul(a, b, M, K, N) {
+    const ctx = this.getContext();
+    const pool = this.getBufferPool();
+    const shaders = this.getShaderManager();
+    const sizeA = M * K * 4;
+    const sizeB = K * N * 4;
+    const sizeResult = M * N * 4;
+    const bufferA = pool.acquireStorageBuffer(sizeA, "matmul-a", true, true);
+    const bufferB = pool.acquireStorageBuffer(sizeB, "matmul-b", true, true);
+    const bufferResult = pool.acquireStorageBuffer(sizeResult, "matmul-result", true, false);
+    const bufferParams = pool.acquireUniformBuffer(16, "params");
+    ctx.writeBuffer(bufferA, a);
+    ctx.writeBuffer(bufferB, b);
+    ctx.writeBuffer(bufferParams, new Uint32Array([M, N, K, 0]));
+    const pipeline = shaders.getRegisteredPipeline("matmul");
+    const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
+      { binding: 0, resource: { buffer: bufferA } },
+      { binding: 1, resource: { buffer: bufferB } },
+      { binding: 2, resource: { buffer: bufferResult } },
+      { binding: 3, resource: { buffer: bufferParams } }
+    ]);
+    ctx.dispatchCompute(pipeline, [bindGroup], this.calculateWorkgroups(M, N));
+    const resultData = await ctx.readBuffer(bufferResult);
+    pool.release(bufferA);
+    pool.release(bufferB);
+    pool.release(bufferResult);
+    pool.release(bufferParams);
+    return new Float32Array(resultData);
   }
   /**
-   * Queue a matrix multiplication operation
+   * Transpose a matrix
    */
-  matmul(inputA, inputB, output, dimensions) {
-    this.queueOperation({
-      type: "matmul",
-      inputA,
-      inputB,
-      output,
-      dimensions
-    });
+  async transpose(a, rows, cols) {
+    const ctx = this.getContext();
+    const pool = this.getBufferPool();
+    const shaders = this.getShaderManager();
+    const size2 = rows * cols * 4;
+    const bufferA = pool.acquireStorageBuffer(size2, "transpose-a", true, true);
+    const bufferResult = pool.acquireStorageBuffer(size2, "transpose-result", true, false);
+    const bufferParams = pool.acquireUniformBuffer(16, "params");
+    ctx.writeBuffer(bufferA, a);
+    ctx.writeBuffer(bufferParams, new Uint32Array([rows, cols, 0, 0]));
+    const pipeline = shaders.getRegisteredPipeline("transpose");
+    const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
+      { binding: 0, resource: { buffer: bufferA } },
+      { binding: 1, resource: { buffer: bufferResult } },
+      { binding: 2, resource: { buffer: bufferParams } }
+    ]);
+    ctx.dispatchCompute(pipeline, [bindGroup], this.calculateWorkgroups(rows, cols));
+    const resultData = await ctx.readBuffer(bufferResult);
+    pool.release(bufferA);
+    pool.release(bufferResult);
+    pool.release(bufferParams);
+    return new Float32Array(resultData);
   }
   /**
-   * Queue a transpose operation
+   * Scale a matrix by a scalar
    */
-  transpose(input, output, dimensions) {
-    this.queueOperation({
-      type: "transpose",
-      inputA: input,
-      output,
-      dimensions
-    });
+  async scale(a, scalar) {
+    const ctx = this.getContext();
+    const pool = this.getBufferPool();
+    const shaders = this.getShaderManager();
+    const size2 = a.length * 4;
+    const bufferA = pool.acquireStorageBuffer(size2, "scale-a", true, true);
+    const bufferResult = pool.acquireStorageBuffer(size2, "scale-result", true, false);
+    const bufferParams = pool.acquireUniformBuffer(16, "params");
+    ctx.writeBuffer(bufferA, a);
+    ctx.writeBuffer(bufferParams, new Float32Array([scalar, a.length, 0, 0]));
+    const pipeline = shaders.getRegisteredPipeline("scalarMul");
+    const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
+      { binding: 0, resource: { buffer: bufferA } },
+      { binding: 1, resource: { buffer: bufferResult } },
+      { binding: 2, resource: { buffer: bufferParams } }
+    ]);
+    const workgroups = Math.ceil(a.length / 256);
+    ctx.dispatchCompute(pipeline, [bindGroup], [workgroups, 1, 1]);
+    const resultData = await ctx.readBuffer(bufferResult);
+    pool.release(bufferA);
+    pool.release(bufferResult);
+    pool.release(bufferParams);
+    return new Float32Array(resultData);
   }
   /**
-   * Queue a sum reduction operation
+   * Get backend statistics
    */
-  reduceSum(input, output, dimensions) {
-    this.queueOperation({
-      type: "reduce_sum",
-      inputA: input,
-      output,
-      dimensions
-    });
+  getStats() {
+    return {
+      status: this._status,
+      capabilities: this._capabilities,
+      bufferPool: this.bufferPool?.getStats() || null,
+      shaders: this.shaderManager?.getStats() || null
+    };
   }
   /**
-   * Queue operation (internal)
+   * Destroy the backend
    */
-  queueOperation(op) {
-    this.operations.push(op);
-    if (this.options.autoFlush && this.isFull) {
-      this.flushSync();
+  destroy() {
+    if (this.bufferPool) {
+      this.bufferPool.destroy();
+      this.bufferPool = null;
+    }
+    if (this.shaderManager) {
+      this.shaderManager.clearCache();
+      this.shaderManager = null;
+    }
+    if (this.context && !this.useGlobalContext) {
+      this.context.destroy();
     }
+    this.context = null;
+    this._status = "uninitialized";
+  }
+};
+var globalBackend = null;
+function getGlobalGPUBackend() {
+  if (!globalBackend) {
+    globalBackend = new GPUBackend({ useGlobalContext: true });
+  }
+  return globalBackend;
+}
+async function initializeGlobalGPUBackend(options) {
+  const backend = getGlobalGPUBackend();
+  return backend.initialize(options);
+}
+function destroyGlobalGPUBackend() {
+  if (globalBackend) {
+    globalBackend.destroy();
+    globalBackend = null;
+  }
+}
+
+// src/backends/GPUMatrixBackend.ts
+import { hasWebGPU as hasWebGPU2, detectGPUCapabilities as detectGPUCapabilities2 } from "@danielsimonjr/mathts-gpu";
+var DEFAULT_CONFIG2 = {
+  minElements: 65536,
+  // 256x256
+  useGlobalBackend: true,
+  gpuOptions: {},
+  fallbackOnError: true
+};
+var GPUMatrixBackend = class {
+  type = "gpu";
+  config;
+  backend = null;
+  capabilities = null;
+  initPromise = null;
+  _available = null;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG2, ...config };
   }
   /**
-   * Flush all queued operations (async)
+   * Check if GPU is available in the current environment
    */
-  async flush() {
-    if (this.isEmpty) {
-      return {
-        success: true,
-        operationCount: 0,
-        duration: 0
-      };
-    }
-    const start = performance.now();
-    const operationCount = this.operations.length;
-    try {
-      const encoder = this.context.createCommandEncoder();
-      for (const op of this.operations) {
-        this.encodeOperation(encoder, op);
-      }
-      const commandBuffer = encoder.finish();
-      this.context.submitCommands([commandBuffer]);
-      if (this.options.waitForCompletion) {
-        await this.context.getDevice().queue.onSubmittedWorkDone();
-      }
-      this.operations = [];
-      return {
-        success: true,
-        operationCount,
-        duration: performance.now() - start
-      };
-    } catch (error) {
-      return {
-        success: false,
-        operationCount,
-        duration: performance.now() - start,
-        error: error instanceof Error ? error.message : String(error)
-      };
+  isAvailable() {
+    if (this._available !== null) {
+      return this._available;
     }
+    this._available = hasWebGPU2();
+    return this._available;
   }
   /**
-   * Flush synchronously (fire and forget)
+   * Initialize the GPU backend
    */
-  flushSync() {
-    if (this.isEmpty) return;
-    try {
-      const encoder = this.context.createCommandEncoder();
-      for (const op of this.operations) {
-        this.encodeOperation(encoder, op);
+  async initialize() {
+    if (this.backend?.isReady) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this.doInitialize();
+    return this.initPromise;
+  }
+  async doInitialize() {
+    if (!this.isAvailable()) {
+      throw new Error("WebGPU is not available in this environment");
+    }
+    this.capabilities = await detectGPUCapabilities2(
+      this.config.gpuOptions?.preferHighPerformance ?? true
+    );
+    if (!this.capabilities.supported) {
+      throw new Error("WebGPU adapter not available");
+    }
+    if (this.config.useGlobalBackend) {
+      const success = await initializeGlobalGPUBackend(this.config.gpuOptions);
+      if (!success) {
+        throw new Error("Failed to initialize global GPU backend");
+      }
+      this.backend = getGlobalGPUBackend();
+    } else {
+      this.backend = new GPUBackend(this.config.gpuOptions);
+      const success = await this.backend.initialize(this.config.gpuOptions);
+      if (!success) {
+        throw new Error(`Failed to initialize GPU backend: ${this.backend.lastError?.message}`);
       }
-      const commandBuffer = encoder.finish();
-      this.context.submitCommands([commandBuffer]);
-      this.operations = [];
-    } catch {
     }
   }
   /**
-   * Encode a single operation into the command encoder
+   * Check if operation should use GPU
    */
-  encodeOperation(encoder, op) {
-    const pipelineName = this.getPipelineName(op.type);
-    const pipeline = this.shaders.getBuiltinPipeline(pipelineName);
-    const entries = [{ binding: 0, resource: { buffer: op.inputA } }];
-    if (op.inputB) {
-      entries.push({ binding: 1, resource: { buffer: op.inputB } });
-    }
-    entries.push({
-      binding: op.inputB ? 2 : 1,
-      resource: { buffer: op.output }
-    });
-    const params = this.createParamsBuffer(op);
-    entries.push({
-      binding: entries.length,
-      resource: { buffer: params }
-    });
-    const bindGroup = this.context.getDevice().createBindGroup({
-      layout: pipeline.getBindGroupLayout(0),
-      entries
-    });
-    const passEncoder = encoder.beginComputePass();
-    passEncoder.setPipeline(pipeline);
-    passEncoder.setBindGroup(0, bindGroup);
-    const [wgX, wgY, wgZ] = this.calculateWorkgroups(op);
-    passEncoder.dispatchWorkgroups(wgX, wgY, wgZ);
-    passEncoder.end();
+  shouldUseGPU(elementCount) {
+    return this.backend !== null && this.backend.isReady && elementCount >= this.config.minElements;
   }
   /**
-   * Get pipeline name for operation type
+   * Execute GPU operation with fallback
    */
-  getPipelineName(type) {
-    const mapping = {
-      add: "matrixAdd",
-      subtract: "matrixSub",
-      multiply: "matrixMul",
-      divide: "matrixDiv",
-      scale: "scalarMul",
-      matmul: "matmul",
-      transpose: "transpose",
-      reduce_sum: "sumReduce",
-      reduce_max: "maxReduce",
-      reduce_min: "minReduce"
-    };
-    return mapping[type] || "matrixAdd";
+  async executeWithFallback(gpuOp, fallback) {
+    if (!this.config.fallbackOnError) {
+      return gpuOp();
+    }
+    try {
+      return await gpuOp();
+    } catch (error) {
+      console.warn("GPU operation failed, falling back to JS:", error);
+      return fallback();
+    }
   }
   /**
-   * Create params buffer for operation
+   * Get GPU capabilities
    */
-  createParamsBuffer(op) {
-    const { rows, cols, k } = op.dimensions;
-    let data;
-    if (op.type === "matmul" && k !== void 0) {
-      data = new Uint32Array([rows, cols, k, 0]);
-    } else if (op.type === "scale" && op.scalar !== void 0) {
-      const floatArray = new Float32Array([op.scalar]);
-      const uintView = new Uint32Array(floatArray.buffer);
-      data = new Uint32Array([rows, cols, uintView[0], 0]);
-    } else {
-      data = new Uint32Array([rows, cols, 0, 0]);
-    }
-    const buffer = this.bufferPool.acquireUniformBuffer(16, "batch-params");
-    this.context.writeBuffer(buffer, data);
-    return buffer;
+  getCapabilities() {
+    return this.capabilities;
   }
   /**
-   * Calculate workgroup dispatch counts
+   * Get backend statistics
    */
-  calculateWorkgroups(op) {
-    const { rows, cols } = op.dimensions;
-    const workgroupSize = 16;
-    if (op.type === "reduce_sum" || op.type === "reduce_max" || op.type === "reduce_min") {
-      const total = rows * cols;
-      return [Math.ceil(total / 256), 1, 1];
+  getStats() {
+    return this.backend?.getStats() ?? null;
+  }
+  // =========================================================================
+  // Element-wise Operations
+  // =========================================================================
+  add(a, b) {
+    const elementCount = a.rows * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.add(a, b);
     }
-    return [Math.ceil(cols / workgroupSize), Math.ceil(rows / workgroupSize), 1];
+    return jsBackend.add(a, b);
   }
   /**
-   * Clear all queued operations without executing
+   * Async add operation using GPU
    */
-  clear() {
-    this.operations = [];
+  async addAsync(a, b) {
+    const elementCount = a.rows * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.add(a, b);
+    }
+    return this.executeWithFallback(
+      async () => {
+        const aData = new Float32Array(a.toFloat64Array());
+        const bData = new Float32Array(b.toFloat64Array());
+        const result = await this.backend.add(aData, bData, a.rows, a.cols);
+        return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
+      },
+      () => jsBackend.add(a, b)
+    );
   }
-  /**
-   * Get statistics about the batch executor
-   */
-  getStats() {
-    return {
-      queuedOperations: this.operations.length,
-      maxBatchSize: this.options.maxBatchSize,
-      autoFlush: this.options.autoFlush
-    };
+  subtract(a, b) {
+    const elementCount = a.rows * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.subtract(a, b);
+    }
+    return jsBackend.subtract(a, b);
   }
-};
-
-// src/backends/gpu/Sync.ts
-var SyncManager = class {
-  context;
-  config;
-  pendingTransfers = /* @__PURE__ */ new Map();
-  nextRequestId = 0;
-  stagingBuffers = [];
-  // Statistics
-  totalUploads = 0;
-  totalDownloads = 0;
-  totalBytesUploaded = 0;
-  totalBytesDownloaded = 0;
-  constructor(context, _bufferPool, config = {}) {
-    this.context = context;
-    this.config = {
-      strategy: config.strategy ?? "lazy",
-      chunkSize: config.chunkSize ?? 1024 * 1024,
-      // 1MB default
-      maxPendingTransfers: config.maxPendingTransfers ?? 16,
-      coalesceTransfers: config.coalesceTransfers ?? true
-    };
+  multiplyElementwise(a, b) {
+    const elementCount = a.rows * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.multiplyElementwise(a, b);
+    }
+    return jsBackend.multiplyElementwise(a, b);
   }
-  /**
-   * Upload data from CPU to GPU
-   */
-  async upload(cpuData, gpuBuffer, options = {}) {
-    const id = this.nextRequestId++;
-    const start = performance.now();
-    try {
-      const offset = options.offset ?? 0;
-      const size2 = options.size ?? cpuData.byteLength;
-      this.context.writeBuffer(gpuBuffer, cpuData, offset);
-      if (this.config.strategy === "immediate") {
-        await this.context.getDevice().queue.onSubmittedWorkDone();
-      }
-      this.totalUploads++;
-      this.totalBytesUploaded += size2;
-      return {
-        id,
-        success: true,
-        duration: performance.now() - start,
-        bytesTransferred: size2
-      };
-    } catch (error) {
-      return {
-        id,
-        success: false,
-        duration: performance.now() - start,
-        bytesTransferred: 0,
-        error: error instanceof Error ? error.message : String(error)
-      };
+  divideElementwise(a, b) {
+    const elementCount = a.rows * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.divideElementwise(a, b);
     }
+    return jsBackend.divideElementwise(a, b);
   }
-  /**
-   * Download data from GPU to CPU
-   */
-  async download(gpuBuffer, options = {}) {
-    const offset = options.offset ?? 0;
-    const size2 = options.size ?? gpuBuffer.size;
-    this.totalDownloads++;
-    this.totalBytesDownloaded += size2;
-    const buffer = await this.context.readBuffer(gpuBuffer, offset, size2);
-    return new Float32Array(buffer);
+  scale(a, scalar) {
+    const elementCount = a.rows * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.scale(a, scalar);
+    }
+    return jsBackend.scale(a, scalar);
   }
   /**
-   * Download data using double-buffering for overlap
+   * Async scale operation using GPU
    */
-  async downloadDoubleBuffered(gpuBuffer, size2) {
-    const staging1 = this.getOrCreateStagingBuffer(size2);
-    const encoder = this.context.createCommandEncoder();
-    encoder.copyBufferToBuffer(gpuBuffer, 0, staging1, 0, size2);
-    this.context.submitCommands([encoder.finish()]);
-    await staging1.mapAsync(GPUMapMode.READ);
-    const data = new Float32Array(staging1.getMappedRange().slice(0));
-    staging1.unmap();
-    return data;
+  async scaleAsync(a, scalar) {
+    const elementCount = a.rows * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.scale(a, scalar);
+    }
+    return this.executeWithFallback(
+      async () => {
+        const aData = new Float32Array(a.toFloat64Array());
+        const result = await this.backend.scale(aData, scalar);
+        return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
+      },
+      () => jsBackend.scale(a, scalar)
+    );
   }
-  /**
-   * Stream large data in chunks
-   */
-  async uploadStreaming(cpuData, gpuBuffer, onProgress) {
-    const id = this.nextRequestId++;
-    const start = performance.now();
-    const chunkSize = this.config.chunkSize / 4;
-    const totalElements = cpuData.length;
-    let transferred = 0;
-    try {
-      for (let offset = 0; offset < totalElements; offset += chunkSize) {
-        const end = Math.min(offset + chunkSize, totalElements);
-        const chunk = cpuData.subarray(offset, end);
-        this.context.writeBuffer(
-          gpuBuffer,
-          chunk,
-          offset * 4
-          // byte offset
-        );
-        transferred = end;
-        if (onProgress) {
-          onProgress(transferred / totalElements);
-        }
-        await new Promise((resolve) => setTimeout(resolve, 0));
-      }
-      await this.context.getDevice().queue.onSubmittedWorkDone();
-      this.totalUploads++;
-      this.totalBytesUploaded += totalElements * 4;
-      return {
-        id,
-        success: true,
-        duration: performance.now() - start,
-        bytesTransferred: totalElements * 4
-      };
-    } catch (error) {
-      return {
-        id,
-        success: false,
-        duration: performance.now() - start,
-        bytesTransferred: transferred * 4,
-        error: error instanceof Error ? error.message : String(error)
-      };
+  abs(a) {
+    return jsBackend.abs(a);
+  }
+  negate(a) {
+    return jsBackend.negate(a);
+  }
+  // =========================================================================
+  // Matrix Operations
+  // =========================================================================
+  multiply(a, b) {
+    const elementCount = a.rows * b.cols * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.multiply(a, b);
     }
+    return jsBackend.multiply(a, b);
   }
   /**
-   * Download large data in chunks
+   * Async matrix multiplication using GPU
    */
-  async downloadStreaming(gpuBuffer, totalSize, onProgress) {
-    const result = new Float32Array(totalSize / 4);
-    const chunkSize = this.config.chunkSize;
-    let downloaded = 0;
-    while (downloaded < totalSize) {
-      const remaining = totalSize - downloaded;
-      const currentChunkSize = Math.min(chunkSize, remaining);
-      const chunk = await this.download(gpuBuffer, {
-        offset: downloaded,
-        size: currentChunkSize
-      });
-      result.set(chunk, downloaded / 4);
-      downloaded += currentChunkSize;
-      if (onProgress) {
-        onProgress(downloaded / totalSize);
-      }
+  async multiplyAsync(a, b) {
+    const elementCount = a.rows * b.cols * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.multiply(a, b);
     }
-    return result;
+    return this.executeWithFallback(
+      async () => {
+        const aData = new Float32Array(a.toFloat64Array());
+        const bData = new Float32Array(b.toFloat64Array());
+        const result = await this.backend.matmul(aData, bData, a.rows, a.cols, b.cols);
+        return DenseMatrix.fromFlat(a.rows, b.cols, Array.from(result));
+      },
+      () => jsBackend.multiply(a, b)
+    );
+  }
+  transpose(a) {
+    const elementCount = a.rows * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.transpose(a);
+    }
+    return jsBackend.transpose(a);
   }
   /**
-   * Batch multiple transfers
+   * Async transpose using GPU
    */
-  async batchTransfer(requests) {
-    const results = [];
-    const start = performance.now();
-    const uploads = requests.filter((r) => r.direction === "cpu-to-gpu");
-    const downloads = requests.filter((r) => r.direction === "gpu-to-cpu");
-    for (const req of uploads) {
-      const result = await this.upload(req.data, req.buffer);
-      results.push(result);
-    }
-    for (const req of downloads) {
-      const id = this.nextRequestId++;
-      try {
-        const data = await this.download(req.buffer);
-        req.data.set(data);
-        results.push({
-          id,
-          success: true,
-          duration: performance.now() - start,
-          bytesTransferred: data.byteLength
-        });
-      } catch (error) {
-        results.push({
-          id,
-          success: false,
-          duration: performance.now() - start,
-          bytesTransferred: 0,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
+  async transposeAsync(a) {
+    const elementCount = a.rows * a.cols;
+    if (!this.shouldUseGPU(elementCount)) {
+      return jsBackend.transpose(a);
     }
-    return results;
+    return this.executeWithFallback(
+      async () => {
+        const aData = new Float32Array(a.toFloat64Array());
+        const result = await this.backend.transpose(aData, a.rows, a.cols);
+        return DenseMatrix.fromFlat(a.cols, a.rows, Array.from(result));
+      },
+      () => jsBackend.transpose(a)
+    );
   }
-  /**
-   * Create or reuse a staging buffer
-   */
-  getOrCreateStagingBuffer(size2) {
-    const alignedSize = this.roundToPowerOf2(size2);
-    for (const buffer2 of this.stagingBuffers) {
-      if (buffer2.size >= alignedSize) {
-        return buffer2;
-      }
-    }
-    const buffer = this.context.createStagingBuffer(alignedSize, "sync-staging");
-    this.stagingBuffers.push(buffer);
-    return buffer;
+  // =========================================================================
+  // Reduction Operations
+  // =========================================================================
+  sum(a) {
+    return jsBackend.sum(a);
   }
-  /**
-   * Round up to next power of 2
-   */
-  roundToPowerOf2(n) {
-    if (n <= 0) return 256;
-    n--;
-    n |= n >> 1;
-    n |= n >> 2;
-    n |= n >> 4;
-    n |= n >> 8;
-    n |= n >> 16;
-    return n + 1;
+  sumAxis(a, axis) {
+    return jsBackend.sumAxis(a, axis);
+  }
+  norm(a) {
+    return jsBackend.norm(a);
+  }
+  dot(a, b) {
+    return jsBackend.dot(a, b);
   }
+  // =========================================================================
+  // Configuration
+  // =========================================================================
   /**
-   * Wait for all pending transfers to complete
+   * Update configuration
    */
-  async flush() {
-    await this.context.getDevice().queue.onSubmittedWorkDone();
-    await Promise.all(this.pendingTransfers.values());
-    this.pendingTransfers.clear();
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
   }
   /**
-   * Get synchronization statistics
+   * Get current configuration
    */
-  getStats() {
-    return {
-      totalUploads: this.totalUploads,
-      totalDownloads: this.totalDownloads,
-      totalBytesUploaded: this.totalBytesUploaded,
-      totalBytesDownloaded: this.totalBytesDownloaded,
-      pendingTransfers: this.pendingTransfers.size,
-      stagingBuffersCount: this.stagingBuffers.length,
-      strategy: this.config.strategy
-    };
+  getConfig() {
+    return { ...this.config };
   }
   /**
-   * Destroy sync manager and release resources
+   * Destroy the backend
    */
   destroy() {
-    for (const buffer of this.stagingBuffers) {
-      buffer.destroy();
+    if (this.backend && !this.config.useGlobalBackend) {
+      this.backend.destroy();
     }
-    this.stagingBuffers = [];
-    this.pendingTransfers.clear();
+    this.backend = null;
   }
 };
-function createSyncManager(context, bufferPool, strategy = "lazy") {
-  return new SyncManager(context, bufferPool, { strategy });
+var gpuMatrixBackend = new GPUMatrixBackend();
+function createGPUMatrixBackend(config) {
+  return new GPUMatrixBackend(config);
 }
 
-// src/backends/GPUBackend.ts
-var DEFAULT_THRESHOLD = 256;
-var GPUBackend = class {
-  context = null;
-  bufferPool = null;
-  shaderManager = null;
-  _status = "uninitialized";
-  _capabilities = null;
-  _lastError = null;
-  threshold;
-  workgroupSize = [16, 16, 1];
-  useGlobalContext;
-  constructor(options = {}) {
-    this.threshold = options.threshold ?? DEFAULT_THRESHOLD;
-    this.useGlobalContext = options.useGlobalContext ?? true;
+// src/config.ts
+var DEFAULT_CONFIG3 = {
+  backends: {
+    js: {
+      enabled: true,
+      preference: "auto",
+      threshold: 0,
+      // Always available
+      operationThresholds: {}
+    },
+    wasm: {
+      enabled: true,
+      preference: "auto",
+      threshold: 1e3,
+      // >1000 elements
+      operationThresholds: {
+        multiply: 500,
+        decomposition: 100,
+        transpose: 2e3
+      }
+    },
+    gpu: {
+      enabled: true,
+      preference: "auto",
+      threshold: 1e5,
+      // >100K elements
+      operationThresholds: {
+        multiply: 5e4,
+        decomposition: 1e4,
+        transpose: 2e5
+      }
+    }
+  },
+  adaptiveTuning: {
+    enabled: true,
+    sampleSize: 10,
+    minSpeedupRatio: 1.2,
+    // 20% improvement to switch
+    maxAdjustmentPercent: 25,
+    cooldownMs: 5e3
+  },
+  profiling: {
+    enabled: false,
+    slowOperationThresholdMs: 100,
+    collectStats: false
+  },
+  precision: "double",
+  debug: false
+};
+var currentConfig = { ...DEFAULT_CONFIG3 };
+var listeners = /* @__PURE__ */ new Set();
+function getConfig() {
+  return currentConfig;
+}
+function onConfigChange(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+// src/backends/register-backends.ts
+backendRegistry.register(jsBackend);
+backendRegistry.register(wasmBackend);
+
+// src/backends/BackendManager.ts
+var DEFAULT_EXTENDED_HINTS = {
+  ...DEFAULT_BACKEND_HINTS,
+  operationThresholds: {
+    // matmul: the SIMD-WASM kernel wins from ~256 elems (16²), solidly 1.3–2.2× (measured,
+    // tools/benchmarks/matmul-threshold.mjs); below that copy/alloc overhead dominates (8²
+    // loses, 12² marginal). Dropped 500→256 to stop forcing 16²–22² matmuls onto JS.
+    multiply: { wasm: 256, gpu: 5e4 },
+    decomposition: { wasm: 100, gpu: 1e4 },
+    // transpose WASM is retired (memory-bound, lost 4–6×) — WASMBackend.transpose always uses
+    // JS regardless of this gate; kept high so the manager doesn't even select the WASM backend.
+    transpose: { wasm: 2e3, gpu: 2e5 }
+  },
+  autoSIMD: true,
+  fallbackOnError: true
+};
+var BackendManager = class {
+  hints;
+  initialized = false;
+  initializationPromise = null;
+  adaptiveState;
+  configUnsubscribe = null;
+  constructor(hints = {}) {
+    this.hints = { ...DEFAULT_EXTENDED_HINTS, ...hints };
+    this.adaptiveState = {
+      samples: [],
+      lastAdjustment: 0,
+      adjustedThresholds: /* @__PURE__ */ new Map()
+    };
+    this.configUnsubscribe = onConfigChange((config) => {
+      this.syncWithConfig(config);
+    });
   }
   /**
-   * Get the current status
+   * Sync manager state with global config
    */
-  get status() {
-    return this._status;
+  syncWithConfig(config) {
+    const { backends } = config;
+    this.hints.wasmThreshold = backends.wasm.threshold;
+    this.hints.gpuThreshold = backends.gpu.threshold;
+    if (backends.wasm.operationThresholds || backends.gpu.operationThresholds) {
+      const opThresholds = {};
+      for (const op of ["multiply", "decomposition", "transpose"]) {
+        opThresholds[op] = {
+          wasm: backends.wasm.operationThresholds?.[op] ?? this.hints.wasmThreshold,
+          gpu: backends.gpu.operationThresholds?.[op] ?? this.hints.gpuThreshold
+        };
+      }
+      this.hints.operationThresholds = opThresholds;
+    }
   }
   /**
-   * Check if backend is ready
+   * Initialize all available backends
    */
-  get isReady() {
-    return this._status === "ready";
+  async initialize() {
+    if (this.initialized) return;
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+    this.initializationPromise = this.doInitialize();
+    return this.initializationPromise;
   }
-  /**
-   * Get capabilities
-   */
-  get capabilities() {
-    return this._capabilities;
+  async doInitialize() {
+    const available = backendRegistry.available();
+    const initPromises = available.map(async (type) => {
+      try {
+        await backendRegistry.initialize(type);
+      } catch (error) {
+        console.warn(`Failed to initialize ${type} backend:`, error);
+      }
+    });
+    await Promise.all(initPromises);
+    this.initialized = true;
   }
   /**
-   * Get last error
+   * Update backend hints
    */
-  get lastError() {
-    return this._lastError;
+  setHints(hints) {
+    this.hints = { ...this.hints, ...hints };
+    backendRegistry.setHints(hints);
   }
   /**
-   * Initialize the GPU backend
+   * Get current hints
    */
-  async initialize(options = {}) {
-    if (this._status === "ready") {
-      return true;
+  getHints() {
+    return { ...this.hints };
+  }
+  /**
+   * 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, operation) {
+    const { preferredBackend, operationThresholds, wasmThreshold, gpuThreshold } = this.hints;
+    if (preferredBackend !== "js" && backendRegistry.has(preferredBackend)) {
+      const backend = backendRegistry.get(preferredBackend);
+      if (backend) {
+        return backend;
+      }
     }
-    if (this._status === "initializing") {
-      throw new Error("Already initializing");
+    let wasmThresh = wasmThreshold;
+    let gpuThresh = gpuThreshold;
+    if (operation && operationThresholds?.[operation]) {
+      const opThresh = operationThresholds[operation];
+      if (opThresh?.wasm !== void 0) wasmThresh = opThresh.wasm;
+      if (opThresh?.gpu !== void 0) gpuThresh = opThresh.gpu;
     }
-    this._status = "initializing";
-    try {
-      if (!hasWebGPU()) {
-        this._status = "unsupported";
-        this._lastError = new Error("WebGPU is not supported");
-        return false;
-      }
-      this._capabilities = await detectGPUCapabilities(options.preferHighPerformance ?? true);
-      if (!this._capabilities.supported) {
-        this._status = "unsupported";
-        this._lastError = new Error("WebGPU adapter not available");
-        return false;
-      }
-      if (this.useGlobalContext) {
-        this.context = getGlobalGPUContext();
-      } else {
-        this.context = new GPUContext({ label: "GPUBackend" });
-      }
-      const success = await this.context.initialize(options);
-      if (!success) {
-        this._status = "error";
-        this._lastError = this.context.lastError;
-        return false;
-      }
-      this.bufferPool = new BufferPool(this.context, options.bufferPoolOptions);
-      this.shaderManager = new ShaderManager(this.context);
-      this.shaderManager.precompileBuiltins();
-      this.workgroupSize = getRecommendedWorkgroupSize(this._capabilities);
-      this._status = "ready";
-      return true;
-    } catch (error) {
-      this._status = "error";
-      this._lastError = error;
-      return false;
+    if (elementCount >= gpuThresh && backendRegistry.has("gpu")) {
+      const gpuBackend = backendRegistry.get("gpu");
+      if (gpuBackend) return gpuBackend;
+    }
+    if (elementCount >= wasmThresh && backendRegistry.has("wasm")) {
+      const wasmBackend2 = backendRegistry.get("wasm");
+      if (wasmBackend2) return wasmBackend2;
     }
+    return jsBackend;
   }
   /**
-   * Check if GPU should be used for the given matrix size
+   * Execute an operation with automatic backend selection
    */
-  shouldUseGPU(rows, cols) {
-    if (!this.isReady) {
-      return false;
+  executeWithFallback(operation, fallback) {
+    if (!this.hints.fallbackOnError) {
+      return operation();
+    }
+    try {
+      return operation();
+    } catch (error) {
+      console.warn("Backend operation failed, falling back to JS:", error);
+      return fallback();
     }
-    return rows >= this.threshold || cols >= this.threshold;
   }
+  // =========================================================================
+  // Element-wise Operations
+  // =========================================================================
   /**
-   * Calculate workgroup counts for a matrix
+   * Matrix addition with auto backend selection
    */
-  calculateWorkgroups(rows, cols) {
-    const [wgX, wgY] = this.workgroupSize;
-    return [Math.ceil(cols / wgX), Math.ceil(rows / wgY), 1];
+  add(a, b) {
+    const backend = this.selectBackend(a.length, "add");
+    return this.executeWithFallback(
+      () => backend.add(a, b),
+      () => jsBackend.add(a, b)
+    );
   }
   /**
-   * Get the GPU context
+   * Matrix subtraction with auto backend selection
    */
-  getContext() {
-    if (!this.context || !this.isReady) {
-      throw new Error("GPUBackend not initialized");
-    }
-    return this.context;
+  subtract(a, b) {
+    const backend = this.selectBackend(a.length, "subtract");
+    return this.executeWithFallback(
+      () => backend.subtract(a, b),
+      () => jsBackend.subtract(a, b)
+    );
   }
   /**
-   * Get the buffer pool
+   * Element-wise multiplication with auto backend selection
    */
-  getBufferPool() {
-    if (!this.bufferPool || !this.isReady) {
-      throw new Error("GPUBackend not initialized");
-    }
-    return this.bufferPool;
+  multiplyElementwise(a, b) {
+    const backend = this.selectBackend(a.length, "multiplyElementwise");
+    return this.executeWithFallback(
+      () => backend.multiplyElementwise(a, b),
+      () => jsBackend.multiplyElementwise(a, b)
+    );
   }
   /**
-   * Get the shader manager
+   * Element-wise division with auto backend selection
    */
-  getShaderManager() {
-    if (!this.shaderManager || !this.isReady) {
-      throw new Error("GPUBackend not initialized");
-    }
-    return this.shaderManager;
+  divideElementwise(a, b) {
+    const backend = this.selectBackend(a.length);
+    return this.executeWithFallback(
+      () => backend.divideElementwise(a, b),
+      () => jsBackend.divideElementwise(a, b)
+    );
   }
   /**
-   * Add two matrices element-wise
+   * Scalar multiplication with auto backend selection
    */
-  async add(a, b, rows, cols) {
-    const ctx = this.getContext();
-    const pool = this.getBufferPool();
-    const shaders = this.getShaderManager();
-    const size2 = rows * cols * 4;
-    const bufferA = pool.acquireStorageBuffer(size2, "matrix-a", true, true);
-    const bufferB = pool.acquireStorageBuffer(size2, "matrix-b", true, true);
-    const bufferResult = pool.acquireStorageBuffer(size2, "matrix-result", true, false);
-    const bufferParams = pool.acquireUniformBuffer(16, "params");
-    ctx.writeBuffer(bufferA, a);
-    ctx.writeBuffer(bufferB, b);
-    ctx.writeBuffer(bufferParams, new Uint32Array([rows, cols, 0, 0]));
-    const pipeline = shaders.getBuiltinPipeline("matrixAdd");
-    const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
-      { binding: 0, resource: { buffer: bufferA } },
-      { binding: 1, resource: { buffer: bufferB } },
-      { binding: 2, resource: { buffer: bufferResult } },
-      { binding: 3, resource: { buffer: bufferParams } }
-    ]);
-    ctx.dispatchCompute(pipeline, [bindGroup], this.calculateWorkgroups(rows, cols));
-    const resultData = await ctx.readBuffer(bufferResult);
-    pool.release(bufferA);
-    pool.release(bufferB);
-    pool.release(bufferResult);
-    pool.release(bufferParams);
-    return new Float32Array(resultData);
+  scale(a, scalar) {
+    const backend = this.selectBackend(a.length, "scale");
+    return this.executeWithFallback(
+      () => backend.scale(a, scalar),
+      () => jsBackend.scale(a, scalar)
+    );
   }
   /**
-   * Multiply two matrices
+   * Element-wise absolute value with auto backend selection
    */
-  async matmul(a, b, M, K, N) {
-    const ctx = this.getContext();
-    const pool = this.getBufferPool();
-    const shaders = this.getShaderManager();
-    const sizeA = M * K * 4;
-    const sizeB = K * N * 4;
-    const sizeResult = M * N * 4;
-    const bufferA = pool.acquireStorageBuffer(sizeA, "matmul-a", true, true);
-    const bufferB = pool.acquireStorageBuffer(sizeB, "matmul-b", true, true);
-    const bufferResult = pool.acquireStorageBuffer(sizeResult, "matmul-result", true, false);
-    const bufferParams = pool.acquireUniformBuffer(16, "params");
-    ctx.writeBuffer(bufferA, a);
-    ctx.writeBuffer(bufferB, b);
-    ctx.writeBuffer(bufferParams, new Uint32Array([M, N, K, 0]));
-    const pipeline = shaders.getBuiltinPipeline("matmul");
-    const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
-      { binding: 0, resource: { buffer: bufferA } },
-      { binding: 1, resource: { buffer: bufferB } },
-      { binding: 2, resource: { buffer: bufferResult } },
-      { binding: 3, resource: { buffer: bufferParams } }
-    ]);
-    ctx.dispatchCompute(pipeline, [bindGroup], this.calculateWorkgroups(M, N));
-    const resultData = await ctx.readBuffer(bufferResult);
-    pool.release(bufferA);
-    pool.release(bufferB);
-    pool.release(bufferResult);
-    pool.release(bufferParams);
-    return new Float32Array(resultData);
+  abs(a) {
+    const backend = this.selectBackend(a.length);
+    return this.executeWithFallback(
+      () => backend.abs(a),
+      () => jsBackend.abs(a)
+    );
   }
   /**
-   * Transpose a matrix
+   * Element-wise negation with auto backend selection
    */
-  async transpose(a, rows, cols) {
-    const ctx = this.getContext();
-    const pool = this.getBufferPool();
-    const shaders = this.getShaderManager();
-    const size2 = rows * cols * 4;
-    const bufferA = pool.acquireStorageBuffer(size2, "transpose-a", true, true);
-    const bufferResult = pool.acquireStorageBuffer(size2, "transpose-result", true, false);
-    const bufferParams = pool.acquireUniformBuffer(16, "params");
-    ctx.writeBuffer(bufferA, a);
-    ctx.writeBuffer(bufferParams, new Uint32Array([rows, cols, 0, 0]));
-    const pipeline = shaders.getBuiltinPipeline("transpose");
-    const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
-      { binding: 0, resource: { buffer: bufferA } },
-      { binding: 1, resource: { buffer: bufferResult } },
-      { binding: 2, resource: { buffer: bufferParams } }
-    ]);
-    ctx.dispatchCompute(pipeline, [bindGroup], this.calculateWorkgroups(rows, cols));
-    const resultData = await ctx.readBuffer(bufferResult);
-    pool.release(bufferA);
-    pool.release(bufferResult);
-    pool.release(bufferParams);
-    return new Float32Array(resultData);
+  negate(a) {
+    const backend = this.selectBackend(a.length);
+    return this.executeWithFallback(
+      () => backend.negate(a),
+      () => jsBackend.negate(a)
+    );
   }
+  // =========================================================================
+  // Matrix Operations
+  // =========================================================================
   /**
-   * Scale a matrix by a scalar
+   * Matrix multiplication with auto backend selection
    */
-  async scale(a, scalar) {
-    const ctx = this.getContext();
-    const pool = this.getBufferPool();
-    const shaders = this.getShaderManager();
-    const size2 = a.length * 4;
-    const bufferA = pool.acquireStorageBuffer(size2, "scale-a", true, true);
-    const bufferResult = pool.acquireStorageBuffer(size2, "scale-result", true, false);
-    const bufferParams = pool.acquireUniformBuffer(16, "params");
-    ctx.writeBuffer(bufferA, a);
-    ctx.writeBuffer(bufferParams, new Float32Array([scalar, a.length, 0, 0]));
-    const pipeline = shaders.getBuiltinPipeline("scalarMul");
-    const bindGroup = ctx.createBindGroup(pipeline.getBindGroupLayout(0), [
-      { binding: 0, resource: { buffer: bufferA } },
-      { binding: 1, resource: { buffer: bufferResult } },
-      { binding: 2, resource: { buffer: bufferParams } }
-    ]);
-    const workgroups = Math.ceil(a.length / 256);
-    ctx.dispatchCompute(pipeline, [bindGroup], [workgroups, 1, 1]);
-    const resultData = await ctx.readBuffer(bufferResult);
-    pool.release(bufferA);
-    pool.release(bufferResult);
-    pool.release(bufferParams);
-    return new Float32Array(resultData);
+  multiply(a, b) {
+    const elementCount = a.rows * b.cols * a.cols;
+    const backend = this.selectBackend(elementCount, "multiply");
+    return this.executeWithFallback(
+      () => backend.multiply(a, b),
+      () => jsBackend.multiply(a, b)
+    );
   }
   /**
-   * Get backend statistics
+   * Matrix transpose with auto backend selection
    */
-  getStats() {
-    return {
-      status: this._status,
-      capabilities: this._capabilities,
-      bufferPool: this.bufferPool?.getStats() || null,
-      shaders: this.shaderManager?.getStats() || null
-    };
+  transpose(a) {
+    const backend = this.selectBackend(a.length, "transpose");
+    return this.executeWithFallback(
+      () => backend.transpose(a),
+      () => jsBackend.transpose(a)
+    );
   }
+  // =========================================================================
+  // Reduction Operations
+  // =========================================================================
   /**
-   * Destroy the backend
+   * Sum of all elements with auto backend selection
    */
-  destroy() {
-    if (this.bufferPool) {
-      this.bufferPool.destroy();
-      this.bufferPool = null;
-    }
-    if (this.shaderManager) {
-      this.shaderManager.clearCache();
-      this.shaderManager = null;
-    }
-    if (this.context && !this.useGlobalContext) {
-      this.context.destroy();
-    }
-    this.context = null;
-    this._status = "uninitialized";
-  }
-};
-var globalBackend = null;
-function getGlobalGPUBackend() {
-  if (!globalBackend) {
-    globalBackend = new GPUBackend({ useGlobalContext: true });
-  }
-  return globalBackend;
-}
-async function initializeGlobalGPUBackend(options) {
-  const backend = getGlobalGPUBackend();
-  return backend.initialize(options);
-}
-function destroyGlobalGPUBackend() {
-  if (globalBackend) {
-    globalBackend.destroy();
-    globalBackend = null;
-  }
-}
-
-// src/backends/GPUMatrixBackend.ts
-var DEFAULT_CONFIG2 = {
-  minElements: 65536,
-  // 256x256
-  useGlobalBackend: true,
-  gpuOptions: {},
-  fallbackOnError: true
-};
-var GPUMatrixBackend = class {
-  type = "gpu";
-  config;
-  backend = null;
-  capabilities = null;
-  initPromise = null;
-  _available = null;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG2, ...config };
+  async sum(a) {
+    const backend = this.selectBackend(a.length);
+    const result = backend.sum(a);
+    return result instanceof Promise ? result : result;
   }
   /**
-   * Check if GPU is available in the current environment
+   * Sum along axis with auto backend selection
    */
-  isAvailable() {
-    if (this._available !== null) {
-      return this._available;
-    }
-    this._available = hasWebGPU();
-    return this._available;
+  sumAxis(a, axis) {
+    const backend = this.selectBackend(a.length);
+    return this.executeWithFallback(
+      () => backend.sumAxis(a, axis),
+      () => jsBackend.sumAxis(a, axis)
+    );
   }
   /**
-   * Initialize the GPU backend
+   * Frobenius norm with auto backend selection
    */
-  async initialize() {
-    if (this.backend?.isReady) return;
-    if (this.initPromise) return this.initPromise;
-    this.initPromise = this.doInitialize();
-    return this.initPromise;
-  }
-  async doInitialize() {
-    if (!this.isAvailable()) {
-      throw new Error("WebGPU is not available in this environment");
-    }
-    this.capabilities = await detectGPUCapabilities(
-      this.config.gpuOptions?.preferHighPerformance ?? true
+  norm(a) {
+    const backend = this.selectBackend(a.length);
+    return this.executeWithFallback(
+      () => backend.norm(a),
+      () => jsBackend.norm(a)
     );
-    if (!this.capabilities.supported) {
-      throw new Error("WebGPU adapter not available");
-    }
-    if (this.config.useGlobalBackend) {
-      const success = await initializeGlobalGPUBackend(this.config.gpuOptions);
-      if (!success) {
-        throw new Error("Failed to initialize global GPU backend");
-      }
-      this.backend = getGlobalGPUBackend();
-    } else {
-      this.backend = new GPUBackend(this.config.gpuOptions);
-      const success = await this.backend.initialize(this.config.gpuOptions);
-      if (!success) {
-        throw new Error(`Failed to initialize GPU backend: ${this.backend.lastError?.message}`);
-      }
-    }
   }
   /**
-   * Check if operation should use GPU
+   * Dot product with auto backend selection
    */
-  shouldUseGPU(elementCount) {
-    return this.backend !== null && this.backend.isReady && elementCount >= this.config.minElements;
+  async dot(a, b) {
+    const backend = this.selectBackend(a.length);
+    const result = backend.dot(a, b);
+    return result instanceof Promise ? result : result;
   }
+  // =========================================================================
+  // Backend Info
+  // =========================================================================
   /**
-   * Execute GPU operation with fallback
+   * Get list of available backends
    */
-  async executeWithFallback(gpuOp, fallback) {
-    if (!this.config.fallbackOnError) {
-      return gpuOp();
-    }
-    try {
-      return await gpuOp();
-    } catch (error) {
-      console.warn("GPU operation failed, falling back to JS:", error);
-      return fallback();
-    }
+  getAvailableBackends() {
+    return backendRegistry.available();
   }
   /**
-   * Get GPU capabilities
+   * Check if a specific backend is available
    */
-  getCapabilities() {
-    return this.capabilities;
+  hasBackend(type) {
+    return backendRegistry.has(type);
   }
   /**
-   * Get backend statistics
+   * Get current active backend for a given operation size
    */
-  getStats() {
-    return this.backend?.getStats() ?? null;
+  getActiveBackend(elementCount, operation) {
+    return this.selectBackend(elementCount, operation).type;
   }
-  // =========================================================================
-  // Element-wise Operations
-  // =========================================================================
-  add(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.add(a, b);
+  /**
+   * Force a specific backend for all operations
+   */
+  forceBackend(type) {
+    if (type === null) {
+      this.hints.preferredBackend = "js";
+    } else {
+      this.hints.preferredBackend = type;
     }
-    return jsBackend.add(a, b);
   }
+  // =========================================================================
+  // Adaptive Threshold Tuning
+  // =========================================================================
   /**
-   * Async add operation using GPU
+   * Record a performance sample for adaptive tuning
    */
-  async addAsync(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.add(a, b);
+  recordSample(operation, elementCount, backend, durationMs) {
+    const config = getConfig();
+    if (!config.adaptiveTuning.enabled) return;
+    this.adaptiveState.samples.push({
+      operation,
+      elementCount,
+      backend,
+      durationMs,
+      timestamp: Date.now()
+    });
+    const maxSamples = config.adaptiveTuning.sampleSize * 10;
+    if (this.adaptiveState.samples.length > maxSamples) {
+      this.adaptiveState.samples = this.adaptiveState.samples.slice(-maxSamples);
     }
-    return this.executeWithFallback(
-      async () => {
-        const aData = new Float32Array(a.toFloat64Array());
-        const bData = new Float32Array(b.toFloat64Array());
-        const result = await this.backend.add(aData, bData, a.rows, a.cols);
-        return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-      },
-      () => jsBackend.add(a, b)
-    );
+    this.maybeAdjustThresholds();
   }
-  subtract(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.subtract(a, b);
+  /**
+   * Adjust thresholds based on collected samples
+   */
+  maybeAdjustThresholds() {
+    const config = getConfig();
+    if (!config.adaptiveTuning.enabled) return;
+    const now = Date.now();
+    const { cooldownMs, sampleSize, minSpeedupRatio, maxAdjustmentPercent } = config.adaptiveTuning;
+    if (now - this.adaptiveState.lastAdjustment < cooldownMs) {
+      return;
     }
-    return jsBackend.subtract(a, b);
-  }
-  multiplyElementwise(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.multiplyElementwise(a, b);
-    }
-    return jsBackend.multiplyElementwise(a, b);
-  }
-  divideElementwise(a, b) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.divideElementwise(a, b);
+    const operationSamples = /* @__PURE__ */ new Map();
+    for (const sample of this.adaptiveState.samples) {
+      const existing = operationSamples.get(sample.operation) ?? [];
+      existing.push(sample);
+      operationSamples.set(sample.operation, existing);
     }
-    return jsBackend.divideElementwise(a, b);
-  }
-  scale(a, scalar) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.scale(a, scalar);
+    for (const [operation, samples] of operationSamples) {
+      if (samples.length < sampleSize) continue;
+      const byBackend = /* @__PURE__ */ new Map();
+      for (const s of samples) {
+        const existing = byBackend.get(s.backend) ?? [];
+        existing.push(s);
+        byBackend.set(s.backend, existing);
+      }
+      const throughput = /* @__PURE__ */ new Map();
+      for (const [backend, backendSamples] of byBackend) {
+        const totalElements = backendSamples.reduce((s, x) => s + x.elementCount, 0);
+        const totalTime = backendSamples.reduce((s, x) => s + x.durationMs, 0);
+        if (totalTime > 0) {
+          throughput.set(backend, totalElements / totalTime);
+        }
+      }
+      const jsThroughput = throughput.get("js") ?? 0;
+      const wasmThroughput = throughput.get("wasm") ?? 0;
+      const gpuThroughput = throughput.get("gpu") ?? 0;
+      const currentThresholds = this.adaptiveState.adjustedThresholds.get(operation) ?? {
+        wasm: this.hints.operationThresholds?.[operation]?.wasm ?? this.hints.wasmThreshold,
+        gpu: this.hints.operationThresholds?.[operation]?.gpu ?? this.hints.gpuThreshold
+      };
+      let newWasmThreshold = currentThresholds.wasm;
+      let newGpuThreshold = currentThresholds.gpu;
+      if (wasmThroughput > jsThroughput * minSpeedupRatio) {
+        const adjustment = currentThresholds.wasm * (maxAdjustmentPercent / 100);
+        newWasmThreshold = Math.max(100, currentThresholds.wasm - adjustment);
+      } else if (jsThroughput > wasmThroughput * minSpeedupRatio) {
+        const adjustment = currentThresholds.wasm * (maxAdjustmentPercent / 100);
+        newWasmThreshold = currentThresholds.wasm + adjustment;
+      }
+      if (gpuThroughput > wasmThroughput * minSpeedupRatio) {
+        const adjustment = currentThresholds.gpu * (maxAdjustmentPercent / 100);
+        newGpuThreshold = Math.max(1e3, currentThresholds.gpu - adjustment);
+      } else if (wasmThroughput > gpuThroughput * minSpeedupRatio) {
+        const adjustment = currentThresholds.gpu * (maxAdjustmentPercent / 100);
+        newGpuThreshold = currentThresholds.gpu + adjustment;
+      }
+      this.adaptiveState.adjustedThresholds.set(operation, {
+        wasm: Math.round(newWasmThreshold),
+        gpu: Math.round(newGpuThreshold)
+      });
     }
-    return jsBackend.scale(a, scalar);
+    this.adaptiveState.lastAdjustment = now;
   }
   /**
-   * Async scale operation using GPU
+   * Get current adaptive thresholds
    */
-  async scaleAsync(a, scalar) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.scale(a, scalar);
-    }
-    return this.executeWithFallback(
-      async () => {
-        const aData = new Float32Array(a.toFloat64Array());
-        const result = await this.backend.scale(aData, scalar);
-        return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-      },
-      () => jsBackend.scale(a, scalar)
-    );
-  }
-  abs(a) {
-    return jsBackend.abs(a);
-  }
-  negate(a) {
-    return jsBackend.negate(a);
+  getAdaptiveThresholds() {
+    return new Map(this.adaptiveState.adjustedThresholds);
   }
-  // =========================================================================
-  // Matrix Operations
-  // =========================================================================
-  multiply(a, b) {
-    const elementCount = a.rows * b.cols * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.multiply(a, b);
-    }
-    return jsBackend.multiply(a, b);
+  /**
+   * Reset adaptive tuning state
+   */
+  resetAdaptiveState() {
+    this.adaptiveState = {
+      samples: [],
+      lastAdjustment: 0,
+      adjustedThresholds: /* @__PURE__ */ new Map()
+    };
   }
   /**
-   * Async matrix multiplication using GPU
+   * Get performance statistics
    */
-  async multiplyAsync(a, b) {
-    const elementCount = a.rows * b.cols * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.multiply(a, b);
+  getPerformanceStats() {
+    const operationStats = /* @__PURE__ */ new Map();
+    const byOperation = /* @__PURE__ */ new Map();
+    for (const sample of this.adaptiveState.samples) {
+      const existing = byOperation.get(sample.operation) ?? [];
+      existing.push(sample);
+      byOperation.set(sample.operation, existing);
     }
-    return this.executeWithFallback(
-      async () => {
-        const aData = new Float32Array(a.toFloat64Array());
-        const bData = new Float32Array(b.toFloat64Array());
-        const result = await this.backend.matmul(aData, bData, a.rows, a.cols, b.cols);
-        return DenseMatrix.fromFlat(a.rows, b.cols, Array.from(result));
-      },
-      () => jsBackend.multiply(a, b)
-    );
-  }
-  transpose(a) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.transpose(a);
+    for (const [op, samples] of byOperation) {
+      const avgDuration = samples.reduce((s, x) => s + x.durationMs, 0) / samples.length;
+      const backendUsage = {
+        js: 0,
+        wasm: 0,
+        gpu: 0,
+        parallel: 0
+      };
+      for (const s of samples) {
+        backendUsage[s.backend]++;
+      }
+      operationStats.set(op, {
+        avgDuration,
+        samples: samples.length,
+        backendUsage
+      });
     }
-    return jsBackend.transpose(a);
+    return {
+      sampleCount: this.adaptiveState.samples.length,
+      operationStats
+    };
   }
   /**
-   * Async transpose using GPU
+   * Cleanup resources
    */
-  async transposeAsync(a) {
-    const elementCount = a.rows * a.cols;
-    if (!this.shouldUseGPU(elementCount)) {
-      return jsBackend.transpose(a);
+  destroy() {
+    if (this.configUnsubscribe) {
+      this.configUnsubscribe();
+      this.configUnsubscribe = null;
     }
-    return this.executeWithFallback(
-      async () => {
-        const aData = new Float32Array(a.toFloat64Array());
-        const result = await this.backend.transpose(aData, a.rows, a.cols);
-        return DenseMatrix.fromFlat(a.cols, a.rows, Array.from(result));
-      },
-      () => jsBackend.transpose(a)
-    );
-  }
-  // =========================================================================
-  // Reduction Operations
-  // =========================================================================
-  sum(a) {
-    return jsBackend.sum(a);
-  }
-  sumAxis(a, axis) {
-    return jsBackend.sumAxis(a, axis);
   }
-  norm(a) {
-    return jsBackend.norm(a);
-  }
-  dot(a, b) {
-    return jsBackend.dot(a, b);
+};
+var backendManager = new BackendManager();
+function createBackendManager(hints) {
+  return new BackendManager(hints);
+}
+
+// src/backends/WasmLoader.ts
+var AS_ID_ARRAY_BUFFER2 = 1;
+var AS_ID_INT32_ARRAY2 = 4;
+var AS_ID_FLOAT64_ARRAY2 = 5;
+var AS_HEADER_BYTES2 = 12;
+var WasmLoader = class _WasmLoader {
+  static instance = null;
+  wasmModule = null;
+  compiledModule = null;
+  loading = null;
+  isNode;
+  lastMetrics = null;
+  // Memory pool for AS allocations.
+  float64Pool = [];
+  int32Pool = [];
+  poolSizeThreshold = 1024 * 1024;
+  // 1MB max per pool entry
+  constructor() {
+    this.isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
   }
-  // =========================================================================
-  // Configuration
-  // =========================================================================
-  /**
-   * Update configuration
-   */
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
+  static getInstance() {
+    if (!_WasmLoader.instance) {
+      _WasmLoader.instance = new _WasmLoader();
+    }
+    return _WasmLoader.instance;
   }
   /**
-   * Get current configuration
+   * Load the WASM module
    */
-  getConfig() {
-    return { ...this.config };
+  async load(wasmPath) {
+    if (this.wasmModule) {
+      return this.wasmModule;
+    }
+    if (this.loading) {
+      return this.loading;
+    }
+    this.loading = this.loadModule(wasmPath);
+    this.wasmModule = await this.loading;
+    return this.wasmModule;
   }
   /**
-   * Destroy the backend
+   * Precompile the WASM module without instantiation
+   * Useful for build-time or startup optimization
    */
-  destroy() {
-    if (this.backend && !this.config.useGlobalBackend) {
-      this.backend.destroy();
-    }
-    this.backend = null;
-  }
-};
-var gpuMatrixBackend = new GPUMatrixBackend();
-function createGPUMatrixBackend(config) {
-  return new GPUMatrixBackend(config);
-}
-
-// src/config.ts
-var DEFAULT_CONFIG3 = {
-  backends: {
-    js: {
-      enabled: true,
-      preference: "auto",
-      threshold: 0,
-      // Always available
-      operationThresholds: {}
-    },
-    wasm: {
-      enabled: true,
-      preference: "auto",
-      threshold: 1e3,
-      // >1000 elements
-      operationThresholds: {
-        multiply: 500,
-        decomposition: 100,
-        transpose: 2e3
-      }
-    },
-    gpu: {
-      enabled: true,
-      preference: "auto",
-      threshold: 1e5,
-      // >100K elements
-      operationThresholds: {
-        multiply: 5e4,
-        decomposition: 1e4,
-        transpose: 2e5
+  async precompile(wasmPath) {
+    if (this.compiledModule) return;
+    const path = wasmPath || await this.getDefaultWasmPath();
+    const startTime = performance.now();
+    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
+    if (this.isNode) {
+      const fs = await import("fs");
+      const { promisify } = await import("util");
+      const readFile = promisify(fs.readFile);
+      const buffer = await readFile(path);
+      await verifyWasmIntegrity(buffer, path);
+      this.compiledModule = await WebAssembly.compile(buffer);
+    } else {
+      const manifest = await loadWasmManifest(path);
+      if (!manifest && typeof WebAssembly.compileStreaming === "function") {
+        this.compiledModule = await WebAssembly.compileStreaming(fetch(path));
+      } else {
+        const response = await fetch(path);
+        const buffer = await response.arrayBuffer();
+        await verifyWasmIntegrity(buffer, path, { manifest });
+        this.compiledModule = await WebAssembly.compile(buffer);
       }
     }
-  },
-  adaptiveTuning: {
-    enabled: true,
-    sampleSize: 10,
-    minSpeedupRatio: 1.2,
-    // 20% improvement to switch
-    maxAdjustmentPercent: 25,
-    cooldownMs: 5e3
-  },
-  profiling: {
-    enabled: false,
-    slowOperationThresholdMs: 100,
-    collectStats: false
-  },
-  precision: "double",
-  debug: false
-};
-var currentConfig = { ...DEFAULT_CONFIG3 };
-var listeners = /* @__PURE__ */ new Set();
-function getConfig() {
-  return currentConfig;
-}
-function onConfigChange(listener) {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-
-// src/backends/register-backends.ts
-backendRegistry.register(jsBackend);
-backendRegistry.register(wasmBackend);
-
-// src/backends/BackendManager.ts
-var DEFAULT_EXTENDED_HINTS = {
-  ...DEFAULT_BACKEND_HINTS,
-  operationThresholds: {
-    // matmul: the SIMD-WASM kernel wins from ~256 elems (16²), solidly 1.3–2.2× (measured,
-    // tools/benchmarks/matmul-threshold.mjs); below that copy/alloc overhead dominates (8²
-    // loses, 12² marginal). Dropped 500→256 to stop forcing 16²–22² matmuls onto JS.
-    multiply: { wasm: 256, gpu: 5e4 },
-    decomposition: { wasm: 100, gpu: 1e4 },
-    // transpose WASM is retired (memory-bound, lost 4–6×) — WASMBackend.transpose always uses
-    // JS regardless of this gate; kept high so the manager doesn't even select the WASM backend.
-    transpose: { wasm: 2e3, gpu: 2e5 }
-  },
-  autoSIMD: true,
-  fallbackOnError: true
-};
-var BackendManager = class {
-  hints;
-  initialized = false;
-  initializationPromise = null;
-  adaptiveState;
-  configUnsubscribe = null;
-  constructor(hints = {}) {
-    this.hints = { ...DEFAULT_EXTENDED_HINTS, ...hints };
-    this.adaptiveState = {
-      samples: [],
-      lastAdjustment: 0,
-      adjustedThresholds: /* @__PURE__ */ new Map()
+    this.lastMetrics = {
+      fileReadMs: 0,
+      compileMs: performance.now() - startTime,
+      instantiateMs: 0,
+      totalMs: performance.now() - startTime,
+      fromCache: false
     };
-    this.configUnsubscribe = onConfigChange((config) => {
-      this.syncWithConfig(config);
-    });
   }
-  /**
-   * Sync manager state with global config
-   */
-  syncWithConfig(config) {
-    const { backends } = config;
-    this.hints.wasmThreshold = backends.wasm.threshold;
-    this.hints.gpuThreshold = backends.gpu.threshold;
-    if (backends.wasm.operationThresholds || backends.gpu.operationThresholds) {
-      const opThresholds = {};
-      for (const op of ["multiply", "decomposition", "transpose"]) {
-        opThresholds[op] = {
-          wasm: backends.wasm.operationThresholds?.[op] ?? this.hints.wasmThreshold,
-          gpu: backends.gpu.operationThresholds?.[op] ?? this.hints.gpuThreshold
-        };
-      }
-      this.hints.operationThresholds = opThresholds;
+  async loadModule(wasmPath) {
+    const path = wasmPath || await this.getDefaultWasmPath();
+    const totalStart = performance.now();
+    if (this.compiledModule) {
+      const instStart = performance.now();
+      const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+      this.lastMetrics = {
+        fileReadMs: 0,
+        compileMs: 0,
+        instantiateMs: performance.now() - instStart,
+        totalMs: performance.now() - totalStart,
+        fromCache: true
+      };
+      return instance.exports;
     }
-  }
-  /**
-   * Initialize all available backends
-   */
-  async initialize() {
-    if (this.initialized) return;
-    if (this.initializationPromise) {
-      return this.initializationPromise;
+    if (this.isNode) {
+      return this.loadNodeWasm(path, totalStart);
+    } else {
+      return this.loadBrowserWasm(path, totalStart);
     }
-    this.initializationPromise = this.doInitialize();
-    return this.initializationPromise;
-  }
-  async doInitialize() {
-    const available = backendRegistry.available();
-    const initPromises = available.map(async (type) => {
-      try {
-        await backendRegistry.initialize(type);
-      } catch (error) {
-        console.warn(`Failed to initialize ${type} backend:`, error);
-      }
-    });
-    await Promise.all(initPromises);
-    this.initialized = true;
-  }
-  /**
-   * Update backend hints
-   */
-  setHints(hints) {
-    this.hints = { ...this.hints, ...hints };
-    backendRegistry.setHints(hints);
-  }
-  /**
-   * Get current hints
-   */
-  getHints() {
-    return { ...this.hints };
   }
   /**
-   * Get the best backend for a given operation and matrix size.
+   * Get the WASM binary path. AssemblyScript is the sole WASM backend
+   * (`mathts-as.wasm`); the legacy second toolchain was removed in the
+   * WASM-backend migration (complete 2026-06-26).
    *
-   * Selection priority:
-   *   1. Preferred backend (if explicitly set)
-   *   2. Elements > gpuThreshold -> GPU (if available)
-   *   3. Elements > wasmThreshold -> AS WASM (if loaded)
-   *   4. JS fallback
+   * Resolution is package-relative and CWD-independent: the packaged artifact
+   * (`dist/wasm/`) is preferred via `resolvePackagedWasm`; when absent, the
+   * canonical expected location is returned so the missing-binary warning is
+   * actionable (see `defaultWasmLocation` in wasm/resolve.ts — B-3).
    */
-  selectBackend(elementCount, operation) {
-    const { preferredBackend, operationThresholds, wasmThreshold, gpuThreshold } = this.hints;
-    if (preferredBackend !== "js" && backendRegistry.has(preferredBackend)) {
-      const backend = backendRegistry.get(preferredBackend);
-      if (backend) {
-        return backend;
-      }
-    }
-    let wasmThresh = wasmThreshold;
-    let gpuThresh = gpuThreshold;
-    if (operation && operationThresholds?.[operation]) {
-      const opThresh = operationThresholds[operation];
-      if (opThresh?.wasm !== void 0) wasmThresh = opThresh.wasm;
-      if (opThresh?.gpu !== void 0) gpuThresh = opThresh.gpu;
-    }
-    if (elementCount >= gpuThresh && backendRegistry.has("gpu")) {
-      const gpuBackend = backendRegistry.get("gpu");
-      if (gpuBackend) return gpuBackend;
-    }
-    if (elementCount >= wasmThresh && backendRegistry.has("wasm")) {
-      const wasmBackend2 = backendRegistry.get("wasm");
-      if (wasmBackend2) return wasmBackend2;
+  async getDefaultWasmPath() {
+    const wasmFile = "mathts-as.wasm";
+    if (this.isNode) {
+      const { resolvePackagedWasm } = await import("./resolve-VJX3YTS6.js");
+      const found = await resolvePackagedWasm(import.meta.url, wasmFile);
+      if (found) return found;
+      const { defaultWasmLocation: defaultWasmLocation2 } = await import("./resolve-VJX3YTS6.js");
+      return defaultWasmLocation2(import.meta.url, wasmFile);
     }
-    return jsBackend;
+    const { defaultWasmLocation } = await import("./resolve-VJX3YTS6.js");
+    return defaultWasmLocation(import.meta.url, wasmFile, { browser: true });
   }
-  /**
-   * Execute an operation with automatic backend selection
-   */
-  executeWithFallback(operation, fallback) {
-    if (!this.hints.fallbackOnError) {
-      return operation();
-    }
-    try {
-      return operation();
-    } catch (error) {
-      console.warn("Backend operation failed, falling back to JS:", error);
-      return fallback();
+  async loadNodeWasm(path, totalStart) {
+    const fs = await import("fs");
+    const { promisify } = await import("util");
+    const readFile = promisify(fs.readFile);
+    const { verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
+    const readStart = performance.now();
+    const buffer = await readFile(path);
+    const readEnd = performance.now();
+    await verifyWasmIntegrity(buffer, path);
+    const compileStart = performance.now();
+    this.compiledModule = await WebAssembly.compile(buffer);
+    const compileEnd = performance.now();
+    const instStart = performance.now();
+    const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+    const instEnd = performance.now();
+    this.lastMetrics = {
+      fileReadMs: readEnd - readStart,
+      compileMs: compileEnd - compileStart,
+      instantiateMs: instEnd - instStart,
+      totalMs: performance.now() - totalStart,
+      fromCache: false
+    };
+    return instance.exports;
+  }
+  async loadBrowserWasm(path, totalStart) {
+    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
+    const manifest = await loadWasmManifest(path);
+    if (!manifest && typeof WebAssembly.instantiateStreaming === "function") {
+      const instStart2 = performance.now();
+      const result = await WebAssembly.instantiateStreaming(fetch(path), this.getImports());
+      this.compiledModule = result.module;
+      this.lastMetrics = {
+        fileReadMs: 0,
+        // Combined with compile in streaming
+        compileMs: 0,
+        // Combined in streaming
+        instantiateMs: performance.now() - instStart2,
+        totalMs: performance.now() - totalStart,
+        fromCache: false
+      };
+      return result.instance.exports;
     }
+    const readStart = performance.now();
+    const response = await fetch(path);
+    const buffer = await response.arrayBuffer();
+    const readEnd = performance.now();
+    await verifyWasmIntegrity(buffer, path, { manifest });
+    const compileStart = performance.now();
+    this.compiledModule = await WebAssembly.compile(buffer);
+    const compileEnd = performance.now();
+    const instStart = performance.now();
+    const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+    const instEnd = performance.now();
+    this.lastMetrics = {
+      fileReadMs: readEnd - readStart,
+      compileMs: compileEnd - compileStart,
+      instantiateMs: instEnd - instStart,
+      totalMs: performance.now() - totalStart,
+      fromCache: false
+    };
+    return instance.exports;
   }
-  // =========================================================================
-  // Element-wise Operations
-  // =========================================================================
-  /**
-   * Matrix addition with auto backend selection
-   */
-  add(a, b) {
-    const backend = this.selectBackend(a.length, "add");
-    return this.executeWithFallback(
-      () => backend.add(a, b),
-      () => jsBackend.add(a, b)
-    );
+  getImports() {
+    return {
+      env: {
+        abort: (msg, file, line, column2) => {
+          console.error("WASM abort", { msg, file, line, column: column2 });
+          throw new Error("WASM abort");
+        },
+        seed: () => Date.now()
+      },
+      Math,
+      Date
+    };
   }
   /**
-   * Matrix subtraction with auto backend selection
+   * Get the loaded WASM module
    */
-  subtract(a, b) {
-    const backend = this.selectBackend(a.length, "subtract");
-    return this.executeWithFallback(
-      () => backend.subtract(a, b),
-      () => jsBackend.subtract(a, b)
-    );
+  getModule() {
+    return this.wasmModule;
   }
   /**
-   * Element-wise multiplication with auto backend selection
+   * Get the compiled WASM module (for caching/serialization)
    */
-  multiplyElementwise(a, b) {
-    const backend = this.selectBackend(a.length, "multiplyElementwise");
-    return this.executeWithFallback(
-      () => backend.multiplyElementwise(a, b),
-      () => jsBackend.multiplyElementwise(a, b)
-    );
+  getCompiledModule() {
+    return this.compiledModule;
   }
   /**
-   * Element-wise division with auto backend selection
+   * Check if WASM is loaded
    */
-  divideElementwise(a, b) {
-    const backend = this.selectBackend(a.length);
-    return this.executeWithFallback(
-      () => backend.divideElementwise(a, b),
-      () => jsBackend.divideElementwise(a, b)
-    );
+  isLoaded() {
+    return this.wasmModule !== null;
   }
   /**
-   * Scalar multiplication with auto backend selection
+   * Check if WASM is precompiled
    */
-  scale(a, scalar) {
-    const backend = this.selectBackend(a.length, "scale");
-    return this.executeWithFallback(
-      () => backend.scale(a, scalar),
-      () => jsBackend.scale(a, scalar)
-    );
+  isPrecompiled() {
+    return this.compiledModule !== null;
   }
   /**
-   * Element-wise absolute value with auto backend selection
+   * Get loading performance metrics
    */
-  abs(a) {
-    const backend = this.selectBackend(a.length);
-    return this.executeWithFallback(
-      () => backend.abs(a),
-      () => jsBackend.abs(a)
-    );
+  getLoadingMetrics() {
+    return this.lastMetrics;
   }
+  // ===========================================================================
+  // Allocation API
+  // ---------------------------------------------------------------------------
+  // The returned handle's `ptr` is the header pointer to pass to WASM
+  // functions (AssemblyScript managed runtime).
+  // ===========================================================================
   /**
-   * Element-wise negation with auto backend selection
+   * Allocate Float64Array in WASM memory and copy `data` into it.
+   * Uses memory pooling.
    */
-  negate(a) {
-    const backend = this.selectBackend(a.length);
-    return this.executeWithFallback(
-      () => backend.negate(a),
-      () => jsBackend.negate(a)
-    );
+  allocateFloat64Array(data) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    const length = data.length;
+    const alloc = this.allocateAsFloat64(module, length);
+    alloc.array.set(data);
+    return alloc;
   }
-  // =========================================================================
-  // Matrix Operations
-  // =========================================================================
   /**
-   * Matrix multiplication with auto backend selection
+   * Decode a managed Float64Array RETURNED by an AssemblyScript export
+   * (e.g. the `matrix_lu_decompose` / `matrix_qr_decompose` outputs) into a fresh JS copy.
+   *
+   * AS exports that return a `Float64Array` hand back the typed-array
+   * *header* pointer. The header is a 12-byte block laid out as
+   * `[buffer, dataStart, byteLength]` (little-endian u32s) — the same shape
+   * the loader writes in `makeAsFloat64`. We read `dataStart`/`byteLength`
+   * and copy the data region out so it survives any later reuse of WASM
+   * memory.
    */
-  multiply(a, b) {
-    const elementCount = a.rows * b.cols * a.cols;
-    const backend = this.selectBackend(elementCount, "multiply");
-    return this.executeWithFallback(
-      () => backend.multiply(a, b),
-      () => jsBackend.multiply(a, b)
-    );
+  readReturnedFloat64Array(headerPtr) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    const hdr = headerPtr >>> 0;
+    const dv = new DataView(module.memory.buffer);
+    const dataStart = dv.getUint32(hdr + 4, true);
+    const byteLength = dv.getUint32(hdr + 8, true);
+    const view = new Float64Array(module.memory.buffer, dataStart, byteLength >>> 3);
+    return new Float64Array(view);
   }
   /**
-   * Matrix transpose with auto backend selection
+   * Allocate Float64Array without copying data (for output buffers)
    */
-  transpose(a) {
-    const backend = this.selectBackend(a.length, "transpose");
-    return this.executeWithFallback(
-      () => backend.transpose(a),
-      () => jsBackend.transpose(a)
-    );
+  allocateFloat64ArrayEmpty(length) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    return this.allocateAsFloat64(module, length);
   }
-  // =========================================================================
-  // Reduction Operations
-  // =========================================================================
   /**
-   * Sum of all elements with auto backend selection
+   * Allocate Int32Array in WASM memory and copy `data` into it.
    */
-  async sum(a) {
-    const backend = this.selectBackend(a.length);
-    const result = backend.sum(a);
-    return result instanceof Promise ? result : result;
+  allocateInt32Array(data) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    const length = data.length;
+    const alloc = this.allocateAsInt32(module, length);
+    alloc.array.set(data);
+    return alloc;
   }
   /**
-   * Sum along axis with auto backend selection
+   * Allocate Int32Array without copying data (for output buffers)
    */
-  sumAxis(a, axis) {
-    const backend = this.selectBackend(a.length);
-    return this.executeWithFallback(
-      () => backend.sumAxis(a, axis),
-      () => jsBackend.sumAxis(a, axis)
-    );
+  allocateInt32ArrayEmpty(length) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    return this.allocateAsInt32(module, length);
   }
-  /**
-   * Frobenius norm with auto backend selection
-   */
-  norm(a) {
-    const backend = this.selectBackend(a.length);
-    return this.executeWithFallback(
-      () => backend.norm(a),
-      () => jsBackend.norm(a)
-    );
+  // ---- AS managed runtime (header pointers) ------------------------------
+  allocateAsFloat64(module, length) {
+    const byteLength = length * 8;
+    if (byteLength <= this.poolSizeThreshold) {
+      const recycled = this.acquireFromAsPool(this.float64Pool, byteLength);
+      if (recycled) {
+        const array = new Float64Array(module.memory.buffer, recycled.dataPtr, length);
+        return {
+          ptr: recycled.ptr,
+          dataPtr: recycled.dataPtr,
+          array,
+          length
+        };
+      }
+    }
+    return this.makeAsFloat64(module, length);
+  }
+  allocateAsInt32(module, length) {
+    const byteLength = length * 4;
+    if (byteLength <= this.poolSizeThreshold) {
+      const recycled = this.acquireFromAsPool(this.int32Pool, byteLength);
+      if (recycled) {
+        const array = new Int32Array(module.memory.buffer, recycled.dataPtr, length);
+        return {
+          ptr: recycled.ptr,
+          dataPtr: recycled.dataPtr,
+          array,
+          length
+        };
+      }
+    }
+    return this.makeAsInt32(module, length);
+  }
+  makeAsFloat64(module, length) {
+    const byteLength = length * 8;
+    const bufferPtr = module.__pin(module.__new(byteLength, AS_ID_ARRAY_BUFFER2)) >>> 0;
+    const headerPtr = module.__new(AS_HEADER_BYTES2, AS_ID_FLOAT64_ARRAY2) >>> 0;
+    module.__pin(headerPtr);
+    const dv = new DataView(module.memory.buffer);
+    dv.setUint32(headerPtr + 0, bufferPtr, true);
+    dv.setUint32(headerPtr + 4, bufferPtr, true);
+    dv.setUint32(headerPtr + 8, byteLength, true);
+    const array = new Float64Array(module.memory.buffer, bufferPtr, length);
+    return { ptr: headerPtr, dataPtr: bufferPtr, array, length };
+  }
+  makeAsInt32(module, length) {
+    const byteLength = length * 4;
+    const bufferPtr = module.__pin(module.__new(byteLength, AS_ID_ARRAY_BUFFER2)) >>> 0;
+    const headerPtr = module.__new(AS_HEADER_BYTES2, AS_ID_INT32_ARRAY2) >>> 0;
+    module.__pin(headerPtr);
+    const dv = new DataView(module.memory.buffer);
+    dv.setUint32(headerPtr + 0, bufferPtr, true);
+    dv.setUint32(headerPtr + 4, bufferPtr, true);
+    dv.setUint32(headerPtr + 8, byteLength, true);
+    const array = new Int32Array(module.memory.buffer, bufferPtr, length);
+    return { ptr: headerPtr, dataPtr: bufferPtr, array, length };
   }
   /**
-   * Dot product with auto backend selection
+   * Find a pool entry whose data region is large enough; returns null when
+   * no suitable entry is available.
    */
-  async dot(a, b) {
-    const backend = this.selectBackend(a.length);
-    const result = backend.dot(a, b);
-    return result instanceof Promise ? result : result;
+  acquireFromAsPool(pool, requestedSize) {
+    let bestFit = null;
+    let bestFitWaste = Infinity;
+    for (const entry of pool) {
+      if (!entry.inUse && entry.size >= requestedSize) {
+        const waste = entry.size - requestedSize;
+        if (waste < bestFitWaste && entry.size <= requestedSize * 2) {
+          bestFit = entry;
+          bestFitWaste = waste;
+        }
+      }
+    }
+    if (bestFit) bestFit.inUse = true;
+    return bestFit;
   }
-  // =========================================================================
-  // Backend Info
-  // =========================================================================
   /**
-   * Get list of available backends
+   * Return an allocation to the pool for reuse.
+   *
+   * `isFloat64` exists for backwards compatibility — callers can still
+   * pass it positionally to disambiguate the pool to use on the AS path.
+   * Prefer `releaseAllocation` for new code, which discovers the pool
+   * automatically.
    */
-  getAvailableBackends() {
-    return backendRegistry.available();
+  release(ptr, isFloat64 = true) {
+    const pool = isFloat64 ? this.float64Pool : this.int32Pool;
+    const entry = pool.find((e) => e.ptr === ptr);
+    if (entry) {
+      entry.inUse = false;
+      return;
+    }
+    this.free(ptr);
   }
   /**
-   * Check if a specific backend is available
+   * Free allocated memory (immediate, bypasses pool): unpin the header pointer.
    */
-  hasBackend(type) {
-    return backendRegistry.has(type);
+  free(ptr) {
+    const module = this.wasmModule;
+    if (!module) return;
+    this.float64Pool = this.float64Pool.filter((e) => e.ptr !== ptr);
+    this.int32Pool = this.int32Pool.filter((e) => e.ptr !== ptr);
+    if (typeof module.__unpin === "function") {
+      module.__unpin(ptr);
+    }
   }
   /**
-   * Get current active backend for a given operation size
+   * Clear the memory pool
    */
-  getActiveBackend(elementCount, operation) {
-    return this.selectBackend(elementCount, operation).type;
+  clearPool() {
+    const module = this.wasmModule;
+    if (!module) return;
+    if (typeof module.__unpin === "function") {
+      for (const entry of this.float64Pool) {
+        module.__unpin(entry.ptr);
+      }
+      for (const entry of this.int32Pool) {
+        module.__unpin(entry.ptr);
+      }
+    }
+    this.float64Pool = [];
+    this.int32Pool = [];
   }
   /**
-   * Force a specific backend for all operations
+   * Get pool statistics
    */
-  forceBackend(type) {
-    if (type === null) {
-      this.hints.preferredBackend = "js";
-    } else {
-      this.hints.preferredBackend = type;
-    }
+  getPoolStats() {
+    const f64InUse = this.float64Pool.filter((e) => e.inUse).length;
+    const f64Bytes = this.float64Pool.reduce((sum3, e) => sum3 + e.size, 0);
+    const i32InUse = this.int32Pool.filter((e) => e.inUse).length;
+    const i32Bytes = this.int32Pool.reduce((sum3, e) => sum3 + e.size, 0);
+    return {
+      float64: {
+        total: this.float64Pool.length,
+        inUse: f64InUse,
+        totalBytes: f64Bytes
+      },
+      int32: {
+        total: this.int32Pool.length,
+        inUse: i32InUse,
+        totalBytes: i32Bytes
+      }
+    };
   }
-  // =========================================================================
-  // Adaptive Threshold Tuning
-  // =========================================================================
   /**
-   * Record a performance sample for adaptive tuning
+   * Run garbage collection.
    */
-  recordSample(operation, elementCount, backend, durationMs) {
-    const config = getConfig();
-    if (!config.adaptiveTuning.enabled) return;
-    this.adaptiveState.samples.push({
-      operation,
-      elementCount,
-      backend,
-      durationMs,
-      timestamp: Date.now()
-    });
-    const maxSamples = config.adaptiveTuning.sampleSize * 10;
-    if (this.adaptiveState.samples.length > maxSamples) {
-      this.adaptiveState.samples = this.adaptiveState.samples.slice(-maxSamples);
+  collect() {
+    const module = this.wasmModule;
+    if (!module) return;
+    if (typeof module.__collect === "function") {
+      module.__collect();
     }
-    this.maybeAdjustThresholds();
   }
   /**
-   * Adjust thresholds based on collected samples
+   * Reset the loader (for testing)
    */
-  maybeAdjustThresholds() {
-    const config = getConfig();
-    if (!config.adaptiveTuning.enabled) return;
-    const now = Date.now();
-    const { cooldownMs, sampleSize, minSpeedupRatio, maxAdjustmentPercent } = config.adaptiveTuning;
-    if (now - this.adaptiveState.lastAdjustment < cooldownMs) {
-      return;
-    }
-    const operationSamples = /* @__PURE__ */ new Map();
-    for (const sample of this.adaptiveState.samples) {
-      const existing = operationSamples.get(sample.operation) ?? [];
-      existing.push(sample);
-      operationSamples.set(sample.operation, existing);
-    }
-    for (const [operation, samples] of operationSamples) {
-      if (samples.length < sampleSize) continue;
-      const byBackend = /* @__PURE__ */ new Map();
-      for (const s of samples) {
-        const existing = byBackend.get(s.backend) ?? [];
-        existing.push(s);
-        byBackend.set(s.backend, existing);
-      }
-      const throughput = /* @__PURE__ */ new Map();
-      for (const [backend, backendSamples] of byBackend) {
-        const totalElements = backendSamples.reduce((s, x) => s + x.elementCount, 0);
-        const totalTime = backendSamples.reduce((s, x) => s + x.durationMs, 0);
-        if (totalTime > 0) {
-          throughput.set(backend, totalElements / totalTime);
-        }
-      }
-      const jsThroughput = throughput.get("js") ?? 0;
-      const wasmThroughput = throughput.get("wasm") ?? 0;
-      const gpuThroughput = throughput.get("gpu") ?? 0;
-      const currentThresholds = this.adaptiveState.adjustedThresholds.get(operation) ?? {
-        wasm: this.hints.operationThresholds?.[operation]?.wasm ?? this.hints.wasmThreshold,
-        gpu: this.hints.operationThresholds?.[operation]?.gpu ?? this.hints.gpuThreshold
-      };
-      let newWasmThreshold = currentThresholds.wasm;
-      let newGpuThreshold = currentThresholds.gpu;
-      if (wasmThroughput > jsThroughput * minSpeedupRatio) {
-        const adjustment = currentThresholds.wasm * (maxAdjustmentPercent / 100);
-        newWasmThreshold = Math.max(100, currentThresholds.wasm - adjustment);
-      } else if (jsThroughput > wasmThroughput * minSpeedupRatio) {
-        const adjustment = currentThresholds.wasm * (maxAdjustmentPercent / 100);
-        newWasmThreshold = currentThresholds.wasm + adjustment;
-      }
-      if (gpuThroughput > wasmThroughput * minSpeedupRatio) {
-        const adjustment = currentThresholds.gpu * (maxAdjustmentPercent / 100);
-        newGpuThreshold = Math.max(1e3, currentThresholds.gpu - adjustment);
-      } else if (wasmThroughput > gpuThroughput * minSpeedupRatio) {
-        const adjustment = currentThresholds.gpu * (maxAdjustmentPercent / 100);
-        newGpuThreshold = currentThresholds.gpu + adjustment;
-      }
-      this.adaptiveState.adjustedThresholds.set(operation, {
-        wasm: Math.round(newWasmThreshold),
-        gpu: Math.round(newGpuThreshold)
-      });
-    }
-    this.adaptiveState.lastAdjustment = now;
+  reset() {
+    this.clearPool();
+    this.wasmModule = null;
+    this.compiledModule = null;
+    this.loading = null;
+    this.lastMetrics = null;
   }
+};
+var wasmLoader = WasmLoader.getInstance();
+
+// src/backends/gpu/index.ts
+import {
+  hasWebGPU as hasWebGPU3,
+  isBrowser,
+  getGPUAdapter,
+  detectGPUCapabilities as detectGPUCapabilities3,
+  isGPUSuitableForMatrixOps,
+  getRecommendedWorkgroupSize as getRecommendedWorkgroupSize2,
+  getMaxMatrixSize,
+  GPUContext as GPUContext2,
+  getGlobalGPUContext as getGlobalGPUContext2,
+  initializeGlobalGPU,
+  destroyGlobalGPU,
+  getGpuDevice,
+  resetGpuDevice,
+  BufferPool as BufferPool2,
+  ShaderManager as ShaderManager2
+} from "@danielsimonjr/mathts-gpu";
+
+// src/backends/gpu/BatchExecutor.ts
+var BatchExecutor = class {
+  context;
+  shaders;
+  bufferPool;
+  operations = [];
+  options;
   /**
-   * Get current adaptive thresholds
+   * Create a new batch executor
    */
-  getAdaptiveThresholds() {
-    return new Map(this.adaptiveState.adjustedThresholds);
+  constructor(context, shaders, bufferPool, options = {}) {
+    this.context = context;
+    this.shaders = shaders;
+    this.bufferPool = bufferPool;
+    this.options = {
+      maxBatchSize: options.maxBatchSize ?? 100,
+      autoFlush: options.autoFlush ?? true,
+      waitForCompletion: options.waitForCompletion ?? true
+    };
   }
   /**
-   * Reset adaptive tuning state
+   * Get current batch size
    */
-  resetAdaptiveState() {
-    this.adaptiveState = {
-      samples: [],
-      lastAdjustment: 0,
-      adjustedThresholds: /* @__PURE__ */ new Map()
-    };
+  get size() {
+    return this.operations.length;
   }
   /**
-   * Get performance statistics
+   * Check if batch is empty
    */
-  getPerformanceStats() {
-    const operationStats = /* @__PURE__ */ new Map();
-    const byOperation = /* @__PURE__ */ new Map();
-    for (const sample of this.adaptiveState.samples) {
-      const existing = byOperation.get(sample.operation) ?? [];
-      existing.push(sample);
-      byOperation.set(sample.operation, existing);
-    }
-    for (const [op, samples] of byOperation) {
-      const avgDuration = samples.reduce((s, x) => s + x.durationMs, 0) / samples.length;
-      const backendUsage = {
-        js: 0,
-        wasm: 0,
-        gpu: 0,
-        parallel: 0
-      };
-      for (const s of samples) {
-        backendUsage[s.backend]++;
-      }
-      operationStats.set(op, {
-        avgDuration,
-        samples: samples.length,
-        backendUsage
-      });
-    }
-    return {
-      sampleCount: this.adaptiveState.samples.length,
-      operationStats
-    };
+  get isEmpty() {
+    return this.operations.length === 0;
   }
   /**
-   * Cleanup resources
+   * Check if batch is full
    */
-  destroy() {
-    if (this.configUnsubscribe) {
-      this.configUnsubscribe();
-      this.configUnsubscribe = null;
-    }
+  get isFull() {
+    return this.operations.length >= this.options.maxBatchSize;
   }
-};
-var backendManager = new BackendManager();
-function createBackendManager(hints) {
-  return new BackendManager(hints);
-}
-
-// src/backends/WasmLoader.ts
-var AS_ID_ARRAY_BUFFER2 = 1;
-var AS_ID_INT32_ARRAY2 = 4;
-var AS_ID_FLOAT64_ARRAY2 = 5;
-var AS_HEADER_BYTES2 = 12;
-var WasmLoader = class _WasmLoader {
-  static instance = null;
-  wasmModule = null;
-  compiledModule = null;
-  loading = null;
-  isNode;
-  lastMetrics = null;
-  // Memory pool for AS allocations.
-  float64Pool = [];
-  int32Pool = [];
-  poolSizeThreshold = 1024 * 1024;
-  // 1MB max per pool entry
-  constructor() {
-    this.isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+  /**
+   * Queue an add operation
+   */
+  add(inputA, inputB, output, dimensions) {
+    this.queueOperation({
+      type: "add",
+      inputA,
+      inputB,
+      output,
+      dimensions
+    });
   }
-  static getInstance() {
-    if (!_WasmLoader.instance) {
-      _WasmLoader.instance = new _WasmLoader();
-    }
-    return _WasmLoader.instance;
+  /**
+   * Queue a subtract operation
+   */
+  subtract(inputA, inputB, output, dimensions) {
+    this.queueOperation({
+      type: "subtract",
+      inputA,
+      inputB,
+      output,
+      dimensions
+    });
   }
   /**
-   * Load the WASM module
+   * Queue an element-wise multiply operation
    */
-  async load(wasmPath) {
-    if (this.wasmModule) {
-      return this.wasmModule;
-    }
-    if (this.loading) {
-      return this.loading;
-    }
-    this.loading = this.loadModule(wasmPath);
-    this.wasmModule = await this.loading;
-    return this.wasmModule;
+  multiply(inputA, inputB, output, dimensions) {
+    this.queueOperation({
+      type: "multiply",
+      inputA,
+      inputB,
+      output,
+      dimensions
+    });
   }
   /**
-   * Precompile the WASM module without instantiation
-   * Useful for build-time or startup optimization
+   * Queue a scale operation
    */
-  async precompile(wasmPath) {
-    if (this.compiledModule) return;
-    const path = wasmPath || await this.getDefaultWasmPath();
-    const startTime = performance.now();
-    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
-    if (this.isNode) {
-      const fs = await import("fs");
-      const { promisify } = await import("util");
-      const readFile = promisify(fs.readFile);
-      const buffer = await readFile(path);
-      await verifyWasmIntegrity(buffer, path);
-      this.compiledModule = await WebAssembly.compile(buffer);
-    } else {
-      const manifest = await loadWasmManifest(path);
-      if (!manifest && typeof WebAssembly.compileStreaming === "function") {
-        this.compiledModule = await WebAssembly.compileStreaming(fetch(path));
-      } else {
-        const response = await fetch(path);
-        const buffer = await response.arrayBuffer();
-        await verifyWasmIntegrity(buffer, path, { manifest });
-        this.compiledModule = await WebAssembly.compile(buffer);
-      }
-    }
-    this.lastMetrics = {
-      fileReadMs: 0,
-      compileMs: performance.now() - startTime,
-      instantiateMs: 0,
-      totalMs: performance.now() - startTime,
-      fromCache: false
-    };
+  scale(input, output, scalar, dimensions) {
+    this.queueOperation({
+      type: "scale",
+      inputA: input,
+      output,
+      dimensions,
+      scalar
+    });
   }
-  async loadModule(wasmPath) {
-    const path = wasmPath || await this.getDefaultWasmPath();
-    const totalStart = performance.now();
-    if (this.compiledModule) {
-      const instStart = performance.now();
-      const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
-      this.lastMetrics = {
-        fileReadMs: 0,
-        compileMs: 0,
-        instantiateMs: performance.now() - instStart,
-        totalMs: performance.now() - totalStart,
-        fromCache: true
-      };
-      return instance.exports;
-    }
-    if (this.isNode) {
-      return this.loadNodeWasm(path, totalStart);
-    } else {
-      return this.loadBrowserWasm(path, totalStart);
-    }
+  /**
+   * Queue a matrix multiplication operation
+   */
+  matmul(inputA, inputB, output, dimensions) {
+    this.queueOperation({
+      type: "matmul",
+      inputA,
+      inputB,
+      output,
+      dimensions
+    });
   }
   /**
-   * Get the WASM binary path. AssemblyScript is the sole WASM backend
-   * (`mathts-as.wasm`); the legacy second toolchain was removed in the
-   * WASM-backend migration (complete 2026-06-26).
-   *
-   * Resolution is package-relative and CWD-independent: the packaged artifact
-   * (`dist/wasm/`) is preferred via `resolvePackagedWasm`; when absent, the
-   * canonical expected location is returned so the missing-binary warning is
-   * actionable (see `defaultWasmLocation` in wasm/resolve.ts — B-3).
+   * Queue a transpose operation
    */
-  async getDefaultWasmPath() {
-    const wasmFile = "mathts-as.wasm";
-    if (this.isNode) {
-      const { resolvePackagedWasm } = await import("./resolve-VJX3YTS6.js");
-      const found = await resolvePackagedWasm(import.meta.url, wasmFile);
-      if (found) return found;
-      const { defaultWasmLocation: defaultWasmLocation2 } = await import("./resolve-VJX3YTS6.js");
-      return defaultWasmLocation2(import.meta.url, wasmFile);
-    }
-    const { defaultWasmLocation } = await import("./resolve-VJX3YTS6.js");
-    return defaultWasmLocation(import.meta.url, wasmFile, { browser: true });
+  transpose(input, output, dimensions) {
+    this.queueOperation({
+      type: "transpose",
+      inputA: input,
+      output,
+      dimensions
+    });
   }
-  async loadNodeWasm(path, totalStart) {
-    const fs = await import("fs");
-    const { promisify } = await import("util");
-    const readFile = promisify(fs.readFile);
-    const { verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
-    const readStart = performance.now();
-    const buffer = await readFile(path);
-    const readEnd = performance.now();
-    await verifyWasmIntegrity(buffer, path);
-    const compileStart = performance.now();
-    this.compiledModule = await WebAssembly.compile(buffer);
-    const compileEnd = performance.now();
-    const instStart = performance.now();
-    const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
-    const instEnd = performance.now();
-    this.lastMetrics = {
-      fileReadMs: readEnd - readStart,
-      compileMs: compileEnd - compileStart,
-      instantiateMs: instEnd - instStart,
-      totalMs: performance.now() - totalStart,
-      fromCache: false
-    };
-    return instance.exports;
+  /**
+   * Queue a sum reduction operation
+   */
+  reduceSum(input, output, dimensions) {
+    this.queueOperation({
+      type: "reduce_sum",
+      inputA: input,
+      output,
+      dimensions
+    });
   }
-  async loadBrowserWasm(path, totalStart) {
-    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
-    const manifest = await loadWasmManifest(path);
-    if (!manifest && typeof WebAssembly.instantiateStreaming === "function") {
-      const instStart2 = performance.now();
-      const result = await WebAssembly.instantiateStreaming(fetch(path), this.getImports());
-      this.compiledModule = result.module;
-      this.lastMetrics = {
-        fileReadMs: 0,
-        // Combined with compile in streaming
-        compileMs: 0,
-        // Combined in streaming
-        instantiateMs: performance.now() - instStart2,
-        totalMs: performance.now() - totalStart,
-        fromCache: false
-      };
-      return result.instance.exports;
+  /**
+   * Queue operation (internal)
+   */
+  queueOperation(op) {
+    this.operations.push(op);
+    if (this.options.autoFlush && this.isFull) {
+      this.flushSync();
     }
-    const readStart = performance.now();
-    const response = await fetch(path);
-    const buffer = await response.arrayBuffer();
-    const readEnd = performance.now();
-    await verifyWasmIntegrity(buffer, path, { manifest });
-    const compileStart = performance.now();
-    this.compiledModule = await WebAssembly.compile(buffer);
-    const compileEnd = performance.now();
-    const instStart = performance.now();
-    const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
-    const instEnd = performance.now();
-    this.lastMetrics = {
-      fileReadMs: readEnd - readStart,
-      compileMs: compileEnd - compileStart,
-      instantiateMs: instEnd - instStart,
-      totalMs: performance.now() - totalStart,
-      fromCache: false
-    };
-    return instance.exports;
-  }
-  getImports() {
-    return {
-      env: {
-        abort: (msg, file, line, column2) => {
-          console.error("WASM abort", { msg, file, line, column: column2 });
-          throw new Error("WASM abort");
-        },
-        seed: () => Date.now()
-      },
-      Math,
-      Date
-    };
   }
   /**
-   * Get the loaded WASM module
+   * Flush all queued operations (async)
    */
-  getModule() {
-    return this.wasmModule;
+  async flush() {
+    if (this.isEmpty) {
+      return {
+        success: true,
+        operationCount: 0,
+        duration: 0
+      };
+    }
+    const start = performance.now();
+    const operationCount = this.operations.length;
+    try {
+      const encoder = this.context.createCommandEncoder();
+      for (const op of this.operations) {
+        this.encodeOperation(encoder, op);
+      }
+      const commandBuffer = encoder.finish();
+      this.context.submitCommands([commandBuffer]);
+      if (this.options.waitForCompletion) {
+        await this.context.getDevice().queue.onSubmittedWorkDone();
+      }
+      this.operations = [];
+      return {
+        success: true,
+        operationCount,
+        duration: performance.now() - start
+      };
+    } catch (error) {
+      return {
+        success: false,
+        operationCount,
+        duration: performance.now() - start,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
   }
   /**
-   * Get the compiled WASM module (for caching/serialization)
+   * Flush synchronously (fire and forget)
    */
-  getCompiledModule() {
-    return this.compiledModule;
+  flushSync() {
+    if (this.isEmpty) return;
+    try {
+      const encoder = this.context.createCommandEncoder();
+      for (const op of this.operations) {
+        this.encodeOperation(encoder, op);
+      }
+      const commandBuffer = encoder.finish();
+      this.context.submitCommands([commandBuffer]);
+      this.operations = [];
+    } catch {
+    }
   }
   /**
-   * Check if WASM is loaded
+   * Encode a single operation into the command encoder
    */
-  isLoaded() {
-    return this.wasmModule !== null;
+  encodeOperation(encoder, op) {
+    const pipelineName = this.getPipelineName(op.type);
+    const pipeline = this.shaders.getRegisteredPipeline(pipelineName);
+    const entries = [{ binding: 0, resource: { buffer: op.inputA } }];
+    if (op.inputB) {
+      entries.push({ binding: 1, resource: { buffer: op.inputB } });
+    }
+    entries.push({
+      binding: op.inputB ? 2 : 1,
+      resource: { buffer: op.output }
+    });
+    const params = this.createParamsBuffer(op);
+    entries.push({
+      binding: entries.length,
+      resource: { buffer: params }
+    });
+    const bindGroup = this.context.getDevice().createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries
+    });
+    const passEncoder = encoder.beginComputePass();
+    passEncoder.setPipeline(pipeline);
+    passEncoder.setBindGroup(0, bindGroup);
+    const [wgX, wgY, wgZ] = this.calculateWorkgroups(op);
+    passEncoder.dispatchWorkgroups(wgX, wgY, wgZ);
+    passEncoder.end();
   }
   /**
-   * Check if WASM is precompiled
+   * Get pipeline name for operation type
    */
-  isPrecompiled() {
-    return this.compiledModule !== null;
+  getPipelineName(type) {
+    const mapping = {
+      add: "matrixAdd",
+      subtract: "matrixSub",
+      multiply: "matrixMul",
+      divide: "matrixDiv",
+      scale: "scalarMul",
+      matmul: "matmul",
+      transpose: "transpose",
+      reduce_sum: "sumReduce",
+      reduce_max: "maxReduce",
+      reduce_min: "minReduce"
+    };
+    return mapping[type] || "matrixAdd";
   }
   /**
-   * Get loading performance metrics
+   * Create params buffer for operation
    */
-  getLoadingMetrics() {
-    return this.lastMetrics;
+  createParamsBuffer(op) {
+    const { rows, cols, k } = op.dimensions;
+    let data;
+    if (op.type === "matmul" && k !== void 0) {
+      data = new Uint32Array([rows, cols, k, 0]);
+    } else if (op.type === "scale" && op.scalar !== void 0) {
+      const floatArray = new Float32Array([op.scalar]);
+      const uintView = new Uint32Array(floatArray.buffer);
+      data = new Uint32Array([rows, cols, uintView[0], 0]);
+    } else {
+      data = new Uint32Array([rows, cols, 0, 0]);
+    }
+    const buffer = this.bufferPool.acquireUniformBuffer(16, "batch-params");
+    this.context.writeBuffer(buffer, data);
+    return buffer;
   }
-  // ===========================================================================
-  // Allocation API
-  // ---------------------------------------------------------------------------
-  // The returned handle's `ptr` is the header pointer to pass to WASM
-  // functions (AssemblyScript managed runtime).
-  // ===========================================================================
   /**
-   * Allocate Float64Array in WASM memory and copy `data` into it.
-   * Uses memory pooling.
+   * Calculate workgroup dispatch counts
    */
-  allocateFloat64Array(data) {
-    const module = this.wasmModule;
-    if (!module) throw new Error("WASM module not loaded");
-    const length = data.length;
-    const alloc = this.allocateAsFloat64(module, length);
-    alloc.array.set(data);
-    return alloc;
+  calculateWorkgroups(op) {
+    const { rows, cols } = op.dimensions;
+    const workgroupSize = 16;
+    if (op.type === "reduce_sum" || op.type === "reduce_max" || op.type === "reduce_min") {
+      const total = rows * cols;
+      return [Math.ceil(total / 256), 1, 1];
+    }
+    return [Math.ceil(cols / workgroupSize), Math.ceil(rows / workgroupSize), 1];
   }
   /**
-   * Decode a managed Float64Array RETURNED by an AssemblyScript export
-   * (e.g. the `matrix_lu_decompose` / `matrix_qr_decompose` outputs) into a fresh JS copy.
-   *
-   * AS exports that return a `Float64Array` hand back the typed-array
-   * *header* pointer. The header is a 12-byte block laid out as
-   * `[buffer, dataStart, byteLength]` (little-endian u32s) — the same shape
-   * the loader writes in `makeAsFloat64`. We read `dataStart`/`byteLength`
-   * and copy the data region out so it survives any later reuse of WASM
-   * memory.
+   * Clear all queued operations without executing
    */
-  readReturnedFloat64Array(headerPtr) {
-    const module = this.wasmModule;
-    if (!module) throw new Error("WASM module not loaded");
-    const hdr = headerPtr >>> 0;
-    const dv = new DataView(module.memory.buffer);
-    const dataStart = dv.getUint32(hdr + 4, true);
-    const byteLength = dv.getUint32(hdr + 8, true);
-    const view = new Float64Array(module.memory.buffer, dataStart, byteLength >>> 3);
-    return new Float64Array(view);
+  clear() {
+    this.operations = [];
   }
   /**
-   * Allocate Float64Array without copying data (for output buffers)
+   * Get statistics about the batch executor
    */
-  allocateFloat64ArrayEmpty(length) {
-    const module = this.wasmModule;
-    if (!module) throw new Error("WASM module not loaded");
-    return this.allocateAsFloat64(module, length);
+  getStats() {
+    return {
+      queuedOperations: this.operations.length,
+      maxBatchSize: this.options.maxBatchSize,
+      autoFlush: this.options.autoFlush
+    };
   }
-  /**
-   * Allocate Int32Array in WASM memory and copy `data` into it.
-   */
-  allocateInt32Array(data) {
-    const module = this.wasmModule;
-    if (!module) throw new Error("WASM module not loaded");
-    const length = data.length;
-    const alloc = this.allocateAsInt32(module, length);
-    alloc.array.set(data);
-    return alloc;
+};
+
+// src/backends/gpu/Sync.ts
+var SyncManager = class {
+  context;
+  config;
+  pendingTransfers = /* @__PURE__ */ new Map();
+  nextRequestId = 0;
+  stagingBuffers = [];
+  // Statistics
+  totalUploads = 0;
+  totalDownloads = 0;
+  totalBytesUploaded = 0;
+  totalBytesDownloaded = 0;
+  constructor(context, _bufferPool, config = {}) {
+    this.context = context;
+    this.config = {
+      strategy: config.strategy ?? "lazy",
+      chunkSize: config.chunkSize ?? 1024 * 1024,
+      // 1MB default
+      maxPendingTransfers: config.maxPendingTransfers ?? 16,
+      coalesceTransfers: config.coalesceTransfers ?? true
+    };
   }
   /**
-   * Allocate Int32Array without copying data (for output buffers)
+   * Upload data from CPU to GPU
    */
-  allocateInt32ArrayEmpty(length) {
-    const module = this.wasmModule;
-    if (!module) throw new Error("WASM module not loaded");
-    return this.allocateAsInt32(module, length);
-  }
-  // ---- AS managed runtime (header pointers) ------------------------------
-  allocateAsFloat64(module, length) {
-    const byteLength = length * 8;
-    if (byteLength <= this.poolSizeThreshold) {
-      const recycled = this.acquireFromAsPool(this.float64Pool, byteLength);
-      if (recycled) {
-        const array = new Float64Array(module.memory.buffer, recycled.dataPtr, length);
-        return {
-          ptr: recycled.ptr,
-          dataPtr: recycled.dataPtr,
-          array,
-          length
-        };
-      }
-    }
-    return this.makeAsFloat64(module, length);
-  }
-  allocateAsInt32(module, length) {
-    const byteLength = length * 4;
-    if (byteLength <= this.poolSizeThreshold) {
-      const recycled = this.acquireFromAsPool(this.int32Pool, byteLength);
-      if (recycled) {
-        const array = new Int32Array(module.memory.buffer, recycled.dataPtr, length);
-        return {
-          ptr: recycled.ptr,
-          dataPtr: recycled.dataPtr,
-          array,
-          length
-        };
+  async upload(cpuData, gpuBuffer, options = {}) {
+    const id = this.nextRequestId++;
+    const start = performance.now();
+    try {
+      const offset = options.offset ?? 0;
+      const size2 = options.size ?? cpuData.byteLength;
+      this.context.writeBuffer(gpuBuffer, cpuData, offset);
+      if (this.config.strategy === "immediate") {
+        await this.context.getDevice().queue.onSubmittedWorkDone();
       }
-    }
-    return this.makeAsInt32(module, length);
-  }
-  makeAsFloat64(module, length) {
-    const byteLength = length * 8;
-    const bufferPtr = module.__pin(module.__new(byteLength, AS_ID_ARRAY_BUFFER2)) >>> 0;
-    const headerPtr = module.__new(AS_HEADER_BYTES2, AS_ID_FLOAT64_ARRAY2) >>> 0;
-    module.__pin(headerPtr);
-    const dv = new DataView(module.memory.buffer);
-    dv.setUint32(headerPtr + 0, bufferPtr, true);
-    dv.setUint32(headerPtr + 4, bufferPtr, true);
-    dv.setUint32(headerPtr + 8, byteLength, true);
-    const array = new Float64Array(module.memory.buffer, bufferPtr, length);
-    return { ptr: headerPtr, dataPtr: bufferPtr, array, length };
+      this.totalUploads++;
+      this.totalBytesUploaded += size2;
+      return {
+        id,
+        success: true,
+        duration: performance.now() - start,
+        bytesTransferred: size2
+      };
+    } catch (error) {
+      return {
+        id,
+        success: false,
+        duration: performance.now() - start,
+        bytesTransferred: 0,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
   }
-  makeAsInt32(module, length) {
-    const byteLength = length * 4;
-    const bufferPtr = module.__pin(module.__new(byteLength, AS_ID_ARRAY_BUFFER2)) >>> 0;
-    const headerPtr = module.__new(AS_HEADER_BYTES2, AS_ID_INT32_ARRAY2) >>> 0;
-    module.__pin(headerPtr);
-    const dv = new DataView(module.memory.buffer);
-    dv.setUint32(headerPtr + 0, bufferPtr, true);
-    dv.setUint32(headerPtr + 4, bufferPtr, true);
-    dv.setUint32(headerPtr + 8, byteLength, true);
-    const array = new Int32Array(module.memory.buffer, bufferPtr, length);
-    return { ptr: headerPtr, dataPtr: bufferPtr, array, length };
+  /**
+   * Download data from GPU to CPU
+   */
+  async download(gpuBuffer, options = {}) {
+    const offset = options.offset ?? 0;
+    const size2 = options.size ?? gpuBuffer.size;
+    this.totalDownloads++;
+    this.totalBytesDownloaded += size2;
+    const buffer = await this.context.readBuffer(gpuBuffer, offset, size2);
+    return new Float32Array(buffer);
   }
   /**
-   * Find a pool entry whose data region is large enough; returns null when
-   * no suitable entry is available.
+   * Download data using double-buffering for overlap
    */
-  acquireFromAsPool(pool, requestedSize) {
-    let bestFit = null;
-    let bestFitWaste = Infinity;
-    for (const entry of pool) {
-      if (!entry.inUse && entry.size >= requestedSize) {
-        const waste = entry.size - requestedSize;
-        if (waste < bestFitWaste && entry.size <= requestedSize * 2) {
-          bestFit = entry;
-          bestFitWaste = waste;
+  async downloadDoubleBuffered(gpuBuffer, size2) {
+    const staging1 = this.getOrCreateStagingBuffer(size2);
+    const encoder = this.context.createCommandEncoder();
+    encoder.copyBufferToBuffer(gpuBuffer, 0, staging1, 0, size2);
+    this.context.submitCommands([encoder.finish()]);
+    await staging1.mapAsync(GPUMapMode.READ);
+    const data = new Float32Array(staging1.getMappedRange().slice(0));
+    staging1.unmap();
+    return data;
+  }
+  /**
+   * Stream large data in chunks
+   */
+  async uploadStreaming(cpuData, gpuBuffer, onProgress) {
+    const id = this.nextRequestId++;
+    const start = performance.now();
+    const chunkSize = this.config.chunkSize / 4;
+    const totalElements = cpuData.length;
+    let transferred = 0;
+    try {
+      for (let offset = 0; offset < totalElements; offset += chunkSize) {
+        const end = Math.min(offset + chunkSize, totalElements);
+        const chunk = cpuData.subarray(offset, end);
+        this.context.writeBuffer(
+          gpuBuffer,
+          chunk,
+          offset * 4
+          // byte offset
+        );
+        transferred = end;
+        if (onProgress) {
+          onProgress(transferred / totalElements);
         }
+        await new Promise((resolve) => setTimeout(resolve, 0));
       }
+      await this.context.getDevice().queue.onSubmittedWorkDone();
+      this.totalUploads++;
+      this.totalBytesUploaded += totalElements * 4;
+      return {
+        id,
+        success: true,
+        duration: performance.now() - start,
+        bytesTransferred: totalElements * 4
+      };
+    } catch (error) {
+      return {
+        id,
+        success: false,
+        duration: performance.now() - start,
+        bytesTransferred: transferred * 4,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-    if (bestFit) bestFit.inUse = true;
-    return bestFit;
   }
   /**
-   * Return an allocation to the pool for reuse.
-   *
-   * `isFloat64` exists for backwards compatibility — callers can still
-   * pass it positionally to disambiguate the pool to use on the AS path.
-   * Prefer `releaseAllocation` for new code, which discovers the pool
-   * automatically.
+   * Download large data in chunks
    */
-  release(ptr, isFloat64 = true) {
-    const pool = isFloat64 ? this.float64Pool : this.int32Pool;
-    const entry = pool.find((e) => e.ptr === ptr);
-    if (entry) {
-      entry.inUse = false;
-      return;
+  async downloadStreaming(gpuBuffer, totalSize, onProgress) {
+    const result = new Float32Array(totalSize / 4);
+    const chunkSize = this.config.chunkSize;
+    let downloaded = 0;
+    while (downloaded < totalSize) {
+      const remaining = totalSize - downloaded;
+      const currentChunkSize = Math.min(chunkSize, remaining);
+      const chunk = await this.download(gpuBuffer, {
+        offset: downloaded,
+        size: currentChunkSize
+      });
+      result.set(chunk, downloaded / 4);
+      downloaded += currentChunkSize;
+      if (onProgress) {
+        onProgress(downloaded / totalSize);
+      }
     }
-    this.free(ptr);
+    return result;
   }
   /**
-   * Free allocated memory (immediate, bypasses pool): unpin the header pointer.
+   * Batch multiple transfers
    */
-  free(ptr) {
-    const module = this.wasmModule;
-    if (!module) return;
-    this.float64Pool = this.float64Pool.filter((e) => e.ptr !== ptr);
-    this.int32Pool = this.int32Pool.filter((e) => e.ptr !== ptr);
-    if (typeof module.__unpin === "function") {
-      module.__unpin(ptr);
+  async batchTransfer(requests) {
+    const results = [];
+    const start = performance.now();
+    const uploads = requests.filter((r) => r.direction === "cpu-to-gpu");
+    const downloads = requests.filter((r) => r.direction === "gpu-to-cpu");
+    for (const req of uploads) {
+      const result = await this.upload(req.data, req.buffer);
+      results.push(result);
+    }
+    for (const req of downloads) {
+      const id = this.nextRequestId++;
+      try {
+        const data = await this.download(req.buffer);
+        req.data.set(data);
+        results.push({
+          id,
+          success: true,
+          duration: performance.now() - start,
+          bytesTransferred: data.byteLength
+        });
+      } catch (error) {
+        results.push({
+          id,
+          success: false,
+          duration: performance.now() - start,
+          bytesTransferred: 0,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
     }
+    return results;
   }
   /**
-   * Clear the memory pool
+   * Create or reuse a staging buffer
    */
-  clearPool() {
-    const module = this.wasmModule;
-    if (!module) return;
-    if (typeof module.__unpin === "function") {
-      for (const entry of this.float64Pool) {
-        module.__unpin(entry.ptr);
-      }
-      for (const entry of this.int32Pool) {
-        module.__unpin(entry.ptr);
+  getOrCreateStagingBuffer(size2) {
+    const alignedSize = this.roundToPowerOf2(size2);
+    for (const buffer2 of this.stagingBuffers) {
+      if (buffer2.size >= alignedSize) {
+        return buffer2;
       }
     }
-    this.float64Pool = [];
-    this.int32Pool = [];
+    const buffer = this.context.createStagingBuffer(alignedSize, "sync-staging");
+    this.stagingBuffers.push(buffer);
+    return buffer;
   }
   /**
-   * Get pool statistics
+   * Round up to next power of 2
    */
-  getPoolStats() {
-    const f64InUse = this.float64Pool.filter((e) => e.inUse).length;
-    const f64Bytes = this.float64Pool.reduce((sum3, e) => sum3 + e.size, 0);
-    const i32InUse = this.int32Pool.filter((e) => e.inUse).length;
-    const i32Bytes = this.int32Pool.reduce((sum3, e) => sum3 + e.size, 0);
-    return {
-      float64: {
-        total: this.float64Pool.length,
-        inUse: f64InUse,
-        totalBytes: f64Bytes
-      },
-      int32: {
-        total: this.int32Pool.length,
-        inUse: i32InUse,
-        totalBytes: i32Bytes
-      }
-    };
+  roundToPowerOf2(n) {
+    if (n <= 0) return 256;
+    n--;
+    n |= n >> 1;
+    n |= n >> 2;
+    n |= n >> 4;
+    n |= n >> 8;
+    n |= n >> 16;
+    return n + 1;
   }
   /**
-   * Run garbage collection.
+   * Wait for all pending transfers to complete
    */
-  collect() {
-    const module = this.wasmModule;
-    if (!module) return;
-    if (typeof module.__collect === "function") {
-      module.__collect();
-    }
+  async flush() {
+    await this.context.getDevice().queue.onSubmittedWorkDone();
+    await Promise.all(this.pendingTransfers.values());
+    this.pendingTransfers.clear();
   }
   /**
-   * Reset the loader (for testing)
+   * Get synchronization statistics
    */
-  reset() {
-    this.clearPool();
-    this.wasmModule = null;
-    this.compiledModule = null;
-    this.loading = null;
-    this.lastMetrics = null;
+  getStats() {
+    return {
+      totalUploads: this.totalUploads,
+      totalDownloads: this.totalDownloads,
+      totalBytesUploaded: this.totalBytesUploaded,
+      totalBytesDownloaded: this.totalBytesDownloaded,
+      pendingTransfers: this.pendingTransfers.size,
+      stagingBuffersCount: this.stagingBuffers.length,
+      strategy: this.config.strategy
+    };
+  }
+  /**
+   * Destroy sync manager and release resources
+   */
+  destroy() {
+    for (const buffer of this.stagingBuffers) {
+      buffer.destroy();
+    }
+    this.stagingBuffers = [];
+    this.pendingTransfers.clear();
   }
 };
-var wasmLoader = WasmLoader.getInstance();
+function createSyncManager(context, bufferPool, strategy = "lazy") {
+  return new SyncManager(context, bufferPool, { strategy });
+}
 
 // src/operations/common.ts
 function eye(n) {
@@ -8816,17 +8197,17 @@ export {
   BackendManager,
   BackendRegistry,
   BatchExecutor,
-  BufferPool,
+  BufferPool2 as BufferPool,
   DEFAULT_BACKEND_HINTS,
   DEFAULT_EXTENDED_HINTS,
   DenseMatrix,
   GPUBackend,
-  GPUContext,
+  GPUContext2 as GPUContext,
   GPUMatrixBackend,
   JSBackend,
   Matrix,
   ParallelBackend,
-  ShaderManager,
+  ShaderManager2 as ShaderManager,
   SparseMatrix,
   SyncManager,
   WASMBackend,
@@ -8845,7 +8226,7 @@ export {
   createWASMBackend,
   destroyGlobalGPU,
   destroyGlobalGPUBackend,
-  detectGPUCapabilities,
+  detectGPUCapabilities3 as detectGPUCapabilities,
   detectWasmFeatures,
   diag,
   diagonal,
@@ -8858,10 +8239,10 @@ export {
   exp,
   getCachedFeatures,
   getGlobalGPUBackend,
-  getGlobalGPUContext,
-  getRecommendedWorkgroupSize,
+  getGlobalGPUContext2 as getGlobalGPUContext,
+  getRecommendedWorkgroupSize2 as getRecommendedWorkgroupSize,
   gpuMatrixBackend,
-  hasWebGPU,
+  hasWebGPU3 as hasWebGPU,
   identity,
   initializeGlobalGPUBackend,
   initializeParallelMatrix,