@holoscript/engine 6.0.3 → 6.0.4

package/dist/gpu/index.cjs

@@ -0,0 +1,4810 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gpu/WebGPUContext.ts
+var WebGPUContext_exports = {};
+__export(WebGPUContext_exports, {
+  WebGPUContext: () => WebGPUContext,
+  createPhysicsSimulation: () => createPhysicsSimulation,
+  getGlobalWebGPUContext: () => getGlobalWebGPUContext
+});
+function getGlobalWebGPUContext(options) {
+  if (!globalContext) {
+    globalContext = new WebGPUContext(options);
+  }
+  return globalContext;
+}
+async function createPhysicsSimulation(options) {
+  if (options.preferGPU !== false) {
+    try {
+      const context = new WebGPUContext({ fallbackToCPU: true });
+      await context.initialize();
+      if (context.isSupported()) {
+        return { usingGPU: true, context };
+      }
+    } catch (error) {
+      console.warn("GPU initialization failed, using CPU fallback:", error);
+    }
+  }
+  return { usingGPU: false };
+}
+var WebGPUContext, globalContext;
+var init_WebGPUContext = __esm({
+  "src/gpu/WebGPUContext.ts"() {
+    "use strict";
+    WebGPUContext = class {
+      adapter = null;
+      device = null;
+      limits = null;
+      features = /* @__PURE__ */ new Set();
+      options;
+      initialized = false;
+      constructor(options = {}) {
+        this.options = {
+          powerPreference: options.powerPreference ?? "high-performance",
+          requiredFeatures: options.requiredFeatures ?? [],
+          requiredLimits: options.requiredLimits ?? {},
+          fallbackToCPU: options.fallbackToCPU ?? true
+        };
+      }
+      /**
+       * Initialize WebGPU context
+       *
+       * @returns Promise that resolves when initialization is complete
+       * @throws Error if WebGPU is not supported and fallbackToCPU is false
+       */
+      async initialize() {
+        if (this.initialized) {
+          console.warn("WebGPUContext already initialized");
+          return;
+        }
+        if (!("gpu" in navigator)) {
+          this.handleUnsupported("WebGPU not supported in this browser");
+          return;
+        }
+        try {
+          this.adapter = await navigator.gpu.requestAdapter({
+            powerPreference: this.options.powerPreference
+          });
+          if (!this.adapter) {
+            this.handleUnsupported("Failed to get WebGPU adapter");
+            return;
+          }
+          this.limits = this.adapter.limits;
+          this.features = new Set(this.adapter.features);
+          const missingFeatures = this.options.requiredFeatures.filter(
+            (feature) => !this.features.has(feature)
+          );
+          if (missingFeatures.length > 0) {
+            throw new Error(`Missing required WebGPU features: ${missingFeatures.join(", ")}`);
+          }
+          const deviceDescriptor = {
+            requiredFeatures: this.options.requiredFeatures,
+            requiredLimits: this.options.requiredLimits
+          };
+          this.device = await this.adapter.requestDevice(deviceDescriptor);
+          this.device.lost.then((info) => {
+            console.error("WebGPU device lost:", info.message, info.reason);
+            if (info.reason !== "destroyed") {
+              this.handleDeviceLost(info);
+            }
+          });
+          this.device.addEventListener("uncapturederror", (event) => {
+            console.error("WebGPU uncaptured error:", event.error);
+          });
+          this.initialized = true;
+        } catch (error) {
+          this.handleUnsupported(`WebGPU initialization failed: ${error}`);
+        }
+      }
+      /**
+       * Check if WebGPU is supported and initialized
+       */
+      isSupported() {
+        return this.initialized && this.device !== null;
+      }
+      /**
+       * Get WebGPU device
+       * @throws Error if device is not initialized
+       */
+      getDevice() {
+        if (!this.device) {
+          throw new Error("WebGPU device not initialized. Call initialize() first.");
+        }
+        return this.device;
+      }
+      /**
+       * Get WebGPU adapter
+       * @throws Error if adapter is not available
+       */
+      getAdapter() {
+        if (!this.adapter) {
+          throw new Error("WebGPU adapter not available");
+        }
+        return this.adapter;
+      }
+      /**
+       * Get device limits
+       */
+      getLimits() {
+        if (!this.limits) {
+          throw new Error("WebGPU limits not available");
+        }
+        return this.limits;
+      }
+      /**
+       * Get supported features
+       */
+      getFeatures() {
+        return this.features;
+      }
+      /**
+       * Check if a specific feature is supported
+       */
+      hasFeature(feature) {
+        return this.features.has(feature);
+      }
+      /**
+       * Get capabilities object
+       */
+      getCapabilities() {
+        return {
+          supported: this.isSupported(),
+          adapter: this.adapter,
+          device: this.device,
+          limits: this.limits,
+          features: this.features
+        };
+      }
+      /**
+       * Get optimal workgroup size for compute shaders
+       *
+       * Returns a workgroup size that maximizes occupancy based on device limits.
+       * Common values: 64, 128, 256 (must be power of 2)
+       */
+      getOptimalWorkgroupSize() {
+        if (!this.limits) return 256;
+        const maxInvocations = this.limits.maxComputeInvocationsPerWorkgroup;
+        if (maxInvocations >= 256) return 256;
+        if (maxInvocations >= 128) return 128;
+        if (maxInvocations >= 64) return 64;
+        return 32;
+      }
+      /**
+       * Cleanup resources
+       */
+      destroy() {
+        if (this.device) {
+          this.device.destroy();
+          this.device = null;
+        }
+        this.adapter = null;
+        this.limits = null;
+        this.features.clear();
+        this.initialized = false;
+      }
+      /**
+       * Handle unsupported browser/device
+       */
+      handleUnsupported(reason) {
+        console.warn(`\u26A0\uFE0F  ${reason}`);
+        if (!this.options.fallbackToCPU) {
+          throw new Error(`WebGPU required but not available: ${reason}`);
+        }
+        console.warn("\u{1F4A1} Falling back to CPU-based physics simulation");
+        this.initialized = false;
+      }
+      /**
+       * Handle device lost event
+       */
+      handleDeviceLost(_info) {
+        console.error("WebGPU device lost, attempting to recreate...");
+        this.initialized = false;
+        this.initialize().catch((error) => {
+          console.error("Failed to reinitialize WebGPU device:", error);
+          if (this.options.fallbackToCPU) {
+            console.warn("Falling back to CPU physics");
+          }
+        });
+      }
+      /**
+       * Detect and log GPU information (for debugging)
+       */
+      async logGPUInfo() {
+        if (!this.adapter) {
+          console.warn("No adapter available");
+          return;
+        }
+        const info = await this.adapter.requestAdapterInfo?.();
+        if (info) {
+          void info;
+        }
+      }
+    };
+    globalContext = null;
+  }
+});
+
+// src/gpu/GPUBuffers.ts
+var GPUBuffers_exports = {};
+__export(GPUBuffers_exports, {
+  GPUBufferManager: () => GPUBufferManager,
+  createInitialParticleData: () => createInitialParticleData
+});
+function createInitialParticleData(count, options = {}) {
+  const { positionRange = { min: -5, max: 5 }, radius = 0.05, mass = 1 } = options;
+  const positions = new Float32Array(count * 4);
+  const velocities = new Float32Array(count * 4);
+  const states = new Float32Array(count * 4);
+  for (let i = 0; i < count; i++) {
+    const idx = i * 4;
+    positions[idx + 0] = Math.random() * (positionRange.max - positionRange.min) + positionRange.min;
+    positions[idx + 1] = Math.random() * (positionRange.max - positionRange.min) + positionRange.min;
+    positions[idx + 2] = Math.random() * (positionRange.max - positionRange.min) + positionRange.min;
+    positions[idx + 3] = radius;
+    velocities[idx + 0] = 0;
+    velocities[idx + 1] = 0;
+    velocities[idx + 2] = 0;
+    velocities[idx + 3] = mass;
+    states[idx + 0] = 1;
+    states[idx + 1] = 0;
+    states[idx + 2] = 1;
+    states[idx + 3] = 0;
+  }
+  return { positions, velocities, states };
+}
+var GPUBufferManager;
+var init_GPUBuffers = __esm({
+  "src/gpu/GPUBuffers.ts"() {
+    "use strict";
+    GPUBufferManager = class {
+      context;
+      device;
+      particleCount;
+      buffers = null;
+      // Buffer sizes (in bytes)
+      positionBufferSize;
+      velocityBufferSize;
+      stateBufferSize;
+      uniformBufferSize;
+      constructor(context, particleCount) {
+        this.context = context;
+        this.device = context.getDevice();
+        this.particleCount = particleCount;
+        this.positionBufferSize = particleCount * 4 * Float32Array.BYTES_PER_ELEMENT;
+        this.velocityBufferSize = particleCount * 4 * Float32Array.BYTES_PER_ELEMENT;
+        this.stateBufferSize = particleCount * 4 * Float32Array.BYTES_PER_ELEMENT;
+        this.uniformBufferSize = 32;
+      }
+      /**
+       * Initialize GPU buffers
+       */
+      async initialize() {
+        const positionsRead = this.createStorageBuffer(this.positionBufferSize, "positions-read");
+        const positionsWrite = this.createStorageBuffer(this.positionBufferSize, "positions-write");
+        const velocitiesRead = this.createStorageBuffer(this.velocityBufferSize, "velocities-read");
+        const velocitiesWrite = this.createStorageBuffer(this.velocityBufferSize, "velocities-write");
+        const statesRead = this.createStorageBuffer(this.stateBufferSize, "states-read");
+        const statesWrite = this.createStorageBuffer(this.stateBufferSize, "states-write");
+        const uniforms = this.device.createBuffer({
+          label: "uniforms",
+          size: this.uniformBufferSize,
+          usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+        });
+        this.buffers = {
+          positionsRead,
+          positionsWrite,
+          velocitiesRead,
+          velocitiesWrite,
+          statesRead,
+          statesWrite,
+          uniforms
+        };
+      }
+      /**
+       * Create a storage buffer
+       */
+      createStorageBuffer(size, label) {
+        return this.device.createBuffer({
+          label,
+          size,
+          usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+        });
+      }
+      /**
+       * Upload particle data to GPU
+       */
+      uploadParticleData(data) {
+        if (!this.buffers) {
+          throw new Error("Buffers not initialized. Call initialize() first.");
+        }
+        this.device.queue.writeBuffer(this.buffers.positionsRead, 0, data.positions.buffer);
+        this.device.queue.writeBuffer(this.buffers.velocitiesRead, 0, data.velocities.buffer);
+        this.device.queue.writeBuffer(this.buffers.statesRead, 0, data.states.buffer);
+      }
+      /**
+       * Upload uniform data (simulation parameters)
+       */
+      uploadUniformData(uniforms) {
+        if (!this.buffers) {
+          throw new Error("Buffers not initialized");
+        }
+        const data = new Float32Array([
+          uniforms.dt,
+          uniforms.gravity,
+          uniforms.groundY,
+          uniforms.restitution,
+          uniforms.friction,
+          uniforms.particleCount,
+          uniforms._pad1 ?? 0,
+          uniforms._pad2 ?? 0
+        ]);
+        this.device.queue.writeBuffer(this.buffers.uniforms, 0, data.buffer);
+      }
+      /**
+       * Download particle data from GPU (for rendering or analysis)
+       *
+       * Note: This is an async operation that stalls the pipeline.
+       * Use sparingly (e.g., once per frame for rendering).
+       */
+      async downloadParticleData() {
+        if (!this.buffers) {
+          throw new Error("Buffers not initialized");
+        }
+        const positionsStaging = this.createStagingBuffer(this.positionBufferSize);
+        const velocitiesStaging = this.createStagingBuffer(this.velocityBufferSize);
+        const statesStaging = this.createStagingBuffer(this.stateBufferSize);
+        const commandEncoder = this.device.createCommandEncoder({ label: "readback-encoder" });
+        commandEncoder.copyBufferToBuffer(
+          this.buffers.positionsRead,
+          0,
+          positionsStaging,
+          0,
+          this.positionBufferSize
+        );
+        commandEncoder.copyBufferToBuffer(
+          this.buffers.velocitiesRead,
+          0,
+          velocitiesStaging,
+          0,
+          this.velocityBufferSize
+        );
+        commandEncoder.copyBufferToBuffer(
+          this.buffers.statesRead,
+          0,
+          statesStaging,
+          0,
+          this.stateBufferSize
+        );
+        this.device.queue.submit([commandEncoder.finish()]);
+        await Promise.all([
+          positionsStaging.mapAsync(GPUMapMode.READ),
+          velocitiesStaging.mapAsync(GPUMapMode.READ),
+          statesStaging.mapAsync(GPUMapMode.READ)
+        ]);
+        const positions = new Float32Array(positionsStaging.getMappedRange()).slice();
+        const velocities = new Float32Array(velocitiesStaging.getMappedRange()).slice();
+        const states = new Float32Array(statesStaging.getMappedRange()).slice();
+        positionsStaging.unmap();
+        velocitiesStaging.unmap();
+        statesStaging.unmap();
+        positionsStaging.destroy();
+        velocitiesStaging.destroy();
+        statesStaging.destroy();
+        return { positions, velocities, states };
+      }
+      /**
+       * Create a staging buffer for GPU→CPU readback
+       */
+      createStagingBuffer(size) {
+        return this.device.createBuffer({
+          size,
+          usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+        });
+      }
+      /**
+       * Swap read/write buffers (ping-pong)
+       *
+       * After a compute pass, the "write" buffers contain the new state.
+       * This function swaps read ↔ write so the next pass can read the latest data.
+       */
+      swap() {
+        if (!this.buffers) {
+          throw new Error("Buffers not initialized");
+        }
+        const tempPos = this.buffers.positionsRead;
+        this.buffers.positionsRead = this.buffers.positionsWrite;
+        this.buffers.positionsWrite = tempPos;
+        const tempVel = this.buffers.velocitiesRead;
+        this.buffers.velocitiesRead = this.buffers.velocitiesWrite;
+        this.buffers.velocitiesWrite = tempVel;
+        const tempState = this.buffers.statesRead;
+        this.buffers.statesRead = this.buffers.statesWrite;
+        this.buffers.statesWrite = tempState;
+      }
+      /**
+       * Get buffer set for binding to compute pipeline
+       */
+      getBuffers() {
+        if (!this.buffers) {
+          throw new Error("Buffers not initialized");
+        }
+        return this.buffers;
+      }
+      /**
+       * Get particle count
+       */
+      getParticleCount() {
+        return this.particleCount;
+      }
+      /**
+       * Destroy buffers and free GPU memory
+       */
+      destroy() {
+        if (!this.buffers) return;
+        this.buffers.positionsRead.destroy();
+        this.buffers.positionsWrite.destroy();
+        this.buffers.velocitiesRead.destroy();
+        this.buffers.velocitiesWrite.destroy();
+        this.buffers.statesRead.destroy();
+        this.buffers.statesWrite.destroy();
+        this.buffers.uniforms.destroy();
+        this.buffers = null;
+      }
+    };
+  }
+});
+
+// src/gpu/index.ts
+var gpu_exports = {};
+__export(gpu_exports, {
+  AbstractGaussianCodec: () => AbstractGaussianCodec,
+  CodecDecodeError: () => CodecDecodeError,
+  CodecDecompressError: () => CodecDecompressError,
+  CodecEncodeError: () => CodecEncodeError,
+  CodecMemoryError: () => CodecMemoryError,
+  CodecNotSupportedError: () => CodecNotSupportedError,
+  ComputePipeline: () => ComputePipeline,
+  GPUBufferManager: () => GPUBufferManager,
+  GaussianCodecError: () => GaussianCodecError,
+  GaussianCodecRegistry: () => GaussianCodecRegistry,
+  GaussianSplatExtractor: () => GaussianSplatExtractor,
+  GaussianSplatSorter: () => GaussianSplatSorter,
+  GltfGaussianSplatCodec: () => GltfGaussianSplatCodec,
+  InstancedRenderer: () => InstancedRenderer,
+  MpegGscCodec: () => MpegGscCodec,
+  SparseLinearSolver: () => SparseLinearSolver,
+  SpatialGrid: () => SpatialGrid,
+  SpzCodec: () => SpzCodec,
+  WebGPUContext: () => WebGPUContext,
+  createDefaultCodecRegistry: () => createDefaultCodecRegistry,
+  createGPUPhysicsSimulation: () => createGPUPhysicsSimulation,
+  createGaussianSplatSorter: () => createGaussianSplatSorter,
+  createInitialParticleData: () => createInitialParticleData,
+  createPhysicsSimulation: () => createPhysicsSimulation,
+  getGlobalCodecRegistry: () => getGlobalCodecRegistry,
+  getGlobalWebGPUContext: () => getGlobalWebGPUContext,
+  resetGlobalCodecRegistry: () => resetGlobalCodecRegistry
+});
+module.exports = __toCommonJS(gpu_exports);
+
+// src/gpu/ComputePipeline.ts
+var ComputePipeline = class {
+  context;
+  bufferManager;
+  device;
+  options;
+  pipeline = null;
+  bindGroupLayout = null;
+  bindGroup = null;
+  workgroupsX = 0;
+  constructor(context, bufferManager, options) {
+    this.context = context;
+    this.bufferManager = bufferManager;
+    this.device = context.getDevice();
+    this.options = {
+      shaderCode: options.shaderCode,
+      entryPoint: options.entryPoint ?? "main",
+      workgroupSize: options.workgroupSize ?? this.context.getOptimalWorkgroupSize()
+    };
+  }
+  /**
+   * Initialize compute pipeline and bind groups
+   */
+  async initialize() {
+    const shaderModule = this.device.createShaderModule({
+      label: "particle-physics-shader",
+      code: this.options.shaderCode
+    });
+    const compilationInfo = await shaderModule.getCompilationInfo();
+    for (const message of compilationInfo.messages) {
+      if (message.type === "error") {
+        console.error("Shader error:", message.message, `at line ${message.lineNum}`);
+      } else if (message.type === "warning") {
+        console.warn("Shader warning:", message.message, `at line ${message.lineNum}`);
+      }
+    }
+    this.bindGroupLayout = this.device.createBindGroupLayout({
+      label: "particle-physics-bind-group-layout",
+      entries: [
+        // @binding(0): Uniforms (read-only)
+        {
+          binding: 0,
+          visibility: GPUShaderStage.COMPUTE,
+          buffer: { type: "uniform" }
+        },
+        // @binding(1): positions_in (read-only)
+        {
+          binding: 1,
+          visibility: GPUShaderStage.COMPUTE,
+          buffer: { type: "read-only-storage" }
+        },
+        // @binding(2): velocities_in (read-only)
+        {
+          binding: 2,
+          visibility: GPUShaderStage.COMPUTE,
+          buffer: { type: "read-only-storage" }
+        },
+        // @binding(3): states_in (read-only)
+        {
+          binding: 3,
+          visibility: GPUShaderStage.COMPUTE,
+          buffer: { type: "read-only-storage" }
+        },
+        // @binding(4): positions_out (read-write)
+        {
+          binding: 4,
+          visibility: GPUShaderStage.COMPUTE,
+          buffer: { type: "storage" }
+        },
+        // @binding(5): velocities_out (read-write)
+        {
+          binding: 5,
+          visibility: GPUShaderStage.COMPUTE,
+          buffer: { type: "storage" }
+        },
+        // @binding(6): states_out (read-write)
+        {
+          binding: 6,
+          visibility: GPUShaderStage.COMPUTE,
+          buffer: { type: "storage" }
+        }
+      ]
+    });
+    const pipelineLayout = this.device.createPipelineLayout({
+      label: "particle-physics-pipeline-layout",
+      bindGroupLayouts: [this.bindGroupLayout]
+    });
+    this.pipeline = this.device.createComputePipeline({
+      label: "particle-physics-pipeline",
+      layout: pipelineLayout,
+      compute: {
+        module: shaderModule,
+        entryPoint: this.options.entryPoint
+      }
+    });
+    this.createBindGroup();
+    const particleCount = this.bufferManager.getParticleCount();
+    this.workgroupsX = Math.ceil(particleCount / this.options.workgroupSize);
+  }
+  /**
+   * Create bind group linking buffers to shader bindings
+   */
+  createBindGroup() {
+    if (!this.bindGroupLayout) {
+      throw new Error("Bind group layout not created");
+    }
+    const buffers = this.bufferManager.getBuffers();
+    this.bindGroup = this.device.createBindGroup({
+      label: "particle-physics-bind-group",
+      layout: this.bindGroupLayout,
+      entries: [
+        { binding: 0, resource: { buffer: buffers.uniforms } },
+        { binding: 1, resource: { buffer: buffers.positionsRead } },
+        { binding: 2, resource: { buffer: buffers.velocitiesRead } },
+        { binding: 3, resource: { buffer: buffers.statesRead } },
+        { binding: 4, resource: { buffer: buffers.positionsWrite } },
+        { binding: 5, resource: { buffer: buffers.velocitiesWrite } },
+        { binding: 6, resource: { buffer: buffers.statesWrite } }
+      ]
+    });
+  }
+  /**
+   * Update uniform buffer with simulation parameters
+   */
+  updateUniforms(uniforms) {
+    this.bufferManager.uploadUniformData(uniforms);
+  }
+  /**
+   * Dispatch compute shader to update all particles
+   *
+   * @param commandEncoder Optional command encoder (creates new one if not provided)
+   * @returns Command encoder (for chaining or submission)
+   */
+  dispatch(commandEncoder) {
+    if (!this.pipeline || !this.bindGroup) {
+      throw new Error("Pipeline not initialized. Call initialize() first.");
+    }
+    const encoder = commandEncoder ?? this.device.createCommandEncoder({
+      label: "particle-physics-compute-encoder"
+    });
+    const computePass = encoder.beginComputePass({
+      label: "particle-physics-compute-pass"
+    });
+    computePass.setPipeline(this.pipeline);
+    computePass.setBindGroup(0, this.bindGroup);
+    computePass.dispatchWorkgroups(this.workgroupsX, 1, 1);
+    computePass.end();
+    return encoder;
+  }
+  /**
+   * Execute a single simulation step
+   *
+   * Convenience method that dispatches compute shader and submits to queue.
+   *
+   * @param uniforms Simulation parameters for this step
+   */
+  async step(uniforms) {
+    this.updateUniforms(uniforms);
+    const encoder = this.dispatch();
+    this.device.queue.submit([encoder.finish()]);
+    this.bufferManager.swap();
+    this.createBindGroup();
+  }
+  /**
+   * Execute multiple simulation steps (batch processing)
+   *
+   * @param steps Number of steps to execute
+   * @param uniforms Simulation parameters (same for all steps)
+   * @param onProgress Optional progress callback
+   */
+  async run(steps, uniforms, onProgress) {
+    const _startTime = performance.now();
+    for (let i = 0; i < steps; i++) {
+      await this.step(uniforms);
+      if (onProgress && i % 10 === 0) {
+        onProgress(i + 1, steps);
+      }
+    }
+  }
+  /**
+   * Get pipeline statistics
+   */
+  getStats() {
+    return {
+      particleCount: this.bufferManager.getParticleCount(),
+      workgroupSize: this.options.workgroupSize,
+      workgroups: this.workgroupsX,
+      threadsTotal: this.workgroupsX * this.options.workgroupSize
+    };
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.pipeline = null;
+    this.bindGroupLayout = null;
+    this.bindGroup = null;
+  }
+};
+async function createGPUPhysicsSimulation(options) {
+  const { WebGPUContext: WebGPUContext2 } = await Promise.resolve().then(() => (init_WebGPUContext(), WebGPUContext_exports));
+  const { GPUBufferManager: GPUBufferManager2 } = await Promise.resolve().then(() => (init_GPUBuffers(), GPUBuffers_exports));
+  const context = new WebGPUContext2(options.contextOptions);
+  await context.initialize();
+  if (!context.isSupported()) {
+    throw new Error("WebGPU not supported on this device");
+  }
+  const bufferManager = new GPUBufferManager2(context, options.particleCount);
+  await bufferManager.initialize();
+  const pipeline = new ComputePipeline(context, bufferManager, {
+    shaderCode: options.shaderCode,
+    workgroupSize: options.workgroupSize
+  });
+  await pipeline.initialize();
+  return { context, bufferManager, pipeline };
+}
+
+// src/gpu/index.ts
+init_GPUBuffers();
+
+// src/gpu/GaussianSplatExtractor.ts
+var GaussianSplatExtractor = class {
+  context;
+  device;
+  options;
+  readbackBuffersA = null;
+  readbackBuffersB = null;
+  isUsingA = true;
+  ongoingReadback = null;
+  frameCounter = 0;
+  constructor(context, options) {
+    this.context = context;
+    this.device = context.getDevice();
+    this.options = {
+      maxSplats: options.maxSplats
+    };
+    this.initializeBuffers();
+  }
+  initializeBuffers() {
+    const compressedSize = this.options.maxSplats * 32;
+    const indicesSize = this.options.maxSplats * 4;
+    this.readbackBuffersA = {
+      compressed: this.createReadbackBuffer(compressedSize),
+      indices: this.createReadbackBuffer(indicesSize)
+    };
+    this.readbackBuffersB = {
+      compressed: this.createReadbackBuffer(compressedSize),
+      indices: this.createReadbackBuffer(indicesSize)
+    };
+  }
+  createReadbackBuffer(size) {
+    return this.device.createBuffer({
+      size,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+  }
+  /**
+   * Captures the sorted state of the GaussianSplatSorter.
+   * Internally pipelines the GPU readback to avoid stalling the main render loop.
+   */
+  extractFrame(sorter, camera, compressedSource, indicesSource) {
+    const stats = sorter.getStats();
+    if (stats.splatCount === 0) return Promise.resolve(null);
+    if (this.ongoingReadback) {
+      return Promise.resolve(null);
+    }
+    const currentBuffers = this.isUsingA ? this.readbackBuffersA : this.readbackBuffersB;
+    this.isUsingA = !this.isUsingA;
+    const compressedSize = stats.splatCount * 32;
+    const indicesSize = stats.splatCount * 4;
+    const currentFrame = ++this.frameCounter;
+    const encoder = this.device.createCommandEncoder({
+      label: "splat-extractor-copy-encoder"
+    });
+    encoder.copyBufferToBuffer(compressedSource, 0, currentBuffers.compressed, 0, compressedSize);
+    encoder.copyBufferToBuffer(indicesSource, 0, currentBuffers.indices, 0, indicesSize);
+    this.device.queue.submit([encoder.finish()]);
+    this.ongoingReadback = Promise.all([
+      currentBuffers.compressed.mapAsync(GPUMapMode.READ, 0, compressedSize),
+      currentBuffers.indices.mapAsync(GPUMapMode.READ, 0, indicesSize)
+    ]).then(() => {
+      const compData = currentBuffers.compressed.getMappedRange(0, compressedSize).slice(0);
+      const indData = currentBuffers.indices.getMappedRange(0, indicesSize).slice(0);
+      currentBuffers.compressed.unmap();
+      currentBuffers.indices.unmap();
+      this.ongoingReadback = null;
+      const packet = {
+        frameId: currentFrame,
+        cameraState: {
+          viewProjectionMatrix: Array.from(camera.viewProjectionMatrix),
+          cameraPosition: [
+            camera.cameraPosition[0],
+            camera.cameraPosition[1],
+            camera.cameraPosition[2]
+          ]
+        },
+        splatCount: stats.splatCount,
+        compressedSplatsBuffer: compData,
+        sortedIndicesBuffer: indData
+      };
+      return packet;
+    }).catch((e) => {
+      console.warn("GaussianSplatExtractor readback failed", e);
+      this.ongoingReadback = null;
+      return null;
+    });
+    return this.ongoingReadback;
+  }
+};
+
+// wgsl-raw:C:\Users\josep\Documents\GitHub\HoloScript\packages\engine\src\gpu\shaders\radix-sort.wgsl
+var radix_sort_default = `/**
+ * Wait-Free Hierarchical Radix Sort - WebGPU Compute Shader
+ *
+ * Implements a 4-pass 8-bit LSD radix sort using Blelloch exclusive prefix sum.
+ * Designed for sorting Gaussian splat indices by depth (back-to-front).
+ *
+ * Architecture:
+ *   - 4 passes, each sorting 8 bits of a 32-bit key (LSD order: bits 0-7, 8-15, 16-23, 24-31)
+ *   - Each pass: histogram -> Blelloch scan -> scatter
+ *   - Wait-free: no global atomics, only workgroup-level shared memory with barriers
+ *   - Hierarchical block scan for cross-workgroup prefix sums
+ *
+ * Key design decisions for cross-browser compatibility:
+ *   - No subgroup operations (not supported in Safari/Firefox)
+ *   - No global atomics (wait-free guarantee)
+ *   - workgroup_size(256) fits all GPU vendors (NVIDIA, AMD, Apple, Qualcomm)
+ *   - All shared memory fits within 16KB (WebGPU minimum guarantee)
+ *
+ * References:
+ *   - Blelloch (1990): "Prefix Sums and Their Applications"
+ *   - Merrill & Grimshaw (2010): "Revisiting Sorting on GPUs"
+ *   - HoloScript W.035, G.030.01 (3.COMPRESS research)
+ *
+ * @version 1.0.0
+ */
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+const WORKGROUP_SIZE: u32 = 256u;
+const RADIX_BITS: u32 = 8u;
+const RADIX_SIZE: u32 = 256u;  // 2^8 = 256 buckets per pass
+const ELEMENTS_PER_THREAD: u32 = 4u;
+const BLOCK_SIZE: u32 = 1024u; // WORKGROUP_SIZE * ELEMENTS_PER_THREAD
+
+// =============================================================================
+// Uniforms
+// =============================================================================
+
+struct SortUniforms {
+  totalCount: u32,     // Total number of splats to sort
+  bitOffset: u32,      // Current bit offset (0, 8, 16, 24)
+  blockCount: u32,     // Number of workgroup blocks
+  _pad: u32,
+};
+
+@group(0) @binding(0) var<uniform> uniforms: SortUniforms;
+
+// =============================================================================
+// Storage Buffers
+// =============================================================================
+
+// Keys (depth values, 32-bit uint - quantized camera-space Z)
+@group(0) @binding(1) var<storage, read> keysIn: array<u32>;
+@group(0) @binding(2) var<storage, read_write> keysOut: array<u32>;
+
+// Values (splat indices, 32-bit uint)
+@group(0) @binding(3) var<storage, read> valuesIn: array<u32>;
+@group(0) @binding(4) var<storage, read_write> valuesOut: array<u32>;
+
+// Per-block histograms: blockCount * RADIX_SIZE
+@group(0) @binding(5) var<storage, read_write> blockHistograms: array<u32>;
+
+// Global prefix sums for each radix digit: RADIX_SIZE
+@group(0) @binding(6) var<storage, read_write> globalPrefixes: array<u32>;
+
+// =============================================================================
+// Shared Memory
+// =============================================================================
+
+// Shared histogram for Blelloch scan (256 entries)
+var<workgroup> sharedHist: array<u32, 256>;
+
+// Shared scratch for local key/value staging
+var<workgroup> sharedKeys: array<u32, 1024>;
+var<workgroup> sharedVals: array<u32, 1024>;
+
+// Shared local histogram for 256-way counting
+var<workgroup> sharedLocalHist: array<atomic<u32>, 256>;
+
+// =============================================================================
+// Helper: Extract radix digit from key
+// =============================================================================
+
+fn extractDigit(key: u32, bitOffset: u32) -> u32 {
+  return (key >> bitOffset) & 0xFFu;
+}
+
+// =============================================================================
+// Pass 1: Build Per-Block Histograms
+// =============================================================================
+
+/**
+ * Each workgroup processes BLOCK_SIZE elements, counting occurrences of each
+ * 8-bit radix digit. Results written to blockHistograms[blockIdx * 256 + digit].
+ *
+ * This is wait-free: each workgroup writes only to its own histogram region.
+ */
+@compute @workgroup_size(256)
+fn buildHistogram(
+  @builtin(global_invocation_id) globalId: vec3<u32>,
+  @builtin(local_invocation_id) localId: vec3<u32>,
+  @builtin(workgroup_id) groupId: vec3<u32>,
+) {
+  let tid = localId.x;
+  let blockIdx = groupId.x;
+  let blockStart = blockIdx * BLOCK_SIZE;
+
+  // Clear shared local histogram
+  atomicStore(&sharedLocalHist[tid], 0u);
+  workgroupBarrier();
+
+  // Each thread counts ELEMENTS_PER_THREAD elements
+  for (var i = 0u; i < ELEMENTS_PER_THREAD; i++) {
+    let idx = blockStart + tid * ELEMENTS_PER_THREAD + i;
+    if (idx < uniforms.totalCount) {
+      let key = keysIn[idx];
+      let digit = extractDigit(key, uniforms.bitOffset);
+      atomicAdd(&sharedLocalHist[digit], 1u);
+    }
+  }
+
+  workgroupBarrier();
+
+  // Write shared histogram to global memory
+  // Each thread writes one bucket value (256 threads, 256 buckets)
+  let histValue = atomicLoad(&sharedLocalHist[tid]);
+  blockHistograms[blockIdx * RADIX_SIZE + tid] = histValue;
+}
+
+// =============================================================================
+// Pass 2: Blelloch Exclusive Prefix Sum (Hierarchical)
+// =============================================================================
+
+/**
+ * Computes exclusive prefix sums across all block histograms for each radix digit.
+ *
+ * For each digit d (0..255):
+ *   globalPrefixes[d] = sum of all blockHistograms[block * 256 + d] for block < blockCount
+ *
+ * This pass processes one radix digit per workgroup.
+ * Each workgroup computes prefix sums across blocks for its assigned digit.
+ *
+ * Wait-free: uses Blelloch scan on shared memory with workgroup barriers only.
+ */
+@compute @workgroup_size(256)
+fn blellochScan(
+  @builtin(local_invocation_id) localId: vec3<u32>,
+  @builtin(workgroup_id) groupId: vec3<u32>,
+) {
+  let tid = localId.x;
+  let digit = groupId.x;  // One workgroup per radix digit
+
+  // Load block histogram values for this digit into shared memory
+  // If blockCount <= 256, each thread loads one value
+  // For larger counts, we'd need multi-pass (rare for typical splat counts)
+  if (tid < uniforms.blockCount) {
+    sharedHist[tid] = blockHistograms[tid * RADIX_SIZE + digit];
+  } else {
+    sharedHist[tid] = 0u;
+  }
+
+  workgroupBarrier();
+
+  // ---- Blelloch Up-Sweep (Reduce) Phase ----
+  // Build partial sums bottom-up in a binary tree
+  var offset = 1u;
+  for (var d = WORKGROUP_SIZE >> 1u; d > 0u; d >>= 1u) {
+    if (tid < d) {
+      let ai = offset * (2u * tid + 1u) - 1u;
+      let bi = offset * (2u * tid + 2u) - 1u;
+      if (ai < WORKGROUP_SIZE && bi < WORKGROUP_SIZE) {
+        sharedHist[bi] += sharedHist[ai];
+      }
+    }
+    offset <<= 1u;
+    workgroupBarrier();
+  }
+
+  // Store total sum and clear last element for exclusive scan
+  if (tid == 0u) {
+    // Total across all blocks for this digit
+    globalPrefixes[digit] = sharedHist[WORKGROUP_SIZE - 1u];
+    sharedHist[WORKGROUP_SIZE - 1u] = 0u;
+  }
+
+  workgroupBarrier();
+
+  // ---- Blelloch Down-Sweep Phase ----
+  // Propagate partial sums back down to produce exclusive prefix sums
+  for (var d = 1u; d < WORKGROUP_SIZE; d <<= 1u) {
+    offset >>= 1u;
+    if (tid < d) {
+      let ai = offset * (2u * tid + 1u) - 1u;
+      let bi = offset * (2u * tid + 2u) - 1u;
+      if (ai < WORKGROUP_SIZE && bi < WORKGROUP_SIZE) {
+        let temp = sharedHist[ai];
+        sharedHist[ai] = sharedHist[bi];
+        sharedHist[bi] += temp;
+      }
+    }
+    workgroupBarrier();
+  }
+
+  // Write back the exclusive prefix sum for each block
+  if (tid < uniforms.blockCount) {
+    blockHistograms[tid * RADIX_SIZE + digit] = sharedHist[tid];
+  }
+}
+
+// =============================================================================
+// Pass 2b: Global Prefix Sum over Digit Totals
+// =============================================================================
+
+/**
+ * After blellochScan, globalPrefixes[d] contains the total count for digit d.
+ * This pass computes an exclusive prefix sum over those totals to get the
+ * global scatter offset for each digit.
+ *
+ * Single workgroup: 256 threads for 256 digits.
+ */
+@compute @workgroup_size(256)
+fn globalPrefixScan(
+  @builtin(local_invocation_id) localId: vec3<u32>,
+) {
+  let tid = localId.x;
+
+  // Load digit totals into shared memory
+  sharedHist[tid] = globalPrefixes[tid];
+
+  workgroupBarrier();
+
+  // ---- Blelloch Up-Sweep ----
+  var offset = 1u;
+  for (var d = WORKGROUP_SIZE >> 1u; d > 0u; d >>= 1u) {
+    if (tid < d) {
+      let ai = offset * (2u * tid + 1u) - 1u;
+      let bi = offset * (2u * tid + 2u) - 1u;
+      if (ai < WORKGROUP_SIZE && bi < WORKGROUP_SIZE) {
+        sharedHist[bi] += sharedHist[ai];
+      }
+    }
+    offset <<= 1u;
+    workgroupBarrier();
+  }
+
+  // Clear last for exclusive scan
+  if (tid == 0u) {
+    sharedHist[WORKGROUP_SIZE - 1u] = 0u;
+  }
+  workgroupBarrier();
+
+  // ---- Blelloch Down-Sweep ----
+  for (var d = 1u; d < WORKGROUP_SIZE; d <<= 1u) {
+    offset >>= 1u;
+    if (tid < d) {
+      let ai = offset * (2u * tid + 1u) - 1u;
+      let bi = offset * (2u * tid + 2u) - 1u;
+      if (ai < WORKGROUP_SIZE && bi < WORKGROUP_SIZE) {
+        let temp = sharedHist[ai];
+        sharedHist[ai] = sharedHist[bi];
+        sharedHist[bi] += temp;
+      }
+    }
+    workgroupBarrier();
+  }
+
+  // Write exclusive prefix sums back
+  globalPrefixes[tid] = sharedHist[tid];
+}
+
+// =============================================================================
+// Pass 3: Scatter (Reorder)
+// =============================================================================
+
+/**
+ * Each workgroup scatters its BLOCK_SIZE elements to globally sorted positions.
+ *
+ * For element at local position i with digit d:
+ *   globalDst = globalPrefixes[d]          // global offset for digit d
+ *             + blockHistograms[block*256+d] // offset from prior blocks
+ *             + localRank                    // rank within this block for digit d
+ *
+ * Wait-free: each element writes to a unique output position.
+ */
+@compute @workgroup_size(256)
+fn scatter(
+  @builtin(local_invocation_id) localId: vec3<u32>,
+  @builtin(workgroup_id) groupId: vec3<u32>,
+) {
+  let tid = localId.x;
+  let blockIdx = groupId.x;
+  let blockStart = blockIdx * BLOCK_SIZE;
+
+  // Clear shared local histogram for rank computation
+  atomicStore(&sharedLocalHist[tid], 0u);
+  workgroupBarrier();
+
+  // Load elements into shared memory and compute local histograms
+  var myKeys: array<u32, 4>;
+  var myVals: array<u32, 4>;
+  var myDigits: array<u32, 4>;
+
+  for (var i = 0u; i < ELEMENTS_PER_THREAD; i++) {
+    let idx = blockStart + tid * ELEMENTS_PER_THREAD + i;
+    if (idx < uniforms.totalCount) {
+      myKeys[i] = keysIn[idx];
+      myVals[i] = valuesIn[idx];
+      myDigits[i] = extractDigit(myKeys[i], uniforms.bitOffset);
+    } else {
+      myKeys[i] = 0xFFFFFFFFu;  // Sentinel: sorts to end
+      myVals[i] = 0u;
+      myDigits[i] = 255u;
+    }
+  }
+
+  // Two-phase local ranking:
+  // Phase 1: Count elements per digit in this block
+  for (var i = 0u; i < ELEMENTS_PER_THREAD; i++) {
+    let idx = blockStart + tid * ELEMENTS_PER_THREAD + i;
+    if (idx < uniforms.totalCount) {
+      atomicAdd(&sharedLocalHist[myDigits[i]], 1u);
+    }
+  }
+
+  workgroupBarrier();
+
+  // Phase 2: Each thread needs its rank within its digit bucket.
+  // We use a serialized approach per-digit that's safe across all browsers.
+  // Load histogram into non-atomic shared for prefix computation.
+  let digitCount = atomicLoad(&sharedLocalHist[tid]);
+  sharedHist[tid] = digitCount;
+
+  workgroupBarrier();
+
+  // Compute exclusive prefix sum of digit counts (local to this block)
+  // This gives the starting offset within the block for each digit
+  var blockDigitOffset = 0u;
+  for (var d = 0u; d < tid; d++) {
+    blockDigitOffset += sharedHist[d];
+  }
+
+  // Store the block-local prefix for digit tid
+  sharedKeys[tid] = blockDigitOffset;
+
+  workgroupBarrier();
+
+  // Reset shared histogram for per-element ranking
+  atomicStore(&sharedLocalHist[tid], 0u);
+
+  workgroupBarrier();
+
+  // Each thread scatters its elements
+  for (var i = 0u; i < ELEMENTS_PER_THREAD; i++) {
+    let idx = blockStart + tid * ELEMENTS_PER_THREAD + i;
+    if (idx < uniforms.totalCount) {
+      let digit = myDigits[i];
+
+      // Get rank within this digit in this block (atomically increment)
+      let localRank = atomicAdd(&sharedLocalHist[digit], 1u);
+
+      // Compute global destination:
+      // globalPrefixes[digit] + blockHistograms[blockIdx * 256 + digit] + localRank
+      let globalOffset = globalPrefixes[digit];
+      let blockOffset = blockHistograms[blockIdx * RADIX_SIZE + digit];
+      let dst = globalOffset + blockOffset + localRank;
+
+      if (dst < uniforms.totalCount) {
+        keysOut[dst] = myKeys[i];
+        valuesOut[dst] = myVals[i];
+      }
+    }
+  }
+}
+`;
+
+// wgsl-raw:C:\Users\josep\Documents\GitHub\HoloScript\packages\engine\src\gpu\shaders\splat-compress.wgsl
+var splat_compress_default = "/**\n * Gaussian Splat Data Compression & Depth Key Generation\n *\n * Compresses Gaussian splat data for efficient GPU sorting and rendering:\n *   - RGBA8 color packing: 4 bytes instead of 16 bytes (vec4<f32>)\n *   - Compressed ellipse axes: 2D covariance stored as 3x f16 (6 bytes)\n *   - Depth key generation: quantized camera-space Z for radix sort\n *\n * Memory layout (compressed, 32 bytes per splat):\n *   [0:12]  position (vec3<f32>)       12 bytes\n *   [12:16] packedColor (u32, RGBA8)    4 bytes\n *   [16:22] packedCov2D (3x u16)        6 bytes  (f16 cov entries)\n *   [22:24] opacity (f16)               2 bytes\n *   [24:28] depth (f32)                 4 bytes  (camera-space Z)\n *   [28:32] padding                     4 bytes\n *\n * vs. uncompressed (64 bytes per splat):\n *   position: vec3<f32>     12 bytes\n *   scale: vec3<f32>        12 bytes\n *   rotation: vec4<f32>     16 bytes\n *   color: vec4<f32>        16 bytes\n *   padding                  8 bytes\n *\n * Compression ratio: 32/64 = 50% memory reduction\n *\n * Cross-browser notes:\n *   - Uses u32 bit packing instead of f16 (f16 requires shader-f16 feature)\n *   - All operations use u32 and f32, universally supported\n *\n * @version 1.0.0\n */\n\n// =============================================================================\n// Structures\n// =============================================================================\n\nstruct SplatRaw {\n  pos: vec3<f32>,\n  scale: vec3<f32>,\n  rot: vec4<f32>,      // quaternion\n  color: vec4<f32>,    // RGBA float\n};\n\nstruct SplatCompressed {\n  pos: vec3<f32>,        // 12 bytes\n  packedColor: u32,      // 4 bytes (RGBA8)\n  packedCov2D_01: u32,   // 4 bytes (cov[0] and cov[1] as f16 pair)\n  packedCov2D_2_opacity: u32, // 4 bytes (cov[2] as f16, opacity as f16)\n  depth: f32,            // 4 bytes (camera-space Z)\n  _pad: u32,             // 4 bytes alignment\n};\n\nstruct CompressUniforms {\n  viewMatrix: mat4x4<f32>,      // 64 bytes\n  projMatrix: mat4x4<f32>,      // 64 bytes\n  screenWidth: f32,              // 4 bytes\n  screenHeight: f32,             // 4 bytes\n  focalX: f32,                   // 4 bytes\n  focalY: f32,                   // 4 bytes\n  splatCount: u32,               // 4 bytes\n  _pad1: u32,\n  _pad2: u32,\n  _pad3: u32,\n};\n\n// =============================================================================\n// Bindings\n// =============================================================================\n\n@group(0) @binding(0) var<uniform> uniforms: CompressUniforms;\n@group(0) @binding(1) var<storage, read> splatsIn: array<SplatRaw>;\n@group(0) @binding(2) var<storage, read_write> splatsOut: array<SplatCompressed>;\n@group(0) @binding(3) var<storage, read_write> sortKeys: array<u32>;\n@group(0) @binding(4) var<storage, read_write> sortValues: array<u32>;\n\n// =============================================================================\n// f16 Packing Helpers (no shader-f16 feature required)\n// =============================================================================\n\n/**\n * Pack a f32 value into f16 (IEEE 754 half-precision) stored in lower 16 bits of u32.\n * Handles normals, denormals, inf, and nan correctly.\n */\nfn f32ToF16(value: f32) -> u32 {\n  let bits = bitcast<u32>(value);\n  let sign = (bits >> 16u) & 0x8000u;\n  let exponent = (bits >> 23u) & 0xFFu;\n  let mantissa = bits & 0x7FFFFFu;\n\n  // Handle special cases\n  if (exponent == 0u) {\n    // Zero or denormal -> zero in f16\n    return sign;\n  }\n  if (exponent == 255u) {\n    // Inf or NaN\n    if (mantissa != 0u) {\n      return sign | 0x7E00u; // NaN\n    }\n    return sign | 0x7C00u; // Inf\n  }\n\n  // Bias conversion: f32 bias=127, f16 bias=15\n  let newExponent = i32(exponent) - 127 + 15;\n\n  if (newExponent <= 0) {\n    // Underflow to zero\n    return sign;\n  }\n  if (newExponent >= 31) {\n    // Overflow to infinity\n    return sign | 0x7C00u;\n  }\n\n  return sign | (u32(newExponent) << 10u) | (mantissa >> 13u);\n}\n\n/**\n * Unpack f16 (stored in lower 16 bits of u32) back to f32.\n */\nfn f16ToF32(h: u32) -> f32 {\n  let sign = (h & 0x8000u) << 16u;\n  let exponent = (h >> 10u) & 0x1Fu;\n  let mantissa = h & 0x3FFu;\n\n  if (exponent == 0u) {\n    if (mantissa == 0u) {\n      return bitcast<f32>(sign); // Signed zero\n    }\n    // Denormalized: convert to normalized f32\n    var m = mantissa;\n    var e = 0u;\n    while ((m & 0x400u) == 0u) {\n      m <<= 1u;\n      e++;\n    }\n    let newExp = (127u - 15u - e) << 23u;\n    let newMant = (m & 0x3FFu) << 13u;\n    return bitcast<f32>(sign | newExp | newMant);\n  }\n  if (exponent == 31u) {\n    if (mantissa == 0u) {\n      return bitcast<f32>(sign | 0x7F800000u); // Inf\n    }\n    return bitcast<f32>(sign | 0x7FC00000u); // NaN\n  }\n\n  let newExp = (exponent + 127u - 15u) << 23u;\n  let newMant = mantissa << 13u;\n  return bitcast<f32>(sign | newExp | newMant);\n}\n\n/**\n * Pack two f16 values into a single u32.\n */\nfn packF16x2(a: f32, b: f32) -> u32 {\n  return f32ToF16(a) | (f32ToF16(b) << 16u);\n}\n\n// =============================================================================\n// RGBA8 Color Packing\n// =============================================================================\n\n/**\n * Pack vec4<f32> color (0..1 range) into RGBA8 u32.\n * Layout: R[7:0] G[15:8] B[23:16] A[31:24]\n */\nfn packRGBA8(color: vec4<f32>) -> u32 {\n  let r = u32(clamp(color.r * 255.0, 0.0, 255.0));\n  let g = u32(clamp(color.g * 255.0, 0.0, 255.0));\n  let b = u32(clamp(color.b * 255.0, 0.0, 255.0));\n  let a = u32(clamp(color.a * 255.0, 0.0, 255.0));\n  return r | (g << 8u) | (b << 16u) | (a << 24u);\n}\n\n/**\n * Unpack RGBA8 u32 back to vec4<f32>.\n */\nfn unpackRGBA8(packed: u32) -> vec4<f32> {\n  return vec4<f32>(\n    f32(packed & 0xFFu) / 255.0,\n    f32((packed >> 8u) & 0xFFu) / 255.0,\n    f32((packed >> 16u) & 0xFFu) / 255.0,\n    f32((packed >> 24u) & 0xFFu) / 255.0,\n  );\n}\n\n// =============================================================================\n// 3D to 2D Covariance Projection (Compressed Ellipse Axes)\n// =============================================================================\n\n/**\n * Compute 2D covariance matrix from 3D Gaussian parameters.\n *\n * The 3D covariance matrix Sigma = R * S * S^T * R^T where:\n *   R = rotation matrix from quaternion\n *   S = diagonal scale matrix\n *\n * Projected to 2D using the Jacobian of the perspective projection:\n *   Sigma_2D = J * V * Sigma * V^T * J^T\n *\n * where V is the upper-left 3x3 of the view matrix and J is the Jacobian.\n *\n * Returns: vec3(cov[0][0], cov[0][1], cov[1][1]) - the symmetric 2x2 matrix.\n */\nfn computeCov2D(\n  pos: vec3<f32>,\n  scale: vec3<f32>,\n  rot: vec4<f32>,\n  viewMatrix: mat4x4<f32>,\n  focalX: f32,\n  focalY: f32,\n) -> vec3<f32> {\n  // Transform position to camera space\n  let camPos = viewMatrix * vec4<f32>(pos, 1.0);\n  let tz = camPos.z;\n\n  // Avoid division by zero\n  let tzSafe = select(tz, 0.001, abs(tz) < 0.001);\n\n  // Jacobian of perspective projection\n  let tanFovX = 1.0 / focalX;\n  let tanFovY = 1.0 / focalY;\n  let limX = 1.3 * tanFovX;\n  let limY = 1.3 * tanFovY;\n\n  let tx = clamp(camPos.x / tzSafe, -limX, limX) * tzSafe;\n  let ty = clamp(camPos.y / tzSafe, -limY, limY) * tzSafe;\n\n  // Jacobian matrix (2x3)\n  let J00 = focalX / tzSafe;\n  let J02 = -focalX * tx / (tzSafe * tzSafe);\n  let J11 = focalY / tzSafe;\n  let J12 = -focalY * ty / (tzSafe * tzSafe);\n\n  // Build rotation matrix from quaternion\n  let r = rot.x;\n  let x = rot.y;\n  let y = rot.z;\n  let z = rot.w;\n\n  let R = mat3x3<f32>(\n    vec3<f32>(1.0 - 2.0*(y*y + z*z), 2.0*(x*y - r*z), 2.0*(x*z + r*y)),\n    vec3<f32>(2.0*(x*y + r*z), 1.0 - 2.0*(x*x + z*z), 2.0*(y*z - r*x)),\n    vec3<f32>(2.0*(x*z - r*y), 2.0*(y*z + r*x), 1.0 - 2.0*(x*x + y*y)),\n  );\n\n  // Scale matrix (diagonal) applied as column scaling\n  let M = mat3x3<f32>(\n    R[0] * scale.x,\n    R[1] * scale.y,\n    R[2] * scale.z,\n  );\n\n  // 3D covariance: Sigma = M * M^T\n  let Sigma = mat3x3<f32>(\n    vec3<f32>(dot(M[0], M[0]), dot(M[0], M[1]), dot(M[0], M[2])),\n    vec3<f32>(dot(M[1], M[0]), dot(M[1], M[1]), dot(M[1], M[2])),\n    vec3<f32>(dot(M[2], M[0]), dot(M[2], M[1]), dot(M[2], M[2])),\n  );\n\n  // View rotation (upper-left 3x3)\n  let V = mat3x3<f32>(\n    viewMatrix[0].xyz,\n    viewMatrix[1].xyz,\n    viewMatrix[2].xyz,\n  );\n\n  // Transform covariance to camera space: T = V * Sigma * V^T\n  let T = V * Sigma * transpose(V);\n\n  // Apply Jacobian to get 2D covariance\n  // cov2D = J * T * J^T (where J is 2x3, T is 3x3)\n  let cov00 = J00 * J00 * T[0][0] + 2.0 * J00 * J02 * T[0][2] + J02 * J02 * T[2][2];\n  let cov01 = J00 * J11 * T[0][1] + J00 * J12 * T[0][2] + J02 * J11 * T[1][2] + J02 * J12 * T[2][2];\n  let cov11 = J11 * J11 * T[1][1] + 2.0 * J11 * J12 * T[1][2] + J12 * J12 * T[2][2];\n\n  // Add low-pass filter to avoid aliasing (minimum 0.3px Gaussian)\n  let covFiltered = vec3<f32>(cov00 + 0.3, cov01, cov11 + 0.3);\n\n  return covFiltered;\n}\n\n// =============================================================================\n// Main Compression + Depth Key Compute Shader\n// =============================================================================\n\n/**\n * Compress raw splats and generate sort keys in a single pass.\n *\n * For each splat:\n *   1. Project to camera space, compute depth\n *   2. Compute 2D covariance (compressed ellipse axes)\n *   3. Pack color as RGBA8\n *   4. Pack covariance as f16x3\n *   5. Generate quantized depth key for radix sort\n *   6. Initialize sort value (splat index)\n */\n@compute @workgroup_size(256)\nfn compressAndKey(\n  @builtin(global_invocation_id) globalId: vec3<u32>,\n) {\n  let idx = globalId.x;\n  if (idx >= uniforms.splatCount) {\n    return;\n  }\n\n  let raw = splatsIn[idx];\n\n  // Transform to camera space for depth\n  let camPos = uniforms.viewMatrix * vec4<f32>(raw.pos, 1.0);\n  let depth = camPos.z;\n\n  // Frustum culling: skip splats behind camera\n  // (They'll be sorted to the end with max depth key)\n  var depthKey: u32;\n  if (depth < 0.01) {\n    depthKey = 0xFFFFFFFFu; // Behind camera -> max depth -> sorted last\n  } else {\n    // Quantize depth to 32-bit uint for radix sort\n    // Use bit-cast of float: IEEE 754 floats sort correctly as uint when positive\n    // (which camera-space depth always is for visible splats)\n    depthKey = bitcast<u32>(depth);\n  }\n\n  // Compute 2D covariance (compressed ellipse axes)\n  let cov2D = computeCov2D(\n    raw.pos,\n    raw.scale,\n    raw.rot,\n    uniforms.viewMatrix,\n    uniforms.focalX,\n    uniforms.focalY,\n  );\n\n  // Pack compressed splat\n  var compressed: SplatCompressed;\n  compressed.pos = raw.pos;\n  compressed.packedColor = packRGBA8(raw.color);\n  compressed.packedCov2D_01 = packF16x2(cov2D.x, cov2D.y);\n  compressed.packedCov2D_2_opacity = packF16x2(cov2D.z, raw.color.a);\n  compressed.depth = depth;\n  compressed._pad = 0u;\n\n  // Write compressed data\n  splatsOut[idx] = compressed;\n\n  // Write sort key-value pair\n  sortKeys[idx] = depthKey;\n  sortValues[idx] = idx;\n}\n";
+
+// wgsl-raw:C:\Users\josep\Documents\GitHub\HoloScript\packages\engine\src\gpu\shaders\splat-render-sorted.wgsl
+var splat_render_sorted_default = "/**\n * Sorted Gaussian Splat Renderer\n *\n * Renders compressed, depth-sorted Gaussian splats using the output\n * of the radix sort pipeline. Reads RGBA8-packed colors and f16-packed\n * 2D covariance (compressed ellipse axes) for efficient memory bandwidth.\n *\n * Rendering approach:\n *   - Instance-based quad rendering (4 vertices per splat)\n *   - Back-to-front order (via radix-sorted indices)\n *   - Alpha blending with premultiplied alpha\n *   - 2D Gaussian falloff using projected covariance (elliptical)\n *\n * Cross-browser compatible:\n *   - No f16 shader feature required\n *   - No subgroup operations\n *   - Standard vertex/fragment pipeline\n *\n * @version 1.0.0\n */\n\n// =============================================================================\n// Structures\n// =============================================================================\n\nstruct SplatCompressed {\n  pos: vec3<f32>,\n  packedColor: u32,\n  packedCov2D_01: u32,\n  packedCov2D_2_opacity: u32,\n  depth: f32,\n  _pad: u32,\n};\n\nstruct RenderUniforms {\n  viewProjection: mat4x4<f32>,\n  viewMatrix: mat4x4<f32>,\n  cameraPosition: vec3<f32>,\n  screenWidth: f32,\n  screenHeight: f32,\n  focalX: f32,\n  focalY: f32,\n  _pad: f32,\n};\n\nstruct VertexOutput {\n  @builtin(position) position: vec4<f32>,\n  @location(0) color: vec4<f32>,\n  @location(1) conicAndOpacity: vec4<f32>,  // conic.xyz + opacity\n  @location(2) centerScreen: vec2<f32>,\n};\n\n// =============================================================================\n// Bindings\n// =============================================================================\n\n@group(0) @binding(0) var<uniform> uniforms: RenderUniforms;\n@group(0) @binding(1) var<storage, read> splats: array<SplatCompressed>;\n@group(0) @binding(2) var<storage, read> sortedIndices: array<u32>;\n\n// =============================================================================\n// f16 Unpacking Helpers\n// =============================================================================\n\nfn f16ToF32(h: u32) -> f32 {\n  let sign = (h & 0x8000u) << 16u;\n  let exponent = (h >> 10u) & 0x1Fu;\n  let mantissa = h & 0x3FFu;\n\n  if (exponent == 0u) {\n    if (mantissa == 0u) {\n      return bitcast<f32>(sign);\n    }\n    var m = mantissa;\n    var e = 0u;\n    while ((m & 0x400u) == 0u) {\n      m <<= 1u;\n      e++;\n    }\n    let newExp = (127u - 15u - e) << 23u;\n    let newMant = (m & 0x3FFu) << 13u;\n    return bitcast<f32>(sign | newExp | newMant);\n  }\n  if (exponent == 31u) {\n    if (mantissa == 0u) {\n      return bitcast<f32>(sign | 0x7F800000u);\n    }\n    return bitcast<f32>(sign | 0x7FC00000u);\n  }\n\n  let newExp = (exponent + 127u - 15u) << 23u;\n  let newMant = mantissa << 13u;\n  return bitcast<f32>(sign | newExp | newMant);\n}\n\nfn unpackF16Low(packed: u32) -> f32 {\n  return f16ToF32(packed & 0xFFFFu);\n}\n\nfn unpackF16High(packed: u32) -> f32 {\n  return f16ToF32((packed >> 16u) & 0xFFFFu);\n}\n\nfn unpackRGBA8(packed: u32) -> vec4<f32> {\n  return vec4<f32>(\n    f32(packed & 0xFFu) / 255.0,\n    f32((packed >> 8u) & 0xFFu) / 255.0,\n    f32((packed >> 16u) & 0xFFu) / 255.0,\n    f32((packed >> 24u) & 0xFFu) / 255.0,\n  );\n}\n\n// =============================================================================\n// Vertex Shader\n// =============================================================================\n\n/**\n * Renders a billboard quad for each sorted Gaussian splat.\n *\n * The quad is sized based on the 2D covariance ellipse to tightly\n * bound the Gaussian at the 3-sigma level.\n *\n * vertex_index 0..3 maps to quad corners:\n *   0: (-1, -1)  1: (1, -1)  2: (-1, 1)  3: (1, 1)\n */\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vertexIndex: u32,\n  @builtin(instance_index) instanceIndex: u32,\n) -> VertexOutput {\n  // Look up sorted splat index\n  let splatIndex = sortedIndices[instanceIndex];\n  let splat = splats[splatIndex];\n\n  // Unpack compressed data\n  let color = unpackRGBA8(splat.packedColor);\n  let cov00 = unpackF16Low(splat.packedCov2D_01);\n  let cov01 = unpackF16High(splat.packedCov2D_01);\n  let cov11 = unpackF16Low(splat.packedCov2D_2_opacity);\n  let opacity = unpackF16High(splat.packedCov2D_2_opacity);\n\n  // Project center to screen space\n  let clipPos = uniforms.viewProjection * vec4<f32>(splat.pos, 1.0);\n  let ndcPos = clipPos.xyz / clipPos.w;\n\n  // Screen-space center\n  let centerScreen = vec2<f32>(\n    (ndcPos.x * 0.5 + 0.5) * uniforms.screenWidth,\n    (ndcPos.y * -0.5 + 0.5) * uniforms.screenHeight,\n  );\n\n  // Compute inverse covariance (conic) for Gaussian evaluation in fragment shader\n  // For 2x2 symmetric matrix [[a, b], [b, c]]:\n  //   det = a*c - b*b\n  //   inv = [[c, -b], [-b, a]] / det\n  let det = cov00 * cov11 - cov01 * cov01;\n  let detSafe = max(det, 1e-6);\n  let conic = vec3<f32>(cov11 / detSafe, -cov01 / detSafe, cov00 / detSafe);\n\n  // Compute eigenvalues for quad sizing (ellipse bounding box)\n  let mid = 0.5 * (cov00 + cov11);\n  let discriminant = max(mid * mid - det, 0.0);\n  let lambda1 = mid + sqrt(discriminant);\n  let lambda2 = mid - sqrt(discriminant);\n\n  // 3-sigma bounding radius in pixels\n  let maxRadius = ceil(3.0 * sqrt(max(lambda1, 0.0)));\n\n  // Quad vertex positions (billboard)\n  let quadUV = vec2<f32>(\n    f32(vertexIndex & 1u) * 2.0 - 1.0,\n    f32((vertexIndex >> 1u) & 1u) * 2.0 - 1.0,\n  );\n\n  let pixelOffset = quadUV * maxRadius;\n  let screenPos = centerScreen + pixelOffset;\n\n  // Convert back to NDC\n  let finalNdc = vec2<f32>(\n    (screenPos.x / uniforms.screenWidth) * 2.0 - 1.0,\n    -((screenPos.y / uniforms.screenHeight) * 2.0 - 1.0),\n  );\n\n  var out: VertexOutput;\n  out.position = vec4<f32>(finalNdc, ndcPos.z, 1.0);\n  out.color = color;\n  out.conicAndOpacity = vec4<f32>(conic, opacity);\n  out.centerScreen = centerScreen;\n\n  return out;\n}\n\n// =============================================================================\n// Fragment Shader\n// =============================================================================\n\n/**\n * Evaluates the 2D Gaussian using the inverse covariance (conic).\n *\n * For a pixel at position p relative to the Gaussian center c:\n *   power = -0.5 * (d^T * Sigma^{-1} * d)\n *   alpha = opacity * exp(power)\n *\n * where d = p - c, and Sigma^{-1} is the conic (inverse covariance).\n */\n@fragment\nfn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {\n  // Fragment position in screen space (pixels)\n  let fragScreen = in.position.xy;\n\n  // Distance from Gaussian center in pixels\n  let d = fragScreen - in.centerScreen;\n\n  // Evaluate Gaussian: power = -0.5 * (conic.x * dx^2 + 2*conic.y * dx*dy + conic.z * dy^2)\n  let power = -0.5 * (in.conicAndOpacity.x * d.x * d.x\n                     + 2.0 * in.conicAndOpacity.y * d.x * d.y\n                     + in.conicAndOpacity.z * d.y * d.y);\n\n  // Clamp power to avoid numerical issues\n  if (power > 0.0) {\n    discard;\n  }\n\n  let alpha = min(0.99, in.conicAndOpacity.w * exp(power));\n\n  // Discard nearly transparent fragments\n  if (alpha < 1.0 / 255.0) {\n    discard;\n  }\n\n  // Premultiplied alpha output for back-to-front compositing\n  return vec4<f32>(in.color.rgb * alpha, alpha);\n}\n";
+
+// src/gpu/GaussianSplatSorter.ts
+var RADIX_BITS = 8;
+var RADIX_SIZE = 256;
+var NUM_PASSES = 4;
+var BYTES_PER_COMPRESSED_SPLAT = 32;
+var BYTES_PER_RAW_SPLAT = 64;
+var GaussianSplatSorter = class {
+  context;
+  device;
+  options;
+  // Shader modules
+  sortShaderModule = null;
+  compressShaderModule = null;
+  renderShaderModule = null;
+  // Compute pipelines
+  compressPipeline = null;
+  histogramPipeline = null;
+  blellochScanPipeline = null;
+  globalPrefixPipeline = null;
+  scatterPipeline = null;
+  // Render pipeline
+  renderPipeline = null;
+  // Buffers
+  rawSplatBuffer = null;
+  compressedSplatBuffer = null;
+  sortKeysA = null;
+  sortKeysB = null;
+  sortValuesA = null;
+  sortValuesB = null;
+  blockHistogramsBuffer = null;
+  globalPrefixesBuffer = null;
+  compressUniformBuffer = null;
+  sortUniformBuffer = null;
+  renderUniformBuffer = null;
+  // Bind groups (rebuilt each frame due to ping-pong)
+  compressBindGroup = null;
+  // State
+  splatCount = 0;
+  blockCount = 0;
+  initialized = false;
+  constructor(context, options) {
+    this.context = context;
+    this.device = context.getDevice();
+    this.options = {
+      maxSplats: options.maxSplats,
+      workgroupSize: options.workgroupSize ?? 256,
+      elementsPerThread: options.elementsPerThread ?? 4,
+      enableTimestamps: options.enableTimestamps ?? false,
+      canvasWidth: options.canvasWidth,
+      canvasHeight: options.canvasHeight
+    };
+  }
+  // ===========================================================================
+  // Initialization
+  // ===========================================================================
+  /**
+   * Initialize all GPU resources: shaders, pipelines, buffers.
+   *
+   * Must be called before any sort or render operations.
+   */
+  async initialize() {
+    if (this.initialized) {
+      console.warn("GaussianSplatSorter already initialized");
+      return;
+    }
+    await this.createShaderModules();
+    this.createComputePipelines();
+    this.createRenderPipeline();
+    this.createBuffers();
+    this.initialized = true;
+  }
+  /**
+   * Create and validate shader modules with cross-browser error reporting.
+   */
+  async createShaderModules() {
+    const createModule = async (code, label) => {
+      const module2 = this.device.createShaderModule({ label, code });
+      try {
+        const info = await module2.getCompilationInfo();
+        for (const msg of info.messages) {
+          if (msg.type === "error") {
+            throw new Error(
+              `Shader compilation error in ${label}: ${msg.message} (line ${msg.lineNum})`
+            );
+          }
+          if (msg.type === "warning") {
+            console.warn(`Shader warning in ${label}: ${msg.message} (line ${msg.lineNum})`);
+          }
+        }
+      } catch (e) {
+        if (e instanceof Error && e.message?.includes("Shader compilation error")) {
+          throw e;
+        }
+        console.warn(
+          `Could not validate shader ${label}:`,
+          e instanceof Error ? e.message : String(e)
+        );
+      }
+      return module2;
+    };
+    this.sortShaderModule = await createModule(radix_sort_default, "radix-sort");
+    this.compressShaderModule = await createModule(splat_compress_default, "splat-compress");
+    this.renderShaderModule = await createModule(splat_render_sorted_default, "splat-render-sorted");
+  }
+  /**
+   * Create all compute pipelines for the sort.
+   */
+  createComputePipelines() {
+    if (!this.sortShaderModule || !this.compressShaderModule) {
+      throw new Error("Shader modules not created");
+    }
+    this.compressPipeline = this.device.createComputePipeline({
+      label: "splat-compress-pipeline",
+      layout: "auto",
+      compute: {
+        module: this.compressShaderModule,
+        entryPoint: "compressAndKey"
+      }
+    });
+    this.histogramPipeline = this.device.createComputePipeline({
+      label: "radix-histogram-pipeline",
+      layout: "auto",
+      compute: {
+        module: this.sortShaderModule,
+        entryPoint: "buildHistogram"
+      }
+    });
+    this.blellochScanPipeline = this.device.createComputePipeline({
+      label: "blelloch-scan-pipeline",
+      layout: "auto",
+      compute: {
+        module: this.sortShaderModule,
+        entryPoint: "blellochScan"
+      }
+    });
+    this.globalPrefixPipeline = this.device.createComputePipeline({
+      label: "global-prefix-pipeline",
+      layout: "auto",
+      compute: {
+        module: this.sortShaderModule,
+        entryPoint: "globalPrefixScan"
+      }
+    });
+    this.scatterPipeline = this.device.createComputePipeline({
+      label: "radix-scatter-pipeline",
+      layout: "auto",
+      compute: {
+        module: this.sortShaderModule,
+        entryPoint: "scatter"
+      }
+    });
+  }
+  /**
+   * Create render pipeline for sorted splat rendering.
+   */
+  createRenderPipeline() {
+    if (!this.renderShaderModule) {
+      throw new Error("Render shader module not created");
+    }
+    this.renderPipeline = this.device.createRenderPipeline({
+      label: "sorted-splat-render-pipeline",
+      layout: "auto",
+      vertex: {
+        module: this.renderShaderModule,
+        entryPoint: "vs_main",
+        buffers: []
+        // All data comes from storage buffers
+      },
+      fragment: {
+        module: this.renderShaderModule,
+        entryPoint: "fs_main",
+        targets: [
+          {
+            format: navigator.gpu.getPreferredCanvasFormat(),
+            blend: {
+              // Premultiplied alpha blending (back-to-front)
+              color: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              },
+              alpha: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              }
+            }
+          }
+        ]
+      },
+      primitive: {
+        topology: "triangle-strip",
+        stripIndexFormat: void 0
+      },
+      depthStencil: {
+        format: "depth24plus",
+        // Disable depth write for sorted splats (they're already in order)
+        depthWriteEnabled: false,
+        depthCompare: "always"
+      }
+    });
+  }
+  /**
+   * Allocate all GPU buffers.
+   */
+  createBuffers() {
+    const maxSplats = this.options.maxSplats;
+    const blockSize = this.options.workgroupSize * this.options.elementsPerThread;
+    const maxBlocks = Math.ceil(maxSplats / blockSize);
+    this.rawSplatBuffer = this.device.createBuffer({
+      label: "raw-splats",
+      size: maxSplats * BYTES_PER_RAW_SPLAT,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    this.compressedSplatBuffer = this.device.createBuffer({
+      label: "compressed-splats",
+      size: maxSplats * BYTES_PER_COMPRESSED_SPLAT,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    const sortBufferSize = maxSplats * 4;
+    this.sortKeysA = this.createSortBuffer("sort-keys-a", sortBufferSize);
+    this.sortKeysB = this.createSortBuffer("sort-keys-b", sortBufferSize);
+    this.sortValuesA = this.createSortBuffer("sort-values-a", sortBufferSize);
+    this.sortValuesB = this.createSortBuffer("sort-values-b", sortBufferSize);
+    this.blockHistogramsBuffer = this.device.createBuffer({
+      label: "block-histograms",
+      size: maxBlocks * RADIX_SIZE * 4,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    this.globalPrefixesBuffer = this.device.createBuffer({
+      label: "global-prefixes",
+      size: RADIX_SIZE * 4,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    this.compressUniformBuffer = this.device.createBuffer({
+      label: "compress-uniforms",
+      size: 160,
+      // 2 * mat4x4 (128) + 4 floats (16) + 4 u32 (16) = 160
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    this.sortUniformBuffer = this.device.createBuffer({
+      label: "sort-uniforms",
+      size: 16,
+      // totalCount (4) + bitOffset (4) + blockCount (4) + pad (4)
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    this.renderUniformBuffer = this.device.createBuffer({
+      label: "render-uniforms",
+      size: 160,
+      // viewProj (64) + view (64) + camPos (12) + 5 floats (20)
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+  }
+  createSortBuffer(label, size) {
+    return this.device.createBuffer({
+      label,
+      size,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+    });
+  }
+  // ===========================================================================
+  // Data Upload
+  // ===========================================================================
+  /**
+   * Upload raw splat data to the GPU.
+   *
+   * Expected layout per splat (64 bytes):
+   *   position: vec3<f32>  (12 bytes)
+   *   scale:    vec3<f32>  (12 bytes)
+   *   rotation: vec4<f32>  (16 bytes) - quaternion (w, x, y, z)
+   *   color:    vec4<f32>  (16 bytes) - RGBA [0..1]
+   *   padding:             (8 bytes)
+   *
+   * @param data Raw splat data as Float32Array
+   * @param count Number of splats (not bytes)
+   */
+  uploadSplatData(data, count) {
+    if (!this.rawSplatBuffer) {
+      throw new Error("Buffers not initialized");
+    }
+    if (count > this.options.maxSplats) {
+      throw new Error(`Splat count ${count} exceeds max ${this.options.maxSplats}`);
+    }
+    this.splatCount = count;
+    this.blockCount = Math.ceil(
+      count / (this.options.workgroupSize * this.options.elementsPerThread)
+    );
+    this.device.queue.writeBuffer(
+      this.rawSplatBuffer,
+      0,
+      data.buffer,
+      data.byteOffset,
+      count * BYTES_PER_RAW_SPLAT
+    );
+  }
+  // ===========================================================================
+  // Sort Execution
+  // ===========================================================================
+  /**
+   * Execute the full sort pipeline: compress -> 4-pass radix sort.
+   *
+   * Should be called each frame before rendering when the camera moves.
+   * Uses a single command encoder for all passes to minimize CPU overhead.
+   *
+   * @param camera Current camera state for depth computation
+   * @param commandEncoder Optional encoder to chain with other passes
+   * @returns Command encoder with all sort passes recorded
+   */
+  sort(camera, commandEncoder) {
+    if (!this.initialized) {
+      throw new Error("Not initialized. Call initialize() first.");
+    }
+    const encoder = commandEncoder ?? this.device.createCommandEncoder({
+      label: "gaussian-splat-sort-encoder"
+    });
+    this.recordCompressPass(encoder, camera);
+    for (let pass = 0; pass < NUM_PASSES; pass++) {
+      const bitOffset = pass * RADIX_BITS;
+      const readFromA = pass % 2 === 0;
+      this.recordSortPass(encoder, bitOffset, readFromA);
+    }
+    return encoder;
+  }
+  /**
+   * Record compression compute pass.
+   */
+  recordCompressPass(encoder, camera) {
+    if (!this.compressPipeline || !this.compressUniformBuffer) {
+      throw new Error("Compress pipeline not created");
+    }
+    const uniforms = new Float32Array(40);
+    uniforms.set(camera.viewMatrix, 0);
+    uniforms.set(camera.projMatrix, 16);
+    const uintView = new Uint32Array(uniforms.buffer);
+    uniforms[32] = this.options.canvasWidth;
+    uniforms[33] = this.options.canvasHeight;
+    uniforms[34] = camera.focalX;
+    uniforms[35] = camera.focalY;
+    uintView[36] = this.splatCount;
+    uintView[37] = 0;
+    uintView[38] = 0;
+    uintView[39] = 0;
+    this.device.queue.writeBuffer(this.compressUniformBuffer, 0, uniforms);
+    this.compressBindGroup = this.device.createBindGroup({
+      label: "compress-bind-group",
+      layout: this.compressPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: this.compressUniformBuffer } },
+        { binding: 1, resource: { buffer: this.rawSplatBuffer } },
+        { binding: 2, resource: { buffer: this.compressedSplatBuffer } },
+        { binding: 3, resource: { buffer: this.sortKeysA } },
+        { binding: 4, resource: { buffer: this.sortValuesA } }
+      ]
+    });
+    const computePass = encoder.beginComputePass({ label: "compress-pass" });
+    computePass.setPipeline(this.compressPipeline);
+    computePass.setBindGroup(0, this.compressBindGroup);
+    computePass.dispatchWorkgroups(Math.ceil(this.splatCount / this.options.workgroupSize));
+    computePass.end();
+  }
+  /**
+   * Record one radix sort pass (histogram + scan + scatter).
+   */
+  recordSortPass(encoder, bitOffset, readFromA) {
+    const keysIn = readFromA ? this.sortKeysA : this.sortKeysB;
+    const keysOut = readFromA ? this.sortKeysB : this.sortKeysA;
+    const valuesIn = readFromA ? this.sortValuesA : this.sortValuesB;
+    const valuesOut = readFromA ? this.sortValuesB : this.sortValuesA;
+    const sortUniforms = new Uint32Array([
+      this.splatCount,
+      bitOffset,
+      this.blockCount,
+      0
+      // pad
+    ]);
+    this.device.queue.writeBuffer(this.sortUniformBuffer, 0, sortUniforms);
+    const histBindGroup = this.device.createBindGroup({
+      label: `histogram-bind-group-pass-${bitOffset}`,
+      layout: this.histogramPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: this.sortUniformBuffer } },
+        { binding: 1, resource: { buffer: keysIn } },
+        { binding: 2, resource: { buffer: keysOut } },
+        { binding: 3, resource: { buffer: valuesIn } },
+        { binding: 4, resource: { buffer: valuesOut } },
+        { binding: 5, resource: { buffer: this.blockHistogramsBuffer } },
+        { binding: 6, resource: { buffer: this.globalPrefixesBuffer } }
+      ]
+    });
+    const histPass = encoder.beginComputePass({ label: `histogram-${bitOffset}` });
+    histPass.setPipeline(this.histogramPipeline);
+    histPass.setBindGroup(0, histBindGroup);
+    histPass.dispatchWorkgroups(this.blockCount);
+    histPass.end();
+    const scanBindGroup = this.device.createBindGroup({
+      label: `blelloch-scan-bind-group-pass-${bitOffset}`,
+      layout: this.blellochScanPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: this.sortUniformBuffer } },
+        { binding: 1, resource: { buffer: keysIn } },
+        { binding: 2, resource: { buffer: keysOut } },
+        { binding: 3, resource: { buffer: valuesIn } },
+        { binding: 4, resource: { buffer: valuesOut } },
+        { binding: 5, resource: { buffer: this.blockHistogramsBuffer } },
+        { binding: 6, resource: { buffer: this.globalPrefixesBuffer } }
+      ]
+    });
+    const scanPass = encoder.beginComputePass({ label: `blelloch-scan-${bitOffset}` });
+    scanPass.setPipeline(this.blellochScanPipeline);
+    scanPass.setBindGroup(0, scanBindGroup);
+    scanPass.dispatchWorkgroups(RADIX_SIZE);
+    scanPass.end();
+    const globalPrefixBindGroup = this.device.createBindGroup({
+      label: `global-prefix-bind-group-pass-${bitOffset}`,
+      layout: this.globalPrefixPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: this.sortUniformBuffer } },
+        { binding: 1, resource: { buffer: keysIn } },
+        { binding: 2, resource: { buffer: keysOut } },
+        { binding: 3, resource: { buffer: valuesIn } },
+        { binding: 4, resource: { buffer: valuesOut } },
+        { binding: 5, resource: { buffer: this.blockHistogramsBuffer } },
+        { binding: 6, resource: { buffer: this.globalPrefixesBuffer } }
+      ]
+    });
+    const globalPrefixPass = encoder.beginComputePass({ label: `global-prefix-${bitOffset}` });
+    globalPrefixPass.setPipeline(this.globalPrefixPipeline);
+    globalPrefixPass.setBindGroup(0, globalPrefixBindGroup);
+    globalPrefixPass.dispatchWorkgroups(1);
+    globalPrefixPass.end();
+    const scatterBindGroup = this.device.createBindGroup({
+      label: `scatter-bind-group-pass-${bitOffset}`,
+      layout: this.scatterPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: this.sortUniformBuffer } },
+        { binding: 1, resource: { buffer: keysIn } },
+        { binding: 2, resource: { buffer: keysOut } },
+        { binding: 3, resource: { buffer: valuesIn } },
+        { binding: 4, resource: { buffer: valuesOut } },
+        { binding: 5, resource: { buffer: this.blockHistogramsBuffer } },
+        { binding: 6, resource: { buffer: this.globalPrefixesBuffer } }
+      ]
+    });
+    const scatterPass = encoder.beginComputePass({ label: `scatter-${bitOffset}` });
+    scatterPass.setPipeline(this.scatterPipeline);
+    scatterPass.setBindGroup(0, scatterBindGroup);
+    scatterPass.dispatchWorkgroups(this.blockCount);
+    scatterPass.end();
+  }
+  // ===========================================================================
+  // Rendering
+  // ===========================================================================
+  /**
+   * Record render pass for sorted Gaussian splats.
+   *
+   * @param encoder Command encoder to record into
+   * @param camera Camera state for rendering
+   * @param colorView Color attachment view
+   * @param depthView Depth attachment view
+   * @param clearColor Optional clear color (default: transparent black)
+   */
+  recordRenderPass(encoder, camera, colorView, depthView, clearColor) {
+    if (!this.renderPipeline || !this.renderUniformBuffer) {
+      throw new Error("Render pipeline not created");
+    }
+    const renderUniforms = new Float32Array(40);
+    renderUniforms.set(camera.viewProjectionMatrix, 0);
+    renderUniforms.set(camera.viewMatrix, 16);
+    renderUniforms[32] = camera.cameraPosition[0];
+    renderUniforms[33] = camera.cameraPosition[1];
+    renderUniforms[34] = camera.cameraPosition[2];
+    renderUniforms[35] = this.options.canvasWidth;
+    renderUniforms[36] = this.options.canvasHeight;
+    renderUniforms[37] = camera.focalX;
+    renderUniforms[38] = camera.focalY;
+    renderUniforms[39] = 0;
+    this.device.queue.writeBuffer(this.renderUniformBuffer, 0, renderUniforms);
+    const sortedIndicesBuffer = this.sortValuesA;
+    const renderBindGroup = this.device.createBindGroup({
+      label: "sorted-splat-render-bind-group",
+      layout: this.renderPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: this.renderUniformBuffer } },
+        { binding: 1, resource: { buffer: this.compressedSplatBuffer } },
+        { binding: 2, resource: { buffer: sortedIndicesBuffer } }
+      ]
+    });
+    const renderPass = encoder.beginRenderPass({
+      label: "sorted-splat-render-pass",
+      colorAttachments: [
+        {
+          view: colorView,
+          clearValue: clearColor ?? { r: 0, g: 0, b: 0, a: 0 },
+          loadOp: clearColor ? "clear" : "load",
+          storeOp: "store"
+        }
+      ],
+      depthStencilAttachment: {
+        view: depthView,
+        depthClearValue: 1,
+        depthLoadOp: "clear",
+        depthStoreOp: "store"
+      }
+    });
+    renderPass.setPipeline(this.renderPipeline);
+    renderPass.setBindGroup(0, renderBindGroup);
+    renderPass.draw(4, this.splatCount);
+    renderPass.end();
+  }
+  /**
+   * Execute full frame: sort + render in a single command submission.
+   *
+   * This is the main per-frame method for most use cases.
+   *
+   * @param camera Current camera state
+   * @param colorView Color attachment view
+   * @param depthView Depth attachment view
+   * @param clearColor Optional clear color
+   */
+  frame(camera, colorView, depthView, clearColor) {
+    const encoder = this.device.createCommandEncoder({
+      label: "gaussian-splat-frame-encoder"
+    });
+    this.sort(camera, encoder);
+    this.recordRenderPass(encoder, camera, colorView, depthView, clearColor);
+    this.device.queue.submit([encoder.finish()]);
+  }
+  // ===========================================================================
+  // Statistics & Debugging
+  // ===========================================================================
+  /**
+   * Get current sort statistics.
+   */
+  getStats() {
+    return {
+      splatCount: this.splatCount,
+      blockCount: this.blockCount,
+      memoryUsageBytes: this.getMemoryUsage()
+    };
+  }
+  /**
+   * Calculate total GPU memory usage in bytes.
+   */
+  getMemoryUsage() {
+    const maxSplats = this.options.maxSplats;
+    const maxBlocks = Math.ceil(
+      maxSplats / (this.options.workgroupSize * this.options.elementsPerThread)
+    );
+    return maxSplats * BYTES_PER_RAW_SPLAT + // raw splats
+    maxSplats * BYTES_PER_COMPRESSED_SPLAT + // compressed splats
+    maxSplats * 4 * 4 + // 2x keys + 2x values (u32 each)
+    maxBlocks * RADIX_SIZE * 4 + // block histograms
+    RADIX_SIZE * 4 + // global prefixes
+    160 + 16 + 160;
+  }
+  /**
+   * Get the sorted index buffer (for external rendering integration).
+   *
+   * After sort(), the sorted indices are in sortValuesA (for even pass count).
+   */
+  getSortedIndicesBuffer() {
+    if (!this.sortValuesA) {
+      throw new Error("Buffers not initialized");
+    }
+    return this.sortValuesA;
+  }
+  /**
+   * Get the compressed splat buffer (for external rendering integration).
+   */
+  getCompressedSplatBuffer() {
+    if (!this.compressedSplatBuffer) {
+      throw new Error("Buffers not initialized");
+    }
+    return this.compressedSplatBuffer;
+  }
+  /**
+   * Update canvas dimensions (e.g., on resize).
+   */
+  updateDimensions(width, height) {
+    this.options.canvasWidth = width;
+    this.options.canvasHeight = height;
+  }
+  // ===========================================================================
+  // Cleanup
+  // ===========================================================================
+  /**
+   * Destroy all GPU resources.
+   */
+  destroy() {
+    const buffers = [
+      this.rawSplatBuffer,
+      this.compressedSplatBuffer,
+      this.sortKeysA,
+      this.sortKeysB,
+      this.sortValuesA,
+      this.sortValuesB,
+      this.blockHistogramsBuffer,
+      this.globalPrefixesBuffer,
+      this.compressUniformBuffer,
+      this.sortUniformBuffer,
+      this.renderUniformBuffer
+    ];
+    for (const buffer of buffers) {
+      buffer?.destroy();
+    }
+    this.rawSplatBuffer = null;
+    this.compressedSplatBuffer = null;
+    this.sortKeysA = null;
+    this.sortKeysB = null;
+    this.sortValuesA = null;
+    this.sortValuesB = null;
+    this.blockHistogramsBuffer = null;
+    this.globalPrefixesBuffer = null;
+    this.compressUniformBuffer = null;
+    this.sortUniformBuffer = null;
+    this.renderUniformBuffer = null;
+    this.sortShaderModule = null;
+    this.compressShaderModule = null;
+    this.renderShaderModule = null;
+    this.compressPipeline = null;
+    this.histogramPipeline = null;
+    this.blellochScanPipeline = null;
+    this.globalPrefixPipeline = null;
+    this.scatterPipeline = null;
+    this.renderPipeline = null;
+    this.initialized = false;
+  }
+};
+async function createGaussianSplatSorter(options) {
+  const { WebGPUContext: WebGPUContext2 } = await Promise.resolve().then(() => (init_WebGPUContext(), WebGPUContext_exports));
+  const context = new WebGPUContext2(options.contextOptions);
+  await context.initialize();
+  if (!context.isSupported()) {
+    throw new Error("WebGPU not supported - GaussianSplatSorter requires WebGPU");
+  }
+  const sorter = new GaussianSplatSorter(context, options);
+  await sorter.initialize();
+  return sorter;
+}
+
+// src/gpu/InstancedRenderer.ts
+var InstancedRenderer = class {
+  context;
+  device;
+  canvas;
+  gpuContext = null;
+  options;
+  // Rendering resources
+  pipeline = null;
+  vertexBuffer = null;
+  indexBuffer = null;
+  instanceBuffer = null;
+  uniformBuffer = null;
+  // Geometry data
+  indexCount = 0;
+  vertexCount = 0;
+  // State
+  lastFrameTime = 0;
+  frameCount = 0;
+  constructor(context, canvas, options) {
+    this.context = context;
+    this.device = context.getDevice();
+    this.canvas = canvas;
+    this.options = {
+      maxParticles: options.maxParticles,
+      sphereSegments: options.sphereSegments ?? 16,
+      enableLOD: options.enableLOD ?? true,
+      lodDistances: options.lodDistances ?? [20, 50, 100],
+      enableFrustumCulling: options.enableFrustumCulling ?? true
+    };
+  }
+  /**
+   * Initialize renderer
+   */
+  async initialize() {
+    this.gpuContext = this.canvas.getContext("webgpu");
+    if (!this.gpuContext) {
+      throw new Error("Failed to get WebGPU canvas context");
+    }
+    const canvasFormat = navigator.gpu.getPreferredCanvasFormat();
+    this.gpuContext.configure({
+      device: this.device,
+      format: canvasFormat,
+      alphaMode: "opaque"
+    });
+    this.createSphereGeometry();
+    this.createBuffers();
+    this.createRenderPipeline(canvasFormat);
+  }
+  /**
+   * Create sphere geometry
+   */
+  createSphereGeometry() {
+    const segments = this.options.sphereSegments;
+    const vertices = [];
+    const indices = [];
+    for (let lat = 0; lat <= segments; lat++) {
+      const theta = lat * Math.PI / segments;
+      const sinTheta = Math.sin(theta);
+      const cosTheta = Math.cos(theta);
+      for (let lon = 0; lon <= segments; lon++) {
+        const phi = lon * 2 * Math.PI / segments;
+        const sinPhi = Math.sin(phi);
+        const cosPhi = Math.cos(phi);
+        const x = cosPhi * sinTheta;
+        const y = cosTheta;
+        const z = sinPhi * sinTheta;
+        vertices.push(x, y, z);
+        vertices.push(x, y, z);
+      }
+    }
+    for (let lat = 0; lat < segments; lat++) {
+      for (let lon = 0; lon < segments; lon++) {
+        const first = lat * (segments + 1) + lon;
+        const second = first + segments + 1;
+        indices.push(first, second, first + 1);
+        indices.push(second, second + 1, first + 1);
+      }
+    }
+    this.vertexCount = vertices.length / 6;
+    this.indexCount = indices.length;
+    this.createVertexBuffer(new Float32Array(vertices));
+    this.createIndexBuffer(new Uint16Array(indices));
+  }
+  /**
+   * Create vertex buffer
+   */
+  createVertexBuffer(vertices) {
+    this.vertexBuffer = this.device.createBuffer({
+      label: "sphere-vertices",
+      size: vertices.byteLength,
+      usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
+    });
+    this.device.queue.writeBuffer(
+      this.vertexBuffer,
+      0,
+      vertices
+    );
+  }
+  /**
+   * Create index buffer
+   */
+  createIndexBuffer(indices) {
+    this.indexBuffer = this.device.createBuffer({
+      label: "sphere-indices",
+      size: indices.byteLength,
+      usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+    });
+    this.device.queue.writeBuffer(
+      this.indexBuffer,
+      0,
+      indices
+    );
+  }
+  /**
+   * Create instance and uniform buffers
+   */
+  createBuffers() {
+    const instanceSize = 8 * Float32Array.BYTES_PER_ELEMENT;
+    const instanceBufferSize = this.options.maxParticles * instanceSize;
+    this.instanceBuffer = this.device.createBuffer({
+      label: "instance-buffer",
+      size: instanceBufferSize,
+      usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
+    });
+    const uniformBufferSize = 32 * Float32Array.BYTES_PER_ELEMENT;
+    this.uniformBuffer = this.device.createBuffer({
+      label: "camera-uniforms",
+      size: uniformBufferSize,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+  }
+  /**
+   * Create render pipeline
+   */
+  createRenderPipeline(format) {
+    const shaderCode = `
+      struct Uniforms {
+        view: mat4x4<f32>,
+        projection: mat4x4<f32>,
+      };
+
+      @group(0) @binding(0) var<uniform> uniforms: Uniforms;
+
+      struct VertexInput {
+        @location(0) position: vec3<f32>,
+        @location(1) normal: vec3<f32>,
+      };
+
+      struct InstanceInput {
+        @location(2) instancePosition: vec4<f32>,  // xyz = pos, w = radius
+        @location(3) instanceColor: vec4<f32>,     // rgba
+      };
+
+      struct VertexOutput {
+        @builtin(position) position: vec4<f32>,
+        @location(0) normal: vec3<f32>,
+        @location(1) worldPos: vec3<f32>,
+        @location(2) color: vec4<f32>,
+      };
+
+      @vertex
+      fn vertexMain(
+        vertex: VertexInput,
+        instance: InstanceInput
+      ) -> VertexOutput {
+        var output: VertexOutput;
+
+        // Scale vertex by instance radius
+        let scaledPos = vertex.position * instance.instancePosition.w;
+
+        // Translate to instance position
+        let worldPos = scaledPos + instance.instancePosition.xyz;
+
+        // Transform to clip space
+        output.position = uniforms.projection * uniforms.view * vec4<f32>(worldPos, 1.0);
+        output.normal = vertex.normal;
+        output.worldPos = worldPos;
+        output.color = instance.instanceColor;
+
+        return output;
+      }
+
+      @fragment
+      fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
+        // Simple Phong lighting
+        let lightDir = normalize(vec3<f32>(1.0, 1.0, 1.0));
+        let normal = normalize(input.normal);
+
+        let ambient = 0.3;
+        let diffuse = max(dot(normal, lightDir), 0.0) * 0.7;
+        let lighting = ambient + diffuse;
+
+        return vec4<f32>(input.color.rgb * lighting, input.color.a);
+      }
+    `;
+    const shaderModule = this.device.createShaderModule({
+      label: "instanced-shader",
+      code: shaderCode
+    });
+    const pipelineLayout = this.device.createPipelineLayout({
+      bindGroupLayouts: [
+        this.device.createBindGroupLayout({
+          entries: [
+            {
+              binding: 0,
+              visibility: GPUShaderStage.VERTEX,
+              buffer: { type: "uniform" }
+            }
+          ]
+        })
+      ]
+    });
+    this.pipeline = this.device.createRenderPipeline({
+      label: "instanced-pipeline",
+      layout: pipelineLayout,
+      vertex: {
+        module: shaderModule,
+        entryPoint: "vertexMain",
+        buffers: [
+          // Vertex buffer (per-vertex)
+          {
+            arrayStride: 6 * Float32Array.BYTES_PER_ELEMENT,
+            // position + normal
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x3" },
+              // position
+              { shaderLocation: 1, offset: 3 * 4, format: "float32x3" }
+              // normal
+            ]
+          },
+          // Instance buffer (per-instance)
+          {
+            arrayStride: 8 * Float32Array.BYTES_PER_ELEMENT,
+            // position+radius + color
+            stepMode: "instance",
+            attributes: [
+              { shaderLocation: 2, offset: 0, format: "float32x4" },
+              // instancePosition
+              { shaderLocation: 3, offset: 4 * 4, format: "float32x4" }
+              // instanceColor
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: shaderModule,
+        entryPoint: "fragmentMain",
+        targets: [{ format }]
+      },
+      primitive: {
+        topology: "triangle-list",
+        cullMode: "back"
+      },
+      depthStencil: {
+        format: "depth24plus",
+        depthWriteEnabled: true,
+        depthCompare: "less"
+      }
+    });
+  }
+  /**
+   * Update instance buffer with particle data
+   */
+  updateInstances(positions, count) {
+    if (!this.instanceBuffer) return;
+    const instanceData = new Float32Array(count * 8);
+    for (let i = 0; i < count; i++) {
+      const posIdx = i * 4;
+      const instIdx = i * 8;
+      instanceData[instIdx + 0] = positions[posIdx + 0];
+      instanceData[instIdx + 1] = positions[posIdx + 1];
+      instanceData[instIdx + 2] = positions[posIdx + 2];
+      instanceData[instIdx + 3] = positions[posIdx + 3];
+      const y = positions[posIdx + 1];
+      instanceData[instIdx + 4] = 0.4 + y * 0.02;
+      instanceData[instIdx + 5] = 0.5 + y * 0.01;
+      instanceData[instIdx + 6] = 0.8;
+      instanceData[instIdx + 7] = 1;
+    }
+    this.device.queue.writeBuffer(this.instanceBuffer, 0, instanceData);
+  }
+  /**
+   * Update camera uniforms
+   */
+  updateCamera(camera) {
+    if (!this.uniformBuffer) return;
+    const view = this.buildViewMatrix(camera.position, camera.target);
+    const projection = this.buildProjectionMatrix(
+      camera.fov,
+      camera.aspect,
+      camera.near,
+      camera.far
+    );
+    const uniforms = new Float32Array(32);
+    uniforms.set(view, 0);
+    uniforms.set(projection, 16);
+    this.device.queue.writeBuffer(this.uniformBuffer, 0, uniforms);
+  }
+  /**
+   * Build view matrix (lookAt)
+   */
+  buildViewMatrix(eye, target) {
+    const zAxis = this.normalize([eye[0] - target[0], eye[1] - target[1], eye[2] - target[2]]);
+    const xAxis = this.normalize(this.cross([0, 1, 0], zAxis));
+    const yAxis = this.cross(zAxis, xAxis);
+    return new Float32Array([
+      xAxis[0],
+      yAxis[0],
+      zAxis[0],
+      0,
+      xAxis[1],
+      yAxis[1],
+      zAxis[1],
+      0,
+      xAxis[2],
+      yAxis[2],
+      zAxis[2],
+      0,
+      -this.dot(xAxis, eye),
+      -this.dot(yAxis, eye),
+      -this.dot(zAxis, eye),
+      1
+    ]);
+  }
+  /**
+   * Build projection matrix (perspective)
+   */
+  buildProjectionMatrix(fov, aspect, near, far) {
+    const f = 1 / Math.tan(fov / 2);
+    const rangeInv = 1 / (near - far);
+    return new Float32Array([
+      f / aspect,
+      0,
+      0,
+      0,
+      0,
+      f,
+      0,
+      0,
+      0,
+      0,
+      (near + far) * rangeInv,
+      -1,
+      0,
+      0,
+      near * far * rangeInv * 2,
+      0
+    ]);
+  }
+  /**
+   * Render particles
+   */
+  render(positions, particleCount, camera) {
+    if (!this.gpuContext || !this.pipeline || !this.vertexBuffer || !this.indexBuffer || !this.instanceBuffer || !this.uniformBuffer) {
+      throw new Error("Renderer not initialized");
+    }
+    this.updateInstances(positions, particleCount);
+    this.updateCamera(camera);
+    const depthTexture = this.device.createTexture({
+      size: [this.canvas.width, this.canvas.height],
+      format: "depth24plus",
+      usage: GPUTextureUsage.RENDER_ATTACHMENT
+    });
+    const bindGroup = this.device.createBindGroup({
+      layout: this.pipeline.getBindGroupLayout(0),
+      entries: [{ binding: 0, resource: { buffer: this.uniformBuffer } }]
+    });
+    const commandEncoder = this.device.createCommandEncoder({ label: "render-encoder" });
+    const renderPass = commandEncoder.beginRenderPass({
+      colorAttachments: [
+        {
+          view: this.gpuContext.getCurrentTexture().createView(),
+          loadOp: "clear",
+          clearValue: { r: 0.1, g: 0.1, b: 0.15, a: 1 },
+          storeOp: "store"
+        }
+      ],
+      depthStencilAttachment: {
+        view: depthTexture.createView(),
+        depthLoadOp: "clear",
+        depthClearValue: 1,
+        depthStoreOp: "store"
+      }
+    });
+    renderPass.setPipeline(this.pipeline);
+    renderPass.setBindGroup(0, bindGroup);
+    renderPass.setVertexBuffer(0, this.vertexBuffer);
+    renderPass.setVertexBuffer(1, this.instanceBuffer);
+    renderPass.setIndexBuffer(this.indexBuffer, "uint16");
+    renderPass.drawIndexed(this.indexCount, particleCount, 0, 0, 0);
+    renderPass.end();
+    this.device.queue.submit([commandEncoder.finish()]);
+    this.frameCount++;
+    const now = performance.now();
+    if (now - this.lastFrameTime >= 1e3) {
+      this.frameCount = 0;
+      this.lastFrameTime = now;
+    }
+  }
+  /**
+   * Vector math helpers
+   */
+  normalize(v) {
+    const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    return [v[0] / len, v[1] / len, v[2] / len];
+  }
+  cross(a, b) {
+    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  }
+  dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.vertexBuffer?.destroy();
+    this.indexBuffer?.destroy();
+    this.instanceBuffer?.destroy();
+    this.uniformBuffer?.destroy();
+    this.pipeline = null;
+  }
+};
+
+// wgsl-raw:C:\Users\josep\Documents\GitHub\HoloScript\packages\engine\src\gpu\shaders\cg_kernels.wgsl
+var cg_kernels_default = "/**\n * Conjugate Gradient Kernels \u2014 Sparse Linear Algebra on WebGPU\n *\n * Unified bind group layout:\n *   group(0): CSR matrix (SpMV only)\n *   group(1): Vectors (vec_in read, vec_out read_write)\n *   group(2): SolverArgs uniform\n *   group(3): Reduction workspace (dot/final_reduce only)\n *\n * Each entry point references only the groups it needs.\n * With layout:'auto', each pipeline gets a layout derived from\n * only the bindings its entry point actually accesses.\n */\n\n// \u2500\u2500 Shared Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nstruct SolverArgs {\n  num_rows: u32,\n  vector_width: u32,\n  n: u32,\n  alpha: f32,\n};\n\n// \u2500\u2500 Group 0: CSR Matrix \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n@group(0) @binding(0) var<storage, read> csr_val: array<f32>;\n@group(0) @binding(1) var<storage, read> csr_col: array<u32>;\n@group(0) @binding(2) var<storage, read> csr_row: array<u32>;\n\n// \u2500\u2500 Group 1: Vectors \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n@group(1) @binding(0) var<storage, read> vec_in: array<f32>;\n@group(1) @binding(1) var<storage, read_write> vec_out: array<f32>;\n\n// \u2500\u2500 Group 2: Solver Arguments \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n@group(2) @binding(0) var<uniform> args: SolverArgs;\n\n// \u2500\u2500 Group 3: Reduction Workspace \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n@group(3) @binding(0) var<storage, read_write> partial_sums: array<f32>;\n@group(3) @binding(1) var<storage, read_write> scalar_result: array<f32>;\n\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n// 1. SpMV \u2014 CSR-Vector (multi-thread per row)\n//    Assigns vector_width threads per row for irregular TET10 sparsity.\n//    Uses: groups 0, 1, 2\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n\nvar<workgroup> spmv_shared: array<f32, 256>;\n\n@compute @workgroup_size(256)\nfn spmv_vector(\n    @builtin(global_invocation_id) global_id: vec3<u32>,\n    @builtin(local_invocation_id) local_id: vec3<u32>\n) {\n    let tid = local_id.x;\n    let gid = global_id.x;\n    let threads_per_row = args.vector_width;\n    let row = gid / threads_per_row;\n    let lane = gid % threads_per_row;\n\n    if (row >= args.num_rows) {\n        return;\n    }\n\n    let row_start = csr_row[row];\n    let row_end = csr_row[row + 1];\n\n    var sum: f32 = 0.0;\n    for (var i = row_start + lane; i < row_end; i = i + threads_per_row) {\n        sum += csr_val[i] * vec_in[csr_col[i]];\n    }\n\n    spmv_shared[tid] = sum;\n    workgroupBarrier();\n\n    for (var s = threads_per_row / 2u; s > 0u; s >>= 1u) {\n        if (lane < s) {\n            spmv_shared[tid] += spmv_shared[tid + s];\n        }\n        workgroupBarrier();\n    }\n\n    if (lane == 0u) {\n        vec_out[row] = spmv_shared[tid];\n    }\n}\n\n// Legacy scalar SpMV (1 thread per row, for small/regular matrices)\n// Uses: groups 0, 1, 2\n@compute @workgroup_size(64)\nfn spmv(@builtin(global_invocation_id) global_id: vec3<u32>) {\n    let row = global_id.x;\n    if (row >= args.num_rows) {\n        return;\n    }\n\n    let row_start = csr_row[row];\n    let row_end = csr_row[row + 1];\n\n    var sum: f32 = 0.0;\n    for (var i = row_start; i < row_end; i = i + 1u) {\n        sum += csr_val[i] * vec_in[csr_col[i]];\n    }\n\n    vec_out[row] = sum;\n}\n\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n// 2. SAXPY: vec_out = alpha * vec_in + vec_out\n//    Uses: groups 1, 2\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n\n@compute @workgroup_size(256)\nfn saxpy(@builtin(global_invocation_id) global_id: vec3<u32>) {\n    let idx = global_id.x;\n    if (idx >= args.n) {\n        return;\n    }\n    vec_out[idx] = args.alpha * vec_in[idx] + vec_out[idx];\n}\n\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n// 3. Fused CG Update: p = r + beta * p\n//    vec_in = r (read), vec_out = p (read_write), args.alpha = beta\n//    Uses: groups 1, 2\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n\n@compute @workgroup_size(256)\nfn p_update(@builtin(global_invocation_id) global_id: vec3<u32>) {\n    let idx = global_id.x;\n    if (idx >= args.n) {\n        return;\n    }\n    vec_out[idx] = vec_in[idx] + args.alpha * vec_out[idx];\n}\n\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n// 4. Vector Copy: vec_out = vec_in\n//    Uses: groups 1, 2\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n\n@compute @workgroup_size(256)\nfn vec_copy(@builtin(global_invocation_id) global_id: vec3<u32>) {\n    let idx = global_id.x;\n    if (idx >= args.n) {\n        return;\n    }\n    vec_out[idx] = vec_in[idx];\n}\n\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n// 5. Vector Zero: vec_out = 0\n//    Uses: groups 1 (binding 1 only), 2\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n\n@compute @workgroup_size(256)\nfn vec_zero(@builtin(global_invocation_id) global_id: vec3<u32>) {\n    let idx = global_id.x;\n    if (idx >= args.n) {\n        return;\n    }\n    vec_out[idx] = 0.0;\n}\n\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n// 6. Dot Product \u2014 Phase 1: per-workgroup partial sums\n//    result[wg_id] = sum of vec_in[i] * vec_out[i] for this workgroup\n//    Uses: groups 1, 2, 3 (binding 0)\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n\nvar<workgroup> dot_shared: array<f32, 256>;\n\n@compute @workgroup_size(256)\nfn dot_product(\n    @builtin(global_invocation_id) global_id: vec3<u32>,\n    @builtin(local_invocation_id) local_id: vec3<u32>,\n    @builtin(workgroup_id) workgroup_id: vec3<u32>\n) {\n    let idx = global_id.x;\n    let tid = local_id.x;\n\n    if (idx < args.n) {\n        dot_shared[tid] = vec_in[idx] * vec_out[idx];\n    } else {\n        dot_shared[tid] = 0.0;\n    }\n\n    workgroupBarrier();\n\n    for (var s = 128u; s > 0u; s >>= 1u) {\n        if (tid < s) {\n            dot_shared[tid] += dot_shared[tid + s];\n        }\n        workgroupBarrier();\n    }\n\n    if (tid == 0u) {\n        partial_sums[workgroup_id.x] = dot_shared[0];\n    }\n}\n\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n// 7. Final Reduce \u2014 Phase 2: sum partial_sums \u2192 scalar_result[0]\n//    args.n = number of partial sums to reduce\n//    Uses: groups 2, 3 (bindings 0 and 1)\n// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n\nvar<workgroup> reduce_shared: array<f32, 256>;\n\n@compute @workgroup_size(256)\nfn final_reduce(@builtin(local_invocation_id) local_id: vec3<u32>) {\n    let tid = local_id.x;\n    let count = args.n;\n\n    var acc: f32 = 0.0;\n    var i = tid;\n    loop {\n        if (i >= count) {\n            break;\n        }\n        acc += partial_sums[i];\n        i += 256u;\n    }\n    reduce_shared[tid] = acc;\n\n    workgroupBarrier();\n\n    for (var s = 128u; s > 0u; s >>= 1u) {\n        if (tid < s) {\n            reduce_shared[tid] += reduce_shared[tid + s];\n        }\n        workgroupBarrier();\n    }\n\n    if (tid == 0u) {\n        scalar_result[0] = reduce_shared[0];\n    }\n}\n";
+
+// src/gpu/SparseLinearSolver.ts
+var WG_SIZE = 256;
+var SparseLinearSolver = class {
+  constructor(context) {
+    this.context = context;
+    this.device = context.getDevice();
+  }
+  context;
+  device;
+  shaderModule;
+  spmvPipeline;
+  spmvVectorPipeline;
+  saxpyPipeline;
+  dotPipeline;
+  finalReducePipeline;
+  vecCopyPipeline;
+  vecZeroPipeline;
+  pUpdatePipeline;
+  initialized = false;
+  /** Compile shaders and create all compute pipelines */
+  async initialize() {
+    if (this.initialized) return;
+    this.shaderModule = this.device.createShaderModule({
+      label: "CG Kernels",
+      code: cg_kernels_default
+    });
+    const [spmv, spmvVec, saxpy, dot, finalReduce, vecCopy, vecZero, pUpdate] = await Promise.all([
+      this.device.createComputePipelineAsync({
+        label: "SpMV Scalar",
+        layout: "auto",
+        compute: { module: this.shaderModule, entryPoint: "spmv" }
+      }),
+      this.device.createComputePipelineAsync({
+        label: "SpMV Vector",
+        layout: "auto",
+        compute: { module: this.shaderModule, entryPoint: "spmv_vector" }
+      }),
+      this.device.createComputePipelineAsync({
+        label: "SAXPY",
+        layout: "auto",
+        compute: { module: this.shaderModule, entryPoint: "saxpy" }
+      }),
+      this.device.createComputePipelineAsync({
+        label: "Dot Product",
+        layout: "auto",
+        compute: { module: this.shaderModule, entryPoint: "dot_product" }
+      }),
+      this.device.createComputePipelineAsync({
+        label: "Final Reduce",
+        layout: "auto",
+        compute: { module: this.shaderModule, entryPoint: "final_reduce" }
+      }),
+      this.device.createComputePipelineAsync({
+        label: "Vec Copy",
+        layout: "auto",
+        compute: { module: this.shaderModule, entryPoint: "vec_copy" }
+      }),
+      this.device.createComputePipelineAsync({
+        label: "Vec Zero",
+        layout: "auto",
+        compute: { module: this.shaderModule, entryPoint: "vec_zero" }
+      }),
+      this.device.createComputePipelineAsync({
+        label: "P-Update",
+        layout: "auto",
+        compute: { module: this.shaderModule, entryPoint: "p_update" }
+      })
+    ]);
+    this.spmvPipeline = spmv;
+    this.spmvVectorPipeline = spmvVec;
+    this.saxpyPipeline = saxpy;
+    this.dotPipeline = dot;
+    this.finalReducePipeline = finalReduce;
+    this.vecCopyPipeline = vecCopy;
+    this.vecZeroPipeline = vecZero;
+    this.pUpdatePipeline = pUpdate;
+    this.initialized = true;
+  }
+  /**
+   * Solve Ax = b using Conjugate Gradient on the GPU.
+   *
+   * Algorithm (Hestenes-Stiefel):
+   *   r₀ = b - A·x₀
+   *   p₀ = r₀
+   *   for k = 0, 1, 2, ...
+   *     Ap = A·p
+   *     α = (r·r) / (p·Ap)
+   *     x = x + α·p
+   *     r = r - α·Ap
+   *     if ||r||² < tol: break
+   *     β = (r_new·r_new) / (r·r)
+   *     p = r + β·p           ← fused kernel
+   */
+  async solveCG(A, b, xGuess, options = {}) {
+    if (!this.initialized) {
+      throw new Error("SparseLinearSolver not initialized. Call initialize() first.");
+    }
+    const {
+      maxIterations = 1e3,
+      toleranceSq = 1e-10,
+      convergenceCheckInterval = 50,
+      onProgress
+    } = options;
+    const n = A.num_rows;
+    const vectorWidth = 16;
+    const numWgSpmvVec = Math.ceil(n * vectorWidth / WG_SIZE);
+    const numWgVec = Math.ceil(n / WG_SIZE);
+    const numWgDot = Math.ceil(n / WG_SIZE);
+    const csrVal = this.uploadStorage(A.val, "csr-val");
+    const csrCol = this.uploadStorage(A.col_ind, "csr-col");
+    const csrRow = this.uploadStorage(A.row_ptr, "csr-row");
+    const bufB = this.uploadStorage(b, "vec-b");
+    const bufX = this.uploadStorage(xGuess, "vec-x");
+    const bufR = this.emptyVec(n, "vec-r");
+    const bufP = this.emptyVec(n, "vec-p");
+    const bufAp = this.emptyVec(n, "vec-Ap");
+    const bufPartials = this.emptyVec(numWgDot, "partial-sums");
+    const bufScalar = this.emptyVec(1, "scalar-result");
+    const bufStaging = this.device.createBuffer({
+      label: "staging",
+      size: 4,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+    const bufArgs = this.device.createBuffer({
+      label: "solver-args",
+      size: 16,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    const allBuffers = [csrVal, csrCol, csrRow, bufB, bufX, bufR, bufP, bufAp, bufPartials, bufScalar, bufStaging, bufArgs];
+    {
+      this.writeArgs(bufArgs, n, vectorWidth, n, 0);
+      const enc = this.device.createCommandEncoder({ label: "init-spmv" });
+      this.dispatchSpmv(enc, csrVal, csrCol, csrRow, bufX, bufAp, bufArgs, numWgSpmvVec, true);
+      this.device.queue.submit([enc.finish()]);
+      await this.device.queue.onSubmittedWorkDone();
+    }
+    {
+      const enc = this.device.createCommandEncoder({ label: "init-residual" });
+      enc.copyBufferToBuffer(bufB, 0, bufR, 0, n * 4);
+      this.device.queue.submit([enc.finish()]);
+      await this.device.queue.onSubmittedWorkDone();
+    }
+    {
+      this.writeArgs(bufArgs, n, vectorWidth, n, -1);
+      const enc = this.device.createCommandEncoder({ label: "init-saxpy" });
+      this.dispatchSaxpy(enc, bufAp, bufR, bufArgs, numWgVec);
+      this.device.queue.submit([enc.finish()]);
+      await this.device.queue.onSubmittedWorkDone();
+    }
+    {
+      this.writeArgs(bufArgs, n, vectorWidth, n, 0);
+      const enc = this.device.createCommandEncoder({ label: "init-copy-p" });
+      this.dispatchVecCopy(enc, bufR, bufP, bufArgs, numWgVec);
+      this.device.queue.submit([enc.finish()]);
+      await this.device.queue.onSubmittedWorkDone();
+    }
+    let rDotR = await this.dotProduct(bufR, bufR, bufPartials, bufScalar, bufStaging, bufArgs, n, numWgDot);
+    if (rDotR < toleranceSq) {
+      const x = await this.readback(bufX, n);
+      this.cleanup(allBuffers);
+      return { x, iterations: 0, residualNormSq: rDotR, converged: true };
+    }
+    let iteration = 0;
+    let converged = false;
+    for (iteration = 0; iteration < maxIterations; iteration++) {
+      {
+        this.writeArgs(bufArgs, n, vectorWidth, n, 0);
+        const enc = this.device.createCommandEncoder();
+        this.dispatchSpmv(enc, csrVal, csrCol, csrRow, bufP, bufAp, bufArgs, numWgSpmvVec, true);
+        this.device.queue.submit([enc.finish()]);
+      }
+      const pAp = await this.dotProduct(bufP, bufAp, bufPartials, bufScalar, bufStaging, bufArgs, n, numWgDot);
+      if (Math.abs(pAp) < 1e-30) {
+        converged = rDotR < toleranceSq;
+        break;
+      }
+      const alpha = rDotR / pAp;
+      {
+        this.writeArgs(bufArgs, n, vectorWidth, n, alpha);
+        const enc = this.device.createCommandEncoder();
+        this.dispatchSaxpy(enc, bufP, bufX, bufArgs, numWgVec);
+        this.device.queue.submit([enc.finish()]);
+        await this.device.queue.onSubmittedWorkDone();
+      }
+      {
+        this.writeArgs(bufArgs, n, vectorWidth, n, -alpha);
+        const enc = this.device.createCommandEncoder();
+        this.dispatchSaxpy(enc, bufAp, bufR, bufArgs, numWgVec);
+        this.device.queue.submit([enc.finish()]);
+        await this.device.queue.onSubmittedWorkDone();
+      }
+      const rNewDotRNew = await this.dotProduct(bufR, bufR, bufPartials, bufScalar, bufStaging, bufArgs, n, numWgDot);
+      if (rNewDotRNew < toleranceSq) {
+        rDotR = rNewDotRNew;
+        converged = true;
+        iteration++;
+        onProgress?.(iteration, rNewDotRNew);
+        break;
+      }
+      if (onProgress && iteration % convergenceCheckInterval === 0) {
+        onProgress(iteration, rNewDotRNew);
+      }
+      const beta = rNewDotRNew / rDotR;
+      {
+        this.writeArgs(bufArgs, n, vectorWidth, n, beta);
+        const enc = this.device.createCommandEncoder();
+        this.dispatchPUpdate(enc, bufR, bufP, bufArgs, numWgVec);
+        this.device.queue.submit([enc.finish()]);
+        await this.device.queue.onSubmittedWorkDone();
+      }
+      rDotR = rNewDotRNew;
+    }
+    const solution = await this.readback(bufX, n);
+    this.cleanup(allBuffers);
+    return { x: solution, iterations: iteration, residualNormSq: rDotR, converged };
+  }
+  /**
+   * solveCGDirect — Direct GPU-to-GPU Conjugate Gradient solve.
+   *
+   * Same as solveCG but avoids CPU readback of the solution vector.
+   * Returns the live GPUBuffer containing the result.
+   *
+   * @warning Caller is responsible for destroying the returned xBuffer.
+   */
+  async solveCGDirect(A, b, x0, options = {}) {
+    const n = A.num_rows;
+    const maxIterations = options.maxIterations ?? 1e3;
+    const toleranceSq = options.toleranceSq ?? 1e-10;
+    const xExtraUsage = options.xExtraUsage ?? 0;
+    const valBuffer = this.uploadStorage(A.val, "val");
+    const colIndBuffer = this.uploadStorage(new Uint32Array(A.col_ind), "col_ind");
+    const rowPtrBuffer = this.uploadStorage(new Uint32Array(A.row_ptr), "row_ptr");
+    const bBuffer = this.uploadStorage(b, "b");
+    const xBuffer = this.uploadStorage(x0, "x", xExtraUsage);
+    const rBuffer = this.emptyVec(n, "r");
+    const pBuffer = this.emptyVec(n, "p");
+    const ApBuffer = this.emptyVec(n, "Ap");
+    const rDotRBuffer = this.emptyVec(1, "rDotR");
+    const rDotRStagingBuffer = this.device.createBuffer({
+      size: 4,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+    const numWgVec = Math.ceil(n / WG_SIZE);
+    const numWgDot = Math.ceil(n / WG_SIZE);
+    const bufArgs = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+    const partials = this.emptyVec(numWgDot, "partials");
+    {
+      const enc = this.device.createCommandEncoder();
+      this.dispatchVecCopy(enc, bBuffer, rBuffer, bufArgs, numWgVec);
+      this.dispatchSpmv(enc, valBuffer, colIndBuffer, rowPtrBuffer, xBuffer, ApBuffer, bufArgs, numWgVec, true);
+      this.device.queue.submit([enc.finish()]);
+    }
+    {
+      this.writeArgs(bufArgs, n, 0, n, -1);
+      const enc = this.device.createCommandEncoder();
+      this.dispatchSaxpy(enc, ApBuffer, rBuffer, bufArgs, numWgVec);
+      this.device.queue.submit([enc.finish()]);
+    }
+    {
+      const enc = this.device.createCommandEncoder();
+      this.dispatchVecCopy(enc, rBuffer, pBuffer, bufArgs, numWgVec);
+      this.device.queue.submit([enc.finish()]);
+    }
+    let iteration = 0;
+    let converged = false;
+    let rDotR = await this.dotProduct(rBuffer, rBuffer, partials, rDotRBuffer, rDotRStagingBuffer, bufArgs, n, numWgDot);
+    for (iteration = 0; iteration < maxIterations; iteration++) {
+      if (rDotR < toleranceSq) {
+        converged = true;
+        break;
+      }
+      {
+        const enc = this.device.createCommandEncoder();
+        this.dispatchSpmv(enc, valBuffer, colIndBuffer, rowPtrBuffer, pBuffer, ApBuffer, bufArgs, numWgVec, true);
+        this.device.queue.submit([enc.finish()]);
+      }
+      const pAp = await this.dotProduct(pBuffer, ApBuffer, partials, rDotRBuffer, rDotRStagingBuffer, bufArgs, n, numWgDot);
+      const alpha = rDotR / (pAp + 1e-20);
+      {
+        this.writeArgs(bufArgs, n, 0, n, alpha);
+        const enc = this.device.createCommandEncoder();
+        this.dispatchSaxpy(enc, pBuffer, xBuffer, bufArgs, numWgVec);
+        this.device.queue.submit([enc.finish()]);
+      }
+      {
+        this.writeArgs(bufArgs, n, 0, n, -alpha);
+        const enc = this.device.createCommandEncoder();
+        this.dispatchSaxpy(enc, ApBuffer, rBuffer, bufArgs, numWgVec);
+        this.device.queue.submit([enc.finish()]);
+      }
+      const oldRDotR = rDotR;
+      rDotR = await this.dotProduct(rBuffer, rBuffer, partials, rDotRBuffer, rDotRStagingBuffer, bufArgs, n, numWgDot);
+      const beta = rDotR / (oldRDotR + 1e-20);
+      {
+        this.writeArgs(bufArgs, n, 0, n, beta);
+        const enc = this.device.createCommandEncoder();
+        this.dispatchPUpdate(enc, rBuffer, pBuffer, bufArgs, numWgVec);
+        this.device.queue.submit([enc.finish()]);
+      }
+    }
+    this.cleanup([
+      valBuffer,
+      colIndBuffer,
+      rowPtrBuffer,
+      bBuffer,
+      rBuffer,
+      pBuffer,
+      ApBuffer,
+      rDotRBuffer,
+      rDotRStagingBuffer
+    ]);
+    return { xBuffer, iterations: iteration, residualNormSq: rDotR, converged };
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // Dispatch helpers — each sets the bind groups its entry point needs
+  // ═══════════════════════════════════════════════════════════════════
+  /** SpMV: groups 0 (CSR), 1 (vecs), 2 (args) */
+  dispatchSpmv(enc, val, col, row, x, y, args, numWgs, useVector) {
+    const pipeline = useVector ? this.spmvVectorPipeline : this.spmvPipeline;
+    const pass = enc.beginComputePass({ label: "spmv" });
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, this.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: val } },
+        { binding: 1, resource: { buffer: col } },
+        { binding: 2, resource: { buffer: row } }
+      ]
+    }));
+    pass.setBindGroup(1, this.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(1),
+      entries: [
+        { binding: 0, resource: { buffer: x } },
+        { binding: 1, resource: { buffer: y } }
+      ]
+    }));
+    pass.setBindGroup(2, this.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(2),
+      entries: [{ binding: 0, resource: { buffer: args } }]
+    }));
+    pass.dispatchWorkgroups(numWgs);
+    pass.end();
+  }
+  /** SAXPY: groups 1 (vecs), 2 (args) */
+  dispatchSaxpy(enc, x, y, args, numWgs) {
+    const pass = enc.beginComputePass({ label: "saxpy" });
+    pass.setPipeline(this.saxpyPipeline);
+    pass.setBindGroup(1, this.device.createBindGroup({
+      layout: this.saxpyPipeline.getBindGroupLayout(1),
+      entries: [
+        { binding: 0, resource: { buffer: x } },
+        { binding: 1, resource: { buffer: y } }
+      ]
+    }));
+    pass.setBindGroup(2, this.device.createBindGroup({
+      layout: this.saxpyPipeline.getBindGroupLayout(2),
+      entries: [{ binding: 0, resource: { buffer: args } }]
+    }));
+    pass.dispatchWorkgroups(numWgs);
+    pass.end();
+  }
+  /** Fused p = r + beta*p: groups 1 (vecs), 2 (args) */
+  dispatchPUpdate(enc, r, p, args, numWgs) {
+    const pass = enc.beginComputePass({ label: "p-update" });
+    pass.setPipeline(this.pUpdatePipeline);
+    pass.setBindGroup(1, this.device.createBindGroup({
+      layout: this.pUpdatePipeline.getBindGroupLayout(1),
+      entries: [
+        { binding: 0, resource: { buffer: r } },
+        { binding: 1, resource: { buffer: p } }
+      ]
+    }));
+    pass.setBindGroup(2, this.device.createBindGroup({
+      layout: this.pUpdatePipeline.getBindGroupLayout(2),
+      entries: [{ binding: 0, resource: { buffer: args } }]
+    }));
+    pass.dispatchWorkgroups(numWgs);
+    pass.end();
+  }
+  /** Vec copy: groups 1 (vecs), 2 (args) */
+  dispatchVecCopy(enc, src, dst, args, numWgs) {
+    const pass = enc.beginComputePass({ label: "vec-copy" });
+    pass.setPipeline(this.vecCopyPipeline);
+    pass.setBindGroup(1, this.device.createBindGroup({
+      layout: this.vecCopyPipeline.getBindGroupLayout(1),
+      entries: [
+        { binding: 0, resource: { buffer: src } },
+        { binding: 1, resource: { buffer: dst } }
+      ]
+    }));
+    pass.setBindGroup(2, this.device.createBindGroup({
+      layout: this.vecCopyPipeline.getBindGroupLayout(2),
+      entries: [{ binding: 0, resource: { buffer: args } }]
+    }));
+    pass.dispatchWorkgroups(numWgs);
+    pass.end();
+  }
+  /**
+   * Full dot product: v1·v2
+   *   Phase 1: dot_product kernel → partial_sums (per-workgroup)
+   *   Phase 2: final_reduce → scalar_result[0]
+   *   Readback: staging mapAsync → CPU f32
+   */
+  async dotProduct(v1, v2, partials, scalar, staging, args, n, numWgDot) {
+    {
+      this.writeArgs(args, n, 0, n, 0);
+      const enc = this.device.createCommandEncoder({ label: "dot-phase1" });
+      const pass = enc.beginComputePass();
+      pass.setPipeline(this.dotPipeline);
+      pass.setBindGroup(1, this.device.createBindGroup({
+        layout: this.dotPipeline.getBindGroupLayout(1),
+        entries: [
+          { binding: 0, resource: { buffer: v1 } },
+          { binding: 1, resource: { buffer: v2 } }
+        ]
+      }));
+      pass.setBindGroup(2, this.device.createBindGroup({
+        layout: this.dotPipeline.getBindGroupLayout(2),
+        entries: [{ binding: 0, resource: { buffer: args } }]
+      }));
+      pass.setBindGroup(3, this.device.createBindGroup({
+        layout: this.dotPipeline.getBindGroupLayout(3),
+        entries: [{ binding: 0, resource: { buffer: partials } }]
+      }));
+      pass.dispatchWorkgroups(numWgDot);
+      pass.end();
+      this.device.queue.submit([enc.finish()]);
+    }
+    {
+      this.writeArgs(args, numWgDot, 0, numWgDot, 0);
+      const enc = this.device.createCommandEncoder({ label: "dot-phase2" });
+      const pass = enc.beginComputePass();
+      pass.setPipeline(this.finalReducePipeline);
+      pass.setBindGroup(2, this.device.createBindGroup({
+        layout: this.finalReducePipeline.getBindGroupLayout(2),
+        entries: [{ binding: 0, resource: { buffer: args } }]
+      }));
+      pass.setBindGroup(3, this.device.createBindGroup({
+        layout: this.finalReducePipeline.getBindGroupLayout(3),
+        entries: [
+          { binding: 0, resource: { buffer: partials } },
+          { binding: 1, resource: { buffer: scalar } }
+        ]
+      }));
+      pass.dispatchWorkgroups(1);
+      pass.end();
+      enc.copyBufferToBuffer(scalar, 0, staging, 0, 4);
+      this.device.queue.submit([enc.finish()]);
+    }
+    await staging.mapAsync(GPUMapMode.READ);
+    const value = new Float32Array(staging.getMappedRange())[0];
+    staging.unmap();
+    return value;
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // Buffer helpers
+  // ═══════════════════════════════════════════════════════════════════
+  writeArgs(buf, numRows, vectorWidth, n, alpha) {
+    const data = new ArrayBuffer(16);
+    new Uint32Array(data, 0, 3).set([numRows, vectorWidth, n]);
+    new Float32Array(data, 12, 1).set([alpha]);
+    this.device.queue.writeBuffer(buf, 0, data);
+  }
+  uploadStorage(data, label, extraUsage = 0) {
+    const buf = this.device.createBuffer({
+      label,
+      size: data.byteLength,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | extraUsage,
+      mappedAtCreation: true
+    });
+    if (data instanceof Float32Array) new Float32Array(buf.getMappedRange()).set(data);
+    else new Uint32Array(buf.getMappedRange()).set(data);
+    buf.unmap();
+    return buf;
+  }
+  emptyVec(n, label, extraUsage = 0) {
+    return this.device.createBuffer({
+      label,
+      size: Math.max(4, n * 4),
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | extraUsage
+    });
+  }
+  async readback(buf, n) {
+    const staging = this.device.createBuffer({
+      size: n * 4,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+    const enc = this.device.createCommandEncoder();
+    enc.copyBufferToBuffer(buf, 0, staging, 0, n * 4);
+    this.device.queue.submit([enc.finish()]);
+    await staging.mapAsync(GPUMapMode.READ);
+    const result = new Float32Array(staging.getMappedRange()).slice();
+    staging.unmap();
+    staging.destroy();
+    return result;
+  }
+  cleanup(buffers) {
+    for (const b of buffers) b.destroy();
+  }
+  destroy() {
+    this.initialized = false;
+  }
+};
+
+// src/gpu/SpatialGrid.ts
+var SpatialGrid = class {
+  context;
+  device;
+  particleCount;
+  options;
+  // Grid dimensions
+  totalCells;
+  // Pipelines
+  clearPipeline = null;
+  buildPipeline = null;
+  collisionPipeline = null;
+  // Buffers
+  uniformBuffer = null;
+  gridCellStartBuffer = null;
+  gridCellEndBuffer = null;
+  gridParticleIndicesBuffer = null;
+  collisionForcesBuffer = null;
+  // Bind groups
+  clearBindGroup = null;
+  buildBindGroup = null;
+  collisionBindGroup = null;
+  constructor(context, particleCount, options) {
+    this.context = context;
+    this.device = context.getDevice();
+    this.particleCount = particleCount;
+    this.options = {
+      cellSize: options.cellSize,
+      gridDimensions: options.gridDimensions,
+      maxParticlesPerCell: options.maxParticlesPerCell ?? 64,
+      shaderCode: options.shaderCode
+    };
+    this.totalCells = this.options.gridDimensions.x * this.options.gridDimensions.y * this.options.gridDimensions.z;
+  }
+  /**
+   * Initialize spatial grid buffers and pipelines
+   */
+  async initialize() {
+    const shaderModule = this.device.createShaderModule({
+      label: "spatial-grid-shader",
+      code: this.options.shaderCode
+    });
+    const compilationInfo = await shaderModule.getCompilationInfo();
+    for (const message of compilationInfo.messages) {
+      if (message.type === "error") {
+        console.error("Spatial grid shader error:", message.message);
+      }
+    }
+    this.createBuffers();
+    this.createPipelines(shaderModule);
+  }
+  /**
+   * Create GPU buffers for spatial grid
+   */
+  createBuffers() {
+    this.uniformBuffer = this.device.createBuffer({
+      label: "spatial-grid-uniforms",
+      size: 32,
+      // 8 × f32/u32 = 32 bytes
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    const cellCounterSize = this.totalCells * Uint32Array.BYTES_PER_ELEMENT;
+    this.gridCellStartBuffer = this.device.createBuffer({
+      label: "grid-cell-start",
+      size: cellCounterSize,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    this.gridCellEndBuffer = this.device.createBuffer({
+      label: "grid-cell-end",
+      size: cellCounterSize,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    const indicesSize = this.totalCells * this.options.maxParticlesPerCell * Uint32Array.BYTES_PER_ELEMENT;
+    this.gridParticleIndicesBuffer = this.device.createBuffer({
+      label: "grid-particle-indices",
+      size: indicesSize,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    const forcesSize = this.particleCount * 4 * Float32Array.BYTES_PER_ELEMENT;
+    this.collisionForcesBuffer = this.device.createBuffer({
+      label: "collision-forces",
+      size: forcesSize,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+    });
+    this.uploadUniforms();
+  }
+  /**
+   * Upload uniform data to GPU
+   */
+  uploadUniforms() {
+    if (!this.uniformBuffer) return;
+    const data = new ArrayBuffer(32);
+    const floatView = new Float32Array(data);
+    const uintView = new Uint32Array(data);
+    floatView[0] = this.options.cellSize;
+    uintView[1] = this.options.gridDimensions.x;
+    uintView[2] = this.options.gridDimensions.y;
+    uintView[3] = this.options.gridDimensions.z;
+    uintView[4] = this.particleCount;
+    uintView[5] = this.options.maxParticlesPerCell;
+    uintView[6] = 0;
+    uintView[7] = 0;
+    this.device.queue.writeBuffer(this.uniformBuffer, 0, data);
+  }
+  /**
+   * Create compute pipelines
+   */
+  createPipelines(shaderModule) {
+    const clearLayout = this.createClearBindGroupLayout();
+    const buildLayout = this.createBuildBindGroupLayout();
+    const collisionLayout = this.createCollisionBindGroupLayout();
+    this.clearPipeline = this.device.createComputePipeline({
+      label: "grid-clear-pipeline",
+      layout: this.device.createPipelineLayout({
+        bindGroupLayouts: [clearLayout]
+      }),
+      compute: {
+        module: shaderModule,
+        entryPoint: "gridClear"
+      }
+    });
+    this.buildPipeline = this.device.createComputePipeline({
+      label: "grid-build-pipeline",
+      layout: this.device.createPipelineLayout({
+        bindGroupLayouts: [buildLayout]
+      }),
+      compute: {
+        module: shaderModule,
+        entryPoint: "gridBuild"
+      }
+    });
+    this.collisionPipeline = this.device.createComputePipeline({
+      label: "grid-collision-pipeline",
+      layout: this.device.createPipelineLayout({
+        bindGroupLayouts: [collisionLayout]
+      }),
+      compute: {
+        module: shaderModule,
+        entryPoint: "gridCollision"
+      }
+    });
+  }
+  /**
+   * Create bind group layout for clear pass
+   */
+  createClearBindGroupLayout() {
+    return this.device.createBindGroupLayout({
+      label: "grid-clear-layout",
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "uniform" } },
+        { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
+        { binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } }
+      ]
+    });
+  }
+  /**
+   * Create bind group layout for build pass
+   */
+  createBuildBindGroupLayout() {
+    return this.device.createBindGroupLayout({
+      label: "grid-build-layout",
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "uniform" } },
+        { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
+        { binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
+        { binding: 5, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } }
+      ]
+    });
+  }
+  /**
+   * Create bind group layout for collision pass
+   */
+  createCollisionBindGroupLayout() {
+    return this.device.createBindGroupLayout({
+      label: "grid-collision-layout",
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "uniform" } },
+        { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
+        { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
+        { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
+        { binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
+        { binding: 5, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
+        { binding: 6, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } }
+      ]
+    });
+  }
+  /**
+   * Clear grid counters (run before buildGrid each frame)
+   */
+  clearGrid(commandEncoder) {
+    if (!this.clearPipeline || !this.uniformBuffer || !this.gridCellStartBuffer || !this.gridCellEndBuffer) {
+      throw new Error("Spatial grid not initialized");
+    }
+    if (!this.clearBindGroup) {
+      this.clearBindGroup = this.device.createBindGroup({
+        layout: this.clearPipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: this.uniformBuffer } },
+          { binding: 3, resource: { buffer: this.gridCellStartBuffer } },
+          { binding: 4, resource: { buffer: this.gridCellEndBuffer } }
+        ]
+      });
+    }
+    const encoder = commandEncoder ?? this.device.createCommandEncoder({ label: "grid-clear-encoder" });
+    const pass = encoder.beginComputePass({ label: "grid-clear-pass" });
+    pass.setPipeline(this.clearPipeline);
+    pass.setBindGroup(0, this.clearBindGroup);
+    const workgroups = Math.ceil(this.totalCells / 256);
+    pass.dispatchWorkgroups(workgroups, 1, 1);
+    pass.end();
+    return encoder;
+  }
+  /**
+   * Build spatial grid from particle positions
+   */
+  buildGrid(positionBuffer, commandEncoder) {
+    if (!this.buildPipeline || !this.uniformBuffer || !this.gridCellEndBuffer || !this.gridParticleIndicesBuffer) {
+      throw new Error("Spatial grid not initialized");
+    }
+    if (!this.buildBindGroup) {
+      this.buildBindGroup = this.device.createBindGroup({
+        layout: this.buildPipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: this.uniformBuffer } },
+          { binding: 1, resource: { buffer: positionBuffer } },
+          { binding: 4, resource: { buffer: this.gridCellEndBuffer } },
+          { binding: 5, resource: { buffer: this.gridParticleIndicesBuffer } }
+        ]
+      });
+    }
+    const encoder = commandEncoder ?? this.device.createCommandEncoder({ label: "grid-build-encoder" });
+    const pass = encoder.beginComputePass({ label: "grid-build-pass" });
+    pass.setPipeline(this.buildPipeline);
+    pass.setBindGroup(0, this.buildBindGroup);
+    const workgroups = Math.ceil(this.particleCount / 256);
+    pass.dispatchWorkgroups(workgroups, 1, 1);
+    pass.end();
+    return encoder;
+  }
+  /**
+   * Detect collisions using spatial grid
+   */
+  detectCollisions(positionBuffer, velocityBuffer, commandEncoder) {
+    if (!this.collisionPipeline || !this.uniformBuffer || !this.collisionForcesBuffer) {
+      throw new Error("Spatial grid not initialized");
+    }
+    if (!this.collisionBindGroup) {
+      this.collisionBindGroup = this.device.createBindGroup({
+        layout: this.collisionPipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: this.uniformBuffer } },
+          { binding: 1, resource: { buffer: positionBuffer } },
+          { binding: 2, resource: { buffer: velocityBuffer } },
+          { binding: 3, resource: { buffer: this.gridCellStartBuffer } },
+          { binding: 4, resource: { buffer: this.gridCellEndBuffer } },
+          { binding: 5, resource: { buffer: this.gridParticleIndicesBuffer } },
+          { binding: 6, resource: { buffer: this.collisionForcesBuffer } }
+        ]
+      });
+    }
+    const encoder = commandEncoder ?? this.device.createCommandEncoder({ label: "grid-collision-encoder" });
+    const pass = encoder.beginComputePass({ label: "grid-collision-pass" });
+    pass.setPipeline(this.collisionPipeline);
+    pass.setBindGroup(0, this.collisionBindGroup);
+    const workgroups = Math.ceil(this.particleCount / 256);
+    pass.dispatchWorkgroups(workgroups, 1, 1);
+    pass.end();
+    return encoder;
+  }
+  /**
+   * Execute full collision detection pipeline
+   *
+   * Convenience method that runs all three passes: clear → build → detect
+   */
+  async execute(positionBuffer, velocityBuffer) {
+    const encoder = this.device.createCommandEncoder({ label: "spatial-grid-full-encoder" });
+    this.clearGrid(encoder);
+    this.buildGrid(positionBuffer, encoder);
+    this.detectCollisions(positionBuffer, velocityBuffer, encoder);
+    this.device.queue.submit([encoder.finish()]);
+    return await this.downloadCollisionForces();
+  }
+  /**
+   * Download collision forces from GPU
+   */
+  async downloadCollisionForces() {
+    if (!this.collisionForcesBuffer) {
+      throw new Error("Collision forces buffer not initialized");
+    }
+    const stagingBuffer = this.device.createBuffer({
+      size: this.collisionForcesBuffer.size,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+    const encoder = this.device.createCommandEncoder({ label: "collision-forces-readback" });
+    encoder.copyBufferToBuffer(
+      this.collisionForcesBuffer,
+      0,
+      stagingBuffer,
+      0,
+      this.collisionForcesBuffer.size
+    );
+    this.device.queue.submit([encoder.finish()]);
+    await stagingBuffer.mapAsync(GPUMapMode.READ);
+    const data = new Float32Array(stagingBuffer.getMappedRange()).slice();
+    stagingBuffer.unmap();
+    stagingBuffer.destroy();
+    return data;
+  }
+  /**
+   * Get collision forces buffer (for use in other compute passes)
+   */
+  getCollisionForcesBuffer() {
+    if (!this.collisionForcesBuffer) {
+      throw new Error("Collision forces buffer not initialized");
+    }
+    return this.collisionForcesBuffer;
+  }
+  /**
+   * Calculate memory usage
+   */
+  calculateMemoryUsage() {
+    const cellCounters = this.totalCells * 4 * 2;
+    const indices = this.totalCells * this.options.maxParticlesPerCell * 4;
+    const forces = this.particleCount * 4 * 4;
+    const total = (cellCounters + indices + forces) / 1024 / 1024;
+    return `${total.toFixed(2)} MB`;
+  }
+  /**
+   * Get grid statistics
+   */
+  getStats() {
+    return {
+      cellSize: this.options.cellSize,
+      gridDimensions: this.options.gridDimensions,
+      totalCells: this.totalCells,
+      maxParticlesPerCell: this.options.maxParticlesPerCell,
+      memoryUsage: this.calculateMemoryUsage()
+    };
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.uniformBuffer?.destroy();
+    this.gridCellStartBuffer?.destroy();
+    this.gridCellEndBuffer?.destroy();
+    this.gridParticleIndicesBuffer?.destroy();
+    this.collisionForcesBuffer?.destroy();
+    this.clearPipeline = null;
+    this.buildPipeline = null;
+    this.collisionPipeline = null;
+    this.clearBindGroup = null;
+    this.buildBindGroup = null;
+    this.collisionBindGroup = null;
+  }
+};
+
+// src/gpu/index.ts
+init_WebGPUContext();
+
+// src/gpu/codecs/IGaussianCodec.ts
+var GaussianCodecError = class extends Error {
+  constructor(message, codecId, operation, cause) {
+    super(`[${codecId}] ${operation}: ${message}`);
+    this.codecId = codecId;
+    this.operation = operation;
+    this.cause = cause;
+    this.name = "GaussianCodecError";
+  }
+  codecId;
+  operation;
+  cause;
+};
+var CodecNotSupportedError = class extends GaussianCodecError {
+  constructor(codecId, operation) {
+    super(
+      `Operation '${operation}' is not supported by this codec. Check capabilities before calling.`,
+      codecId,
+      operation
+    );
+    this.name = "CodecNotSupportedError";
+  }
+};
+var CodecDecodeError = class extends GaussianCodecError {
+  constructor(codecId, message, cause) {
+    super(message, codecId, "decode", cause);
+    this.name = "CodecDecodeError";
+  }
+};
+var CodecEncodeError = class extends GaussianCodecError {
+  constructor(codecId, message, cause) {
+    super(message, codecId, "encode", cause);
+    this.name = "CodecEncodeError";
+  }
+};
+var CodecMemoryError = class extends GaussianCodecError {
+  constructor(codecId, requiredMB, budgetMB) {
+    super(
+      `Memory budget exceeded: operation requires ~${requiredMB.toFixed(1)} MB but budget is ${budgetMB} MB`,
+      codecId,
+      "decode"
+    );
+    this.requiredMB = requiredMB;
+    this.budgetMB = budgetMB;
+    this.name = "CodecMemoryError";
+  }
+  requiredMB;
+  budgetMB;
+};
+var CodecDecompressError = class extends GaussianCodecError {
+  constructor(codecId, message, cause) {
+    super(message, codecId, "decompress", cause);
+    this.name = "CodecDecompressError";
+  }
+};
+var AbstractGaussianCodec = class {
+  initialized = false;
+  // Default implementations for optional operations:
+  async encode(_data, _options) {
+    throw new CodecNotSupportedError(this.getCapabilities().id, "encode");
+  }
+  async *stream(_source, _options) {
+    throw new CodecNotSupportedError(this.getCapabilities().id, "stream");
+  }
+  async decompress(_compressed) {
+    throw new CodecNotSupportedError(this.getCapabilities().id, "decompress");
+  }
+  async initialize() {
+    this.initialized = true;
+  }
+  dispose() {
+    this.initialized = false;
+  }
+  /**
+   * Estimate memory footprint in MB for a given Gaussian count.
+   * Used by decode() to check memory budgets.
+   */
+  estimateMemoryMB(gaussianCount) {
+    const bytesPerGaussian = 15 * 4;
+    return gaussianCount * bytesPerGaussian / (1024 * 1024);
+  }
+  /**
+   * Check if a decode operation would exceed the memory budget.
+   * @throws CodecMemoryError if budget would be exceeded
+   */
+  checkMemoryBudget(gaussianCount, maxMemoryMB) {
+    const requiredMB = this.estimateMemoryMB(gaussianCount);
+    if (requiredMB > maxMemoryMB) {
+      throw new CodecMemoryError(this.getCapabilities().id, requiredMB, maxMemoryMB);
+    }
+  }
+};
+
+// src/gpu/codecs/SpzCodec.ts
+var SPZ_MAGIC = 1347635022;
+var SPZ_HEADER_SIZE = 16;
+var SPZ_MAX_POINTS = 1e7;
+var DEFAULT_MAX_MEMORY_MB = 512;
+var SPZ_COLOR_SCALE = 0.15;
+var SH_C0 = 0.2820948;
+var SQRT1_2 = Math.SQRT1_2;
+var GZIP_MAGIC_0 = 31;
+var GZIP_MAGIC_1 = 139;
+var SpzCodec = class extends AbstractGaussianCodec {
+  codecId;
+  constructor() {
+    super();
+    this.codecId = "khr.spz.v2";
+  }
+  // ─── Capabilities ─────────────────────────────────────────────────────────
+  getCapabilities() {
+    return {
+      id: this.codecId,
+      name: "Niantic SPZ Gaussian Splat Codec",
+      version: "1.0.0",
+      fileExtensions: ["spz"],
+      mimeTypes: ["application/x-spz", "application/gzip"],
+      canEncode: true,
+      canDecode: true,
+      canStream: true,
+      canDecodeTemporal: false,
+      maxSHDegree: 3,
+      maxGaussianCount: SPZ_MAX_POINTS,
+      requiresWasm: false,
+      requiresWebGPU: false,
+      standard: "khronos",
+      maturity: "production"
+    };
+  }
+  // ─── Probe ────────────────────────────────────────────────────────────────
+  canDecode(buffer) {
+    if (buffer.byteLength < 2) return false;
+    const bytes = new Uint8Array(buffer, 0, 2);
+    return bytes[0] === GZIP_MAGIC_0 && bytes[1] === GZIP_MAGIC_1;
+  }
+  // ─── Decompress ───────────────────────────────────────────────────────────
+  async decompress(compressed) {
+    try {
+      return await decompressGzip(compressed);
+    } catch (err) {
+      throw new CodecDecompressError(
+        this.codecId,
+        "Gzip decompression failed. Ensure the data is a valid SPZ file.",
+        err instanceof Error ? err : void 0
+      );
+    }
+  }
+  // ─── Extract Metadata ─────────────────────────────────────────────────────
+  async extractMetadata(buffer) {
+    const raw = await this.decompress(buffer);
+    const header = parseSpzHeader(new DataView(raw));
+    validateSpzHeader(header, this.codecId);
+    const isV3 = header.version >= 3;
+    const rotBytes = isV3 ? 4 : 3;
+    const shDim = shDimForDegree(header.shDegree);
+    const uncompressedSize = SPZ_HEADER_SIZE + header.numPoints * 9 + // positions
+    header.numPoints + // alphas
+    header.numPoints * 3 + // colors
+    header.numPoints * 3 + // scales
+    header.numPoints * rotBytes + // rotations
+    header.numPoints * shDim * 3;
+    return {
+      version: header.version,
+      gaussianCount: header.numPoints,
+      shDegree: header.shDegree,
+      compressedSizeBytes: buffer.byteLength,
+      uncompressedSizeBytes: uncompressedSize,
+      compressionRatio: buffer.byteLength / uncompressedSize,
+      antialiased: (header.flags & 1) !== 0
+    };
+  }
+  // ─── Decode ───────────────────────────────────────────────────────────────
+  async decode(buffer, options) {
+    const startTime = performance.now();
+    const warnings = [];
+    const maxGaussians = options?.maxGaussians ?? SPZ_MAX_POINTS;
+    const maxMemoryMB = options?.maxMemoryMB ?? DEFAULT_MAX_MEMORY_MB;
+    const decodeSH = options?.decodeSH ?? true;
+    const alphaThreshold = options?.alphaThreshold ?? 0;
+    const raw = await this.decompress(buffer);
+    const data = new Uint8Array(raw);
+    const view = new DataView(raw);
+    const header = parseSpzHeader(view);
+    validateSpzHeader(header, this.codecId);
+    const N = Math.min(header.numPoints, maxGaussians);
+    if (N < header.numPoints) {
+      warnings.push(
+        `Clamped Gaussian count from ${header.numPoints.toLocaleString()} to ${N.toLocaleString()} (maxGaussians limit)`
+      );
+    }
+    this.checkMemoryBudget(N, maxMemoryMB);
+    const isV3 = header.version >= 3;
+    const rotBytes = isV3 ? 4 : 3;
+    const shDim = decodeSH ? shDimForDegree(header.shDegree) : 0;
+    const posScale = 1 / (1 << header.fractionalBits);
+    const posStart = SPZ_HEADER_SIZE;
+    const alphaStart = posStart + header.numPoints * 9;
+    const colorStart = alphaStart + header.numPoints;
+    const scaleStart = colorStart + header.numPoints * 3;
+    const rotStart = scaleStart + header.numPoints * 3;
+    const shStart = rotStart + header.numPoints * rotBytes;
+    const expectedSize = shStart + header.numPoints * shDimForDegree(header.shDegree) * 3;
+    if (data.length < expectedSize) {
+      throw new CodecDecodeError(
+        this.codecId,
+        `SPZ buffer too short: ${data.length} bytes, expected at least ${expectedSize} bytes for ${header.numPoints} points with SH degree ${header.shDegree}`
+      );
+    }
+    const positions = new Float32Array(N * 3);
+    const scales = new Float32Array(N * 3);
+    const rotations = new Float32Array(N * 4);
+    const colors = new Float32Array(N * 4);
+    const opacities = new Float32Array(N);
+    let shCoefficients;
+    if (shDim > 0) {
+      shCoefficients = new Float32Array(N * shDim * 3);
+    }
+    for (let i = 0; i < N; i++) {
+      const pOff = posStart + i * 9;
+      for (let c = 0; c < 3; c++) {
+        const byteOff = pOff + c * 3;
+        let fixed32 = data[byteOff] | data[byteOff + 1] << 8 | data[byteOff + 2] << 16;
+        if (fixed32 & 8388608) fixed32 |= 4278190080;
+        fixed32 = fixed32 | 0;
+        positions[i * 3 + c] = fixed32 * posScale;
+      }
+    }
+    for (let i = 0; i < N; i++) {
+      const rawAlpha = data[alphaStart + i] / 255;
+      opacities[i] = rawAlpha;
+      colors[i * 4 + 3] = rawAlpha;
+    }
+    for (let i = 0; i < N; i++) {
+      const cOff = colorStart + i * 3;
+      for (let c = 0; c < 3; c++) {
+        const normalized = data[cOff + c] / 255;
+        const shCoeff = (normalized - 0.5) / SPZ_COLOR_SCALE;
+        const rgb = 0.5 + SH_C0 * shCoeff;
+        colors[i * 4 + c] = Math.max(0, Math.min(1, rgb));
+      }
+    }
+    for (let i = 0; i < N; i++) {
+      const sOff = scaleStart + i * 3;
+      for (let c = 0; c < 3; c++) {
+        const logScale = data[sOff + c] / 16 - 10;
+        scales[i * 3 + c] = Math.exp(logScale);
+      }
+    }
+    for (let i = 0; i < N; i++) {
+      const rOff = rotStart + i * rotBytes;
+      let quat;
+      if (isV3) {
+        quat = decodeQuaternionV3(data, rOff);
+      } else {
+        quat = decodeQuaternionV2(data, rOff);
+      }
+      rotations[i * 4] = quat[0];
+      rotations[i * 4 + 1] = quat[1];
+      rotations[i * 4 + 2] = quat[2];
+      rotations[i * 4 + 3] = quat[3];
+    }
+    if (shCoefficients && shDim > 0) {
+      for (let i = 0; i < N; i++) {
+        for (let s = 0; s < shDim; s++) {
+          const off = shStart + (i * shDim + s) * 3;
+          for (let c = 0; c < 3; c++) {
+            const raw2 = data[off + c];
+            const signed = raw2 > 127 ? raw2 - 256 : raw2;
+            shCoefficients[(i * shDim + s) * 3 + c] = signed / 128 * SPZ_COLOR_SCALE;
+          }
+        }
+      }
+    }
+    let finalCount = N;
+    if (alphaThreshold > 0) {
+      let writeIdx = 0;
+      for (let i = 0; i < N; i++) {
+        if (opacities[i] >= alphaThreshold) {
+          if (writeIdx !== i) {
+            positions[writeIdx * 3] = positions[i * 3];
+            positions[writeIdx * 3 + 1] = positions[i * 3 + 1];
+            positions[writeIdx * 3 + 2] = positions[i * 3 + 2];
+            scales[writeIdx * 3] = scales[i * 3];
+            scales[writeIdx * 3 + 1] = scales[i * 3 + 1];
+            scales[writeIdx * 3 + 2] = scales[i * 3 + 2];
+            rotations[writeIdx * 4] = rotations[i * 4];
+            rotations[writeIdx * 4 + 1] = rotations[i * 4 + 1];
+            rotations[writeIdx * 4 + 2] = rotations[i * 4 + 2];
+            rotations[writeIdx * 4 + 3] = rotations[i * 4 + 3];
+            colors[writeIdx * 4] = colors[i * 4];
+            colors[writeIdx * 4 + 1] = colors[i * 4 + 1];
+            colors[writeIdx * 4 + 2] = colors[i * 4 + 2];
+            colors[writeIdx * 4 + 3] = colors[i * 4 + 3];
+            opacities[writeIdx] = opacities[i];
+          }
+          writeIdx++;
+        }
+      }
+      finalCount = writeIdx;
+      if (finalCount < N) {
+        warnings.push(
+          `Filtered ${N - finalCount} Gaussians below alpha threshold ${alphaThreshold}`
+        );
+      }
+    }
+    const result = {
+      positions: finalCount < N ? positions.slice(0, finalCount * 3) : positions,
+      scales: finalCount < N ? scales.slice(0, finalCount * 3) : scales,
+      rotations: finalCount < N ? rotations.slice(0, finalCount * 4) : rotations,
+      colors: finalCount < N ? colors.slice(0, finalCount * 4) : colors,
+      opacities: finalCount < N ? opacities.slice(0, finalCount) : opacities,
+      shCoefficients: shCoefficients ? finalCount < N ? shCoefficients.slice(0, finalCount * shDim * 3) : shCoefficients : void 0,
+      shDegree: decodeSH ? header.shDegree : 0,
+      count: finalCount
+    };
+    const durationMs = performance.now() - startTime;
+    return {
+      data: result,
+      durationMs,
+      warnings
+    };
+  }
+  // ─── Encode ───────────────────────────────────────────────────────────────
+  async encode(data, options) {
+    const startTime = performance.now();
+    const warnings = [];
+    const shDegree = options?.shDegree ?? data.shDegree;
+    const fractionalBits = options?.fractionalBits ?? 12;
+    const antialiased = options?.antialiased ?? false;
+    const encodingVersion = options?.encodingVersion ?? 3;
+    const N = data.count;
+    if (N > SPZ_MAX_POINTS) {
+      throw new CodecEncodeError(
+        this.codecId,
+        `Cannot encode ${N.toLocaleString()} Gaussians: exceeds maximum of ${SPZ_MAX_POINTS.toLocaleString()}`
+      );
+    }
+    const isV3 = encodingVersion >= 3;
+    const shDim = shDimForDegree(shDegree);
+    const rotBytes = isV3 ? 4 : 3;
+    const payloadSize = SPZ_HEADER_SIZE + N * 9 + // positions
+    N + // alphas
+    N * 3 + // colors
+    N * 3 + // scales
+    N * rotBytes + // rotations
+    N * shDim * 3;
+    const buffer = new ArrayBuffer(payloadSize);
+    const out = new Uint8Array(buffer);
+    const outView = new DataView(buffer);
+    outView.setUint32(0, SPZ_MAGIC, true);
+    outView.setUint32(4, encodingVersion, true);
+    outView.setUint32(8, N, true);
+    out[12] = shDegree;
+    out[13] = fractionalBits;
+    out[14] = antialiased ? 1 : 0;
+    out[15] = 0;
+    const posScale = 1 << fractionalBits;
+    const posStart = SPZ_HEADER_SIZE;
+    for (let i = 0; i < N; i++) {
+      const pOff = posStart + i * 9;
+      for (let c = 0; c < 3; c++) {
+        const fixed = Math.round(data.positions[i * 3 + c] * posScale);
+        const clamped = Math.max(-8388608, Math.min(8388607, fixed));
+        const unsigned = clamped & 16777215;
+        const byteOff = pOff + c * 3;
+        out[byteOff] = unsigned & 255;
+        out[byteOff + 1] = unsigned >> 8 & 255;
+        out[byteOff + 2] = unsigned >> 16 & 255;
+      }
+    }
+    const alphaStart = posStart + N * 9;
+    for (let i = 0; i < N; i++) {
+      out[alphaStart + i] = Math.round(Math.max(0, Math.min(1, data.opacities[i])) * 255);
+    }
+    const colorStart = alphaStart + N;
+    for (let i = 0; i < N; i++) {
+      const cOff = colorStart + i * 3;
+      for (let c = 0; c < 3; c++) {
+        const rgb = data.colors[i * 4 + c];
+        const shCoeff = (rgb - 0.5) / SH_C0;
+        const normalized = shCoeff * SPZ_COLOR_SCALE + 0.5;
+        out[cOff + c] = Math.round(Math.max(0, Math.min(1, normalized)) * 255);
+      }
+    }
+    const scaleStart = colorStart + N * 3;
+    for (let i = 0; i < N; i++) {
+      const sOff = scaleStart + i * 3;
+      for (let c = 0; c < 3; c++) {
+        const scale = data.scales[i * 3 + c];
+        const logScale = Math.log(Math.max(1e-10, scale));
+        const encoded2 = Math.round((logScale + 10) * 16);
+        out[sOff + c] = Math.max(0, Math.min(255, encoded2));
+      }
+    }
+    const rotStart = scaleStart + N * 3;
+    if (isV3) {
+      for (let i = 0; i < N; i++) {
+        const rOff = rotStart + i * 4;
+        const packed = encodeQuaternionV3(
+          data.rotations[i * 4],
+          data.rotations[i * 4 + 1],
+          data.rotations[i * 4 + 2],
+          data.rotations[i * 4 + 3]
+        );
+        out[rOff] = packed & 255;
+        out[rOff + 1] = packed >>> 8 & 255;
+        out[rOff + 2] = packed >>> 16 & 255;
+        out[rOff + 3] = packed >>> 24 & 255;
+      }
+    } else {
+      for (let i = 0; i < N; i++) {
+        const rOff = rotStart + i * 3;
+        const x = data.rotations[i * 4];
+        const y = data.rotations[i * 4 + 1];
+        const z = data.rotations[i * 4 + 2];
+        out[rOff] = Math.round(Math.max(0, Math.min(255, (x + 1) * 127.5)));
+        out[rOff + 1] = Math.round(Math.max(0, Math.min(255, (y + 1) * 127.5)));
+        out[rOff + 2] = Math.round(Math.max(0, Math.min(255, (z + 1) * 127.5)));
+      }
+    }
+    if (shDim > 0 && data.shCoefficients) {
+      const shStartOffset = rotStart + N * rotBytes;
+      for (let i = 0; i < N; i++) {
+        for (let s = 0; s < shDim; s++) {
+          const off = shStartOffset + (i * shDim + s) * 3;
+          for (let c = 0; c < 3; c++) {
+            const coeff = data.shCoefficients[(i * shDim + s) * 3 + c];
+            const scaled = coeff / SPZ_COLOR_SCALE * 128;
+            const clamped = Math.round(Math.max(-128, Math.min(127, scaled)));
+            out[off + c] = clamped < 0 ? clamped + 256 : clamped;
+          }
+        }
+      }
+    }
+    const compressed = await compressGzip(buffer);
+    const metadata = {
+      version: encodingVersion,
+      gaussianCount: N,
+      shDegree,
+      compressedSizeBytes: compressed.byteLength,
+      uncompressedSizeBytes: payloadSize,
+      compressionRatio: compressed.byteLength / payloadSize,
+      antialiased
+    };
+    const encoded = {
+      data: compressed,
+      codecId: this.codecId,
+      metadata
+    };
+    return {
+      data: encoded,
+      durationMs: performance.now() - startTime,
+      warnings
+    };
+  }
+  // ─── Stream Decode ────────────────────────────────────────────────────────
+  async *stream(source, options) {
+    const signal = options?.signal;
+    let buffer;
+    if (typeof source === "string") {
+      const response = await fetch(source, { signal });
+      if (!response.ok) {
+        throw new CodecDecodeError(this.codecId, `HTTP ${response.status}: ${response.statusText}`);
+      }
+      const contentLength = parseInt(response.headers.get("content-length") ?? "0", 10);
+      if (!response.body) {
+        buffer = await response.arrayBuffer();
+        options?.onProgress?.({
+          bytesLoaded: buffer.byteLength,
+          bytesTotal: buffer.byteLength,
+          gaussiansDecoded: 0,
+          gaussiansTotal: -1,
+          phase: "downloading"
+        });
+      } else {
+        const reader = response.body.getReader();
+        const chunks = [];
+        let loaded = 0;
+        while (true) {
+          if (signal?.aborted) {
+            reader.cancel();
+            return;
+          }
+          const { done, value } = await reader.read();
+          if (done) break;
+          chunks.push(value);
+          loaded += value.byteLength;
+          options?.onProgress?.({
+            bytesLoaded: loaded,
+            bytesTotal: contentLength || -1,
+            gaussiansDecoded: 0,
+            gaussiansTotal: -1,
+            phase: "downloading"
+          });
+        }
+        const result = new Uint8Array(loaded);
+        let offset = 0;
+        for (const chunk of chunks) {
+          result.set(chunk, offset);
+          offset += chunk.byteLength;
+        }
+        buffer = result.buffer;
+      }
+    } else {
+      const reader = source.getReader();
+      const chunks = [];
+      let loaded = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+        loaded += value.byteLength;
+      }
+      const result = new Uint8Array(loaded);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      buffer = result.buffer;
+    }
+    options?.onProgress?.({
+      bytesLoaded: buffer.byteLength,
+      bytesTotal: buffer.byteLength,
+      gaussiansDecoded: 0,
+      gaussiansTotal: -1,
+      phase: "decompressing"
+    });
+    const decoded = await this.decode(buffer, options);
+    options?.onProgress?.({
+      bytesLoaded: buffer.byteLength,
+      bytesTotal: buffer.byteLength,
+      gaussiansDecoded: decoded.data.count,
+      gaussiansTotal: decoded.data.count,
+      phase: "complete"
+    });
+    yield decoded;
+  }
+};
+async function decompressGzip(compressed) {
+  if (typeof DecompressionStream !== "undefined") {
+    const ds = new DecompressionStream("gzip");
+    const writer = ds.writable.getWriter();
+    const reader = ds.readable.getReader();
+    writer.write(new Uint8Array(compressed));
+    writer.close();
+    const chunks = [];
+    let totalLength = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      totalLength += value.byteLength;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result.buffer;
+  }
+  const _global = globalThis;
+  if (typeof globalThis !== "undefined" && _global.pako) {
+    const pako = _global.pako;
+    const decompressed = pako.inflate(new Uint8Array(compressed));
+    return decompressed.buffer;
+  }
+  throw new Error(
+    "SPZ decompression requires DecompressionStream API (modern browsers) or pako library."
+  );
+}
+async function compressGzip(data) {
+  if (typeof CompressionStream !== "undefined") {
+    const cs = new CompressionStream("gzip");
+    const writer = cs.writable.getWriter();
+    const reader = cs.readable.getReader();
+    writer.write(new Uint8Array(data));
+    writer.close();
+    const chunks = [];
+    let totalLength = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      totalLength += value.byteLength;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result.buffer;
+  }
+  throw new Error("SPZ encoding requires CompressionStream API (modern browsers).");
+}
+function parseSpzHeader(view) {
+  return {
+    magic: view.getUint32(0, true),
+    version: view.getUint32(4, true),
+    numPoints: view.getUint32(8, true),
+    shDegree: view.getUint8(12),
+    fractionalBits: view.getUint8(13),
+    flags: view.getUint8(14),
+    reserved: view.getUint8(15)
+  };
+}
+function validateSpzHeader(header, codecId) {
+  if (header.magic !== SPZ_MAGIC) {
+    throw new CodecDecodeError(
+      codecId,
+      `Invalid SPZ magic: 0x${header.magic.toString(16).toUpperCase()}, expected 0x${SPZ_MAGIC.toString(16).toUpperCase()} ("NGSP")`
+    );
+  }
+  if (header.version < 1 || header.version > 3) {
+    throw new CodecDecodeError(
+      codecId,
+      `Unsupported SPZ version: ${header.version} (supported: 1-3)`
+    );
+  }
+  if (header.numPoints > SPZ_MAX_POINTS) {
+    throw new CodecDecodeError(
+      codecId,
+      `SPZ file contains ${header.numPoints.toLocaleString()} points, exceeding maximum of ${SPZ_MAX_POINTS.toLocaleString()}`
+    );
+  }
+  if (header.shDegree > 3) {
+    throw new CodecDecodeError(codecId, `Invalid SPZ SH degree: ${header.shDegree} (max 3)`);
+  }
+}
+function shDimForDegree(degree) {
+  switch (degree) {
+    case 0:
+      return 0;
+    case 1:
+      return 3;
+    case 2:
+      return 8;
+    case 3:
+      return 15;
+    default:
+      return 0;
+  }
+}
+function decodeQuaternionV2(data, offset) {
+  const x = data[offset] / 127.5 - 1;
+  const y = data[offset + 1] / 127.5 - 1;
+  const z = data[offset + 2] / 127.5 - 1;
+  const w = Math.sqrt(Math.max(0, 1 - x * x - y * y - z * z));
+  return [x, y, z, w];
+}
+function decodeQuaternionV3(data, offset) {
+  const comp = data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24;
+  const iLargest = comp >>> 30 & 3;
+  const MASK_9 = (1 << 9) - 1;
+  const quat = [0, 0, 0, 0];
+  let sumSquares = 0;
+  let bitPos = 0;
+  for (let i = 0; i < 4; i++) {
+    if (i === iLargest) continue;
+    const mag = comp >>> bitPos & MASK_9;
+    const negBit = comp >>> bitPos + 9 & 1;
+    bitPos += 10;
+    let value = SQRT1_2 * mag / MASK_9;
+    if (negBit === 1) value = -value;
+    quat[i] = value;
+    sumSquares += value * value;
+  }
+  quat[iLargest] = Math.sqrt(Math.max(0, 1 - sumSquares));
+  return quat;
+}
+function encodeQuaternionV3(x, y, z, w) {
+  const len = Math.sqrt(x * x + y * y + z * z + w * w);
+  if (len > 0) {
+    const invLen = 1 / len;
+    x *= invLen;
+    y *= invLen;
+    z *= invLen;
+    w *= invLen;
+  } else {
+    x = 0;
+    y = 0;
+    z = 0;
+    w = 1;
+  }
+  const abs = [Math.abs(x), Math.abs(y), Math.abs(z), Math.abs(w)];
+  let iLargest = 0;
+  if (abs[1] > abs[iLargest]) iLargest = 1;
+  if (abs[2] > abs[iLargest]) iLargest = 2;
+  if (abs[3] > abs[iLargest]) iLargest = 3;
+  const quat = [x, y, z, w];
+  if (quat[iLargest] < 0) {
+    quat[0] = -quat[0];
+    quat[1] = -quat[1];
+    quat[2] = -quat[2];
+    quat[3] = -quat[3];
+  }
+  const MASK_9 = (1 << 9) - 1;
+  let packed = 0;
+  let bitPos = 0;
+  for (let i = 0; i < 4; i++) {
+    if (i === iLargest) continue;
+    const value = quat[i];
+    const negBit = value < 0 ? 1 : 0;
+    const mag = Math.min(MASK_9, Math.round(Math.abs(value) / SQRT1_2 * MASK_9));
+    packed |= mag << bitPos;
+    packed |= negBit << bitPos + 9;
+    bitPos += 10;
+  }
+  packed |= iLargest << 30;
+  return packed >>> 0;
+}
+
+// src/gpu/codecs/GltfGaussianSplatCodec.ts
+var GLB_MAGIC = 1179937895;
+var GLB_HEADER_SIZE = 12;
+var GLB_CHUNK_HEADER_SIZE = 8;
+var GLB_CHUNK_TYPE_JSON = 1313821514;
+var GLB_CHUNK_TYPE_BIN = 5130562;
+var EXT_GAUSSIAN_SPLATTING = "KHR_gaussian_splatting";
+var EXT_GAUSSIAN_SPLATTING_COMPRESSION_SPZ = "KHR_gaussian_splatting_compression_spz";
+var MAX_GAUSSIAN_COUNT = 1e7;
+var DEFAULT_MAX_MEMORY_MB2 = 512;
+var SH_C02 = 0.2820947917738781;
+var SH_DC_BIAS = 0.5;
+var GLTF_TYPE_SIZES = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+var GLTF_COMPONENT_SIZES = {
+  [5120 /* BYTE */]: 1,
+  [5121 /* UNSIGNED_BYTE */]: 1,
+  [5122 /* SHORT */]: 2,
+  [5123 /* UNSIGNED_SHORT */]: 2,
+  [5125 /* UNSIGNED_INT */]: 4,
+  [5126 /* FLOAT */]: 4
+};
+function linearToSrgb(linear) {
+  return linear <= 31308e-7 ? linear * 12.92 : 1.055 * Math.pow(linear, 1 / 2.4) - 0.055;
+}
+var GltfGaussianSplatCodec = class extends AbstractGaussianCodec {
+  codecId;
+  spzCodec;
+  constructor() {
+    super();
+    this.codecId = "khr.gltf.gaussian";
+    this.spzCodec = new SpzCodec();
+  }
+  // ─── Capabilities ─────────────────────────────────────────────────────────
+  getCapabilities() {
+    return {
+      id: this.codecId,
+      name: "glTF Gaussian Splat Codec (KHR_gaussian_splatting)",
+      version: "1.0.0",
+      fileExtensions: ["glb", "gltf"],
+      mimeTypes: ["model/gltf-binary", "model/gltf+json"],
+      canEncode: false,
+      canDecode: true,
+      canStream: false,
+      canDecodeTemporal: false,
+      maxSHDegree: 3,
+      maxGaussianCount: MAX_GAUSSIAN_COUNT,
+      requiresWasm: false,
+      requiresWebGPU: false,
+      standard: "khronos",
+      maturity: "beta"
+    };
+  }
+  // ─── Probe ────────────────────────────────────────────────────────────────
+  /**
+   * Check if a buffer contains a GLB file by inspecting the magic bytes,
+   * or if it starts with a JSON object (potential .gltf).
+   */
+  canDecode(buffer) {
+    if (buffer.byteLength < 4) return false;
+    const view = new DataView(buffer);
+    if (view.getUint32(0, true) === GLB_MAGIC) {
+      return true;
+    }
+    const firstByte = new Uint8Array(buffer, 0, 1)[0];
+    if (firstByte === 123) {
+      try {
+        const decoder = new TextDecoder("utf-8");
+        const preview = decoder.decode(buffer.slice(0, Math.min(buffer.byteLength, 4096)));
+        return preview.includes(EXT_GAUSSIAN_SPLATTING);
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  // ─── Extract Metadata ─────────────────────────────────────────────────────
+  async extractMetadata(buffer) {
+    const parsed = this.parseGltfContainer(buffer);
+    const gltf = parsed.json;
+    const { primitive, gaussianExt, spzExt } = this.findGaussianPrimitive(gltf);
+    let gaussianCount = 0;
+    let shDegree = 0;
+    if (spzExt) {
+      const spzData = this.extractBufferViewData(parsed, spzExt.bufferView);
+      const spzMeta = await this.spzCodec.extractMetadata(spzData);
+      gaussianCount = spzMeta.gaussianCount;
+      shDegree = spzMeta.shDegree;
+    } else {
+      const posAccessorIndex = primitive.attributes["POSITION"];
+      if (posAccessorIndex !== void 0 && gltf.accessors) {
+        gaussianCount = gltf.accessors[posAccessorIndex].count;
+      }
+      shDegree = this.detectShDegree(primitive);
+    }
+    return {
+      version: 1,
+      gaussianCount,
+      shDegree,
+      compressedSizeBytes: buffer.byteLength,
+      uncompressedSizeBytes: gaussianCount * 60,
+      // estimate
+      compressionRatio: spzExt ? buffer.byteLength / (gaussianCount * 60) : 1,
+      antialiased: false,
+      extensions: {
+        colorSpace: gaussianExt.colorSpace ?? "srgb_rec709_display",
+        hasSpzCompression: !!spzExt
+      }
+    };
+  }
+  // ─── Decode ───────────────────────────────────────────────────────────────
+  async decode(buffer, options) {
+    const startTime = performance.now();
+    const warnings = [];
+    const maxGaussians = options?.maxGaussians ?? MAX_GAUSSIAN_COUNT;
+    const maxMemoryMB = options?.maxMemoryMB ?? DEFAULT_MAX_MEMORY_MB2;
+    const decodeSH = options?.decodeSH ?? true;
+    const parsed = this.parseGltfContainer(buffer);
+    const gltf = parsed.json;
+    const { primitive, gaussianExt, spzExt } = this.findGaussianPrimitive(gltf);
+    let result;
+    if (spzExt) {
+      warnings.push("Decoding via SPZ compression extension delegation");
+      const spzData = this.extractBufferViewData(parsed, spzExt.bufferView);
+      result = await this.spzCodec.decode(spzData, options);
+      const colorSpace = gaussianExt.colorSpace ?? "srgb_rec709_display";
+      if (colorSpace === "lin_rec709_display") {
+        this.convertColorsLinearToSrgb(result.data.colors, result.data.count);
+        warnings.push("Converted linear RGB to sRGB for display");
+      }
+    } else {
+      result = this.decodeBaseline(
+        parsed,
+        gltf,
+        primitive,
+        gaussianExt,
+        maxGaussians,
+        maxMemoryMB,
+        decodeSH,
+        warnings
+      );
+    }
+    const durationMs = performance.now() - startTime;
+    return {
+      data: result.data,
+      durationMs,
+      warnings: [...warnings, ...result.warnings]
+    };
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────────────────────
+  async initialize() {
+    await super.initialize();
+    await this.spzCodec.initialize();
+  }
+  dispose() {
+    this.spzCodec.dispose();
+    super.dispose();
+  }
+  // ─── Private: glTF Container Parsing ────────────────────────────────────
+  /**
+   * Parse a glTF container, handling both GLB and JSON-only formats.
+   *
+   * @returns Parsed glTF JSON and optional binary buffer
+   */
+  parseGltfContainer(buffer) {
+    const view = new DataView(buffer);
+    if (buffer.byteLength >= GLB_HEADER_SIZE && view.getUint32(0, true) === GLB_MAGIC) {
+      return this.parseGlb(buffer, view);
+    }
+    return this.parseGltfJson(buffer);
+  }
+  /**
+   * Parse a GLB binary container.
+   *
+   * GLB layout:
+   *   [Header: 12 bytes] magic(4) + version(4) + length(4)
+   *   [JSON chunk: 8 + N bytes] chunkLength(4) + chunkType(4) + jsonData(N)
+   *   [BIN chunk: 8 + M bytes] chunkLength(4) + chunkType(4) + binData(M)
+   */
+  parseGlb(buffer, view) {
+    const version = view.getUint32(4, true);
+    const totalLength = view.getUint32(8, true);
+    if (version < 2) {
+      throw new CodecDecodeError(
+        this.codecId,
+        `Unsupported GLB version: ${version} (expected >= 2)`
+      );
+    }
+    if (totalLength > buffer.byteLength) {
+      throw new CodecDecodeError(
+        this.codecId,
+        `GLB header declares ${totalLength} bytes but buffer is only ${buffer.byteLength} bytes`
+      );
+    }
+    let jsonChunk;
+    let binChunk;
+    let offset = GLB_HEADER_SIZE;
+    while (offset < totalLength) {
+      if (offset + GLB_CHUNK_HEADER_SIZE > totalLength) break;
+      const chunkLength = view.getUint32(offset, true);
+      const chunkType = view.getUint32(offset + 4, true);
+      const chunkDataStart = offset + GLB_CHUNK_HEADER_SIZE;
+      const chunkDataEnd = chunkDataStart + chunkLength;
+      if (chunkDataEnd > totalLength) {
+        throw new CodecDecodeError(
+          this.codecId,
+          `GLB chunk at offset ${offset} extends beyond file (${chunkDataEnd} > ${totalLength})`
+        );
+      }
+      if (chunkType === GLB_CHUNK_TYPE_JSON) {
+        const jsonBytes = new Uint8Array(buffer, chunkDataStart, chunkLength);
+        const decoder = new TextDecoder("utf-8");
+        const jsonText = decoder.decode(jsonBytes);
+        try {
+          jsonChunk = JSON.parse(jsonText);
+        } catch (e) {
+          throw new CodecDecodeError(
+            this.codecId,
+            "Failed to parse GLB JSON chunk",
+            e instanceof Error ? e : void 0
+          );
+        }
+      } else if (chunkType === GLB_CHUNK_TYPE_BIN) {
+        binChunk = buffer.slice(chunkDataStart, chunkDataEnd);
+      }
+      offset = chunkDataEnd;
+      while (offset % 4 !== 0 && offset < totalLength) offset++;
+    }
+    if (!jsonChunk) {
+      throw new CodecDecodeError(this.codecId, "GLB file does not contain a JSON chunk");
+    }
+    return {
+      json: jsonChunk,
+      binaryChunks: binChunk ? [binChunk] : []
+    };
+  }
+  /**
+   * Parse a JSON-only glTF file.
+   */
+  parseGltfJson(buffer) {
+    const decoder = new TextDecoder("utf-8");
+    const jsonText = decoder.decode(buffer);
+    let json;
+    try {
+      json = JSON.parse(jsonText);
+    } catch (e) {
+      throw new CodecDecodeError(
+        this.codecId,
+        "Failed to parse glTF JSON",
+        e instanceof Error ? e : void 0
+      );
+    }
+    return {
+      json,
+      binaryChunks: []
+    };
+  }
+  // ─── Private: Gaussian Primitive Discovery ──────────────────────────────
+  /**
+   * Find the first mesh primitive that carries KHR_gaussian_splatting.
+   *
+   * @throws CodecDecodeError if no Gaussian splatting primitive is found
+   */
+  findGaussianPrimitive(gltf) {
+    if (!gltf.meshes || gltf.meshes.length === 0) {
+      throw new CodecDecodeError(this.codecId, "glTF file contains no meshes");
+    }
+    for (const mesh of gltf.meshes) {
+      for (const primitive of mesh.primitives) {
+        const gsExt = primitive.extensions?.[EXT_GAUSSIAN_SPLATTING];
+        if (gsExt) {
+          const spzExt = primitive.extensions?.[EXT_GAUSSIAN_SPLATTING_COMPRESSION_SPZ];
+          return { primitive, gaussianExt: gsExt, spzExt };
+        }
+      }
+    }
+    throw new CodecDecodeError(
+      this.codecId,
+      `No mesh primitive with ${EXT_GAUSSIAN_SPLATTING} extension found in glTF file`
+    );
+  }
+  // ─── Private: BufferView Data Extraction ────────────────────────────────
+  /**
+   * Extract raw bytes from a glTF bufferView.
+   */
+  extractBufferViewData(parsed, bufferViewIndex) {
+    const gltf = parsed.json;
+    if (!gltf.bufferViews || bufferViewIndex >= gltf.bufferViews.length) {
+      throw new CodecDecodeError(
+        this.codecId,
+        `BufferView index ${bufferViewIndex} is out of range (${gltf.bufferViews?.length ?? 0} bufferViews)`
+      );
+    }
+    const bv = gltf.bufferViews[bufferViewIndex];
+    const bufferIndex = bv.buffer;
+    const byteOffset = bv.byteOffset ?? 0;
+    const byteLength = bv.byteLength;
+    const bufferData = this.resolveBuffer(parsed, bufferIndex);
+    if (byteOffset + byteLength > bufferData.byteLength) {
+      throw new CodecDecodeError(
+        this.codecId,
+        `BufferView [${bufferViewIndex}] range (${byteOffset}..${byteOffset + byteLength}) exceeds buffer [${bufferIndex}] size (${bufferData.byteLength})`
+      );
+    }
+    return bufferData.slice(byteOffset, byteOffset + byteLength);
+  }
+  /**
+   * Resolve a glTF buffer index to its ArrayBuffer data.
+   *
+   * For GLB: buffer 0 is the BIN chunk.
+   * For external URIs: not supported (would require async fetch).
+   */
+  resolveBuffer(parsed, bufferIndex) {
+    if (bufferIndex === 0 && parsed.binaryChunks.length > 0) {
+      return parsed.binaryChunks[0];
+    }
+    const gltf = parsed.json;
+    if (gltf.buffers && bufferIndex < gltf.buffers.length) {
+      const buffer = gltf.buffers[bufferIndex];
+      if (buffer.uri && buffer.uri.startsWith("data:")) {
+        return this.decodeDataUri(buffer.uri);
+      }
+    }
+    throw new CodecDecodeError(
+      this.codecId,
+      `Cannot resolve buffer [${bufferIndex}]: external URI buffers are not supported in synchronous decode. Use GLB format or data URIs for embedded data.`
+    );
+  }
+  /**
+   * Decode a data URI to an ArrayBuffer.
+   */
+  decodeDataUri(uri) {
+    const commaIndex = uri.indexOf(",");
+    if (commaIndex === -1) {
+      throw new CodecDecodeError(this.codecId, "Invalid data URI format");
+    }
+    const header = uri.substring(0, commaIndex);
+    const data = uri.substring(commaIndex + 1);
+    if (header.includes(";base64")) {
+      const binary = atob(data);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+      }
+      return bytes.buffer;
+    }
+    const decoded = decodeURIComponent(data);
+    const encoder = new TextEncoder();
+    return encoder.encode(decoded).buffer;
+  }
+  // ─── Private: Accessor Data Reading ─────────────────────────────────────
+  /**
+   * Read accessor data as a Float32Array.
+   *
+   * Handles component type conversion and normalization for:
+   *   - FLOAT: Direct read
+   *   - BYTE/SHORT (normalized): Scale to [-1, 1]
+   *   - UNSIGNED_BYTE/UNSIGNED_SHORT (normalized): Scale to [0, 1]
+   *   - BYTE/SHORT/UNSIGNED_BYTE/UNSIGNED_SHORT (non-normalized): Direct int-to-float
+   */
+  readAccessorFloat32(parsed, accessorIndex) {
+    const gltf = parsed.json;
+    if (!gltf.accessors || accessorIndex >= gltf.accessors.length) {
+      throw new CodecDecodeError(this.codecId, `Accessor index ${accessorIndex} is out of range`);
+    }
+    const accessor = gltf.accessors[accessorIndex];
+    const componentCount = GLTF_TYPE_SIZES[accessor.type] ?? 1;
+    const totalElements = accessor.count * componentCount;
+    const result = new Float32Array(totalElements);
+    if (accessor.bufferView === void 0) {
+      return result;
+    }
+    const bv = gltf.bufferViews[accessor.bufferView];
+    const bufferData = this.resolveBuffer(parsed, bv.buffer);
+    const byteOffset = (bv.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
+    const componentSize = GLTF_COMPONENT_SIZES[accessor.componentType] ?? 4;
+    const stride = bv.byteStride ?? componentCount * componentSize;
+    const dataView = new DataView(bufferData);
+    for (let i = 0; i < accessor.count; i++) {
+      const elementOffset = byteOffset + i * stride;
+      for (let c = 0; c < componentCount; c++) {
+        const compOffset = elementOffset + c * componentSize;
+        let value;
+        switch (accessor.componentType) {
+          case 5126 /* FLOAT */:
+            value = dataView.getFloat32(compOffset, true);
+            break;
+          case 5120 /* BYTE */:
+            value = dataView.getInt8(compOffset);
+            if (accessor.normalized) value = Math.max(value / 127, -1);
+            break;
+          case 5121 /* UNSIGNED_BYTE */:
+            value = dataView.getUint8(compOffset);
+            if (accessor.normalized) value = value / 255;
+            break;
+          case 5122 /* SHORT */:
+            value = dataView.getInt16(compOffset, true);
+            if (accessor.normalized) value = Math.max(value / 32767, -1);
+            break;
+          case 5123 /* UNSIGNED_SHORT */:
+            value = dataView.getUint16(compOffset, true);
+            if (accessor.normalized) value = value / 65535;
+            break;
+          case 5125 /* UNSIGNED_INT */:
+            value = dataView.getUint32(compOffset, true);
+            break;
+          default:
+            value = 0;
+        }
+        result[i * componentCount + c] = value;
+      }
+    }
+    return result;
+  }
+  // ─── Private: Baseline Decode ─────────────────────────────────────────────
+  /**
+   * Decode uncompressed KHR_gaussian_splatting attributes from glTF accessors.
+   */
+  decodeBaseline(parsed, gltf, primitive, gaussianExt, maxGaussians, maxMemoryMB, decodeSH, warnings) {
+    const attrs = primitive.attributes;
+    const posIndex = attrs["POSITION"];
+    if (posIndex === void 0) {
+      throw new CodecDecodeError(
+        this.codecId,
+        "Missing required POSITION attribute in Gaussian splatting primitive"
+      );
+    }
+    const posAccessor = gltf.accessors[posIndex];
+    const totalCount = posAccessor.count;
+    const N = Math.min(totalCount, maxGaussians);
+    if (N < totalCount) {
+      warnings.push(
+        `Clamped Gaussian count from ${totalCount.toLocaleString()} to ${N.toLocaleString()} (maxGaussians limit)`
+      );
+    }
+    this.checkMemoryBudget(N, maxMemoryMB);
+    const rawPositions = this.readAccessorFloat32(parsed, posIndex);
+    const positions = N < totalCount ? rawPositions.slice(0, N * 3) : rawPositions;
+    const rotIndex = attrs["KHR_gaussian_splatting:ROTATION"] ?? attrs["_ROTATION"];
+    let rotations;
+    if (rotIndex !== void 0) {
+      const rawRotations = this.readAccessorFloat32(parsed, rotIndex);
+      rotations = N < totalCount ? rawRotations.slice(0, N * 4) : rawRotations;
+    } else {
+      warnings.push("Missing ROTATION attribute; using identity quaternions");
+      rotations = new Float32Array(N * 4);
+      for (let i = 0; i < N; i++) {
+        rotations[i * 4 + 3] = 1;
+      }
+    }
+    const scaleIndex = attrs["KHR_gaussian_splatting:SCALE"] ?? attrs["_SCALE"];
+    let scales;
+    if (scaleIndex !== void 0) {
+      const rawScales = this.readAccessorFloat32(parsed, scaleIndex);
+      scales = new Float32Array(N * 3);
+      const count = Math.min(rawScales.length, N * 3);
+      for (let i = 0; i < count; i++) {
+        scales[i] = Math.exp(rawScales[i]);
+      }
+    } else {
+      warnings.push("Missing SCALE attribute; using uniform scale 0.01");
+      scales = new Float32Array(N * 3);
+      scales.fill(0.01);
+    }
+    const opacityIndex = attrs["KHR_gaussian_splatting:OPACITY"] ?? attrs["_OPACITY"];
+    let opacities;
+    if (opacityIndex !== void 0) {
+      const rawOpacities = this.readAccessorFloat32(parsed, opacityIndex);
+      opacities = N < totalCount ? rawOpacities.slice(0, N) : rawOpacities;
+    } else {
+      warnings.push("Missing OPACITY attribute; using full opacity (1.0)");
+      opacities = new Float32Array(N);
+      opacities.fill(1);
+    }
+    const colors = new Float32Array(N * 4);
+    const colorIndex = attrs["COLOR_0"];
+    const shDc0Index = attrs["KHR_gaussian_splatting:SH_DEGREE_0_COEF_0"] ?? attrs["_SH_DEGREE_0_COEF_0"];
+    if (colorIndex !== void 0) {
+      const rawColors = this.readAccessorFloat32(parsed, colorIndex);
+      const colorAccessor = gltf.accessors[colorIndex];
+      const colorComponents = GLTF_TYPE_SIZES[colorAccessor.type] ?? 4;
+      for (let i = 0; i < N; i++) {
+        if (colorComponents >= 3) {
+          colors[i * 4] = rawColors[i * colorComponents];
+          colors[i * 4 + 1] = rawColors[i * colorComponents + 1];
+          colors[i * 4 + 2] = rawColors[i * colorComponents + 2];
+        }
+        colors[i * 4 + 3] = colorComponents >= 4 ? rawColors[i * colorComponents + 3] : opacities[i];
+      }
+    } else if (shDc0Index !== void 0) {
+      const rawSh0 = this.readAccessorFloat32(parsed, shDc0Index);
+      for (let i = 0; i < N; i++) {
+        for (let c = 0; c < 3; c++) {
+          const shCoeff = rawSh0[i * 3 + c];
+          colors[i * 4 + c] = Math.max(0, Math.min(1, SH_C02 * shCoeff + SH_DC_BIAS));
+        }
+        colors[i * 4 + 3] = opacities[i];
+      }
+    } else {
+      warnings.push("No color or SH degree 0 data found; using mid-gray");
+      for (let i = 0; i < N; i++) {
+        colors[i * 4] = 0.5;
+        colors[i * 4 + 1] = 0.5;
+        colors[i * 4 + 2] = 0.5;
+        colors[i * 4 + 3] = opacities[i];
+      }
+    }
+    const colorSpace = gaussianExt.colorSpace ?? "srgb_rec709_display";
+    if (colorSpace === "lin_rec709_display") {
+      this.convertColorsLinearToSrgb(colors, N);
+      warnings.push("Converted linear RGB to sRGB for display");
+    }
+    let shCoefficients;
+    let shDegree = 0;
+    if (decodeSH) {
+      shDegree = this.detectShDegree(primitive);
+      if (shDegree > 0) {
+        const shDim = shDimForDegree2(shDegree);
+        shCoefficients = new Float32Array(N * shDim * 3);
+        let shOffset = 0;
+        for (let d = 1; d <= shDegree; d++) {
+          const coeffsPerDegree = 2 * d + 1;
+          for (let coef = 0; coef < coeffsPerDegree; coef++) {
+            const attrName = attrs[`KHR_gaussian_splatting:SH_DEGREE_${d}_COEF_${coef}`] ?? attrs[`_SH_DEGREE_${d}_COEF_${coef}`];
+            if (attrName !== void 0) {
+              const rawSh = this.readAccessorFloat32(parsed, attrName);
+              for (let i = 0; i < N; i++) {
+                for (let c = 0; c < 3; c++) {
+                  shCoefficients[(i * shDim + shOffset) * 3 + c] = rawSh[i * 3 + c];
+                }
+              }
+            }
+            shOffset++;
+          }
+        }
+      }
+    }
+    const data = {
+      positions,
+      scales,
+      rotations,
+      colors,
+      opacities,
+      shCoefficients,
+      shDegree,
+      count: N
+    };
+    return {
+      data,
+      durationMs: 0,
+      // Will be overridden by caller
+      warnings
+    };
+  }
+  // ─── Private: SH Degree Detection ─────────────────────────────────────────
+  /**
+   * Detect the highest SH degree present in a primitive's attributes.
+   */
+  detectShDegree(primitive) {
+    const attrs = primitive.attributes;
+    let degree = 0;
+    if (attrs["KHR_gaussian_splatting:SH_DEGREE_3_COEF_0"] !== void 0 || attrs["_SH_DEGREE_3_COEF_0"] !== void 0) {
+      degree = 3;
+    } else if (attrs["KHR_gaussian_splatting:SH_DEGREE_2_COEF_0"] !== void 0 || attrs["_SH_DEGREE_2_COEF_0"] !== void 0) {
+      degree = 2;
+    } else if (attrs["KHR_gaussian_splatting:SH_DEGREE_1_COEF_0"] !== void 0 || attrs["_SH_DEGREE_1_COEF_0"] !== void 0) {
+      degree = 1;
+    }
+    return degree;
+  }
+  // ─── Private: Color Space Conversion ──────────────────────────────────────
+  /**
+   * Convert color array from linear RGB to sRGB in-place.
+   */
+  convertColorsLinearToSrgb(colors, count) {
+    for (let i = 0; i < count; i++) {
+      colors[i * 4] = linearToSrgb(Math.max(0, Math.min(1, colors[i * 4])));
+      colors[i * 4 + 1] = linearToSrgb(Math.max(0, Math.min(1, colors[i * 4 + 1])));
+      colors[i * 4 + 2] = linearToSrgb(Math.max(0, Math.min(1, colors[i * 4 + 2])));
+    }
+  }
+};
+function shDimForDegree2(degree) {
+  switch (degree) {
+    case 0:
+      return 0;
+    case 1:
+      return 3;
+    case 2:
+      return 8;
+    case 3:
+      return 15;
+    default:
+      return 0;
+  }
+}
+
+// src/gpu/codecs/MpegGscCodec.ts
+var MPEG_GSC_MAGIC = 1296520003;
+var MpegGscCodec = class extends AbstractGaussianCodec {
+  codecId = "mpeg.gsc.v1";
+  // ─── Capabilities ─────────────────────────────────────────────────────────
+  getCapabilities() {
+    return {
+      id: this.codecId,
+      name: "MPEG Gaussian Splat Coding (Stub)",
+      version: "0.1.0-stub",
+      fileExtensions: [],
+      // TBD when standard is finalized
+      mimeTypes: [],
+      // TBD when standard is finalized
+      canEncode: false,
+      canDecode: false,
+      canStream: false,
+      canDecodeTemporal: false,
+      maxSHDegree: 3,
+      maxGaussianCount: -1,
+      // Unlimited (TBD)
+      requiresWasm: true,
+      // Likely will require WASM for HEVC decode
+      requiresWebGPU: false,
+      standard: "mpeg",
+      maturity: "stub"
+    };
+  }
+  // ─── Probe ────────────────────────────────────────────────────────────────
+  canDecode(buffer) {
+    if (buffer.byteLength < 4) return false;
+    const view = new DataView(buffer);
+    return view.getUint32(0, true) === MPEG_GSC_MAGIC;
+  }
+  // ─── Extract Metadata (Stub) ──────────────────────────────────────────────
+  async extractMetadata(_buffer) {
+    throw new CodecNotSupportedError(
+      this.codecId,
+      "extractMetadata (MPEG GSC standard is not yet finalized)"
+    );
+  }
+  // ─── Decode (Stub) ────────────────────────────────────────────────────────
+  async decode(_buffer, _options) {
+    throw new CodecNotSupportedError(
+      this.codecId,
+      "decode (MPEG GSC standard is not yet finalized - currently in MPEG Exploration phase as of 2026-03-01)"
+    );
+  }
+  // ─── Decompress (Stub) ────────────────────────────────────────────────────
+  async decompress(_compressed) {
+    throw new CodecNotSupportedError(
+      this.codecId,
+      "decompress (MPEG GSC standard is not yet finalized)"
+    );
+  }
+  // ─── Informational Methods ────────────────────────────────────────────────
+  /**
+   * Get the current standardization status of MPEG GSC.
+   *
+   * This method is specific to the MPEG stub and provides context about
+   * when the full implementation can be expected.
+   */
+  getStandardizationStatus() {
+    return {
+      phase: "exploration",
+      workingGroups: ["WG4", "WG5", "WG7"],
+      lastMeetingDate: "2026-01-23",
+      lastMeetingName: "41st JVET / 153rd MPEG",
+      compressionApproaches: [
+        "GPCC v1 (Geometry-based Point Cloud Compression)",
+        "HEVC (High Efficiency Video Coding) for attribute maps",
+        "Custom Gaussian-specific entropy coding"
+      ],
+      expectedTimeline: "TBD - no formal standardization kicked off",
+      referenceUrl: "https://mpeg.expert/gsc/index.html"
+    };
+  }
+  /**
+   * Check if a newer version of the MPEG GSC codec is available.
+   *
+   * In the future, this could check a remote registry for codec updates.
+   * For now, it always returns false since the standard is not finalized.
+   */
+  async checkForUpdates() {
+    return false;
+  }
+};
+
+// src/gpu/codecs/GaussianCodecRegistry.ts
+var GaussianCodecRegistry = class {
+  codecs = /* @__PURE__ */ new Map();
+  // ─── Registration ─────────────────────────────────────────────────────────
+  /**
+   * Register a codec with the registry.
+   *
+   * @param codec - Codec instance to register
+   * @param priority - Priority for codec selection (default: 0, higher = preferred)
+   * @returns The registry instance (for chaining)
+   */
+  register(codec, priority = 0) {
+    const capabilities = codec.getCapabilities();
+    this.codecs.set(capabilities.id, {
+      codec,
+      capabilities,
+      priority,
+      initialized: false
+    });
+    return this;
+  }
+  /**
+   * Unregister a codec by ID.
+   *
+   * @param codecId - ID of the codec to unregister
+   * @returns true if the codec was found and removed
+   */
+  unregister(codecId) {
+    const entry = this.codecs.get(codecId);
+    if (entry) {
+      entry.codec.dispose();
+      this.codecs.delete(codecId);
+      return true;
+    }
+    return false;
+  }
+  // ─── Codec Access ─────────────────────────────────────────────────────────
+  /**
+   * Get a specific codec by ID.
+   *
+   * @param codecId - Codec identifier
+   * @returns The codec instance, or undefined if not registered
+   */
+  getCodec(codecId) {
+    return this.codecs.get(codecId)?.codec;
+  }
+  /**
+   * Get a specific codec by ID, throwing if not found.
+   *
+   * @param codecId - Codec identifier
+   * @returns The codec instance
+   * @throws Error if the codec is not registered
+   */
+  requireCodec(codecId) {
+    const codec = this.getCodec(codecId);
+    if (!codec) {
+      throw new Error(
+        `Codec '${codecId}' is not registered. Available codecs: ${this.getRegisteredIds().join(", ")}`
+      );
+    }
+    return codec;
+  }
+  /**
+   * Get all registered codec IDs.
+   */
+  getRegisteredIds() {
+    return Array.from(this.codecs.keys());
+  }
+  /**
+   * Get capabilities of all registered codecs.
+   */
+  getAllCapabilities() {
+    return Array.from(this.codecs.values()).map((entry) => entry.capabilities);
+  }
+  /**
+   * Check if a specific codec is registered.
+   */
+  hasCodec(codecId) {
+    return this.codecs.has(codecId);
+  }
+  // ─── Auto-Detection ───────────────────────────────────────────────────────
+  /**
+   * Auto-detect the best codec for a given file.
+   *
+   * Detection priority:
+   *   1. Explicit codecId in options (bypass detection)
+   *   2. Magic byte detection from headerBytes
+   *   3. File extension detection from URL
+   *   4. Priority-based fallback among matching codecs
+   *
+   * @param options - Detection options (URL, header bytes, etc.)
+   * @returns Best-matching codec, or undefined if no codec can handle the file
+   */
+  detectCodec(options) {
+    if (options.codecId) {
+      return this.getCodec(options.codecId);
+    }
+    const candidates = [];
+    if (options.headerBytes) {
+      for (const entry of this.codecs.values()) {
+        if (this.matchesMaturity(entry, options.maturityFilter)) {
+          if (entry.codec.canDecode(options.headerBytes)) {
+            candidates.push(entry);
+          }
+        }
+      }
+    }
+    if (candidates.length === 0 && options.url) {
+      const ext = this.extractExtension(options.url);
+      if (ext) {
+        for (const entry of this.codecs.values()) {
+          if (this.matchesMaturity(entry, options.maturityFilter)) {
+            if (entry.capabilities.fileExtensions.includes(ext)) {
+              candidates.push(entry);
+            }
+          }
+        }
+      }
+    }
+    if (candidates.length === 0) return void 0;
+    candidates.sort((a, b) => b.priority - a.priority);
+    return candidates[0].codec;
+  }
+  /**
+   * Auto-detect and decode a buffer.
+   *
+   * Convenience method that combines detection and decode in one call.
+   *
+   * @param buffer - Raw binary data
+   * @param options - Decode options + detection options
+   * @returns Decoded Gaussian data
+   * @throws Error if no codec can handle the data
+   */
+  async decode(buffer, options) {
+    const codec = this.detectCodec({
+      codecId: options?.codecId,
+      headerBytes: buffer.slice(0, Math.min(buffer.byteLength, 64)),
+      url: options?.url,
+      maturityFilter: options?.maturityFilter
+    });
+    if (!codec) {
+      throw new Error(
+        `No codec found that can decode this data. Registered codecs: ${this.getRegisteredIds().join(", ")}. Ensure the correct codec is registered or specify codecId explicitly.`
+      );
+    }
+    await this.ensureInitialized(codec);
+    return codec.decode(buffer, options);
+  }
+  /**
+   * Auto-detect codec from URL and decode via streaming.
+   *
+   * @param url - URL to fetch and decode
+   * @param options - Decode and detection options
+   * @returns Decoded Gaussian data
+   */
+  async decodeFromUrl(url, options) {
+    const codec = this.detectCodec({
+      codecId: options?.codecId,
+      url,
+      maturityFilter: options?.maturityFilter ?? ["production", "beta"]
+    });
+    if (!codec) {
+      throw new Error(
+        `No codec found for URL '${url}'. Registered codecs: ${this.getRegisteredIds().join(", ")}`
+      );
+    }
+    await this.ensureInitialized(codec);
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText} for ${url}`);
+    }
+    const buffer = await response.arrayBuffer();
+    return codec.decode(buffer, options);
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  /**
+   * Initialize all registered codecs.
+   *
+   * Useful for pre-warming at application startup.
+   */
+  async initializeAll() {
+    const entries = Array.from(this.codecs.values());
+    await Promise.all(
+      entries.map(async (entry) => {
+        if (!entry.initialized) {
+          await entry.codec.initialize();
+          entry.initialized = true;
+        }
+      })
+    );
+  }
+  /**
+   * Dispose all registered codecs and clear the registry.
+   */
+  disposeAll() {
+    for (const entry of this.codecs.values()) {
+      entry.codec.dispose();
+    }
+    this.codecs.clear();
+  }
+  // ─── Private Helpers ──────────────────────────────────────────────────────
+  async ensureInitialized(codec) {
+    const id = codec.getCapabilities().id;
+    const entry = this.codecs.get(id);
+    if (entry && !entry.initialized) {
+      await codec.initialize();
+      entry.initialized = true;
+    }
+  }
+  extractExtension(url) {
+    const clean = url.split(/[?#]/)[0];
+    const ext = clean.split(".").pop()?.toLowerCase();
+    return ext;
+  }
+  matchesMaturity(entry, filter) {
+    if (!filter) return true;
+    return filter.includes(entry.capabilities.maturity);
+  }
+};
+function createDefaultCodecRegistry() {
+  const registry = new GaussianCodecRegistry();
+  registry.register(new SpzCodec(), 100);
+  registry.register(new GltfGaussianSplatCodec(), 50);
+  registry.register(new MpegGscCodec(), 0);
+  return registry;
+}
+var globalRegistry = null;
+function getGlobalCodecRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = createDefaultCodecRegistry();
+  }
+  return globalRegistry;
+}
+function resetGlobalCodecRegistry() {
+  if (globalRegistry) {
+    globalRegistry.disposeAll();
+    globalRegistry = null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractGaussianCodec,
+  CodecDecodeError,
+  CodecDecompressError,
+  CodecEncodeError,
+  CodecMemoryError,
+  CodecNotSupportedError,
+  ComputePipeline,
+  GPUBufferManager,
+  GaussianCodecError,
+  GaussianCodecRegistry,
+  GaussianSplatExtractor,
+  GaussianSplatSorter,
+  GltfGaussianSplatCodec,
+  InstancedRenderer,
+  MpegGscCodec,
+  SparseLinearSolver,
+  SpatialGrid,
+  SpzCodec,
+  WebGPUContext,
+  createDefaultCodecRegistry,
+  createGPUPhysicsSimulation,
+  createGaussianSplatSorter,
+  createInitialParticleData,
+  createPhysicsSimulation,
+  getGlobalCodecRegistry,
+  getGlobalWebGPUContext,
+  resetGlobalCodecRegistry
+});