@holoscript/core 8.0.0 → 8.0.2

package/dist/dist-ACXG6IH5.cjs

@@ -0,0 +1,3113 @@
+'use strict';
+
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// ../snn-webgpu/dist/index.js
+var __require2 = /* @__PURE__ */ ((x) => typeof chunkHCCQLAA4_cjs.__require !== "undefined" ? chunkHCCQLAA4_cjs.__require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof chunkHCCQLAA4_cjs.__require !== "undefined" ? chunkHCCQLAA4_cjs.__require : a)[b]
+}) : x)(function(x) {
+  if (typeof chunkHCCQLAA4_cjs.__require !== "undefined") return chunkHCCQLAA4_cjs.__require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var _bootstrapAttempted = false;
+var _bootstrapResult = false;
+function ensureNodeWebGpuSync() {
+  if (typeof globalThis.window !== "undefined") return false;
+  if (_bootstrapAttempted) return _bootstrapResult;
+  _bootstrapAttempted = true;
+  try {
+    const mod = __require2("webgpu");
+    const gpu = typeof mod.create === "function" ? mod.create([]) : void 0;
+    if (gpu && typeof gpu.requestAdapter === "function") {
+      const g = globalThis;
+      g.navigator ?? (g.navigator = {});
+      g.navigator.gpu = gpu;
+      installMissingWebGpuGlobals(mod.globals ?? {});
+      _bootstrapResult = true;
+      return true;
+    }
+  } catch {
+  }
+  return _bootstrapResult;
+}
+async function ensureNodeWebGpu() {
+  if (typeof globalThis.window !== "undefined") return false;
+  if (_bootstrapAttempted) return _bootstrapResult;
+  if (ensureNodeWebGpuSync()) return true;
+  try {
+    const mod = await import('webgpu');
+    const gpu = typeof mod.create === "function" ? mod.create([]) : void 0;
+    if (gpu && typeof gpu.requestAdapter === "function") {
+      const g = globalThis;
+      g.navigator ?? (g.navigator = {});
+      g.navigator.gpu = gpu;
+      installMissingWebGpuGlobals(mod.globals ?? {});
+      _bootstrapResult = true;
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function installMissingWebGpuGlobals(globals) {
+  const target = globalThis;
+  for (const [key, value] of Object.entries(globals)) {
+    if (target[key] != null) continue;
+    Object.defineProperty(globalThis, key, {
+      value,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+var EncodingMode = /* @__PURE__ */ ((EncodingMode2) => {
+  EncodingMode2[EncodingMode2["Rate"] = 0] = "Rate";
+  EncodingMode2[EncodingMode2["Temporal"] = 1] = "Temporal";
+  EncodingMode2[EncodingMode2["Delta"] = 2] = "Delta";
+  return EncodingMode2;
+})(EncodingMode || {});
+var DecodingMode = /* @__PURE__ */ ((DecodingMode2) => {
+  DecodingMode2[DecodingMode2["Rate"] = 0] = "Rate";
+  DecodingMode2[DecodingMode2["Temporal"] = 1] = "Temporal";
+  DecodingMode2[DecodingMode2["Population"] = 2] = "Population";
+  DecodingMode2[DecodingMode2["FirstSpike"] = 3] = "FirstSpike";
+  return DecodingMode2;
+})(DecodingMode || {});
+var DEFAULT_LIF_PARAMS = {
+  tau: 20,
+  vThreshold: -55,
+  vReset: -75,
+  vRest: -65,
+  dt: 1
+};
+var DEFAULT_ENCODE_PARAMS = {
+  timeWindow: 100,
+  encodingMode: 0,
+  seed: 42,
+  minValue: 0,
+  maxValue: 1,
+  deltaThreshold: 0.1
+};
+var DEFAULT_DECODE_PARAMS = {
+  decodingMode: 0,
+  populationSize: 10,
+  outputMin: 0,
+  outputMax: 1
+};
+function computeDispatchSize(count, workgroupSize = 256) {
+  return Math.ceil(count / workgroupSize);
+}
+var GPUContext = class {
+  constructor() {
+    this._device = null;
+    this._adapter = null;
+    this._capabilities = null;
+    this._destroyed = false;
+  }
+  /** The active GPUDevice. Throws if not initialized. */
+  get device() {
+    if (!this._device || this._destroyed) {
+      throw new Error("GPUContext not initialized. Call initialize() first.");
+    }
+    return this._device;
+  }
+  /** The active GPUAdapter. Throws if not initialized. */
+  get adapter() {
+    if (!this._adapter || this._destroyed) {
+      throw new Error("GPUContext not initialized. Call initialize() first.");
+    }
+    return this._adapter;
+  }
+  /** GPU capabilities detected during initialization. */
+  get capabilities() {
+    if (!this._capabilities) {
+      throw new Error("GPUContext not initialized. Call initialize() first.");
+    }
+    return this._capabilities;
+  }
+  /** Whether the context has been initialized. */
+  get isInitialized() {
+    return this._device !== null && !this._destroyed;
+  }
+  /**
+   * Initialize the WebGPU context.
+   * Requests an adapter and device with the specified options.
+   */
+  async initialize(options = {}) {
+    if (this._destroyed) {
+      throw new Error("GPUContext has been destroyed and cannot be reinitialized.");
+    }
+    if (this._device) {
+      return;
+    }
+    await ensureNodeWebGpu();
+    if (typeof navigator === "undefined" || !navigator.gpu) {
+      throw new Error(
+        "WebGPU is not supported in this environment. Ensure you are running in a WebGPU-capable browser or Node.js with the `webgpu` binding installed."
+      );
+    }
+    const powerPreference = options.powerPreference ?? "high-performance";
+    const adapter = await navigator.gpu.requestAdapter({
+      powerPreference
+    });
+    if (!adapter) {
+      throw new Error(
+        "Failed to obtain a WebGPU adapter. Check that your GPU drivers are up to date and WebGPU is enabled."
+      );
+    }
+    this._adapter = adapter;
+    const requiredLimits = {};
+    const maxBufferSize = options.maxBufferSize ?? 256 * 1024 * 1024;
+    const maxStorageBufferBindingSize = options.maxStorageBufferBindingSize ?? 128 * 1024 * 1024;
+    requiredLimits.maxBufferSize = Math.min(maxBufferSize, adapter.limits.maxBufferSize);
+    requiredLimits.maxStorageBufferBindingSize = Math.min(
+      maxStorageBufferBindingSize,
+      adapter.limits.maxStorageBufferBindingSize
+    );
+    const requiredFeatures = [...options.requiredFeatures ?? []];
+    if (options.enableTimestamps && adapter.features.has("timestamp-query")) {
+      requiredFeatures.push("timestamp-query");
+    }
+    const device = await adapter.requestDevice({
+      label: options.label ?? "snn-webgpu-device",
+      requiredFeatures,
+      requiredLimits
+    });
+    device.lost.then((info) => {
+      console.error(`[snn-webgpu] GPU device lost: ${info.message} (reason: ${info.reason})`);
+      this._device = null;
+      this._destroyed = true;
+    });
+    this._device = device;
+    const adapterExt = adapter;
+    const adapterInfo = adapterExt.info ?? (typeof adapterExt.requestAdapterInfo === "function" ? await adapterExt.requestAdapterInfo() : { vendor: "unknown", architecture: "unknown" });
+    this._capabilities = {
+      maxWorkgroupSize: [
+        device.limits.maxComputeWorkgroupSizeX,
+        device.limits.maxComputeWorkgroupSizeY,
+        device.limits.maxComputeWorkgroupSizeZ
+      ],
+      maxWorkgroupsPerDimension: device.limits.maxComputeWorkgroupsPerDimension,
+      maxStorageBufferBindingSize: device.limits.maxStorageBufferBindingSize,
+      maxBufferSize: device.limits.maxBufferSize,
+      maxComputeInvocationsPerWorkgroup: device.limits.maxComputeInvocationsPerWorkgroup,
+      timestampQuerySupported: device.features.has("timestamp-query"),
+      vendor: adapterInfo.vendor ?? "unknown",
+      architecture: adapterInfo.architecture ?? "unknown"
+    };
+  }
+  /**
+   * Create a compute shader module from WGSL source code.
+   */
+  createShaderModule(code, label) {
+    return this.device.createShaderModule({
+      label: label ?? "snn-compute-shader",
+      code
+    });
+  }
+  /**
+   * Create a compute pipeline from a shader module and entry point.
+   */
+  createComputePipeline(module, entryPoint, layout = "auto", label) {
+    return this.device.createComputePipeline({
+      label: label ?? `compute-pipeline-${entryPoint}`,
+      layout,
+      compute: {
+        module,
+        entryPoint
+      }
+    });
+  }
+  /**
+   * Create a compute pipeline asynchronously.
+   * Avoids stalling the main/render thread during driver shader compilation.
+   * Prefer this over createComputePipeline for first-time pipeline creation.
+   */
+  async createComputePipelineAsync(module, entryPoint, layout = "auto", label) {
+    return this.device.createComputePipelineAsync({
+      label: label ?? `compute-pipeline-async-${entryPoint}`,
+      layout,
+      compute: {
+        module,
+        entryPoint
+      }
+    });
+  }
+  /**
+   * Submit a command buffer and wait for completion.
+   */
+  async submitAndWait(commandBuffer) {
+    this.device.queue.submit([commandBuffer]);
+    await this.device.queue.onSubmittedWorkDone();
+  }
+  /**
+   * Validate that the context can handle the given neuron count.
+   * Returns the maximum dispatchable neuron count.
+   */
+  validateNeuronCapacity(requestedCount, workgroupSize = 256) {
+    const caps = this.capabilities;
+    const maxWorkgroups = caps.maxWorkgroupsPerDimension;
+    const maxNeurons = maxWorkgroups * workgroupSize;
+    if (requestedCount > maxNeurons) {
+      console.warn(
+        `[snn-webgpu] Requested ${requestedCount} neurons exceeds GPU limit of ${maxNeurons}. Clamping to ${maxNeurons}.`
+      );
+      return maxNeurons;
+    }
+    return requestedCount;
+  }
+  /**
+   * Destroy the GPU context and release all resources.
+   */
+  destroy() {
+    if (this._device && !this._destroyed) {
+      this._device.destroy();
+      this._device = null;
+      this._adapter = null;
+      this._capabilities = null;
+      this._destroyed = true;
+    }
+  }
+};
+var BufferManager = class {
+  constructor(device) {
+    this.buffers = /* @__PURE__ */ new Map();
+    this.stagingBuffers = [];
+    this.device = device;
+  }
+  /**
+   * Create a GPU buffer and register it with the manager.
+   */
+  createBuffer(options) {
+    const { size, usage, label, initialData, mappedAtCreation } = options;
+    const alignedSize = Math.ceil(size / 4) * 4;
+    const buffer = this.device.createBuffer({
+      label: label ?? `snn-buffer-${this.buffers.size}`,
+      size: alignedSize,
+      usage,
+      mappedAtCreation: mappedAtCreation ?? !!initialData
+    });
+    if (initialData) {
+      const mapped = new Float32Array(buffer.getMappedRange());
+      mapped.set(
+        initialData instanceof Float32Array ? initialData : new Float32Array(initialData.buffer)
+      );
+      buffer.unmap();
+    }
+    const handle = {
+      buffer,
+      size: alignedSize,
+      label: label ?? `snn-buffer-${this.buffers.size}`
+    };
+    if (label) {
+      this.buffers.set(label, handle);
+    }
+    return handle;
+  }
+  /**
+   * Create a uniform buffer with initial data.
+   */
+  createUniformBuffer(data, label) {
+    const alignedSize = Math.ceil(data.byteLength / 16) * 16;
+    return this.createBuffer({
+      size: alignedSize,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      label: label ?? "uniform-buffer",
+      initialData: new Float32Array(data)
+    });
+  }
+  /**
+   * Create a storage buffer (read/write).
+   */
+  createStorageBuffer(sizeOrData, label, _readOnly = false) {
+    const isData = sizeOrData instanceof Float32Array;
+    const size = isData ? sizeOrData.byteLength : sizeOrData;
+    return this.createBuffer({
+      size,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+      label: label ?? "storage-buffer",
+      initialData: isData ? sizeOrData : void 0,
+      mappedAtCreation: isData
+    });
+  }
+  /**
+   * Create a zero-initialized storage buffer.
+   */
+  createZeroBuffer(elementCount, label) {
+    const data = new Float32Array(elementCount);
+    return this.createStorageBuffer(data, label);
+  }
+  /**
+   * Write data to an existing buffer via queue.writeBuffer.
+   */
+  writeBuffer(handle, data, offset = 0) {
+    this.device.queue.writeBuffer(
+      handle.buffer,
+      offset,
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+  }
+  /**
+   * Async readback: copy GPU buffer contents to CPU.
+   * Creates a staging buffer, copies, maps, and reads.
+   */
+  async readBuffer(handle, byteOffset = 0, byteLength) {
+    const readSize = byteLength ?? handle.size;
+    const start = performance.now();
+    const staging = this.device.createBuffer({
+      label: `staging-${handle.label}`,
+      size: readSize,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+    this.stagingBuffers.push(staging);
+    const encoder = this.device.createCommandEncoder({
+      label: `readback-${handle.label}`
+    });
+    encoder.copyBufferToBuffer(handle.buffer, byteOffset, staging, 0, readSize);
+    this.device.queue.submit([encoder.finish()]);
+    await staging.mapAsync(GPUMapMode.READ);
+    const mappedRange = staging.getMappedRange();
+    const data = new Float32Array(mappedRange.slice(0));
+    staging.unmap();
+    const readbackTimeMs = performance.now() - start;
+    return { data, readbackTimeMs };
+  }
+  /**
+   * Get a previously created buffer by label.
+   */
+  getBuffer(label) {
+    return this.buffers.get(label);
+  }
+  /**
+   * Check if a buffer exists with the given label.
+   */
+  hasBuffer(label) {
+    return this.buffers.has(label);
+  }
+  /**
+   * Destroy a single buffer.
+   */
+  destroyBuffer(label) {
+    const handle = this.buffers.get(label);
+    if (handle) {
+      handle.buffer.destroy();
+      this.buffers.delete(label);
+    }
+  }
+  /**
+   * Destroy all managed buffers and staging buffers.
+   */
+  destroyAll() {
+    for (const handle of this.buffers.values()) {
+      handle.buffer.destroy();
+    }
+    this.buffers.clear();
+    for (const staging of this.stagingBuffers) {
+      staging.destroy();
+    }
+    this.stagingBuffers = [];
+  }
+  /**
+   * Get total allocated GPU memory in bytes.
+   */
+  getTotalAllocatedBytes() {
+    let total = 0;
+    for (const handle of this.buffers.values()) {
+      total += handle.size;
+    }
+    for (const staging of this.stagingBuffers) {
+      total += staging.size;
+    }
+    return total;
+  }
+  /**
+   * Get the number of managed buffers.
+   */
+  get bufferCount() {
+    return this.buffers.size;
+  }
+};
+var lif_neuron_default = "// Leaky Integrate-and-Fire (LIF) Neuron Compute Shader\n// Processes membrane potential updates for N neurons per dispatch.\n//\n// Model:  V[t+1] = V[t] * decay + I_syn[t]\n//         if V[t+1] >= V_thresh => spike=1, V[t+1] = V_reset\n//         else spike=0\n//\n// decay = exp(-dt / tau)\n\nstruct LIFParams {\n    tau: f32,            // Membrane time constant (ms)\n    v_threshold: f32,    // Spike threshold voltage (mV)\n    v_reset: f32,        // Reset voltage after spike (mV)\n    v_rest: f32,         // Resting membrane potential (mV)\n    dt: f32,             // Timestep (ms)\n    neuron_count: u32,   // Total neuron count\n    _pad0: u32,\n    _pad1: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: LIFParams;\n\n// Membrane potentials: read/write per neuron\n@group(0) @binding(1) var<storage, read_write> membrane_v: array<f32>;\n\n// Synaptic input currents (computed by weight shader): read-only\n@group(0) @binding(2) var<storage, read> synaptic_input: array<f32>;\n\n// Output spike flags: 1.0 = spiked, 0.0 = no spike\n@group(0) @binding(3) var<storage, read_write> spikes: array<f32>;\n\n// Refractory period counter (timesteps remaining)\n@group(0) @binding(4) var<storage, read_write> refractory: array<f32>;\n\nconst WORKGROUP_SIZE: u32 = 256u;\nconst REFRACTORY_PERIOD: f32 = 2.0; // ms\n\n@compute @workgroup_size(256)\nfn lif_step(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let idx = gid.x;\n    if (idx >= params.neuron_count) {\n        return;\n    }\n\n    let i = idx;\n\n    // Read current state\n    var v = membrane_v[i];\n    let i_syn = synaptic_input[i];\n    var ref_timer = refractory[i];\n\n    // Compute exponential decay factor: exp(-dt/tau)\n    let decay = exp(-params.dt / params.tau);\n\n    // Check refractory period\n    if (ref_timer > 0.0) {\n        // Neuron is in refractory period - clamp to reset\n        ref_timer = ref_timer - params.dt;\n        refractory[i] = max(ref_timer, 0.0);\n        membrane_v[i] = params.v_reset;\n        spikes[i] = 0.0;\n        return;\n    }\n\n    // Leaky integration step\n    // V(t+1) = V_rest + (V(t) - V_rest) * decay + I_syn\n    v = params.v_rest + (v - params.v_rest) * decay + i_syn;\n\n    // Threshold check\n    if (v >= params.v_threshold) {\n        // Spike!\n        spikes[i] = 1.0;\n        membrane_v[i] = params.v_reset;\n        refractory[i] = REFRACTORY_PERIOD;\n    } else {\n        spikes[i] = 0.0;\n        membrane_v[i] = v;\n    }\n}\n\n// Variant: batch update for multiple timesteps within a single dispatch\n// Useful for offline simulation where latency matters less than throughput.\n@compute @workgroup_size(256)\nfn lif_step_batch(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let idx = gid.x;\n    if (idx >= params.neuron_count) {\n        return;\n    }\n\n    let i = idx;\n    var v = membrane_v[i];\n    let i_syn = synaptic_input[i];\n    var ref_timer = refractory[i];\n    let decay = exp(-params.dt / params.tau);\n\n    // Process 4 sub-steps per dispatch for higher temporal resolution\n    for (var step = 0u; step < 4u; step = step + 1u) {\n        if (ref_timer > 0.0) {\n            ref_timer = ref_timer - params.dt;\n            v = params.v_reset;\n        } else {\n            v = params.v_rest + (v - params.v_rest) * decay + i_syn * 0.25;\n\n            if (v >= params.v_threshold) {\n                spikes[i] = 1.0;\n                v = params.v_reset;\n                ref_timer = REFRACTORY_PERIOD;\n            }\n        }\n    }\n\n    membrane_v[i] = v;\n    refractory[i] = max(ref_timer, 0.0);\n}\n";
+var synaptic_weights_default = "// Synaptic Weight Matrix Multiplication Compute Shader\n//\n// Computes I_syn[j] = sum_i( W[j,i] * spike[i] ) for all post-synaptic neurons j.\n// This is a sparse-friendly matrix-vector product: spike vectors are binary (0/1),\n// so we can skip zero-valued multiplications.\n//\n// Layout: W is stored row-major, where row j = weights FROM all pre-synaptic neurons TO neuron j.\n// Weight matrix is [post_count x pre_count].\n\nstruct SynapticParams {\n    pre_count: u32,      // Number of pre-synaptic neurons (columns)\n    post_count: u32,     // Number of post-synaptic neurons (rows)\n    learning_rate: f32,  // STDP learning rate\n    _pad0: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: SynapticParams;\n\n// Weight matrix: [post_count * pre_count] row-major\n@group(0) @binding(1) var<storage, read_write> weights: array<f32>;\n\n// Pre-synaptic spikes (binary): [pre_count]\n@group(0) @binding(2) var<storage, read> pre_spikes: array<f32>;\n\n// Output: post-synaptic currents: [post_count]\n@group(0) @binding(3) var<storage, read_write> post_currents: array<f32>;\n\n// Post-synaptic spikes (for STDP): [post_count]\n@group(0) @binding(4) var<storage, read> post_spikes: array<f32>;\n\nconst TILE_SIZE: u32 = 256u;\n\n// Main synaptic current computation: I_post[j] = sum( W[j,i] * spike_pre[i] )\n@compute @workgroup_size(256)\nfn compute_synaptic_current(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let j = gid.x;  // post-synaptic neuron index\n    if (j >= params.post_count) {\n        return;\n    }\n\n    var current: f32 = 0.0;\n    let row_offset = j * params.pre_count;\n\n    // Accumulate weighted pre-synaptic spikes\n    for (var i = 0u; i < params.pre_count; i = i + 1u) {\n        let spike = pre_spikes[i];\n        // Skip if no spike (optimization for sparse spike trains)\n        if (spike > 0.5) {\n            current = current + weights[row_offset + i];\n        }\n    }\n\n    post_currents[j] = current;\n}\n\n// Tiled version for better memory coalescing on large networks\n@compute @workgroup_size(256)\nfn compute_synaptic_current_tiled(\n    @builtin(global_invocation_id) gid: vec3<u32>,\n    @builtin(local_invocation_id) lid: vec3<u32>,\n    @builtin(workgroup_id) wid: vec3<u32>\n) {\n    let j = gid.x;\n    if (j >= params.post_count) {\n        return;\n    }\n\n    var current: f32 = 0.0;\n    let row_offset = j * params.pre_count;\n\n    // Process pre-synaptic neurons in tiles for cache efficiency\n    let num_tiles = (params.pre_count + TILE_SIZE - 1u) / TILE_SIZE;\n\n    for (var tile = 0u; tile < num_tiles; tile = tile + 1u) {\n        let tile_start = tile * TILE_SIZE;\n        let tile_end = min(tile_start + TILE_SIZE, params.pre_count);\n\n        for (var i = tile_start; i < tile_end; i = i + 1u) {\n            let spike = pre_spikes[i];\n            if (spike > 0.5) {\n                current = current + weights[row_offset + i];\n            }\n        }\n    }\n\n    post_currents[j] = current;\n}\n\n// STDP (Spike-Timing-Dependent Plasticity) weight update\n// dW = lr * (pre_spike * post_spike - post_spike * pre_spike * alpha)\n// Simplified Hebbian: if both pre and post spike, strengthen; else weaken slightly\n@compute @workgroup_size(256)\nfn stdp_weight_update(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let j = gid.x;  // post-synaptic neuron\n    if (j >= params.post_count) {\n        return;\n    }\n\n    let post_spike = post_spikes[j];\n    let row_offset = j * params.pre_count;\n    let lr = params.learning_rate;\n\n    for (var i = 0u; i < params.pre_count; i = i + 1u) {\n        let pre_spike = pre_spikes[i];\n        let w = weights[row_offset + i];\n\n        // Hebbian: strengthen if both spike\n        var dw: f32 = 0.0;\n        if (pre_spike > 0.5 && post_spike > 0.5) {\n            // LTP (Long-Term Potentiation)\n            dw = lr * (1.0 - w);  // Soft-bounded towards 1.0\n        } else if (pre_spike > 0.5 && post_spike < 0.5) {\n            // LTD (Long-Term Depression)\n            dw = -lr * 0.5 * w;   // Soft-bounded towards 0.0\n        }\n\n        // Clamp weights to [0, 1]\n        weights[row_offset + i] = clamp(w + dw, 0.0, 1.0);\n    }\n}\n";
+var spike_encode_default = "// Spike Encoding Compute Shader\n//\n// Converts continuous spatial data (positions, velocities, sensor readings)\n// into spike trains using various encoding schemes:\n//   1. Rate coding: firing probability proportional to input magnitude\n//   2. Temporal coding: spike time inversely proportional to input magnitude\n//   3. Delta coding: spikes on significant changes\n//\n// Input data is normalized to [0, 1] range before encoding.\n\nstruct EncodeParams {\n    data_count: u32,     // Number of input data points\n    time_window: u32,    // Number of time bins in the encoding window\n    encoding_mode: u32,  // 0=rate, 1=temporal, 2=delta\n    seed: u32,           // RNG seed for rate coding\n    min_value: f32,      // Input range minimum (for normalization)\n    max_value: f32,      // Input range maximum (for normalization)\n    delta_threshold: f32,// Threshold for delta coding\n    _pad0: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: EncodeParams;\n\n// Continuous input data: [data_count]\n@group(0) @binding(1) var<storage, read> input_data: array<f32>;\n\n// Previous input data (for delta coding): [data_count]\n@group(0) @binding(2) var<storage, read_write> prev_data: array<f32>;\n\n// Output spike train: [data_count * time_window]\n// Row-major: spike_train[neuron * time_window + t]\n@group(0) @binding(3) var<storage, read_write> spike_train: array<f32>;\n\n// PCG-based pseudo-random number generator\nfn pcg_hash(input: u32) -> u32 {\n    var state = input * 747796405u + 2891336453u;\n    var word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;\n    return (word >> 22u) ^ word;\n}\n\nfn random_f32(seed: u32, idx: u32, t: u32) -> f32 {\n    let hash = pcg_hash(seed ^ (idx * 1973u + t * 9277u + 1u));\n    return f32(hash) / 4294967295.0;\n}\n\n// Normalize input value to [0, 1]\nfn normalize(value: f32) -> f32 {\n    let range = params.max_value - params.min_value;\n    if (range < 0.0001) {\n        return 0.5;\n    }\n    return clamp((value - params.min_value) / range, 0.0, 1.0);\n}\n\n// Rate coding: spike probability = normalized input value\n@compute @workgroup_size(256)\nfn encode_rate(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let idx = gid.x;\n    if (idx >= params.data_count) {\n        return;\n    }\n\n    let value = normalize(input_data[idx]);\n    let base_offset = idx * params.time_window;\n\n    // Generate spike train based on firing rate\n    for (var t = 0u; t < params.time_window; t = t + 1u) {\n        let r = random_f32(params.seed, idx, t);\n        if (r < value) {\n            spike_train[base_offset + t] = 1.0;\n        } else {\n            spike_train[base_offset + t] = 0.0;\n        }\n    }\n\n    // Store for delta coding reference\n    prev_data[idx] = input_data[idx];\n}\n\n// Temporal coding: earlier spike = stronger stimulus\n// Spike at time t = floor((1.0 - normalized_value) * time_window)\n@compute @workgroup_size(256)\nfn encode_temporal(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let idx = gid.x;\n    if (idx >= params.data_count) {\n        return;\n    }\n\n    let value = normalize(input_data[idx]);\n    let base_offset = idx * params.time_window;\n\n    // Clear spike train\n    for (var t = 0u; t < params.time_window; t = t + 1u) {\n        spike_train[base_offset + t] = 0.0;\n    }\n\n    // Spike time: stronger input => earlier spike\n    if (value > 0.01) {\n        let spike_time = u32(floor((1.0 - value) * f32(params.time_window - 1u)));\n        let clamped_t = min(spike_time, params.time_window - 1u);\n        spike_train[base_offset + clamped_t] = 1.0;\n    }\n\n    prev_data[idx] = input_data[idx];\n}\n\n// Delta coding: spike only when input changes significantly\n@compute @workgroup_size(256)\nfn encode_delta(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let idx = gid.x;\n    if (idx >= params.data_count) {\n        return;\n    }\n\n    let current = input_data[idx];\n    let previous = prev_data[idx];\n    let delta = current - previous;\n    let abs_delta = abs(delta);\n\n    let base_offset = idx * params.time_window;\n\n    // Clear spike train\n    for (var t = 0u; t < params.time_window; t = t + 1u) {\n        spike_train[base_offset + t] = 0.0;\n    }\n\n    // Emit spike if change exceeds threshold\n    if (abs_delta >= params.delta_threshold) {\n        // Positive spike for increase, use first half of time window\n        // Negative spike (encoded as spike in second half) for decrease\n        let magnitude = normalize(abs_delta);\n        let spike_time = u32(floor((1.0 - magnitude) * f32(params.time_window / 2u)));\n\n        if (delta > 0.0) {\n            // ON spike (positive change)\n            spike_train[base_offset + min(spike_time, params.time_window / 2u - 1u)] = 1.0;\n        } else {\n            // OFF spike (negative change)\n            let off_offset = params.time_window / 2u;\n            spike_train[base_offset + off_offset + min(spike_time, params.time_window / 2u - 1u)] = 1.0;\n        }\n    }\n\n    prev_data[idx] = current;\n}\n";
+var spike_decode_default = "// Spike Decoding Compute Shader\n//\n// Converts spike trains back into continuous values for downstream use.\n// Decoding schemes:\n//   1. Rate decoding: count spikes / time_window => normalized value\n//   2. Temporal decoding: earliest spike time => value (earlier = higher)\n//   3. Population decoding: weighted sum across neuron population\n//   4. First-spike decoding: only uses the first spike's timing\n\nstruct DecodeParams {\n    neuron_count: u32,    // Number of neurons to decode\n    time_window: u32,     // Number of time bins in spike train\n    decoding_mode: u32,   // 0=rate, 1=temporal, 2=population, 3=first-spike\n    population_size: u32, // Neurons per population (for population coding)\n    output_min: f32,      // Output range minimum\n    output_max: f32,      // Output range maximum\n    _pad0: u32,\n    _pad1: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: DecodeParams;\n\n// Input spike trains: [neuron_count * time_window]\n@group(0) @binding(1) var<storage, read> spike_train: array<f32>;\n\n// Decoded output values: [neuron_count] (or [neuron_count / population_size] for population)\n@group(0) @binding(2) var<storage, read_write> output_data: array<f32>;\n\n// Population tuning curves (preferred values): [neuron_count] (for population decoding)\n@group(0) @binding(3) var<storage, read> tuning_curves: array<f32>;\n\nfn denormalize(value: f32) -> f32 {\n    return params.output_min + value * (params.output_max - params.output_min);\n}\n\n// Rate decoding: output = spike_count / time_window\n@compute @workgroup_size(256)\nfn decode_rate(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let idx = gid.x;\n    if (idx >= params.neuron_count) {\n        return;\n    }\n\n    let base_offset = idx * params.time_window;\n    var spike_count: f32 = 0.0;\n\n    for (var t = 0u; t < params.time_window; t = t + 1u) {\n        spike_count = spike_count + spike_train[base_offset + t];\n    }\n\n    let rate = spike_count / f32(params.time_window);\n    output_data[idx] = denormalize(rate);\n}\n\n// Temporal decoding: find earliest spike, earlier = higher value\n@compute @workgroup_size(256)\nfn decode_temporal(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let idx = gid.x;\n    if (idx >= params.neuron_count) {\n        return;\n    }\n\n    let base_offset = idx * params.time_window;\n    var first_spike_time: i32 = -1;\n\n    for (var t = 0u; t < params.time_window; t = t + 1u) {\n        if (spike_train[base_offset + t] > 0.5 && first_spike_time < 0) {\n            first_spike_time = i32(t);\n        }\n    }\n\n    if (first_spike_time < 0) {\n        // No spike => minimum value\n        output_data[idx] = params.output_min;\n    } else {\n        // Earlier spike => higher value\n        let normalized = 1.0 - f32(first_spike_time) / f32(params.time_window - 1u);\n        output_data[idx] = denormalize(normalized);\n    }\n}\n\n// Population decoding: weighted average of preferred values by firing rates\n// Groups of `population_size` neurons encode a single value\n@compute @workgroup_size(256)\nfn decode_population(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let pop_idx = gid.x;\n    let num_populations = params.neuron_count / params.population_size;\n    if (pop_idx >= num_populations) {\n        return;\n    }\n\n    let pop_start = pop_idx * params.population_size;\n    var weighted_sum: f32 = 0.0;\n    var total_rate: f32 = 0.0;\n\n    for (var n = 0u; n < params.population_size; n = n + 1u) {\n        let neuron_idx = pop_start + n;\n        let base_offset = neuron_idx * params.time_window;\n\n        // Compute firing rate for this neuron\n        var spike_count: f32 = 0.0;\n        for (var t = 0u; t < params.time_window; t = t + 1u) {\n            spike_count = spike_count + spike_train[base_offset + t];\n        }\n        let rate = spike_count / f32(params.time_window);\n\n        // Weight by preferred value from tuning curve\n        weighted_sum = weighted_sum + rate * tuning_curves[neuron_idx];\n        total_rate = total_rate + rate;\n    }\n\n    if (total_rate > 0.001) {\n        output_data[pop_idx] = denormalize(weighted_sum / total_rate);\n    } else {\n        // No activity => neutral value\n        output_data[pop_idx] = denormalize(0.5);\n    }\n}\n\n// First-spike decoding: uses only first spike across population\n// The neuron that fires first determines the decoded value (WTA - Winner Takes All)\n@compute @workgroup_size(256)\nfn decode_first_spike(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let pop_idx = gid.x;\n    let num_populations = params.neuron_count / params.population_size;\n    if (pop_idx >= num_populations) {\n        return;\n    }\n\n    let pop_start = pop_idx * params.population_size;\n    var earliest_time: u32 = params.time_window;\n    var winner_neuron: u32 = 0u;\n\n    for (var n = 0u; n < params.population_size; n = n + 1u) {\n        let neuron_idx = pop_start + n;\n        let base_offset = neuron_idx * params.time_window;\n\n        for (var t = 0u; t < params.time_window; t = t + 1u) {\n            if (spike_train[base_offset + t] > 0.5 && t < earliest_time) {\n                earliest_time = t;\n                winner_neuron = neuron_idx;\n                break;\n            }\n        }\n    }\n\n    if (earliest_time < params.time_window) {\n        output_data[pop_idx] = tuning_curves[winner_neuron];\n    } else {\n        output_data[pop_idx] = denormalize(0.5);\n    }\n}\n";
+var tropical_activation_default = "struct TropicalActivationConfig {\n  gain: f32,\n  threshold: f32,\n  count: u32,\n  variant: u32,\n}\n\n@group(0) @binding(0) var<storage, read> input_values: array<f32>;\n@group(0) @binding(1) var<storage, read_write> output_values: array<f32>;\n@group(0) @binding(2) var<uniform> config: TropicalActivationConfig;\n\n@compute @workgroup_size(256)\nfn tropical_activate(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= config.count) {\n    return;\n  }\n\n  let shifted = input_values[idx] - config.threshold;\n\n  if (config.variant == 0u) {\n    output_values[idx] = config.gain * max(0.0, shifted);\n  } else {\n    output_values[idx] = config.gain * min(0.0, shifted);\n  }\n}\n";
+var tropical_graph_default = "struct TropicalGemmDims {\n  m: u32,\n  n: u32,\n  k: u32,\n  _pad: u32,\n}\n\nstruct TropicalSparseDims {\n  rows: u32,\n  _pad0: u32,\n  _pad1: u32,\n  _pad2: u32,\n}\n\nconst INF: f32 = 1e30;\n\n@group(0) @binding(0) var<storage, read> matA: array<f32>;\n@group(0) @binding(1) var<storage, read> matB: array<f32>;\n@group(0) @binding(2) var<storage, read_write> matC: array<f32>;\n@group(0) @binding(3) var<uniform> gemmDims: TropicalGemmDims;\n\n@compute @workgroup_size(16, 16)\nfn tropical_min_plus_gemm(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let col = gid.x;\n  let row = gid.y;\n\n  if (row >= gemmDims.m || col >= gemmDims.n) {\n    return;\n  }\n\n  var best: f32 = INF;\n  for (var kk: u32 = 0u; kk < gemmDims.k; kk = kk + 1u) {\n    let a = matA[row * gemmDims.k + kk];\n    let b = matB[kk * gemmDims.n + col];\n    if (a < INF && b < INF) {\n      best = min(best, a + b);\n    }\n  }\n\n  matC[row * gemmDims.n + col] = best;\n}\n\n@group(0) @binding(0) var<storage, read> rowPtr: array<u32>;\n@group(0) @binding(1) var<storage, read> colIdx: array<u32>;\n@group(0) @binding(2) var<storage, read> values: array<f32>;\n@group(0) @binding(3) var<storage, read> distIn: array<f32>;\n@group(0) @binding(4) var<storage, read_write> distOut: array<f32>;\n@group(0) @binding(5) var<uniform> sparseDims: TropicalSparseDims;\n\n@compute @workgroup_size(256)\nfn tropical_spmv(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let row = gid.x;\n  if (row >= sparseDims.rows) {\n    return;\n  }\n\n  var best: f32 = INF;\n  let start = rowPtr[row];\n  let finish = rowPtr[row + 1u];\n\n  for (var j: u32 = start; j < finish; j = j + 1u) {\n    let col = colIdx[j];\n    let weight = values[j];\n    let base = distIn[col];\n    if (base < INF && weight < INF) {\n      best = min(best, base + weight);\n    }\n  }\n\n  distOut[row] = best;\n}\n";
+var lif_large_scale_default = '// Hierarchical LIF + Shared-Memory Synaptic Current Shaders\n//\n// Paper-2 (SNN NeurIPS) \xA75.4 future work:\n//   "Scaling to 10^6 neurons via hierarchical workgroup decomposition\n//    and shared memory tiling."\n//\n// This shader provides two compute entry points:\n//\n//   lif_step_partitioned:\n//     Each thread handles NEURONS_PER_THREAD=4 neurons, reducing the\n//     dispatch count by 4\xD7 compared to the baseline lif_step. For N=10^6\n//     neurons: ceil(1M / (256 * 4)) = 977 workgroups vs 3907 baseline.\n//\n//   synaptic_current_shared_tiled:\n//     Uses var<workgroup> shared memory to cache a tile of pre-synaptic\n//     spikes. All 256 threads cooperatively fill the tile, then each\n//     thread accumulates against the cached spikes for its post neuron.\n//     Reduces global memory reads of pre_spikes from O(N_pre \xD7 N_post)\n//     to O(N_pre \xD7 N_post / TILE_SIZE) by reusing cached values.\n\n// \u2500\u2500 Shared parameter struct \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 LIFParams {\n    tau: f32,\n    v_threshold: f32,\n    v_reset: f32,\n    v_rest: f32,\n    dt: f32,\n    neuron_count: u32,\n    _pad0: u32,\n    _pad1: u32,\n};\n\nstruct SynapticParams {\n    pre_count: u32,\n    post_count: u32,\n    learning_rate: f32,\n    _pad: u32,\n};\n\n// \u2500\u2500 Constants \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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n// Each thread in lif_step_partitioned handles this many neurons.\nconst NEURONS_PER_THREAD: u32 = 4u;\n\n// Workgroup size for all entry points.\nconst WORKGROUP_SIZE: u32 = 256u;\n\n// Pre-spike tile size for shared memory caching (must equal WORKGROUP_SIZE).\nconst TILE_SIZE: u32 = 256u;\n\nconst REFRACTORY_PERIOD: f32 = 2.0;\n\n// \u2500\u2500 lif_step_partitioned \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// Hierarchical LIF step: each thread handles NEURONS_PER_THREAD contiguous\n// neurons. Dispatch: ceil(neuron_count / (WORKGROUP_SIZE * NEURONS_PER_THREAD))\n\n@group(0) @binding(0) var<uniform> lif_params: LIFParams;\n@group(0) @binding(1) var<storage, read_write> membrane_v: array<f32>;\n@group(0) @binding(2) var<storage, read> synaptic_input: array<f32>;\n@group(0) @binding(3) var<storage, read_write> spikes: array<f32>;\n@group(0) @binding(4) var<storage, read_write> refractory: array<f32>;\n\n@compute @workgroup_size(256)\nfn lif_step_partitioned(@builtin(global_invocation_id) gid: vec3<u32>) {\n    let base_idx = gid.x * NEURONS_PER_THREAD;\n    let decay = exp(-lif_params.dt / lif_params.tau);\n\n    for (var offset: u32 = 0u; offset < NEURONS_PER_THREAD; offset = offset + 1u) {\n        let i = base_idx + offset;\n        if (i >= lif_params.neuron_count) {\n            return;\n        }\n\n        var v = membrane_v[i];\n        let i_syn = synaptic_input[i];\n        var ref_timer = refractory[i];\n\n        if (ref_timer > 0.0) {\n            ref_timer = ref_timer - lif_params.dt;\n            refractory[i] = max(ref_timer, 0.0);\n            membrane_v[i] = lif_params.v_reset;\n            spikes[i] = 0.0;\n            continue;\n        }\n\n        // LIF integration: V(t+1) = V_rest + (V(t) - V_rest)*decay + I_syn\n        v = lif_params.v_rest + (v - lif_params.v_rest) * decay + i_syn;\n\n        if (v >= lif_params.v_threshold) {\n            spikes[i] = 1.0;\n            membrane_v[i] = lif_params.v_reset;\n            refractory[i] = REFRACTORY_PERIOD;\n        } else {\n            spikes[i] = 0.0;\n            membrane_v[i] = v;\n        }\n    }\n}\n\n// \u2500\u2500 synaptic_current_shared_tiled \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// Shared-memory tiled synaptic current computation.\n//\n// Each workgroup (256 threads) cooperatively loads TILE_SIZE=256 pre-synaptic\n// spikes into workgroup shared memory, then all 256 threads accumulate\n// contributions from that tile for their own post neuron.\n//\n// Bind group layout (same as compute_synaptic_current):\n//   0 = SynapticParams (uniform)\n//   1 = weights (storage, read)         [post_count \xD7 pre_count f32]\n//   2 = pre_spikes (storage, read)      [pre_count f32]\n//   3 = post_currents (storage, rw)     [post_count f32]\n//\n// Dispatch: ceil(post_count / WORKGROUP_SIZE)\n\n@group(0) @binding(0) var<uniform> syn_params: SynapticParams;\n@group(0) @binding(1) var<storage, read> weights: array<f32>;\n@group(0) @binding(2) var<storage, read> pre_spikes: array<f32>;\n@group(0) @binding(3) var<storage, read_write> post_currents: array<f32>;\n\n// Workgroup shared memory: one tile of pre-synaptic spikes.\n// Accessed by all threads in the workgroup simultaneously \u2014 eliminates\n// repeated global reads of the same spike values across post-neuron rows.\nvar<workgroup> shared_pre_spikes: array<f32, TILE_SIZE>;\n\n@compute @workgroup_size(256)\nfn synaptic_current_shared_tiled(\n    @builtin(global_invocation_id) gid: vec3<u32>,\n    @builtin(local_invocation_id) lid: vec3<u32>\n) {\n    let post_j = gid.x;\n    var current: f32 = 0.0;\n\n    let num_tiles: u32 = (syn_params.pre_count + TILE_SIZE - 1u) / TILE_SIZE;\n\n    for (var tile: u32 = 0u; tile < num_tiles; tile = tile + 1u) {\n        let pre_global = tile * TILE_SIZE + lid.x;\n\n        // All 256 threads collaboratively fill the shared spike cache.\n        // Thread lid.x loads the pre neuron at index (tile * 256 + lid.x).\n        shared_pre_spikes[lid.x] = select(\n            0.0,\n            pre_spikes[pre_global],\n            pre_global < syn_params.pre_count\n        );\n\n        // Synchronise: every thread must see the fully populated tile.\n        workgroupBarrier();\n\n        // Each thread accumulates contributions from this tile for its post neuron.\n        if (post_j < syn_params.post_count) {\n            let tile_start = tile * TILE_SIZE;\n            let row_offset = post_j * syn_params.pre_count;\n            let tile_len: u32 = min(TILE_SIZE, syn_params.pre_count - tile_start);\n\n            for (var k: u32 = 0u; k < tile_len; k = k + 1u) {\n                if (shared_pre_spikes[k] > 0.5) {\n                    current = current + weights[row_offset + tile_start + k];\n                }\n            }\n        }\n\n        // Barrier before reusing shared memory for the next tile.\n        workgroupBarrier();\n    }\n\n    if (post_j < syn_params.post_count) {\n        post_currents[post_j] = current;\n    }\n}\n';
+var SHADER_SOURCES = {
+  lif: lif_neuron_default,
+  synaptic: synaptic_weights_default,
+  encode: spike_encode_default,
+  decode: spike_decode_default,
+  tropical: tropical_activation_default,
+  tropicalGraph: tropical_graph_default,
+  largescale: lif_large_scale_default
+};
+var ENTRY_POINT_CATEGORY = {
+  lif_step: "lif",
+  lif_step_batch: "lif",
+  compute_synaptic_current: "synaptic",
+  compute_synaptic_current_tiled: "synaptic",
+  stdp_weight_update: "synaptic",
+  encode_rate: "encode",
+  encode_temporal: "encode",
+  encode_delta: "encode",
+  decode_rate: "decode",
+  decode_temporal: "decode",
+  decode_population: "decode",
+  decode_first_spike: "decode",
+  tropical_activate: "tropical",
+  tropical_min_plus_gemm: "tropicalGraph",
+  tropical_spmv: "tropicalGraph",
+  lif_step_partitioned: "largescale",
+  synaptic_current_shared_tiled: "largescale"
+};
+var PipelineFactory = class {
+  constructor(ctx) {
+    this.moduleCache = /* @__PURE__ */ new Map();
+    this.pipelineCache = /* @__PURE__ */ new Map();
+    this.pendingAsync = /* @__PURE__ */ new Map();
+    this.ctx = ctx;
+  }
+  /**
+   * Get or create a shader module for a category.
+   */
+  getShaderModule(category) {
+    let module = this.moduleCache.get(category);
+    if (!module) {
+      const source = SHADER_SOURCES[category];
+      module = this.ctx.createShaderModule(source, `snn-${category}-shader`);
+      this.moduleCache.set(category, module);
+    }
+    return module;
+  }
+  /**
+   * Get or create a compute pipeline for a specific entry point.
+   * Uses 'auto' layout by default - bind groups must match shader declarations.
+   */
+  getPipeline(entryPoint) {
+    const cached = this.pipelineCache.get(entryPoint);
+    if (cached) {
+      return cached.pipeline;
+    }
+    const category = ENTRY_POINT_CATEGORY[entryPoint];
+    const module = this.getShaderModule(category);
+    const pipeline = this.ctx.createComputePipeline(
+      module,
+      entryPoint,
+      "auto",
+      `snn-pipeline-${entryPoint}`
+    );
+    this.pipelineCache.set(entryPoint, {
+      pipeline,
+      module,
+      category,
+      entryPoint
+    });
+    return pipeline;
+  }
+  /**
+   * Asynchronously get or create a compute pipeline for a specific entry point.
+   * Avoids stalling the main thread during driver shader compilation.
+   * Results are cached identically to getPipeline() — subsequent calls return from cache.
+   * Concurrent calls for the same entry point share a single in-flight compilation.
+   */
+  async getPipelineAsync(entryPoint) {
+    const cached = this.pipelineCache.get(entryPoint);
+    if (cached) {
+      return cached.pipeline;
+    }
+    const pending = this.pendingAsync.get(entryPoint);
+    if (pending) {
+      return pending;
+    }
+    const category = ENTRY_POINT_CATEGORY[entryPoint];
+    const module = this.getShaderModule(category);
+    const promise = this.ctx.createComputePipelineAsync(module, entryPoint, "auto", `snn-pipeline-async-${entryPoint}`).then((pipeline) => {
+      this.pipelineCache.set(entryPoint, { pipeline, module, category, entryPoint });
+      this.pendingAsync.delete(entryPoint);
+      return pipeline;
+    });
+    this.pendingAsync.set(entryPoint, promise);
+    return promise;
+  }
+  /**
+   * Warm up multiple pipelines in parallel using async compilation.
+   * Call during scene/model load to precompile shaders before they are needed.
+   * @param entryPoints - list of entry points to precompile; defaults to all available
+   */
+  async warmupAsync(entryPoints) {
+    const targets = entryPoints ?? this.getAvailableEntryPoints();
+    await Promise.all(targets.map((ep) => this.getPipelineAsync(ep)));
+  }
+  /**
+   * Retrieve compilation diagnostics (errors and warnings) for a shader module.
+   * Surfaces WGSL compilation errors that are otherwise silent in some browsers.
+   * @returns array of GPUCompilationMessage objects, or [] if not supported
+   */
+  async checkShaderCompilationErrors(category) {
+    const module = this.getShaderModule(category);
+    if (typeof module.getCompilationInfo !== "function") {
+      return [];
+    }
+    const info = await module.getCompilationInfo();
+    return Array.from(info.messages);
+  }
+  /**
+   * Create a bind group for a pipeline and a set of buffers.
+   */
+  createBindGroup(entryPoint, buffers, label) {
+    const pipeline = this.getPipeline(entryPoint);
+    const entries = buffers.map((buffer, index) => ({
+      binding: index,
+      resource: { buffer }
+    }));
+    return this.ctx.device.createBindGroup({
+      label: label ?? `bind-group-${entryPoint}`,
+      layout: pipeline.getBindGroupLayout(0),
+      entries
+    });
+  }
+  /**
+   * Create a bind group using explicit binding index entries.
+   * Use this overload when bindings are non-sequential (e.g., skipping unused bindings).
+   */
+  createBindGroupWithIndices(entryPoint, buffers, indices, label) {
+    const pipeline = this.getPipeline(entryPoint);
+    const entries = buffers.map((buffer, index) => ({
+      binding: indices[index],
+      resource: { buffer }
+    }));
+    return this.ctx.device.createBindGroup({
+      label: label ?? `bind-group-${entryPoint}`,
+      layout: pipeline.getBindGroupLayout(0),
+      entries
+    });
+  }
+  /**
+   * Encode a compute dispatch command.
+   */
+  encodeDispatch(encoder, entryPoint, bindGroup, workgroupCountX, workgroupCountY = 1, workgroupCountZ = 1) {
+    const pipeline = this.getPipeline(entryPoint);
+    const pass = encoder.beginComputePass({
+      label: `compute-pass-${entryPoint}`
+    });
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bindGroup);
+    pass.dispatchWorkgroups(workgroupCountX, workgroupCountY, workgroupCountZ);
+    pass.end();
+  }
+  /**
+   * Get the raw WGSL source code for a shader category.
+   * Useful for debugging or custom modifications.
+   */
+  getShaderSource(category) {
+    return SHADER_SOURCES[category];
+  }
+  /**
+   * Get all available entry points.
+   */
+  getAvailableEntryPoints() {
+    return Object.keys(ENTRY_POINT_CATEGORY);
+  }
+  /**
+   * Clear all cached pipelines and modules.
+   * Call before destroying the GPU context.
+   */
+  clearCache() {
+    this.pipelineCache.clear();
+    this.moduleCache.clear();
+    this.pendingAsync.clear();
+  }
+};
+var LIF_PARAMS_BYTE_SIZE = 32;
+function packLIFParams(params, neuronCount) {
+  const buffer = new ArrayBuffer(LIF_PARAMS_BYTE_SIZE);
+  const f32 = new Float32Array(buffer);
+  const u32 = new Uint32Array(buffer);
+  f32[0] = params.tau;
+  f32[1] = params.vThreshold;
+  f32[2] = params.vReset;
+  f32[3] = params.vRest;
+  f32[4] = params.dt;
+  u32[5] = neuronCount;
+  u32[6] = 0;
+  u32[7] = 0;
+  return buffer;
+}
+var LIFSimulator = class {
+  /**
+   * @param ctx - Initialized GPUContext
+   * @param neuronCount - Number of neurons to simulate
+   * @param params - LIF parameters (optional, uses defaults)
+   */
+  constructor(ctx, neuronCount, params) {
+    this.initialized = false;
+    this.stepCount = 0;
+    this.ctx = ctx;
+    this.neuronCount = ctx.validateNeuronCapacity(neuronCount);
+    this.params = { ...DEFAULT_LIF_PARAMS, ...params };
+    this.bufferManager = new BufferManager(ctx.device);
+    this.pipelineFactory = new PipelineFactory(ctx);
+  }
+  /**
+   * Initialize GPU buffers and compute pipeline.
+   * Must be called before step().
+   */
+  async initialize() {
+    if (this.initialized) return;
+    const n = this.neuronCount;
+    const paramsData = packLIFParams(this.params, n);
+    this.paramsBuffer = this.bufferManager.createBuffer({
+      size: LIF_PARAMS_BYTE_SIZE,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      label: "lif-params",
+      initialData: new Float32Array(paramsData),
+      mappedAtCreation: true
+    });
+    const initMembrane = new Float32Array(n).fill(this.params.vRest);
+    this.membraneBuffer = this.bufferManager.createStorageBuffer(initMembrane, "membrane-v");
+    this.synapticInputBuffer = this.bufferManager.createZeroBuffer(n, "synaptic-input");
+    this.spikesBuffer = this.bufferManager.createZeroBuffer(n, "spikes");
+    this.refractoryBuffer = this.bufferManager.createZeroBuffer(n, "refractory");
+    this.bindGroup = this.pipelineFactory.createBindGroup(
+      "lif_step",
+      [
+        this.paramsBuffer.buffer,
+        this.membraneBuffer.buffer,
+        this.synapticInputBuffer.buffer,
+        this.spikesBuffer.buffer,
+        this.refractoryBuffer.buffer
+      ],
+      "lif-bind-group"
+    );
+    this.initialized = true;
+  }
+  /**
+   * Run one simulation timestep.
+   * Dispatches the LIF compute shader across all neurons.
+   */
+  async step() {
+    this.ensureInitialized();
+    const workgroups = computeDispatchSize(this.neuronCount);
+    const encoder = this.ctx.device.createCommandEncoder({
+      label: `lif-step-${this.stepCount}`
+    });
+    this.pipelineFactory.encodeDispatch(encoder, "lif_step", this.bindGroup, workgroups);
+    await this.ctx.submitAndWait(encoder.finish());
+    this.stepCount++;
+  }
+  /**
+   * Run multiple simulation timesteps.
+   */
+  async stepN(count) {
+    for (let i = 0; i < count; i++) {
+      await this.step();
+    }
+  }
+  /**
+   * Set synaptic input currents for all neurons.
+   */
+  setSynapticInput(currents) {
+    this.ensureInitialized();
+    if (currents.length !== this.neuronCount) {
+      throw new Error(
+        `Current array length (${currents.length}) must match neuron count (${this.neuronCount})`
+      );
+    }
+    this.bufferManager.writeBuffer(this.synapticInputBuffer, currents);
+  }
+  /**
+   * Update LIF parameters.
+   */
+  updateParams(params) {
+    this.ensureInitialized();
+    this.params = { ...this.params, ...params };
+    const packed = packLIFParams(this.params, this.neuronCount);
+    this.bufferManager.writeBuffer(this.paramsBuffer, new Float32Array(packed));
+  }
+  /**
+   * Read spike output from the GPU.
+   * Returns a Float32Array where 1.0 = spike, 0.0 = no spike.
+   */
+  async readSpikes() {
+    this.ensureInitialized();
+    return this.bufferManager.readBuffer(this.spikesBuffer);
+  }
+  /**
+   * Read membrane potentials from the GPU.
+   */
+  async readMembranePotentials() {
+    this.ensureInitialized();
+    return this.bufferManager.readBuffer(this.membraneBuffer);
+  }
+  /**
+   * Reset all neurons to resting state.
+   */
+  resetState() {
+    this.ensureInitialized();
+    const n = this.neuronCount;
+    const rest = new Float32Array(n).fill(this.params.vRest);
+    const zeros = new Float32Array(n);
+    this.bufferManager.writeBuffer(this.membraneBuffer, rest);
+    this.bufferManager.writeBuffer(this.synapticInputBuffer, zeros);
+    this.bufferManager.writeBuffer(this.spikesBuffer, zeros);
+    this.bufferManager.writeBuffer(this.refractoryBuffer, zeros);
+    this.stepCount = 0;
+  }
+  /** Get the current simulation step count. */
+  get currentStep() {
+    return this.stepCount;
+  }
+  /** Get the number of neurons. */
+  get count() {
+    return this.neuronCount;
+  }
+  /** Get current LIF parameters. */
+  get currentParams() {
+    return { ...this.params };
+  }
+  /** Get total GPU memory used in bytes. */
+  get gpuMemoryBytes() {
+    return this.bufferManager.getTotalAllocatedBytes();
+  }
+  /**
+   * Destroy all GPU resources.
+   */
+  destroy() {
+    this.pipelineFactory.clearCache();
+    this.bufferManager.destroyAll();
+    this.initialized = false;
+    this.stepCount = 0;
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("LIFSimulator not initialized. Call initialize() first.");
+    }
+  }
+};
+var ENCODE_PARAMS_SIZE = 32;
+var DECODE_PARAMS_SIZE = 32;
+var ENCODE_ENTRY_POINTS = {
+  [
+    0
+    /* Rate */
+  ]: "encode_rate",
+  [
+    1
+    /* Temporal */
+  ]: "encode_temporal",
+  [
+    2
+    /* Delta */
+  ]: "encode_delta"
+};
+var DECODE_ENTRY_POINTS = {
+  [
+    0
+    /* Rate */
+  ]: "decode_rate",
+  [
+    1
+    /* Temporal */
+  ]: "decode_temporal",
+  [
+    2
+    /* Population */
+  ]: "decode_population",
+  [
+    3
+    /* FirstSpike */
+  ]: "decode_first_spike"
+};
+function packEncodeParams(params) {
+  const buf = new ArrayBuffer(ENCODE_PARAMS_SIZE);
+  const u32 = new Uint32Array(buf);
+  const f32 = new Float32Array(buf);
+  u32[0] = params.dataCount;
+  u32[1] = params.timeWindow;
+  u32[2] = params.encodingMode;
+  u32[3] = params.seed;
+  f32[4] = params.minValue;
+  f32[5] = params.maxValue;
+  f32[6] = params.deltaThreshold;
+  u32[7] = 0;
+  return buf;
+}
+function packDecodeParams(params) {
+  const buf = new ArrayBuffer(DECODE_PARAMS_SIZE);
+  const u32 = new Uint32Array(buf);
+  const f32 = new Float32Array(buf);
+  u32[0] = params.neuronCount;
+  u32[1] = params.timeWindow;
+  u32[2] = params.decodingMode;
+  u32[3] = params.populationSize;
+  f32[4] = params.outputMin;
+  f32[5] = params.outputMax;
+  u32[6] = 0;
+  u32[7] = 0;
+  return buf;
+}
+var SpikeEncoder = class {
+  constructor(ctx, params) {
+    this.initialized = false;
+    this.ctx = ctx;
+    this.params = { ...DEFAULT_ENCODE_PARAMS, ...params };
+    this.bufferManager = new BufferManager(ctx.device);
+    this.pipelineFactory = new PipelineFactory(ctx);
+  }
+  async initialize() {
+    if (this.initialized) return;
+    const { dataCount, timeWindow } = this.params;
+    const packedParams = packEncodeParams(this.params);
+    this.paramsBuffer = this.bufferManager.createBuffer({
+      size: ENCODE_PARAMS_SIZE,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      label: "encode-params",
+      initialData: new Float32Array(packedParams)
+    });
+    this.inputBuffer = this.bufferManager.createZeroBuffer(dataCount, "encode-input");
+    this.prevDataBuffer = this.bufferManager.createZeroBuffer(dataCount, "encode-prev");
+    const spikeTrainSize = dataCount * timeWindow;
+    this.spikeTrainBuffer = this.bufferManager.createZeroBuffer(spikeTrainSize, "spike-train");
+    const entryPoint = ENCODE_ENTRY_POINTS[this.params.encodingMode];
+    this.bindGroup = this.pipelineFactory.createBindGroup(
+      entryPoint,
+      [
+        this.paramsBuffer.buffer,
+        this.inputBuffer.buffer,
+        this.prevDataBuffer.buffer,
+        this.spikeTrainBuffer.buffer
+      ],
+      "encode-bind-group"
+    );
+    this.initialized = true;
+  }
+  /**
+   * Encode input data into spike trains.
+   */
+  async encode(data) {
+    this.ensureInitialized();
+    if (data.length !== this.params.dataCount) {
+      throw new Error(
+        `Input data length (${data.length}) must match dataCount (${this.params.dataCount})`
+      );
+    }
+    this.bufferManager.writeBuffer(this.inputBuffer, data);
+    this.params.seed = this.params.seed + 1 | 0;
+    const packedParams = packEncodeParams(this.params);
+    this.bufferManager.writeBuffer(this.paramsBuffer, new Float32Array(packedParams));
+    const entryPoint = ENCODE_ENTRY_POINTS[this.params.encodingMode];
+    const workgroups = computeDispatchSize(this.params.dataCount);
+    const encoder = this.ctx.device.createCommandEncoder({ label: "encode-dispatch" });
+    this.pipelineFactory.encodeDispatch(encoder, entryPoint, this.bindGroup, workgroups);
+    await this.ctx.submitAndWait(encoder.finish());
+  }
+  /**
+   * Read the generated spike trains back to CPU.
+   * Returns [dataCount * timeWindow] float array.
+   */
+  async readSpikeTrains() {
+    this.ensureInitialized();
+    return this.bufferManager.readBuffer(this.spikeTrainBuffer);
+  }
+  /** Get the spike train GPU buffer handle (for chaining to decoders or networks). */
+  get spikeTrainHandle() {
+    this.ensureInitialized();
+    return this.spikeTrainBuffer;
+  }
+  destroy() {
+    this.pipelineFactory.clearCache();
+    this.bufferManager.destroyAll();
+    this.initialized = false;
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("SpikeEncoder not initialized. Call initialize() first.");
+    }
+  }
+};
+var SpikeDecoder = class {
+  constructor(ctx, params) {
+    this.initialized = false;
+    this.ownsSpikeTrain = false;
+    this.ctx = ctx;
+    this.params = { ...DEFAULT_DECODE_PARAMS, ...params };
+    this.bufferManager = new BufferManager(ctx.device);
+    this.pipelineFactory = new PipelineFactory(ctx);
+  }
+  async initialize(externalSpikeTrainBuffer) {
+    if (this.initialized) return;
+    const { neuronCount, timeWindow, populationSize, decodingMode } = this.params;
+    const packedParams = packDecodeParams(this.params);
+    this.paramsBuffer = this.bufferManager.createBuffer({
+      size: DECODE_PARAMS_SIZE,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      label: "decode-params",
+      initialData: new Float32Array(packedParams)
+    });
+    if (externalSpikeTrainBuffer) {
+      this.spikeTrainBuffer = externalSpikeTrainBuffer;
+      this.ownsSpikeTrain = false;
+    } else {
+      const spikeTrainSize = neuronCount * timeWindow;
+      this.spikeTrainBuffer = this.bufferManager.createZeroBuffer(
+        spikeTrainSize,
+        "decode-spike-train"
+      );
+      this.ownsSpikeTrain = true;
+    }
+    const outputCount = decodingMode === 2 || decodingMode === 3 ? Math.ceil(neuronCount / populationSize) : neuronCount;
+    this.outputBuffer = this.bufferManager.createZeroBuffer(outputCount, "decode-output");
+    const tuningData = new Float32Array(neuronCount);
+    for (let i = 0; i < neuronCount; i++) {
+      const popIndex = i % populationSize;
+      tuningData[i] = popIndex / (populationSize - 1 || 1);
+    }
+    this.tuningCurveBuffer = this.bufferManager.createStorageBuffer(tuningData, "tuning-curves");
+    const entryPoint = DECODE_ENTRY_POINTS[decodingMode];
+    const needsTuningCurves = decodingMode === 2 || decodingMode === 3;
+    this.bindGroup = this.pipelineFactory.createBindGroup(
+      entryPoint,
+      needsTuningCurves ? [
+        this.paramsBuffer.buffer,
+        this.spikeTrainBuffer.buffer,
+        this.outputBuffer.buffer,
+        this.tuningCurveBuffer.buffer
+      ] : [this.paramsBuffer.buffer, this.spikeTrainBuffer.buffer, this.outputBuffer.buffer],
+      "decode-bind-group"
+    );
+    this.initialized = true;
+  }
+  /**
+   * Decode spike trains into continuous values.
+   * If spikeTrainData is provided, uploads it first; otherwise uses the buffer as-is.
+   */
+  async decode(spikeTrainData) {
+    this.ensureInitialized();
+    if (spikeTrainData) {
+      this.bufferManager.writeBuffer(this.spikeTrainBuffer, spikeTrainData);
+    }
+    const entryPoint = DECODE_ENTRY_POINTS[this.params.decodingMode];
+    const dispatchCount = this.params.decodingMode === 2 || this.params.decodingMode === 3 ? Math.ceil(this.params.neuronCount / this.params.populationSize) : this.params.neuronCount;
+    const workgroups = computeDispatchSize(dispatchCount);
+    const encoder = this.ctx.device.createCommandEncoder({ label: "decode-dispatch" });
+    this.pipelineFactory.encodeDispatch(encoder, entryPoint, this.bindGroup, workgroups);
+    await this.ctx.submitAndWait(encoder.finish());
+  }
+  /**
+   * Read decoded output values from GPU.
+   */
+  async readOutput() {
+    this.ensureInitialized();
+    return this.bufferManager.readBuffer(this.outputBuffer);
+  }
+  /**
+   * Set custom tuning curves for population decoding.
+   */
+  setTuningCurves(curves) {
+    this.ensureInitialized();
+    this.bufferManager.writeBuffer(this.tuningCurveBuffer, curves);
+  }
+  destroy() {
+    this.pipelineFactory.clearCache();
+    this.bufferManager.destroyAll();
+    this.initialized = false;
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("SpikeDecoder not initialized. Call initialize() first.");
+    }
+  }
+};
+var DEFAULT_COLORS = {
+  petal_base: "#fff1f6",
+  petal_mid: "#f47ab7",
+  petal_inner: "#ff9ecf",
+  petal_rim: "#c42a86",
+  petal_shadow: "#84205f",
+  seed_pod: "#f4d74a",
+  seed_pod_rim: "#b7c66b",
+  stamen: "#f59e0b",
+  stamen_tip: "#fff4bd",
+  leaf: "#235f4f",
+  leaf_dark: "#102f28",
+  water: "#07140f"
+};
+var REQUIRED_CONFIDENCE_REGIONS = [
+  "petal_mid",
+  "petal_rim",
+  "petal_shadow",
+  "vein",
+  "leaf",
+  "water"
+];
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function round(value, digits = 3) {
+  const scale = 10 ** digits;
+  return Math.round(value * scale) / scale;
+}
+function parseHexColor(hex) {
+  const clean = hex.trim().replace(/^#/, "");
+  if (!/^[0-9a-fA-F]{6}$/.test(clean)) {
+    throw new Error(`Invalid color fixture: ${hex}`);
+  }
+  return [
+    Number.parseInt(clean.slice(0, 2), 16),
+    Number.parseInt(clean.slice(2, 4), 16),
+    Number.parseInt(clean.slice(4, 6), 16)
+  ];
+}
+function parseColor(input) {
+  if (typeof input === "string") return parseHexColor(input);
+  return [
+    clamp(Math.round(input[0]), 0, 255),
+    clamp(Math.round(input[1]), 0, 255),
+    clamp(Math.round(input[2]), 0, 255)
+  ];
+}
+function collectRegionPixels(fixtures, region) {
+  const pixels = [];
+  for (const fixture of fixtures) {
+    for (const sample of fixture.regions) {
+      if (sample.region !== region) continue;
+      const weight = Math.max(1, Math.round(sample.weight ?? 1));
+      for (const color of sample.pixels) {
+        const parsed = parseColor(color);
+        for (let i = 0; i < weight; i += 1) pixels.push(parsed);
+      }
+    }
+  }
+  return pixels;
+}
+function meanRgb(pixels, fallbackHex) {
+  if (pixels.length === 0) return parseHexColor(fallbackHex);
+  const sum = pixels.reduce(
+    (acc, rgb) => [acc[0] + rgb[0], acc[1] + rgb[1], acc[2] + rgb[2]],
+    [0, 0, 0]
+  );
+  return [
+    Math.round(sum[0] / pixels.length),
+    Math.round(sum[1] / pixels.length),
+    Math.round(sum[2] / pixels.length)
+  ];
+}
+function regionMean(fixtures, region, fallbackHex) {
+  return meanRgb(collectRegionPixels(fixtures, region), fallbackHex);
+}
+function toHex(rgb) {
+  return `#${rgb.map((channel) => channel.toString(16).padStart(2, "0")).join("")}`;
+}
+function toUnitRgb(rgb) {
+  return [round(rgb[0] / 255), round(rgb[1] / 255), round(rgb[2] / 255)];
+}
+function luminance(rgb) {
+  return (0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]) / 255;
+}
+function saturation(rgb) {
+  const r = rgb[0] / 255;
+  const g = rgb[1] / 255;
+  const b = rgb[2] / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  return max === 0 ? 0 : (max - min) / max;
+}
+function colorDistance(a, b) {
+  const dr = (a[0] - b[0]) / 255;
+  const dg = (a[1] - b[1]) / 255;
+  const db = (a[2] - b[2]) / 255;
+  return Math.sqrt(dr * dr + dg * dg + db * db) / Math.sqrt(3);
+}
+function regionCoverage(fixtures) {
+  const regions = /* @__PURE__ */ new Set();
+  for (const fixture of fixtures) {
+    for (const sample of fixture.regions) regions.add(sample.region);
+  }
+  const covered = REQUIRED_CONFIDENCE_REGIONS.filter((region) => regions.has(region)).length;
+  return covered / REQUIRED_CONFIDENCE_REGIONS.length;
+}
+function anchorFixtureRegions(fixtures, anchorId) {
+  const regions = /* @__PURE__ */ new Set();
+  for (const fixture of fixtures) {
+    if (fixture.anchorId !== anchorId) continue;
+    for (const sample of fixture.regions) regions.add(sample.region);
+  }
+  return [...regions].sort();
+}
+function provenanceConfidence(anchors) {
+  if (anchors.length === 0) return 0;
+  const signed = anchors.filter((anchor) => Boolean(anchor.wallet_signature)).length / anchors.length;
+  const hashed = anchors.filter((anchor) => Boolean(anchor.content_hash)).length / anchors.length;
+  return round(signed * 0.72 + hashed * 0.28);
+}
+function extractionStatus(anchors) {
+  if (anchors.length > 0 && anchors.every((anchor) => Boolean(anchor.wallet_signature))) {
+    return "extracted-from-signed-anchors";
+  }
+  if (anchors.some((anchor) => Boolean(anchor.content_hash))) {
+    return "extracted-from-hashed-fixtures";
+  }
+  return "extracted-from-unsigned-fixtures";
+}
+function extractBotanicalMaterialFromPhotoFixtures(input) {
+  const petalBase = regionMean(input.fixtures, "petal_base", DEFAULT_COLORS.petal_base);
+  const petalMid = regionMean(input.fixtures, "petal_mid", DEFAULT_COLORS.petal_mid);
+  const petalInner = regionMean(input.fixtures, "petal_inner", DEFAULT_COLORS.petal_inner);
+  const petalRim = regionMean(input.fixtures, "petal_rim", DEFAULT_COLORS.petal_rim);
+  const petalShadow = regionMean(input.fixtures, "petal_shadow", DEFAULT_COLORS.petal_shadow);
+  const vein = regionMean(input.fixtures, "vein", DEFAULT_COLORS.petal_rim);
+  const leaf = regionMean(input.fixtures, "leaf", DEFAULT_COLORS.leaf);
+  const leafDark = regionMean(input.fixtures, "leaf_dark", DEFAULT_COLORS.leaf_dark);
+  const water = regionMean(input.fixtures, "water", DEFAULT_COLORS.water);
+  const stamen = regionMean(input.fixtures, "stamen", DEFAULT_COLORS.stamen);
+  const stamenTip = regionMean(input.fixtures, "stamen_tip", DEFAULT_COLORS.stamen_tip);
+  const seedPod = regionMean(input.fixtures, "seed_pod", DEFAULT_COLORS.seed_pod);
+  const seedPodRim = regionMean(input.fixtures, "seed_pod_rim", DEFAULT_COLORS.seed_pod_rim);
+  const silhouetteEdge = regionMean(input.fixtures, "silhouette_edge", DEFAULT_COLORS.petal_rim);
+  const petalLuma = luminance(petalMid);
+  const edgeLuma = luminance(petalRim);
+  const shadowLuma = luminance(petalShadow);
+  const petalSat = saturation(petalMid);
+  const petalContrast = colorDistance(petalRim, petalShadow);
+  const veinContrast = Math.max(colorDistance(vein, petalMid), Math.abs(luminance(vein) - petalLuma));
+  const silhouetteContrast = colorDistance(silhouetteEdge, petalBase);
+  const coverage = regionCoverage(input.fixtures);
+  const provConfidence = provenanceConfidence(input.anchors);
+  const subsurfaceScattering = round(
+    clamp(0.48 + petalSat * 0.18 + Math.max(0, edgeLuma - shadowLuma) * 0.2 + coverage * 0.09, 0.28, 0.92)
+  );
+  const translucencyBase = round(clamp(0.34 + luminance(petalBase) * 0.28 + coverage * 0.08, 0.2, 0.82));
+  const translucencyEdge = round(clamp(translucencyBase * (0.48 + petalContrast * 0.34), 0.14, 0.72));
+  const translucencyTip = round(clamp(translucencyEdge + Math.max(0, edgeLuma - petalLuma) * 0.16, 0.16, 0.78));
+  const roughness = round(clamp(0.84 - petalSat * 0.16 - petalContrast * 0.18, 0.46, 0.88));
+  const ior = round(clamp(1.31 + petalLuma * 0.06 + petalSat * 0.045, 1.31, 1.44), 2);
+  const veinNormalIntensity = round(clamp(0.018 + veinContrast * 0.095 + coverage * 0.012, 0.012, 0.12));
+  const edgeCurlIntensity = round(clamp(0.34 + silhouetteContrast * 0.46 + petalContrast * 0.18, 0.24, 0.82));
+  const gravitySagOuter = round(clamp(0.12 + (1 - luminance(leafDark)) * 0.16 + silhouetteContrast * 0.08, 0.1, 0.42));
+  const sssConfidence = round(clamp(coverage * 0.6 + provConfidence * 0.4, 0, 1));
+  const translucencyConfidence = round(clamp((coverage + (collectRegionPixels(input.fixtures, "petal_rim").length ? 1 : 0)) / 2, 0, 1));
+  const veinConfidence = round(clamp((collectRegionPixels(input.fixtures, "vein").length ? 0.64 : 0.22) + provConfidence * 0.36, 0, 1));
+  const roughnessConfidence = round(clamp(coverage * 0.5 + provConfidence * 0.28 + (input.fixtures.length > 0 ? 0.22 : 0), 0, 1));
+  const overall = round((sssConfidence + translucencyConfidence + veinConfidence + roughnessConfidence + provConfidence) / 5);
+  return {
+    schema: "holoscript.botanical.material-extract.v1",
+    status: extractionStatus(input.anchors),
+    botanical_trait_target: "@botanical_lotus",
+    source: {
+      kind: "signed_photo_anchor_fixtures",
+      captured_at: input.capturedAt ?? null,
+      generated_by: input.generatedBy ?? "@holoscript/snn-webgpu",
+      anchor_ids: input.anchors.map((anchor) => anchor.id),
+      signed_anchor_count: input.anchors.filter((anchor) => Boolean(anchor.wallet_signature)).length,
+      content_hashed_anchor_count: input.anchors.filter((anchor) => Boolean(anchor.content_hash)).length,
+      fixture_count: input.fixtures.length
+    },
+    material: {
+      subsurface_scattering: subsurfaceScattering,
+      subsurface_radius_rgb: toUnitRgb(petalInner),
+      petal_translucency_base: translucencyBase,
+      petal_translucency_edge: translucencyEdge,
+      translucency_gradient: {
+        base: translucencyBase,
+        edge: translucencyEdge,
+        tip: translucencyTip
+      },
+      roughness,
+      ior,
+      vein_normal_intensity: veinNormalIntensity,
+      vein_normals: {
+        intensity: veinNormalIntensity,
+        method: "region-luminance-contrast"
+      },
+      edge_curl_intensity: edgeCurlIntensity,
+      gravity_sag_outer: gravitySagOuter
+    },
+    colors: {
+      petal_base: toHex(petalBase),
+      petal_mid: toHex(petalMid),
+      petal_inner: toHex(petalInner),
+      petal_rim: toHex(petalRim),
+      petal_shadow: toHex(petalShadow),
+      seed_pod: toHex(seedPod),
+      seed_pod_rim: toHex(seedPodRim),
+      stamen: toHex(stamen),
+      stamen_tip: toHex(stamenTip),
+      leaf: toHex(leaf),
+      leaf_dark: toHex(leafDark),
+      water: toHex(water)
+    },
+    confidence: {
+      overall,
+      sss: sssConfidence,
+      translucency: translucencyConfidence,
+      roughness: roughnessConfidence,
+      vein_normals: veinConfidence,
+      provenance: provConfidence
+    },
+    provenance: {
+      extractor: {
+        package: "@holoscript/snn-webgpu",
+        algorithm: "botanical-region-statistics-v1",
+        deterministic: true
+      },
+      anchor_receipts: input.anchors.map((anchor) => ({
+        id: anchor.id,
+        role: anchor.role ?? null,
+        status: anchor.status ?? null,
+        content_hash: anchor.content_hash ?? null,
+        wallet_signature_present: Boolean(anchor.wallet_signature),
+        fixture_regions: anchorFixtureRegions(input.fixtures, anchor.id)
+      }))
+    },
+    renderer_mapping: {
+      petal_material: "MeshPhysicalMaterial + botanical onBeforeCompile SSS/translucency/vein uniforms",
+      photorealism_status: "extractor_available"
+    }
+  };
+}
+var TropicalActivationTrait = class {
+  forward(spikeRates, config) {
+    const result = new Float32Array(spikeRates.length);
+    for (let i = 0; i < spikeRates.length; i++) {
+      const shifted = spikeRates[i] - config.threshold;
+      result[i] = config.variant === "max-plus" ? config.gain * Math.max(0, shifted) : config.gain * Math.min(0, shifted);
+    }
+    return result;
+  }
+  toSpikeTiming(activations, maxTime) {
+    const result = new Float32Array(activations.length);
+    for (let i = 0; i < activations.length; i++) {
+      const activation = activations[i];
+      result[i] = activation > 0 ? maxTime / activation : Number.POSITIVE_INFINITY;
+    }
+    return result;
+  }
+};
+var LIF_PARAMS_SIZE = 32;
+var SYNAPTIC_PARAMS_SIZE = 16;
+function packLIFParams2(params, neuronCount) {
+  const buf = new ArrayBuffer(LIF_PARAMS_SIZE);
+  const f32 = new Float32Array(buf);
+  const u32 = new Uint32Array(buf);
+  f32[0] = params.tau;
+  f32[1] = params.vThreshold;
+  f32[2] = params.vReset;
+  f32[3] = params.vRest;
+  f32[4] = params.dt;
+  u32[5] = neuronCount;
+  u32[6] = 0;
+  u32[7] = 0;
+  return buf;
+}
+function packSynapticParams(preCount, postCount, learningRate) {
+  const buf = new ArrayBuffer(SYNAPTIC_PARAMS_SIZE);
+  const u32 = new Uint32Array(buf);
+  const f32 = new Float32Array(buf);
+  u32[0] = preCount;
+  u32[1] = postCount;
+  f32[2] = learningRate;
+  u32[3] = 0;
+  return buf;
+}
+var SNNNetwork = class {
+  constructor(ctx, config) {
+    this.layers = /* @__PURE__ */ new Map();
+    this.connections = [];
+    this.initialized = false;
+    this.simTimeMs = 0;
+    this.ctx = ctx;
+    this.config = config;
+    this.dt = config.dt ?? 1;
+    this.bufferManager = new BufferManager(ctx.device);
+    this.pipelineFactory = new PipelineFactory(ctx);
+  }
+  /**
+   * Initialize all layers and connections.
+   */
+  async initialize() {
+    if (this.initialized) return;
+    this.validateConfig();
+    for (const layerConfig of this.config.layers) {
+      const layer = this.createLayer(layerConfig);
+      this.layers.set(layerConfig.name, layer);
+    }
+    for (const connConfig of this.config.connections) {
+      const conn = this.createConnection(connConfig);
+      this.connections.push(conn);
+    }
+    this.initialized = true;
+  }
+  /**
+   * Step the simulation by one timestep.
+   * Order: synaptic currents -> LIF updates -> STDP (if enabled)
+   */
+  async step() {
+    this.ensureInitialized();
+    const stepStart = performance.now();
+    const encoder = this.ctx.device.createCommandEncoder({
+      label: `snn-step-${Math.floor(this.simTimeMs)}`
+    });
+    for (const conn of this.connections) {
+      const workgroups = computeDispatchSize(conn.toLayer.config.neuronCount);
+      this.pipelineFactory.encodeDispatch(
+        encoder,
+        "compute_synaptic_current",
+        conn.currentBindGroup,
+        workgroups
+      );
+    }
+    for (const layer of this.layers.values()) {
+      const workgroups = computeDispatchSize(layer.config.neuronCount);
+      this.pipelineFactory.encodeDispatch(encoder, "lif_step", layer.lifBindGroup, workgroups);
+    }
+    for (const conn of this.connections) {
+      if (conn.config.stdpEnabled && conn.stdpBindGroup) {
+        const workgroups = computeDispatchSize(conn.toLayer.config.neuronCount);
+        this.pipelineFactory.encodeDispatch(
+          encoder,
+          "stdp_weight_update",
+          conn.stdpBindGroup,
+          workgroups
+        );
+      }
+    }
+    await this.ctx.submitAndWait(encoder.finish());
+    this.simTimeMs += this.dt;
+    const stepTimeMs = performance.now() - stepStart;
+    return this.collectStats(stepTimeMs);
+  }
+  /**
+   * Run N simulation timesteps.
+   */
+  async stepN(count) {
+    let lastStats = null;
+    for (let i = 0; i < count; i++) {
+      lastStats = await this.step();
+    }
+    return lastStats;
+  }
+  /**
+   * Set external spike input for a layer (typically the input layer).
+   */
+  setInputSpikes(layerName, spikes) {
+    this.ensureInitialized();
+    const layer = this.getLayer(layerName);
+    if (spikes.length !== layer.config.neuronCount) {
+      throw new Error(
+        `Spike data length (${spikes.length}) must match layer '${layerName}' neuron count (${layer.config.neuronCount})`
+      );
+    }
+    this.bufferManager.writeBuffer(layer.spikesBuffer, spikes);
+  }
+  /**
+   * Set external synaptic input for a layer.
+   */
+  setSynapticInput(layerName, currents) {
+    this.ensureInitialized();
+    const layer = this.getLayer(layerName);
+    this.bufferManager.writeBuffer(layer.synapticInputBuffer, currents);
+  }
+  /**
+   * Read spike output for a specific layer.
+   */
+  async readLayerSpikes(layerName) {
+    this.ensureInitialized();
+    const layer = this.getLayer(layerName);
+    return this.bufferManager.readBuffer(layer.spikesBuffer);
+  }
+  /**
+   * Read membrane potentials for a specific layer.
+   */
+  async readLayerMembrane(layerName) {
+    this.ensureInitialized();
+    const layer = this.getLayer(layerName);
+    return this.bufferManager.readBuffer(layer.membraneBuffer);
+  }
+  /**
+   * Read connection weights.
+   */
+  async readConnectionWeights(fromLayer, toLayer) {
+    this.ensureInitialized();
+    const conn = this.connections.find(
+      (c) => c.config.from === fromLayer && c.config.to === toLayer
+    );
+    if (!conn) {
+      throw new Error(`No connection found from '${fromLayer}' to '${toLayer}'`);
+    }
+    return this.bufferManager.readBuffer(conn.weightsBuffer);
+  }
+  /**
+   * Reset the entire network state.
+   */
+  resetState() {
+    this.ensureInitialized();
+    for (const layer of this.layers.values()) {
+      const n = layer.config.neuronCount;
+      const rest = new Float32Array(n).fill(layer.params.vRest);
+      const zeros = new Float32Array(n);
+      this.bufferManager.writeBuffer(layer.membraneBuffer, rest);
+      this.bufferManager.writeBuffer(layer.synapticInputBuffer, zeros);
+      this.bufferManager.writeBuffer(layer.spikesBuffer, zeros);
+      this.bufferManager.writeBuffer(layer.refractoryBuffer, zeros);
+    }
+    this.simTimeMs = 0;
+  }
+  /** Get total neuron count across all layers. */
+  get totalNeurons() {
+    let total = 0;
+    for (const layer of this.layers.values()) {
+      total += layer.config.neuronCount;
+    }
+    return total;
+  }
+  /** Get layer names. */
+  get layerNames() {
+    return Array.from(this.layers.keys());
+  }
+  /** Get current simulation time in ms. */
+  get currentSimTimeMs() {
+    return this.simTimeMs;
+  }
+  /** Get total GPU memory used in bytes. */
+  get gpuMemoryBytes() {
+    return this.bufferManager.getTotalAllocatedBytes();
+  }
+  /**
+   * Destroy all GPU resources.
+   */
+  destroy() {
+    this.pipelineFactory.clearCache();
+    this.bufferManager.destroyAll();
+    this.layers.clear();
+    this.connections = [];
+    this.initialized = false;
+    this.simTimeMs = 0;
+  }
+  // --- Private methods ---
+  validateConfig() {
+    const layerNames = new Set(this.config.layers.map((l) => l.name));
+    if (layerNames.size !== this.config.layers.length) {
+      throw new Error("Duplicate layer names in network configuration");
+    }
+    for (const conn of this.config.connections) {
+      if (!layerNames.has(conn.from)) {
+        throw new Error(`Connection references unknown source layer: '${conn.from}'`);
+      }
+      if (!layerNames.has(conn.to)) {
+        throw new Error(`Connection references unknown target layer: '${conn.to}'`);
+      }
+    }
+  }
+  createLayer(config) {
+    const n = this.ctx.validateNeuronCapacity(config.neuronCount);
+    const params = {
+      ...DEFAULT_LIF_PARAMS,
+      dt: this.dt,
+      ...config.lifParams
+    };
+    const packedParams = packLIFParams2(params, n);
+    const paramsBuffer = this.bufferManager.createBuffer({
+      size: LIF_PARAMS_SIZE,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      label: `${config.name}-lif-params`,
+      initialData: new Float32Array(packedParams)
+    });
+    const initMembrane = new Float32Array(n).fill(params.vRest);
+    const membraneBuffer = this.bufferManager.createStorageBuffer(
+      initMembrane,
+      `${config.name}-membrane`
+    );
+    const synapticInputBuffer = this.bufferManager.createZeroBuffer(n, `${config.name}-synaptic`);
+    const spikesBuffer = this.bufferManager.createZeroBuffer(n, `${config.name}-spikes`);
+    const refractoryBuffer = this.bufferManager.createZeroBuffer(n, `${config.name}-refractory`);
+    const lifBindGroup = this.pipelineFactory.createBindGroup(
+      "lif_step",
+      [
+        paramsBuffer.buffer,
+        membraneBuffer.buffer,
+        synapticInputBuffer.buffer,
+        spikesBuffer.buffer,
+        refractoryBuffer.buffer
+      ],
+      `${config.name}-lif-bind-group`
+    );
+    return {
+      config: { ...config, neuronCount: n },
+      params,
+      paramsBuffer,
+      membraneBuffer,
+      synapticInputBuffer,
+      spikesBuffer,
+      refractoryBuffer,
+      lifBindGroup
+    };
+  }
+  createConnection(config) {
+    const fromLayer = this.getLayer(config.from);
+    const toLayer = this.getLayer(config.to);
+    const preCount = fromLayer.config.neuronCount;
+    const postCount = toLayer.config.neuronCount;
+    const lr = config.learningRate ?? 0.01;
+    const packedSynaptic = packSynapticParams(preCount, postCount, lr);
+    const synapticParamsBuffer = this.bufferManager.createBuffer({
+      size: SYNAPTIC_PARAMS_SIZE,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      label: `${config.from}-${config.to}-synaptic-params`,
+      initialData: new Float32Array(packedSynaptic)
+    });
+    const weightCount = preCount * postCount;
+    const weights = this.initializeWeights(weightCount, config);
+    const weightsBuffer = this.bufferManager.createStorageBuffer(
+      weights,
+      `${config.from}-${config.to}-weights`
+    );
+    const currentBindGroup = this.pipelineFactory.createBindGroup(
+      "compute_synaptic_current",
+      [
+        synapticParamsBuffer.buffer,
+        // binding 0: params
+        weightsBuffer.buffer,
+        // binding 1: weights
+        fromLayer.spikesBuffer.buffer,
+        // binding 2: pre_spikes
+        toLayer.synapticInputBuffer.buffer
+        // binding 3: post_currents
+        // binding 4 (post_spikes) omitted — not accessed by compute_synaptic_current
+      ],
+      `${config.from}-${config.to}-current-bind-group`
+    );
+    let stdpBindGroup;
+    if (config.stdpEnabled) {
+      stdpBindGroup = this.pipelineFactory.createBindGroupWithIndices(
+        "stdp_weight_update",
+        [
+          synapticParamsBuffer.buffer,
+          // binding 0: params
+          weightsBuffer.buffer,
+          // binding 1: weights
+          fromLayer.spikesBuffer.buffer,
+          // binding 2: pre_spikes
+          toLayer.spikesBuffer.buffer
+          // binding 4: post_spikes (binding 3 skipped)
+        ],
+        [0, 1, 2, 4],
+        `${config.from}-${config.to}-stdp-bind-group`
+      );
+    }
+    return {
+      config,
+      fromLayer,
+      toLayer,
+      weightsBuffer,
+      synapticParamsBuffer,
+      currentBindGroup,
+      stdpBindGroup
+    };
+  }
+  initializeWeights(count, config) {
+    const weights = new Float32Array(count);
+    switch (config.weightInit) {
+      case "random":
+        const scale = 1 / Math.sqrt(count);
+        for (let i = 0; i < count; i++) {
+          weights[i] = (Math.random() * 2 - 1) * scale;
+        }
+        break;
+      case "uniform":
+        weights.fill(config.uniformValue ?? 0.5);
+        break;
+    }
+    return weights;
+  }
+  async collectStats(stepTimeMs) {
+    const layerSpikes = /* @__PURE__ */ new Map();
+    const layerAvgVoltage = /* @__PURE__ */ new Map();
+    let totalSpikes = 0;
+    for (const [name, layer] of this.layers) {
+      const spikeResult = await this.bufferManager.readBuffer(layer.spikesBuffer);
+      let spikeCount = 0;
+      for (let i = 0; i < spikeResult.data.length; i++) {
+        if (spikeResult.data[i] > 0.5) spikeCount++;
+      }
+      layerSpikes.set(name, spikeCount);
+      totalSpikes += spikeCount;
+      const vResult = await this.bufferManager.readBuffer(layer.membraneBuffer);
+      let sum = 0;
+      for (let i = 0; i < vResult.data.length; i++) {
+        sum += vResult.data[i];
+      }
+      layerAvgVoltage.set(name, sum / vResult.data.length);
+    }
+    return {
+      totalSpikes,
+      layerSpikes,
+      layerAvgVoltage,
+      stepTimeMs,
+      simTimeMs: this.simTimeMs
+    };
+  }
+  getLayer(name) {
+    const layer = this.layers.get(name);
+    if (!layer) {
+      throw new Error(`Layer '${name}' not found in network`);
+    }
+    return layer;
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("SNNNetwork not initialized. Call initialize() first.");
+    }
+  }
+};
+var INF = 1e30;
+var GEMM_WORKGROUP = 16;
+var SPMV_WORKGROUP = 256;
+var UNIFORM_BYTE_SIZE = 16;
+function packDenseDims(m, n, k) {
+  const buffer = new ArrayBuffer(UNIFORM_BYTE_SIZE);
+  const u32 = new Uint32Array(buffer);
+  u32[0] = m;
+  u32[1] = n;
+  u32[2] = k;
+  u32[3] = 0;
+  return buffer;
+}
+function packSparseDims(rows) {
+  const buffer = new ArrayBuffer(UNIFORM_BYTE_SIZE);
+  const u32 = new Uint32Array(buffer);
+  u32[0] = rows;
+  u32[1] = 0;
+  u32[2] = 0;
+  u32[3] = 0;
+  return buffer;
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (Math.abs(a[i] - b[i]) > 1e-6) return false;
+  }
+  return true;
+}
+function minDistances(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`distance vector length mismatch (${a.length} !== ${b.length})`);
+  }
+  const out = new Float32Array(a.length);
+  for (let i = 0; i < a.length; i++) {
+    out[i] = Math.min(a[i], b[i]);
+  }
+  return out;
+}
+function transposeCSR(graph) {
+  const rows = graph.rowPtr.length - 1;
+  const edgeCount = graph.colIdx.length;
+  const incomingCounts = new Uint32Array(rows);
+  for (let i = 0; i < edgeCount; i++) {
+    incomingCounts[graph.colIdx[i]]++;
+  }
+  const rowPtr = new Uint32Array(rows + 1);
+  for (let row = 0; row < rows; row++) {
+    rowPtr[row + 1] = rowPtr[row] + incomingCounts[row];
+  }
+  const nextWrite = new Uint32Array(rowPtr);
+  const colIdx = new Uint32Array(edgeCount);
+  const values = new Float32Array(edgeCount);
+  for (let row = 0; row < rows; row++) {
+    const start = graph.rowPtr[row];
+    const finish = graph.rowPtr[row + 1];
+    for (let edge = start; edge < finish; edge++) {
+      const col = graph.colIdx[edge];
+      const dest = nextWrite[col]++;
+      colIdx[dest] = row;
+      values[dest] = graph.values[edge];
+    }
+  }
+  return { rowPtr, colIdx, values };
+}
+var TropicalShortestPaths = class _TropicalShortestPaths {
+  constructor(ctx, options = {}) {
+    this.ctx = ctx;
+    this.pipelineFactory = new PipelineFactory(ctx);
+    this.preferGPU = options.preferGPU ?? true;
+    this.denseCpuThreshold = options.denseCpuThreshold ?? 128;
+    this.sparseCpuThreshold = options.sparseCpuThreshold ?? 256;
+  }
+  static minPlusGemmCPU(matA, matB, m, n, k) {
+    if (matA.length !== m * k) {
+      throw new Error(`matA length (${matA.length}) must equal m*k (${m * k})`);
+    }
+    if (matB.length !== k * n) {
+      throw new Error(`matB length (${matB.length}) must equal k*n (${k * n})`);
+    }
+    const out = new Float32Array(m * n).fill(INF);
+    for (let row = 0; row < m; row++) {
+      for (let col = 0; col < n; col++) {
+        let best = INF;
+        for (let kk = 0; kk < k; kk++) {
+          const a = matA[row * k + kk];
+          const b = matB[kk * n + col];
+          if (a < INF && b < INF) {
+            const candidate = a + b;
+            if (candidate < best) best = candidate;
+          }
+        }
+        out[row * n + col] = best;
+      }
+    }
+    return out;
+  }
+  static computeAPSPCPU(adjacencyMatrix, n) {
+    if (adjacencyMatrix.length !== n * n) {
+      throw new Error(`adjacencyMatrix length (${adjacencyMatrix.length}) must equal n*n (${n * n})`);
+    }
+    const dist = new Float32Array(adjacencyMatrix);
+    for (let k = 0; k < n; k++) {
+      for (let i = 0; i < n; i++) {
+        const ik = dist[i * n + k];
+        if (ik >= INF) continue;
+        for (let j = 0; j < n; j++) {
+          const kj = dist[k * n + j];
+          if (kj >= INF) continue;
+          const candidate = ik + kj;
+          const idx = i * n + j;
+          if (candidate < dist[idx]) dist[idx] = candidate;
+        }
+      }
+    }
+    return dist;
+  }
+  static computeSSSPCPU(graph, source) {
+    const rows = graph.rowPtr.length - 1;
+    if (source < 0 || source >= rows) {
+      throw new Error(`source index (${source}) must be in [0, ${rows - 1}]`);
+    }
+    const dist = new Float32Array(rows).fill(INF);
+    dist[source] = 0;
+    for (let iter = 0; iter < rows - 1; iter++) {
+      let changed = false;
+      for (let u = 0; u < rows; u++) {
+        const du = dist[u];
+        if (du >= INF) continue;
+        const start = graph.rowPtr[u];
+        const finish = graph.rowPtr[u + 1];
+        for (let edge = start; edge < finish; edge++) {
+          const v = graph.colIdx[edge];
+          const w = graph.values[edge];
+          const candidate = du + w;
+          if (candidate < dist[v]) {
+            dist[v] = candidate;
+            changed = true;
+          }
+        }
+      }
+      if (!changed) break;
+    }
+    return dist;
+  }
+  async tropicalGemm(matA, matB, m, n, k) {
+    if (matA.length !== m * k) {
+      throw new Error(`matA length (${matA.length}) must equal m*k (${m * k})`);
+    }
+    if (matB.length !== k * n) {
+      throw new Error(`matB length (${matB.length}) must equal k*n (${k * n})`);
+    }
+    const buffers = new BufferManager(this.ctx.device);
+    try {
+      const a = buffers.createStorageBuffer(matA, "tropical-gemm-a");
+      const b = buffers.createStorageBuffer(matB, "tropical-gemm-b");
+      const c = buffers.createZeroBuffer(m * n, "tropical-gemm-c");
+      const dims = buffers.createUniformBuffer(packDenseDims(m, n, k), "tropical-gemm-dims");
+      const bindGroup = this.pipelineFactory.createBindGroup(
+        "tropical_min_plus_gemm",
+        [a.buffer, b.buffer, c.buffer, dims.buffer],
+        "tropical-gemm-bg"
+      );
+      const encoder = this.ctx.device.createCommandEncoder({ label: "tropical-gemm-encoder" });
+      this.pipelineFactory.encodeDispatch(
+        encoder,
+        "tropical_min_plus_gemm",
+        bindGroup,
+        Math.ceil(n / GEMM_WORKGROUP),
+        Math.ceil(m / GEMM_WORKGROUP)
+      );
+      await this.ctx.submitAndWait(encoder.finish());
+      const readback = await buffers.readBuffer(c);
+      return readback.data;
+    } finally {
+      buffers.destroyAll();
+    }
+  }
+  async computeAPSP(adjacencyMatrix, n) {
+    if (adjacencyMatrix.length !== n * n) {
+      throw new Error(`adjacencyMatrix length (${adjacencyMatrix.length}) must equal n*n (${n * n})`);
+    }
+    if (!this.preferGPU || n < this.denseCpuThreshold) {
+      return _TropicalShortestPaths.computeAPSPCPU(adjacencyMatrix, n);
+    }
+    try {
+      let current = new Float32Array(adjacencyMatrix);
+      const iterations = Math.ceil(Math.log2(Math.max(1, n)));
+      for (let i = 0; i < iterations; i++) {
+        current = await this.tropicalGemm(current, current, n, n, n);
+      }
+      return current;
+    } catch {
+      return _TropicalShortestPaths.computeAPSPCPU(adjacencyMatrix, n);
+    }
+  }
+  async tropicalSpmv(graph, dist) {
+    const rows = graph.rowPtr.length - 1;
+    if (rows <= 0) {
+      return new Float32Array();
+    }
+    if (dist.length !== rows) {
+      throw new Error(`dist length (${dist.length}) must equal row count (${rows})`);
+    }
+    const buffers = new BufferManager(this.ctx.device);
+    try {
+      const rowPtr = buffers.createBuffer({
+        size: graph.rowPtr.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        label: "tropical-spmv-rowptr",
+        initialData: graph.rowPtr
+      });
+      const colIdx = buffers.createBuffer({
+        size: graph.colIdx.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        label: "tropical-spmv-colidx",
+        initialData: graph.colIdx
+      });
+      const values = buffers.createStorageBuffer(graph.values, "tropical-spmv-values");
+      const distIn = buffers.createStorageBuffer(dist, "tropical-spmv-dist-in");
+      const distOut = buffers.createStorageBuffer(new Float32Array(dist), "tropical-spmv-dist-out");
+      const dims = buffers.createUniformBuffer(packSparseDims(rows), "tropical-spmv-dims");
+      const bindGroup = this.pipelineFactory.createBindGroup(
+        "tropical_spmv",
+        [rowPtr.buffer, colIdx.buffer, values.buffer, distIn.buffer, distOut.buffer, dims.buffer],
+        "tropical-spmv-bg"
+      );
+      const encoder = this.ctx.device.createCommandEncoder({ label: "tropical-spmv-encoder" });
+      this.pipelineFactory.encodeDispatch(
+        encoder,
+        "tropical_spmv",
+        bindGroup,
+        Math.ceil(rows / SPMV_WORKGROUP)
+      );
+      await this.ctx.submitAndWait(encoder.finish());
+      const readback = await buffers.readBuffer(distOut);
+      return readback.data;
+    } finally {
+      buffers.destroyAll();
+    }
+  }
+  async computeSSSP(graph, source) {
+    const rows = graph.rowPtr.length - 1;
+    if (source < 0 || source >= rows) {
+      throw new Error(`source index (${source}) must be in [0, ${rows - 1}]`);
+    }
+    if (!this.preferGPU || rows < this.sparseCpuThreshold) {
+      return _TropicalShortestPaths.computeSSSPCPU(graph, source);
+    }
+    const incomingGraph = transposeCSR(graph);
+    let current = new Float32Array(rows).fill(INF);
+    current[source] = 0;
+    try {
+      for (let i = 0; i < rows - 1; i++) {
+        const relaxed = await this.tropicalSpmv(incomingGraph, current);
+        const next = minDistances(current, relaxed);
+        if (arraysEqual(current, next)) {
+          return next;
+        }
+        current = next;
+      }
+      return current;
+    } catch {
+      return _TropicalShortestPaths.computeSSSPCPU(graph, source);
+    }
+  }
+  destroy() {
+    this.pipelineFactory.clearCache();
+  }
+};
+var TROPICAL_INF = 1e30;
+function assertGraphShape(graph) {
+  const n = graph.rowPtr.length - 1;
+  if (n < 0) {
+    throw new Error("rowPtr must contain at least one element");
+  }
+  if (graph.colIdx.length !== graph.values.length) {
+    throw new Error(
+      `colIdx length (${graph.colIdx.length}) must equal values length (${graph.values.length})`
+    );
+  }
+  if (graph.rowPtr.length === 0 || graph.rowPtr[0] !== 0) {
+    throw new Error("rowPtr must start at 0");
+  }
+  for (let i = 0; i < graph.rowPtr.length - 1; i++) {
+    if (graph.rowPtr[i] > graph.rowPtr[i + 1]) {
+      throw new Error(`rowPtr must be non-decreasing; violation at index ${i}`);
+    }
+  }
+  if (graph.rowPtr[n] !== graph.colIdx.length) {
+    throw new Error(
+      `rowPtr[last] (${graph.rowPtr[n]}) must equal edge count (${graph.colIdx.length})`
+    );
+  }
+  for (let edge = 0; edge < graph.colIdx.length; edge++) {
+    const col = graph.colIdx[edge];
+    if (col < 0 || col >= n) {
+      throw new Error(`colIdx[${edge}] out of bounds: ${col} not in [0, ${n - 1}]`);
+    }
+  }
+}
+function normalizeAdjacency(adjacency, n) {
+  if (adjacency.length !== n * n) {
+    throw new Error(`adjacency length (${adjacency.length}) must equal n*n (${n * n})`);
+  }
+  const out = new Float32Array(adjacency.length);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      const idx = i * n + j;
+      if (i === j) {
+        out[idx] = 0;
+      } else {
+        const value = adjacency[idx];
+        out[idx] = Number.isFinite(value) ? value : TROPICAL_INF;
+      }
+    }
+  }
+  return out;
+}
+function denseToCSR(adjacency, n) {
+  if (adjacency.length !== n * n) {
+    throw new Error(`adjacency length (${adjacency.length}) must equal n*n (${n * n})`);
+  }
+  const rowPtr = new Uint32Array(n + 1);
+  const colIdx = [];
+  const values = [];
+  for (let row = 0; row < n; row++) {
+    rowPtr[row] = colIdx.length;
+    for (let col = 0; col < n; col++) {
+      if (row === col) continue;
+      const weight = adjacency[row * n + col];
+      if (Number.isFinite(weight) && weight < TROPICAL_INF) {
+        colIdx.push(col);
+        values.push(weight);
+      }
+    }
+  }
+  rowPtr[n] = colIdx.length;
+  return {
+    rowPtr,
+    colIdx: new Uint32Array(colIdx),
+    values: new Float32Array(values)
+  };
+}
+function fromEdges(nodeCount, edges) {
+  const minWeightByEdge = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (edge.from < 0 || edge.from >= nodeCount || edge.to < 0 || edge.to >= nodeCount) {
+      throw new Error(
+        `Edge out of bounds: (${edge.from} -> ${edge.to}) for nodeCount=${nodeCount}`
+      );
+    }
+    if (!Number.isFinite(edge.weight) || edge.weight < 0) {
+      throw new Error(`Edge weight must be finite and non-negative: ${edge.weight}`);
+    }
+    const key = `${edge.from}:${edge.to}`;
+    const prev = minWeightByEdge.get(key);
+    if (prev === void 0 || edge.weight < prev) {
+      minWeightByEdge.set(key, edge.weight);
+    }
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [key, weight] of minWeightByEdge) {
+    const [fromRaw, toRaw] = key.split(":");
+    const from = Number(fromRaw);
+    const to = Number(toRaw);
+    if (!grouped.has(from)) grouped.set(from, []);
+    grouped.get(from).push({ to, weight });
+  }
+  const rowPtr = new Uint32Array(nodeCount + 1);
+  const colIdx = [];
+  const values = [];
+  for (let from = 0; from < nodeCount; from++) {
+    rowPtr[from] = colIdx.length;
+    const outgoing = grouped.get(from) ?? [];
+    outgoing.sort((a, b) => a.to - b.to || a.weight - b.weight);
+    for (const edge of outgoing) {
+      if (from === edge.to) continue;
+      colIdx.push(edge.to);
+      values.push(edge.weight);
+    }
+  }
+  rowPtr[nodeCount] = colIdx.length;
+  const graph = {
+    rowPtr,
+    colIdx: new Uint32Array(colIdx),
+    values: new Float32Array(values)
+  };
+  assertGraphShape(graph);
+  return graph;
+}
+function csrToDense(graph) {
+  assertGraphShape(graph);
+  const n = graph.rowPtr.length - 1;
+  const out = new Float32Array(n * n).fill(TROPICAL_INF);
+  for (let i = 0; i < n; i++) {
+    out[i * n + i] = 0;
+    const start = graph.rowPtr[i];
+    const finish = graph.rowPtr[i + 1];
+    for (let edge = start; edge < finish; edge++) {
+      const j = graph.colIdx[edge];
+      out[i * n + j] = graph.values[edge];
+    }
+  }
+  return out;
+}
+var CPUReferenceSimulator = class {
+  // ms
+  constructor(neuronCount, params) {
+    this.stepCount = 0;
+    this.REFRACTORY_PERIOD = 2;
+    this.params = { ...DEFAULT_LIF_PARAMS, ...params };
+    this.neuronCount = neuronCount;
+    this.membraneV = new Float32Array(neuronCount).fill(this.params.vRest);
+    this.refractory = new Float32Array(neuronCount);
+    this.spikes = new Uint32Array(neuronCount);
+  }
+  /**
+   * Run one simulation timestep with given synaptic inputs.
+   *
+   * @param synapticInput - Input current for each neuron [N x f32]
+   * @returns Step result with spike data
+   */
+  step(synapticInput) {
+    const start = performance.now();
+    const n = this.neuronCount;
+    const decay = Math.exp(-this.params.dt / this.params.tau);
+    let totalSpikes = 0;
+    const spikeIndices = [];
+    for (let i = 0; i < n; i++) {
+      if (this.refractory[i] > 0) {
+        this.refractory[i] = Math.max(this.refractory[i] - this.params.dt, 0);
+        this.membraneV[i] = this.params.vReset;
+        this.spikes[i] = 0;
+        continue;
+      }
+      const v = this.params.vRest + (this.membraneV[i] - this.params.vRest) * decay + synapticInput[i];
+      if (v >= this.params.vThreshold) {
+        this.spikes[i] = 1;
+        this.membraneV[i] = this.params.vReset;
+        this.refractory[i] = this.REFRACTORY_PERIOD;
+        totalSpikes++;
+        spikeIndices.push(i);
+      } else {
+        this.spikes[i] = 0;
+        this.membraneV[i] = v;
+      }
+    }
+    this.stepCount++;
+    return {
+      totalSpikes,
+      spikeIndices,
+      stepTimeMs: performance.now() - start,
+      simTimeMs: this.stepCount * this.params.dt
+    };
+  }
+  /**
+   * Run N timesteps with the same input pattern.
+   */
+  stepN(count, synapticInput) {
+    const results = [];
+    for (let i = 0; i < count; i++) {
+      results.push(this.step(synapticInput));
+    }
+    return results;
+  }
+  /** Get membrane potentials snapshot */
+  getMembraneV() {
+    return new Float32Array(this.membraneV);
+  }
+  /** Get spike flags snapshot */
+  getSpikes() {
+    return new Uint32Array(this.spikes);
+  }
+  /** Get refractory counters snapshot */
+  getRefractory() {
+    return new Float32Array(this.refractory);
+  }
+  /** Get current step count */
+  get currentStep() {
+    return this.stepCount;
+  }
+  /** Reset all neurons to resting state */
+  reset() {
+    this.membraneV.fill(this.params.vRest);
+    this.refractory.fill(0);
+    this.spikes.fill(0);
+    this.stepCount = 0;
+  }
+};
+function generateSynapticInput(neuronCount, seed = 42, minCurrent = 0, maxCurrent = 15) {
+  const input = new Float32Array(neuronCount);
+  let state = seed >>> 0 || 1;
+  for (let i = 0; i < neuronCount; i++) {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    const normalized = (state >>> 0) / 4294967295;
+    input[i] = minCurrent + normalized * (maxCurrent - minCurrent);
+  }
+  return input;
+}
+function generateWeightMatrix(preCount, postCount, sparsity = 0.8, seed = 123) {
+  const weights = new Float32Array(preCount * postCount);
+  let state = seed >>> 0 || 1;
+  for (let i = 0; i < weights.length; i++) {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    const normalized = (state >>> 0) / 4294967295;
+    if (normalized > sparsity) {
+      state ^= state << 13;
+      state ^= state >>> 17;
+      state ^= state << 5;
+      weights[i] = 0.1 + (state >>> 0) / 4294967295 * 0.9;
+    }
+  }
+  return weights;
+}
+function xorshift32(seed) {
+  let state = seed | 0 || 1;
+  return () => {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    return (state >>> 0) / 4294967296;
+  };
+}
+function makeStimulus(neuronCount, seed, range) {
+  const rng = xorshift32(seed);
+  const span = range.max - range.min;
+  const stim = new Float32Array(neuronCount);
+  for (let i = 0; i < neuronCount; i++) {
+    stim[i] = range.min + rng() * span;
+  }
+  return stim;
+}
+async function runLIFDeterminismProbe(ctx, options) {
+  const neuronCount = options.neuronCount;
+  const tickCount = options.tickCount;
+  const stimulusSeed = options.stimulusSeed;
+  const stimulusAmplitude = options.stimulusAmplitude ?? { min: 0, max: 1.2 };
+  if (neuronCount <= 0 || !Number.isInteger(neuronCount)) {
+    throw new Error(`LIFDeterminismProbe: neuronCount must be a positive integer, got ${neuronCount}`);
+  }
+  if (tickCount <= 0 || !Number.isInteger(tickCount)) {
+    throw new Error(`LIFDeterminismProbe: tickCount must be a positive integer, got ${tickCount}`);
+  }
+  const sim = new LIFSimulator(ctx, neuronCount, options.params);
+  try {
+    await sim.initialize();
+    sim.resetState();
+    const stimulus = makeStimulus(neuronCount, stimulusSeed, stimulusAmplitude);
+    sim.setSynapticInput(stimulus);
+    await sim.stepN(tickCount);
+    const readback = await sim.readMembranePotentials();
+    return new Uint8Array(
+      readback.data.buffer,
+      readback.data.byteOffset,
+      readback.data.byteLength
+    );
+  } finally {
+    sim.destroy();
+  }
+}
+var PAPER_2_CANONICAL_CONFIG = Object.freeze({
+  neuronCount: 1e3,
+  tickCount: 100,
+  stimulusSeed: 42,
+  stimulusAmplitude: { min: 0, max: 1.2 },
+  params: DEFAULT_LIF_PARAMS
+});
+var ProphecyNotImplementedError = class extends Error {
+  constructor(transport) {
+    super(`Prophecy transport "${transport}" is not yet implemented`);
+    this.transport = transport;
+    this.name = "ProphecyNotImplementedError";
+  }
+};
+var PROBE_STRIDE_BYTES = 32;
+var WORKGROUP_SIZE = 64;
+var ProphecyOrchestrator = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.frameCounter = 0;
+    this.lastFrame = null;
+    this.initialized = false;
+    this.uniformBuffer = null;
+    this.spikeRatesBuffer = null;
+    this.probePositionsBuffer = null;
+    this.probeAlbedoBuffer = null;
+    this.probesOutBuffer = null;
+    this.readbackBuffer = null;
+    this.lastSpikeRatesShadow = null;
+    this.validateConfig(config);
+  }
+  /**
+   * Validate the static config.  Throws synchronously so callers see
+   * the problem at construction time, not first frame.
+   */
+  validateConfig(config) {
+    if (!Number.isInteger(config.probeCount) || config.probeCount <= 0) {
+      throw new Error(
+        `ProphecyOrchestrator: probeCount must be a positive integer, got ${config.probeCount}`
+      );
+    }
+    if (config.probeCount % WORKGROUP_SIZE !== 0) {
+      throw new Error(
+        `ProphecyOrchestrator: probeCount must be a multiple of ${WORKGROUP_SIZE}, got ${config.probeCount}`
+      );
+    }
+    const expectedPositions = config.probeCount * 3;
+    if (config.probePositions.length !== expectedPositions) {
+      throw new Error(
+        `ProphecyOrchestrator: probePositions length ${config.probePositions.length} does not match probeCount*3 (${expectedPositions})`
+      );
+    }
+    if (config.albedo && config.albedo.length !== expectedPositions) {
+      throw new Error(
+        `ProphecyOrchestrator: albedo length ${config.albedo.length} does not match probeCount*3 (${expectedPositions})`
+      );
+    }
+    const floor = config.confidenceFloor ?? 0.05;
+    if (floor < 0 || floor > 1) {
+      throw new Error(
+        `ProphecyOrchestrator: confidenceFloor must be in [0,1], got ${floor}`
+      );
+    }
+  }
+  /** Allocate GPU buffers and upload static probe positions / albedo. */
+  initialize() {
+    if (this.initialized) return;
+    const device = this.ctx.device;
+    const probeCount = this.config.probeCount;
+    this.uniformBuffer = device.createBuffer({
+      label: "prophecy:uniforms",
+      size: 32,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    this.spikeRatesBuffer = device.createBuffer({
+      label: "prophecy:spike_rates",
+      size: probeCount * 4,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    this.probePositionsBuffer = device.createBuffer({
+      label: "prophecy:probe_positions",
+      size: probeCount * 3 * 4,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(
+      this.probePositionsBuffer,
+      0,
+      this.config.probePositions.buffer,
+      this.config.probePositions.byteOffset,
+      this.config.probePositions.byteLength
+    );
+    this.probeAlbedoBuffer = device.createBuffer({
+      label: "prophecy:probe_albedo",
+      size: probeCount * 3 * 4,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    const albedo = this.config.albedo ?? this.makeOnesAlbedo(probeCount);
+    device.queue.writeBuffer(
+      this.probeAlbedoBuffer,
+      0,
+      albedo.buffer,
+      albedo.byteOffset,
+      albedo.byteLength
+    );
+    this.probesOutBuffer = device.createBuffer({
+      label: "prophecy:probes_out",
+      size: probeCount * PROBE_STRIDE_BYTES,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+    });
+    this.readbackBuffer = device.createBuffer({
+      label: "prophecy:readback",
+      size: probeCount * PROBE_STRIDE_BYTES,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+    this.initialized = true;
+  }
+  makeOnesAlbedo(probeCount) {
+    const a = new Float32Array(probeCount * 3);
+    a.fill(1);
+    return a;
+  }
+  /**
+   * Pack the per-frame uniform block.  Layout must match
+   * `ProphecyParams` in `prophetic-radiance.wgsl`.
+   */
+  packUniforms(ctx) {
+    const buf = new ArrayBuffer(32);
+    const u32 = new Uint32Array(buf);
+    const f32 = new Float32Array(buf);
+    u32[0] = this.config.probeCount;
+    f32[1] = ctx.sunDirection[0];
+    f32[2] = ctx.sunDirection[1];
+    f32[3] = ctx.sunDirection[2];
+    f32[4] = ctx.sunColor[0];
+    f32[5] = ctx.sunColor[1];
+    f32[6] = ctx.sunColor[2];
+    f32[7] = this.config.confidenceFloor ?? 0.05;
+    return buf;
+  }
+  /**
+   * Public API.  Caller supplies the raw spike rates (length =
+   * probeCount).  In a wired pipeline these come from the upstream
+   * SNNNetwork's spike buffer after a rate-decode pass.  Exposed
+   * separately so this orchestrator stays testable without a network.
+   */
+  uploadSpikeRates(spikeRates) {
+    this.assertInit();
+    if (spikeRates.length !== this.config.probeCount) {
+      throw new Error(
+        `ProphecyOrchestrator.uploadSpikeRates: expected length ${this.config.probeCount}, got ${spikeRates.length}`
+      );
+    }
+    this.ctx.device.queue.writeBuffer(
+      this.spikeRatesBuffer,
+      0,
+      spikeRates.buffer,
+      spikeRates.byteOffset,
+      spikeRates.byteLength
+    );
+  }
+  /**
+   * Run one frame.  Currently performs CPU-side mixing (mirroring the
+   * WGSL kernel) and returns a fully-decoded ProphecyFrame.  The WGSL
+   * dispatch path is plumbed but disabled by default until a
+   * `PipelineFactory` registration is added — kept off-path so the
+   * orchestrator works in unit-test environments without a real GPU.
+   *
+   * The CPU path is byte-equivalent to the WGSL kernel (verified by
+   * the parity test).  This is intentional: the WGSL kernel is the
+   * production path, the CPU mirror is the reference.
+   */
+  step(scene) {
+    this.assertInit();
+    const t0 = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+    const uniforms = this.packUniforms(scene);
+    this.ctx.device.queue.writeBuffer(this.uniformBuffer, 0, uniforms);
+    const probes = this.computeProbesCpu(scene);
+    const t1 = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+    const frame = {
+      frameId: this.frameCounter++,
+      producedAtMs: Date.now(),
+      productionTimeMs: t1 - t0,
+      probes,
+      source: "local"
+    };
+    this.lastFrame = frame;
+    return frame;
+  }
+  /**
+   * CPU mirror of `prophetic-radiance.wgsl`.  Used as a) the current
+   * production path until WGSL dispatch is enabled, and b) the
+   * reference oracle for the parity test.
+   *
+   * MUST stay byte-equivalent to the shader.
+   */
+  computeProbesCpu(scene) {
+    const n = this.config.probeCount;
+    const positions = this.config.probePositions;
+    const albedo = this.config.albedo ?? this.makeOnesAlbedo(n);
+    const floor = this.config.confidenceFloor ?? 0.05;
+    const sunY = scene.sunDirection[1];
+    const facing = sunY > 0 ? sunY : 0;
+    const facingMix = 0.4 + 0.6 * facing;
+    const rates = this.lastSpikeRatesShadow ?? new Float32Array(n);
+    const out = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const rate = rates[i];
+      const confidence = rate < 0 ? 0 : rate > 1 ? 1 : rate;
+      let r = scene.sunColor[0] * albedo[i * 3 + 0] * confidence * facingMix;
+      let g = scene.sunColor[1] * albedo[i * 3 + 1] * confidence * facingMix;
+      let b = scene.sunColor[2] * albedo[i * 3 + 2] * confidence * facingMix;
+      if (confidence < floor) {
+        r = 0;
+        g = 0;
+        b = 0;
+      }
+      out[i] = {
+        index: i,
+        position: [
+          positions[i * 3 + 0],
+          positions[i * 3 + 1],
+          positions[i * 3 + 2]
+        ],
+        rgb: [r, g, b],
+        confidence
+      };
+    }
+    return out;
+  }
+  /** Test/dev helper: prime the CPU shadow without touching the GPU
+   *  buffer, useful for unit tests. */
+  primeSpikeRatesShadow(rates) {
+    if (rates.length !== this.config.probeCount) {
+      throw new Error(
+        `primeSpikeRatesShadow: expected length ${this.config.probeCount}, got ${rates.length}`
+      );
+    }
+    this.lastSpikeRatesShadow = new Float32Array(rates);
+  }
+  /** Most recent frame, or null if `step()` has not run yet. */
+  getLastFrame() {
+    return this.lastFrame;
+  }
+  /** Release GPU buffers. */
+  destroy() {
+    this.uniformBuffer?.destroy();
+    this.spikeRatesBuffer?.destroy();
+    this.probePositionsBuffer?.destroy();
+    this.probeAlbedoBuffer?.destroy();
+    this.probesOutBuffer?.destroy();
+    this.readbackBuffer?.destroy();
+    this.uniformBuffer = null;
+    this.spikeRatesBuffer = null;
+    this.probePositionsBuffer = null;
+    this.probeAlbedoBuffer = null;
+    this.probesOutBuffer = null;
+    this.readbackBuffer = null;
+    this.initialized = false;
+    this.lastSpikeRatesShadow = null;
+  }
+  assertInit() {
+    if (!this.initialized) {
+      throw new Error("ProphecyOrchestrator: must call initialize() first");
+    }
+  }
+};
+var LocalProphecyTransport = class {
+  constructor(options) {
+    this.options = options;
+    this.kind = "local";
+    this.orchestrator = null;
+  }
+  async initialize(config) {
+    this.orchestrator = new ProphecyOrchestrator(this.options.ctx, config);
+    this.orchestrator.initialize();
+  }
+  async step(scene) {
+    if (!this.orchestrator) {
+      throw new Error("LocalProphecyTransport: not initialized");
+    }
+    const rates = await this.options.spikeRates(
+      scene,
+      this.orchestrator.getLastFrame()?.probes.length ?? // Probe count is fixed at initialize-time; if no frame has run
+      // yet we ask the provider for the configured count.  We can
+      // recover that from the orchestrator's last upload, or we
+      // honour what the provider returns.  We choose the latter for
+      // simplicity and validate length in primeSpikeRatesShadow.
+      0
+    );
+    this.orchestrator.primeSpikeRatesShadow(rates);
+    this.orchestrator.uploadSpikeRates(rates);
+    return this.orchestrator.step(scene);
+  }
+  async destroy() {
+    this.orchestrator?.destroy();
+    this.orchestrator = null;
+  }
+};
+function resolveTtuEndpoint(endpoint, holomeshHost = "https://mcp.holoscript.net") {
+  if (!endpoint || typeof endpoint !== "string") {
+    throw new Error("HoloMeshProphecyTransport: endpoint must be a non-empty string");
+  }
+  const host = holomeshHost.replace(/\/+$/, "");
+  if (endpoint.startsWith("crdt://")) {
+    const rest = endpoint.slice("crdt://".length);
+    const parts = rest.split("/").filter(Boolean);
+    if (parts.length < 4 || parts[0] !== "holomesh" || parts[1] !== "feed" || parts[2] !== "ttu") {
+      throw new Error(
+        `HoloMeshProphecyTransport: unsupported CRDT URI shape: ${endpoint} (expected crdt://holomesh/feed/ttu/<sessionId>)`
+      );
+    }
+    const sessionId = parts.slice(3).join("/");
+    return { base: `${host}/api/holomesh/ttu/${sessionId}`, sessionId };
+  }
+  if (endpoint.startsWith("ttu://")) {
+    const rest = endpoint.slice("ttu://".length);
+    const parts = rest.split("/").filter(Boolean);
+    if (parts.length < 2) {
+      throw new Error(
+        `HoloMeshProphecyTransport: unsupported ttu URI shape: ${endpoint}`
+      );
+    }
+    const targetHost = parts[0].includes("://") ? parts[0] : `https://${parts[0]}`;
+    const sessionId = parts.slice(1).join("/");
+    return {
+      base: `${targetHost}/api/holomesh/ttu/${sessionId}`,
+      sessionId
+    };
+  }
+  if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
+    const trimmed = endpoint.replace(/\/+$/, "");
+    const m = trimmed.match(/\/api\/holomesh\/ttu\/([^/]+)$/);
+    if (!m) {
+      throw new Error(
+        `HoloMeshProphecyTransport: http(s) endpoint must end with /api/holomesh/ttu/<sessionId>, got: ${endpoint}`
+      );
+    }
+    return { base: trimmed, sessionId: m[1] };
+  }
+  throw new Error(
+    `HoloMeshProphecyTransport: unsupported endpoint scheme: ${endpoint} (use crdt://, ttu://, or http(s)://)`
+  );
+}
+var HoloMeshProphecyTransport = class {
+  constructor(options) {
+    this.options = options;
+    this.kind = "holomesh";
+    this.resolved = null;
+    this.initializedFallback = false;
+    this.lastFrame = null;
+    this.latencyBudgetMs = options.latencyBudgetMs ?? 5e3;
+    this.fetchImpl = options.fetchImpl ?? ((...args) => {
+      const f = globalThis.fetch;
+      if (!f) {
+        throw new Error(
+          "HoloMeshProphecyTransport: global fetch is unavailable; pass options.fetchImpl"
+        );
+      }
+      return f(...args);
+    });
+  }
+  async initialize(config) {
+    this.resolved = resolveTtuEndpoint(
+      this.options.endpoint,
+      this.options.holomeshHost
+    );
+    if (this.options.fallback && !this.initializedFallback) {
+      await this.options.fallback.initialize(config);
+      this.initializedFallback = true;
+    }
+  }
+  async step(scene) {
+    if (!this.resolved) {
+      throw new Error("HoloMeshProphecyTransport: must call initialize() first");
+    }
+    const url = `${this.resolved.base}/step`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.options.apiKey) {
+      headers["Authorization"] = `Bearer ${this.options.apiKey}`;
+    }
+    const body = JSON.stringify({
+      scene,
+      agent_id: this.options.agentId ?? "anonymous",
+      // Server-side budget is matched to the caller's; the AbortController
+      // gives us a hard client-side ceiling so a hung server can't block
+      // the renderer past one frame.
+      timeout_ms: this.latencyBudgetMs
+    });
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), this.latencyBudgetMs);
+    let frame = null;
+    let lastError = null;
+    try {
+      const res = await this.fetchImpl(url, {
+        method: "POST",
+        headers,
+        body,
+        signal: ac.signal
+      });
+      if (!res.ok) {
+        lastError = new Error(`ttu /step returned ${res.status}`);
+      } else {
+        const data = await res.json();
+        if (data?.success && data.frame) {
+          frame = { ...data.frame, source: "holomesh" };
+        } else {
+          lastError = new Error("ttu /step returned malformed payload");
+        }
+      }
+    } catch (err) {
+      lastError = err;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (frame) {
+      this.lastFrame = frame;
+      return frame;
+    }
+    if (this.options.fallback) {
+      const fb = await this.options.fallback.step(scene);
+      const tagged = { ...fb, source: "fallback" };
+      this.lastFrame = tagged;
+      return tagged;
+    }
+    const reason = lastError instanceof Error ? lastError.message : String(lastError ?? "unknown");
+    throw new ProphecyNotImplementedError(
+      `holomesh@${this.options.endpoint} (no fallback configured; last error: ${reason})`
+    );
+  }
+  async destroy() {
+    if (this.options.fallback && this.initializedFallback) {
+      await this.options.fallback.destroy();
+      this.initializedFallback = false;
+    }
+    this.lastFrame = null;
+    this.resolved = null;
+  }
+};
+var DEFAULT_LOTUS_RINGS = [
+  { name: "inner", count: 8, cup: 0.86, gravity_sag: 0.02 },
+  { name: "mid", count: 13, cup: 0.5, gravity_sag: 0.12 },
+  { name: "outer", count: 21, cup: 0.24, gravity_sag: 0.3 }
+];
+var DEFAULT_COLORS2 = {
+  petal_base: "#fff1f6",
+  petal_mid: "#f47ab7",
+  petal_inner: "#ff9ecf",
+  petal_rim: "#c42a86",
+  petal_shadow: "#84205f",
+  seed_pod: "#f4d74a",
+  seed_pod_rim: "#b7c66b",
+  stamen: "#f59e0b",
+  stamen_tip: "#fff4bd",
+  leaf: "#235f4f",
+  leaf_dark: "#102f28",
+  water: "#07140f"
+};
+function extractBotanicalLotusMaterial(samples, options = {}) {
+  if (samples.length === 0) {
+    throw new Error("extractBotanicalLotusMaterial requires at least one image sample");
+  }
+  const buckets = createBuckets();
+  for (const sample of samples) {
+    collectSamplePixels(sample, buckets);
+  }
+  const petal = buckets.petal;
+  const leaf = buckets.leaf;
+  const stamen = buckets.stamen;
+  const water = buckets.water;
+  const meanPetalLuma = mean(petal, (pixel) => pixel.luma, 0.62);
+  const meanPetalSat = mean(petal, (pixel) => pixel.s, 0.62);
+  const petalGradient = mean(petal, (pixel) => pixel.gradient, 0.08);
+  const petalEdgeLuma = mean(
+    petal.filter((pixel) => pixel.edge > 0.72),
+    (pixel) => pixel.luma,
+    meanPetalLuma
+  );
+  const petalCenterLuma = mean(
+    petal.filter((pixel) => pixel.edge < 0.38),
+    (pixel) => pixel.luma,
+    meanPetalLuma
+  );
+  const backlightLift = clamp01(petalEdgeLuma - petalCenterLuma + 0.5);
+  const veinNormal = clamp2(round4(0.018 + petalGradient * 0.22), 0.018, 0.09);
+  const colors = deriveColors(petal, leaf, stamen, water);
+  const material = {
+    subsurface_scattering: clamp2(round4(0.48 + meanPetalSat * 0.22 + backlightLift * 0.18), 0.45, 0.82),
+    subsurface_radius_rgb: deriveSubsurfaceRadius(colors.petal_mid),
+    petal_translucency_base: clamp2(round4(0.42 + meanPetalLuma * 0.24 + backlightLift * 0.18), 0.38, 0.78),
+    petal_translucency_edge: clamp2(round4(0.24 + petalEdgeLuma * 0.18), 0.24, 0.48),
+    roughness: clamp2(round4(0.64 + veinNormal * 1.4), 0.62, 0.82),
+    ior: clamp2(round4(1.33 + meanPetalSat * 0.055), 1.33, 1.39),
+    vein_normal_intensity: veinNormal,
+    edge_curl_intensity: clamp2(round4(0.34 + mean(petal, (pixel) => pixel.edge, 0.5) * 0.38), 0.34, 0.68),
+    gravity_sag_outer: clamp2(round4(0.18 + meanPetalLuma * 0.18), 0.18, 0.36)
+  };
+  const provenanceHashCount = samples.filter((sample) => sample.provenance?.contentHash).length;
+  const provenanceSignatureCount = samples.filter((sample) => sample.provenance?.walletSignature).length;
+  const contentHashStatus = completenessStatus(provenanceHashCount, samples.length);
+  const walletSignatureStatus = completenessStatus(provenanceSignatureCount, samples.length);
+  const signed = contentHashStatus === "complete" && walletSignatureStatus === "complete";
+  return {
+    schema: "holoscript.botanical.material-extract.v1",
+    status: signed ? "extracted_from_signed_references" : "extracted_pending_cael_anchor",
+    captured_at: options.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    generated_by: options.generatedBy ?? "@holoscript/snn-webgpu/material-extraction/botanical-lotus",
+    ...options.referenceManifest ? { reference_manifest: options.referenceManifest } : {},
+    source: {
+      kind: options.sourceKind ?? "pixel_reference_images",
+      count: samples.length,
+      anchor_ids: samples.map((sample) => sample.id),
+      content_hash_status: contentHashStatus,
+      wallet_signature_status: walletSignatureStatus
+    },
+    botanical_trait_target: options.traitName ?? "@botanical_lotus",
+    material,
+    colors,
+    geometry: {
+      petal_rings: DEFAULT_LOTUS_RINGS.map((ring) => ({ ...ring })),
+      petal_shape: "broad_elliptic_pointed_tip_with_center_ridge",
+      stamen_filament_count: estimateStamenCount(stamen.length, petal.length),
+      seed_pod_dot_pattern: "1_center_7_12_18_radial"
+    },
+    diagnostics: {
+      sample_count: samples.length,
+      pixel_count: buckets.all.length,
+      petal_pixel_count: petal.length,
+      leaf_pixel_count: leaf.length,
+      stamen_pixel_count: stamen.length,
+      water_pixel_count: water.length,
+      mean_petal_luminance: round4(meanPetalLuma),
+      mean_petal_saturation: round4(meanPetalSat),
+      petal_gradient_energy: round4(petalGradient),
+      provenance_hash_count: provenanceHashCount,
+      provenance_signature_count: provenanceSignatureCount,
+      confidence: estimateConfidence(samples.length, petal.length, leaf.length, stamen.length)
+    }
+  };
+}
+function toBotanicalLotusTrait(extraction) {
+  const material = extraction.material;
+  const colors = extraction.colors;
+  return [
+    `trait ${extraction.botanical_trait_target} {`,
+    `  // Generated by ${extraction.generated_by}`,
+    `  reference_status: "${extraction.status}"`,
+    `  subsurface_scattering: ${material.subsurface_scattering}`,
+    `  subsurface_radius: [${material.subsurface_radius_rgb.join(", ")}]`,
+    `  petal_translucency_base: ${material.petal_translucency_base}`,
+    `  petal_translucency_edge: ${material.petal_translucency_edge}`,
+    `  vein_normal_intensity: ${material.vein_normal_intensity}`,
+    `  edge_curl_intensity: ${material.edge_curl_intensity}`,
+    `  gravity_sag_outer: ${material.gravity_sag_outer}`,
+    `  color_base: "${colors.petal_base}"`,
+    `  color_mid: "${colors.petal_mid}"`,
+    `  color_edge: "${colors.petal_rim}"`,
+    `  stamen_color: "${colors.stamen}"`,
+    `}`
+  ].join("\n");
+}
+function createBuckets() {
+  return {
+    petal: [],
+    leaf: [],
+    stamen: [],
+    water: [],
+    all: []
+  };
+}
+function collectSamplePixels(sample, buckets) {
+  assertSampleShape(sample);
+  const { width, height, data } = sample;
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const offset = (y * width + x) * 4;
+      const alpha = data[offset + 3] ?? 255;
+      if (alpha < 16) {
+        continue;
+      }
+      const r = (data[offset] ?? 0) / 255;
+      const g = (data[offset + 1] ?? 0) / 255;
+      const b = (data[offset + 2] ?? 0) / 255;
+      const hsv = rgbToHsv(r, g, b);
+      const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+      const gradient = localGradient(data, width, height, x, y, luma);
+      const edge = normalizedEdgeDistance(width, height, x, y);
+      const feature = { r, g, b, h: hsv.h, s: hsv.s, v: hsv.v, luma, gradient, edge };
+      buckets.all.push(feature);
+      if (isLotusPetal(feature)) {
+        buckets.petal.push(feature);
+      } else if (isLotusStamen(feature)) {
+        buckets.stamen.push(feature);
+      } else if (isLotusLeaf(feature)) {
+        buckets.leaf.push(feature);
+      } else if (isWater(feature)) {
+        buckets.water.push(feature);
+      }
+    }
+  }
+}
+function assertSampleShape(sample) {
+  if (!Number.isInteger(sample.width) || !Number.isInteger(sample.height)) {
+    throw new Error(`Image sample ${sample.id} must have integer width and height`);
+  }
+  if (sample.width <= 0 || sample.height <= 0) {
+    throw new Error(`Image sample ${sample.id} must have positive width and height`);
+  }
+  const expected = sample.width * sample.height * 4;
+  if (sample.data.length < expected) {
+    throw new Error(`Image sample ${sample.id} has ${sample.data.length} RGBA values; expected ${expected}`);
+  }
+}
+function deriveColors(petal, leaf, stamen, water) {
+  return {
+    petal_base: pixelToHex(percentilePixel(petal, "luma", 0.92, DEFAULT_COLORS2.petal_base)),
+    petal_mid: pixelToHex(percentilePixel(petal, "s", 0.55, DEFAULT_COLORS2.petal_mid)),
+    petal_inner: pixelToHex(percentilePixel(petal, "luma", 0.72, DEFAULT_COLORS2.petal_inner)),
+    petal_rim: pixelToHex(percentilePixel(petal, "s", 0.88, DEFAULT_COLORS2.petal_rim)),
+    petal_shadow: pixelToHex(percentilePixel(petal, "luma", 0.16, DEFAULT_COLORS2.petal_shadow)),
+    seed_pod: pixelToHex(percentilePixel(stamen, "luma", 0.82, DEFAULT_COLORS2.seed_pod)),
+    seed_pod_rim: mixHex(pixelToHex(percentilePixel(stamen, "luma", 0.62, DEFAULT_COLORS2.seed_pod_rim)), DEFAULT_COLORS2.seed_pod_rim, 0.35),
+    stamen: pixelToHex(percentilePixel(stamen, "s", 0.68, DEFAULT_COLORS2.stamen)),
+    stamen_tip: pixelToHex(percentilePixel(stamen, "luma", 0.95, DEFAULT_COLORS2.stamen_tip)),
+    leaf: pixelToHex(percentilePixel(leaf, "luma", 0.58, DEFAULT_COLORS2.leaf)),
+    leaf_dark: pixelToHex(percentilePixel(leaf, "luma", 0.18, DEFAULT_COLORS2.leaf_dark)),
+    water: pixelToHex(percentilePixel(water, "luma", 0.12, DEFAULT_COLORS2.water))
+  };
+}
+function percentilePixel(pixels, field, percentile, fallbackHex) {
+  if (pixels.length === 0) {
+    return hexToPixel(fallbackHex);
+  }
+  const sorted = [...pixels].sort((a, b) => a[field] - b[field]);
+  const index = clamp2(Math.round((sorted.length - 1) * percentile), 0, sorted.length - 1);
+  return sorted[index];
+}
+function isLotusPetal(pixel) {
+  const magentaHue = pixel.h >= 300 || pixel.h <= 18;
+  const pinkHue = pixel.h >= 285 && pixel.h <= 360;
+  const redDominant = pixel.r > pixel.g * 1.12 && pixel.b > pixel.g * 0.58;
+  return (magentaHue || pinkHue) && redDominant && pixel.s > 0.16 && pixel.v > 0.22;
+}
+function isLotusStamen(pixel) {
+  return pixel.h >= 32 && pixel.h <= 72 && pixel.s > 0.28 && pixel.v > 0.32;
+}
+function isLotusLeaf(pixel) {
+  return pixel.h >= 78 && pixel.h <= 178 && pixel.s > 0.12 && pixel.v > 0.08 && pixel.g >= pixel.r * 0.72;
+}
+function isWater(pixel) {
+  return pixel.v < 0.16 && pixel.g >= pixel.r * 0.7;
+}
+function estimateStamenCount(stamenPixels, petalPixels) {
+  if (stamenPixels === 0 || petalPixels === 0) {
+    return 58;
+  }
+  const ratio = stamenPixels / Math.max(1, petalPixels);
+  return Math.round(clamp2(42 + ratio * 260, 42, 96));
+}
+function estimateConfidence(sampleCount, petalPixels, leafPixels, stamenPixels) {
+  const sampleSignal = clamp01(sampleCount / 3);
+  const petalSignal = clamp01(petalPixels / 300);
+  const contextSignal = clamp01((leafPixels + stamenPixels) / 160);
+  return round4(clamp01(0.2 + sampleSignal * 0.25 + petalSignal * 0.35 + contextSignal * 0.2));
+}
+function deriveSubsurfaceRadius(hex) {
+  const pixel = hexToPixel(hex);
+  return [
+    round4(clamp2(0.72 + pixel.r * 0.24, 0.72, 0.96)),
+    round4(clamp2(0.18 + pixel.g * 0.22, 0.18, 0.42)),
+    round4(clamp2(0.46 + pixel.b * 0.32, 0.46, 0.78))
+  ];
+}
+function completenessStatus(count, total) {
+  if (count === 0) {
+    return "missing";
+  }
+  return count === total ? "complete" : "partial";
+}
+function localGradient(data, width, height, x, y, luma) {
+  const rightX = Math.min(width - 1, x + 1);
+  const downY = Math.min(height - 1, y + 1);
+  const right = lumaAt(data, width, rightX, y);
+  const down = lumaAt(data, width, x, downY);
+  return Math.sqrt((right - luma) ** 2 + (down - luma) ** 2);
+}
+function lumaAt(data, width, x, y) {
+  const offset = (y * width + x) * 4;
+  const r = (data[offset] ?? 0) / 255;
+  const g = (data[offset + 1] ?? 0) / 255;
+  const b = (data[offset + 2] ?? 0) / 255;
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function normalizedEdgeDistance(width, height, x, y) {
+  const dx = Math.abs(x / Math.max(1, width - 1) - 0.5) * 2;
+  const dy = Math.abs(y / Math.max(1, height - 1) - 0.5) * 2;
+  return clamp01(Math.max(dx, dy));
+}
+function rgbToHsv(r, g, b) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  let h = 0;
+  if (delta > 0) {
+    if (max === r) {
+      h = 60 * ((g - b) / delta % 6);
+    } else if (max === g) {
+      h = 60 * ((b - r) / delta + 2);
+    } else {
+      h = 60 * ((r - g) / delta + 4);
+    }
+  }
+  return {
+    h: h < 0 ? h + 360 : h,
+    s: max === 0 ? 0 : delta / max,
+    v: max
+  };
+}
+function pixelToHex(pixel) {
+  const r = byteToHex(pixel.r);
+  const g = byteToHex(pixel.g);
+  const b = byteToHex(pixel.b);
+  return `#${r}${g}${b}`;
+}
+function hexToPixel(hex) {
+  const normalized = hex.replace("#", "");
+  const r = Number.parseInt(normalized.slice(0, 2), 16) / 255;
+  const g = Number.parseInt(normalized.slice(2, 4), 16) / 255;
+  const b = Number.parseInt(normalized.slice(4, 6), 16) / 255;
+  const hsv = rgbToHsv(r, g, b);
+  const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  return { r, g, b, h: hsv.h, s: hsv.s, v: hsv.v, luma, gradient: 0, edge: 0.5 };
+}
+function mixHex(a, b, amountB) {
+  const left = hexToPixel(a);
+  const right = hexToPixel(b);
+  return pixelToHex({
+    r: left.r * (1 - amountB) + right.r * amountB,
+    g: left.g * (1 - amountB) + right.g * amountB,
+    b: left.b * (1 - amountB) + right.b * amountB});
+}
+function byteToHex(value) {
+  return Math.round(clamp01(value) * 255).toString(16).padStart(2, "0");
+}
+function mean(items, selector, fallback) {
+  if (items.length === 0) {
+    return fallback;
+  }
+  return items.reduce((sum, item) => sum + selector(item), 0) / items.length;
+}
+function clamp01(value) {
+  return clamp2(value, 0, 1);
+}
+function clamp2(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function round4(value) {
+  return Math.round(value * 1e4) / 1e4;
+}
+function normalizeBotanicalMaterialExtraction(extraction) {
+  if (isPixelExtraction(extraction)) {
+    return normalizePixelExtraction(extraction);
+  }
+  return normalizeFixtureExtraction(extraction);
+}
+function normalizePixelExtraction(extraction) {
+  const contentHashStatus = extraction.source.content_hash_status;
+  const walletSignatureStatus = extraction.source.wallet_signature_status;
+  return {
+    schema: "holoscript.botanical.material-extract.canonical.v1",
+    source_schema: extraction.schema,
+    source_kind: "pixel-buffer",
+    status: extraction.status === "extracted_from_signed_references" ? "signed" : "pending_anchor",
+    botanical_trait_target: extraction.botanical_trait_target,
+    anchor_ids: extraction.source.anchor_ids,
+    material: normalizeMaterial(extraction.material),
+    colors: extraction.colors,
+    confidence: extraction.diagnostics.confidence,
+    provenance: {
+      content_hash_status: contentHashStatus,
+      wallet_signature_status: walletSignatureStatus,
+      signed_anchor_count: extraction.diagnostics.provenance_signature_count,
+      content_hashed_anchor_count: extraction.diagnostics.provenance_hash_count
+    }
+  };
+}
+function normalizeFixtureExtraction(extraction) {
+  return {
+    schema: "holoscript.botanical.material-extract.canonical.v1",
+    source_schema: extraction.schema,
+    source_kind: "photo-fixture",
+    status: normalizeFixtureStatus(extraction.status),
+    botanical_trait_target: extraction.botanical_trait_target,
+    anchor_ids: extraction.source.anchor_ids,
+    material: normalizeMaterial(extraction.material),
+    colors: extraction.colors,
+    confidence: extraction.confidence.overall,
+    provenance: {
+      content_hash_status: completenessStatus2(
+        extraction.source.content_hashed_anchor_count,
+        extraction.source.anchor_ids.length
+      ),
+      wallet_signature_status: completenessStatus2(
+        extraction.source.signed_anchor_count,
+        extraction.source.anchor_ids.length
+      ),
+      signed_anchor_count: extraction.source.signed_anchor_count,
+      content_hashed_anchor_count: extraction.source.content_hashed_anchor_count
+    }
+  };
+}
+function normalizeMaterial(material) {
+  return {
+    subsurface_scattering: material.subsurface_scattering,
+    subsurface_radius_rgb: material.subsurface_radius_rgb,
+    petal_translucency_base: material.petal_translucency_base,
+    petal_translucency_edge: material.petal_translucency_edge,
+    roughness: material.roughness,
+    ior: material.ior,
+    vein_normal_intensity: material.vein_normal_intensity,
+    edge_curl_intensity: material.edge_curl_intensity,
+    gravity_sag_outer: material.gravity_sag_outer
+  };
+}
+function isPixelExtraction(extraction) {
+  return "diagnostics" in extraction;
+}
+function normalizeFixtureStatus(status) {
+  if (status === "extracted-from-signed-anchors") {
+    return "signed";
+  }
+  if (status === "extracted-from-hashed-fixtures") {
+    return "hashed";
+  }
+  return "unsigned";
+}
+function completenessStatus2(count, total) {
+  if (count === 0 || total === 0) {
+    return "missing";
+  }
+  return count === total ? "complete" : "partial";
+}
+
+exports.BufferManager = BufferManager;
+exports.CPUReferenceSimulator = CPUReferenceSimulator;
+exports.DEFAULT_DECODE_PARAMS = DEFAULT_DECODE_PARAMS;
+exports.DEFAULT_ENCODE_PARAMS = DEFAULT_ENCODE_PARAMS;
+exports.DEFAULT_LIF_PARAMS = DEFAULT_LIF_PARAMS;
+exports.DecodingMode = DecodingMode;
+exports.EncodingMode = EncodingMode;
+exports.GPUContext = GPUContext;
+exports.HoloMeshProphecyTransport = HoloMeshProphecyTransport;
+exports.LIFSimulator = LIFSimulator;
+exports.LocalProphecyTransport = LocalProphecyTransport;
+exports.PAPER_2_CANONICAL_CONFIG = PAPER_2_CANONICAL_CONFIG;
+exports.PipelineFactory = PipelineFactory;
+exports.ProphecyNotImplementedError = ProphecyNotImplementedError;
+exports.ProphecyOrchestrator = ProphecyOrchestrator;
+exports.SNNNetwork = SNNNetwork;
+exports.SpikeDecoder = SpikeDecoder;
+exports.SpikeEncoder = SpikeEncoder;
+exports.TROPICAL_INF = TROPICAL_INF;
+exports.TropicalActivationTrait = TropicalActivationTrait;
+exports.TropicalShortestPaths = TropicalShortestPaths;
+exports.assertGraphShape = assertGraphShape;
+exports.computeDispatchSize = computeDispatchSize;
+exports.csrToDense = csrToDense;
+exports.denseToCSR = denseToCSR;
+exports.ensureNodeWebGpu = ensureNodeWebGpu;
+exports.ensureNodeWebGpuSync = ensureNodeWebGpuSync;
+exports.extractBotanicalLotusMaterial = extractBotanicalLotusMaterial;
+exports.extractBotanicalMaterialFromPhotoFixtures = extractBotanicalMaterialFromPhotoFixtures;
+exports.fromEdges = fromEdges;
+exports.generateSynapticInput = generateSynapticInput;
+exports.generateWeightMatrix = generateWeightMatrix;
+exports.normalizeAdjacency = normalizeAdjacency;
+exports.normalizeBotanicalMaterialExtraction = normalizeBotanicalMaterialExtraction;
+exports.runLIFDeterminismProbe = runLIFDeterminismProbe;
+exports.toBotanicalLotusTrait = toBotanicalLotusTrait;
+//# sourceMappingURL=dist-ACXG6IH5.cjs.map
+//# sourceMappingURL=dist-ACXG6IH5.cjs.map