@holoscript/core 8.0.8 → 8.0.9

package/dist/{dist-ACXG6IH5.cjs → dist-GRMOP2UL.cjs}

@@ -1,12 +1,12 @@
 'use strict';
 
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.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]
+var __require2 = /* @__PURE__ */ ((x) => typeof chunkZHPMP447_cjs.__require !== "undefined" ? chunkZHPMP447_cjs.__require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof chunkZHPMP447_cjs.__require !== "undefined" ? chunkZHPMP447_cjs.__require : a)[b]
 }) : x)(function(x) {
-  if (typeof chunkHCCQLAA4_cjs.__require !== "undefined") return chunkHCCQLAA4_cjs.__require.apply(this, arguments);
+  if (typeof chunkZHPMP447_cjs.__require !== "undefined") return chunkZHPMP447_cjs.__require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var _bootstrapAttempted = false;
@@ -1173,26 +1173,57 @@ function extractBotanicalMaterialFromPhotoFixtures(input) {
   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 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)
+    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 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 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);
+  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),
@@ -1762,7 +1793,9 @@ var TropicalShortestPaths = class _TropicalShortestPaths {
   }
   static computeAPSPCPU(adjacencyMatrix, n) {
     if (adjacencyMatrix.length !== n * n) {
-      throw new Error(`adjacencyMatrix length (${adjacencyMatrix.length}) must equal n*n (${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++) {
@@ -1843,7 +1876,9 @@ var TropicalShortestPaths = class _TropicalShortestPaths {
   }
   async computeAPSP(adjacencyMatrix, n) {
     if (adjacencyMatrix.length !== n * n) {
-      throw new Error(`adjacencyMatrix length (${adjacencyMatrix.length}) must equal n*n (${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);
@@ -2206,7 +2241,9 @@ async function runLIFDeterminismProbe(ctx, options) {
   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}`);
+    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}`);
@@ -2219,11 +2256,7 @@ async function runLIFDeterminismProbe(ctx, options) {
     sim.setSynapticInput(stimulus);
     await sim.stepN(tickCount);
     const readback = await sim.readMembranePotentials();
-    return new Uint8Array(
-      readback.data.buffer,
-      readback.data.byteOffset,
-      readback.data.byteLength
-    );
+    return new Uint8Array(readback.data.buffer, readback.data.byteOffset, readback.data.byteLength);
   } finally {
     sim.destroy();
   }
@@ -2250,6 +2283,7 @@ var ProphecyOrchestrator = class {
     this.config = config;
     this.frameCounter = 0;
     this.lastFrame = null;
+    this.lastScene = null;
     this.initialized = false;
     this.uniformBuffer = null;
     this.spikeRatesBuffer = null;
@@ -2288,9 +2322,7 @@ var ProphecyOrchestrator = class {
     }
     const floor = config.confidenceFloor ?? 0.05;
     if (floor < 0 || floor > 1) {
-      throw new Error(
-        `ProphecyOrchestrator: confidenceFloor must be in [0,1], got ${floor}`
-      );
+      throw new Error(`ProphecyOrchestrator: confidenceFloor must be in [0,1], got ${floor}`);
     }
   }
   /** Allocate GPU buffers and upload static probe positions / albedo. */
@@ -2405,7 +2437,7 @@ var ProphecyOrchestrator = class {
     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 probes = this.applyTemporalReprojection(this.computeProbesCpu(scene), scene);
     const t1 = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
     const frame = {
       frameId: this.frameCounter++,
@@ -2415,6 +2447,7 @@ var ProphecyOrchestrator = class {
       source: "local"
     };
     this.lastFrame = frame;
+    this.lastScene = scene;
     return frame;
   }
   /**
@@ -2447,17 +2480,61 @@ var ProphecyOrchestrator = class {
       }
       out[i] = {
         index: i,
-        position: [
-          positions[i * 3 + 0],
-          positions[i * 3 + 1],
-          positions[i * 3 + 2]
-        ],
+        position: [positions[i * 3 + 0], positions[i * 3 + 1], positions[i * 3 + 2]],
         rgb: [r, g, b],
         confidence
       };
     }
     return out;
   }
+  applyTemporalReprojection(probes, scene) {
+    const temporal = this.config.temporalReprojection;
+    if (!temporal?.enabled || !this.lastFrame || !this.lastScene) {
+      return probes;
+    }
+    const historyWeight = this.clamp01(temporal.historyWeight ?? 0.85);
+    const confidenceDecay = this.clamp01(temporal.confidenceDecay ?? 0.98);
+    const maxCameraDelta = temporal.maxCameraDelta ?? 0.5;
+    const maxSunDelta = temporal.maxSunDelta ?? 0.5;
+    const cameraDelta = this.vecDistance(scene.cameraPosition, this.lastScene.cameraPosition);
+    const sunDelta = this.vecDistance(scene.sunDirection, this.lastScene.sunDirection);
+    const cameraFactor = maxCameraDelta <= 0 ? 0 : this.clamp01(1 - cameraDelta / maxCameraDelta);
+    const sunFactor = maxSunDelta <= 0 ? 0 : this.clamp01(1 - sunDelta / maxSunDelta);
+    const alpha = historyWeight * cameraFactor * sunFactor;
+    if (alpha <= 0) {
+      return probes;
+    }
+    const previous = this.lastFrame.probes;
+    return probes.map((probe, index) => {
+      const prev = previous[index];
+      if (!prev || prev.index !== probe.index) {
+        return probe;
+      }
+      return {
+        ...probe,
+        rgb: [
+          prev.rgb[0] * alpha + probe.rgb[0] * (1 - alpha),
+          prev.rgb[1] * alpha + probe.rgb[1] * (1 - alpha),
+          prev.rgb[2] * alpha + probe.rgb[2] * (1 - alpha)
+        ],
+        confidence: this.clamp01(
+          prev.confidence * confidenceDecay * alpha + probe.confidence * (1 - alpha)
+        )
+      };
+    });
+  }
+  vecDistance(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+  clamp01(value) {
+    if (!Number.isFinite(value)) return 0;
+    if (value < 0) return 0;
+    if (value > 1) return 1;
+    return value;
+  }
   /** Test/dev helper: prime the CPU shadow without touching the GPU
    *  buffer, useful for unit tests. */
   primeSpikeRatesShadow(rates) {
@@ -2488,6 +2565,8 @@ var ProphecyOrchestrator = class {
     this.readbackBuffer = null;
     this.initialized = false;
     this.lastSpikeRatesShadow = null;
+    this.lastFrame = null;
+    this.lastScene = null;
   }
   assertInit() {
     if (!this.initialized) {
@@ -2500,8 +2579,10 @@ var LocalProphecyTransport = class {
     this.options = options;
     this.kind = "local";
     this.orchestrator = null;
+    this.config = null;
   }
   async initialize(config) {
+    this.config = config;
     this.orchestrator = new ProphecyOrchestrator(this.options.ctx, config);
     this.orchestrator.initialize();
   }
@@ -2509,15 +2590,7 @@ var LocalProphecyTransport = class {
     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
-    );
+    const rates = await this.options.spikeRates(scene, this.config?.probeCount ?? 0);
     this.orchestrator.primeSpikeRatesShadow(rates);
     this.orchestrator.uploadSpikeRates(rates);
     return this.orchestrator.step(scene);
@@ -2525,8 +2598,190 @@ var LocalProphecyTransport = class {
   async destroy() {
     this.orchestrator?.destroy();
     this.orchestrator = null;
+    this.config = null;
   }
 };
+var PROPHECY_SPIKE_FEATURE_COUNT = 9;
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function sigmoid(value) {
+  if (value <= -30) return 0;
+  if (value >= 30) return 1;
+  return 1 / (1 + Math.exp(-value));
+}
+function vectorLength3(x, y, z) {
+  return Math.sqrt(x * x + y * y + z * z);
+}
+function writeFeatureVector(out, scene, probePositions, probeIndex) {
+  const px = probePositions[probeIndex * 3 + 0];
+  const py = probePositions[probeIndex * 3 + 1];
+  const pz = probePositions[probeIndex * 3 + 2];
+  const dx = px - scene.cameraPosition[0];
+  const dy = py - scene.cameraPosition[1];
+  const dz = pz - scene.cameraPosition[2];
+  const distance = vectorLength3(dx, dy, dz);
+  const invDistance = 1 / (1 + distance);
+  const dirScale = distance > 0 ? 1 / distance : 0;
+  const forwardDot = (dx * dirScale * scene.cameraForward[0] + dy * dirScale * scene.cameraForward[1] + dz * dirScale * scene.cameraForward[2] + 1) * 0.5;
+  const sunAlignment = (scene.sunDirection[0] * dx * dirScale + scene.sunDirection[1] * dy * dirScale + scene.sunDirection[2] * dz * dirScale + 1) * 0.5;
+  const sunLuminance = scene.sunColor[0] * 0.2126 + scene.sunColor[1] * 0.7152 + scene.sunColor[2] * 0.0722;
+  out[0] = invDistance;
+  out[1] = clamp01(forwardDot);
+  out[2] = clamp01((py + 4) / 8);
+  out[3] = clamp01((scene.sunDirection[1] + 1) * 0.5);
+  out[4] = clamp01(sunAlignment);
+  out[5] = clamp01(scene.sunColor[0]);
+  out[6] = clamp01(scene.sunColor[1]);
+  out[7] = clamp01(scene.sunColor[2]);
+  out[8] = clamp01(scene.prevAvgLuminance ?? sunLuminance);
+}
+function encodeProphecySceneProbeFeatures(scene, probePositions, probeIndex) {
+  const features = new Float32Array(PROPHECY_SPIKE_FEATURE_COUNT);
+  writeFeatureVector(features, scene, probePositions, probeIndex);
+  return features;
+}
+function assertTrainingShape(samples, options) {
+  if (!Number.isInteger(options.probeCount) || options.probeCount <= 0) {
+    throw new Error(
+      `trainProphecySpikeRateModel: probeCount must be positive, got ${options.probeCount}`
+    );
+  }
+  if (options.probePositions.length !== options.probeCount * 3) {
+    throw new Error(
+      `trainProphecySpikeRateModel: probePositions length ${options.probePositions.length} does not match probeCount*3 (${options.probeCount * 3})`
+    );
+  }
+  if (samples.length === 0) {
+    throw new Error("trainProphecySpikeRateModel: at least one training sample is required");
+  }
+  for (const sample of samples) {
+    if (sample.targetSpikeRates.length !== options.probeCount) {
+      throw new Error(
+        `trainProphecySpikeRateModel: targetSpikeRates length ${sample.targetSpikeRates.length} does not match probeCount ${options.probeCount}`
+      );
+    }
+  }
+}
+function modelLoss(model, samples) {
+  const features = new Float32Array(PROPHECY_SPIKE_FEATURE_COUNT);
+  let loss = 0;
+  let count = 0;
+  for (const sample of samples) {
+    const sampleWeight = sample.weight ?? 1;
+    for (let probe = 0; probe < model.probeCount; probe++) {
+      writeFeatureVector(features, sample.scene, model.probePositions, probe);
+      let z = model.bias[probe];
+      const offset = probe * PROPHECY_SPIKE_FEATURE_COUNT;
+      for (let i = 0; i < PROPHECY_SPIKE_FEATURE_COUNT; i++) {
+        z += model.weights[offset + i] * features[i];
+      }
+      const err = clamp01(sample.targetSpikeRates[probe]) - sigmoid(z);
+      loss += err * err * sampleWeight;
+      count += sampleWeight;
+    }
+  }
+  return count > 0 ? loss / count : 0;
+}
+function trainProphecySpikeRateModel(samples, options) {
+  assertTrainingShape(samples, options);
+  const epochs = options.epochs ?? 32;
+  const learningRate = options.learningRate ?? 0.08;
+  const l2 = options.l2 ?? 1e-4;
+  const weights = new Float32Array(options.probeCount * PROPHECY_SPIKE_FEATURE_COUNT);
+  const bias = new Float32Array(options.probeCount);
+  const probePositions = new Float32Array(options.probePositions);
+  const features = new Float32Array(PROPHECY_SPIKE_FEATURE_COUNT);
+  const modelBase = { probeCount: options.probeCount, probePositions, weights, bias };
+  const initialLoss = modelLoss(modelBase, samples);
+  for (let epoch = 0; epoch < epochs; epoch++) {
+    for (const sample of samples) {
+      const sampleWeight = sample.weight ?? 1;
+      for (let probe = 0; probe < options.probeCount; probe++) {
+        writeFeatureVector(features, sample.scene, probePositions, probe);
+        const offset = probe * PROPHECY_SPIKE_FEATURE_COUNT;
+        let z = bias[probe];
+        for (let i = 0; i < PROPHECY_SPIKE_FEATURE_COUNT; i++) {
+          z += weights[offset + i] * features[i];
+        }
+        const prediction = sigmoid(z);
+        const target = clamp01(sample.targetSpikeRates[probe]);
+        const grad = (target - prediction) * prediction * (1 - prediction) * sampleWeight;
+        for (let i = 0; i < PROPHECY_SPIKE_FEATURE_COUNT; i++) {
+          const wi = offset + i;
+          weights[wi] += learningRate * (grad * features[i] - l2 * weights[wi]);
+        }
+        bias[probe] += learningRate * grad;
+      }
+    }
+  }
+  const finalLoss = modelLoss(modelBase, samples);
+  return {
+    kind: "prophetic-gi-spike-rate-model",
+    version: 1,
+    probeCount: options.probeCount,
+    featureCount: PROPHECY_SPIKE_FEATURE_COUNT,
+    probePositions,
+    weights,
+    bias,
+    training: {
+      epochs,
+      learningRate,
+      l2,
+      sampleCount: samples.length,
+      initialLoss,
+      finalLoss
+    }
+  };
+}
+function decodeProphecySpikeRates(model, scene, probeCount = model.probeCount) {
+  if (probeCount !== model.probeCount) {
+    throw new Error(
+      `decodeProphecySpikeRates: provider asked for ${probeCount} probes, model has ${model.probeCount}`
+    );
+  }
+  const features = new Float32Array(PROPHECY_SPIKE_FEATURE_COUNT);
+  const out = new Float32Array(model.probeCount);
+  for (let probe = 0; probe < model.probeCount; probe++) {
+    writeFeatureVector(features, scene, model.probePositions, probe);
+    const offset = probe * PROPHECY_SPIKE_FEATURE_COUNT;
+    let z = model.bias[probe];
+    for (let i = 0; i < PROPHECY_SPIKE_FEATURE_COUNT; i++) {
+      z += model.weights[offset + i] * features[i];
+    }
+    out[probe] = clamp01(sigmoid(z));
+  }
+  return out;
+}
+function decodeSpikeRateWindow(spikeWindow, probeCount, timeWindow) {
+  if (!Number.isInteger(probeCount) || probeCount <= 0) {
+    throw new Error(`decodeSpikeRateWindow: probeCount must be positive, got ${probeCount}`);
+  }
+  if (!Number.isInteger(timeWindow) || timeWindow <= 0) {
+    throw new Error(`decodeSpikeRateWindow: timeWindow must be positive, got ${timeWindow}`);
+  }
+  if (spikeWindow.length !== probeCount * timeWindow) {
+    throw new Error(
+      `decodeSpikeRateWindow: spike window length ${spikeWindow.length} does not match probeCount*timeWindow (${probeCount * timeWindow})`
+    );
+  }
+  const out = new Float32Array(probeCount);
+  for (let probe = 0; probe < probeCount; probe++) {
+    let spikes = 0;
+    const offset = probe * timeWindow;
+    for (let t = 0; t < timeWindow; t++) {
+      if (spikeWindow[offset + t] > 0.5) spikes++;
+    }
+    out[probe] = spikes / timeWindow;
+  }
+  return out;
+}
+function createTrainedSpikeRateProvider(model) {
+  return (scene, probeCount) => decodeProphecySpikeRates(model, scene, probeCount);
+}
 function resolveTtuEndpoint(endpoint, holomeshHost = "https://mcp.holoscript.net") {
   if (!endpoint || typeof endpoint !== "string") {
     throw new Error("HoloMeshProphecyTransport: endpoint must be a non-empty string");
@@ -2547,9 +2802,7 @@ function resolveTtuEndpoint(endpoint, holomeshHost = "https://mcp.holoscript.net
     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}`
-      );
+      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("/");
@@ -2591,10 +2844,7 @@ var HoloMeshProphecyTransport = class {
     });
   }
   async initialize(config) {
-    this.resolved = resolveTtuEndpoint(
-      this.options.endpoint,
-      this.options.holomeshHost
-    );
+    this.resolved = resolveTtuEndpoint(this.options.endpoint, this.options.holomeshHost);
     if (this.options.fallback && !this.initializedFallback) {
       await this.options.fallback.initialize(config);
       this.initializedFallback = true;
@@ -2713,22 +2963,36 @@ function extractBotanicalLotusMaterial(samples, options = {}) {
     (pixel) => pixel.luma,
     meanPetalLuma
   );
-  const backlightLift = clamp01(petalEdgeLuma - petalCenterLuma + 0.5);
+  const backlightLift = clamp012(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_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_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),
+    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 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";
@@ -2840,7 +3104,9 @@ function assertSampleShape(sample) {
   }
   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}`);
+    throw new Error(
+      `Image sample ${sample.id} has ${sample.data.length} RGBA values; expected ${expected}`
+    );
   }
 }
 function deriveColors(petal, leaf, stamen, water) {
@@ -2851,7 +3117,11 @@ function deriveColors(petal, leaf, stamen, water) {
     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),
+    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)),
@@ -2890,10 +3160,10 @@ function estimateStamenCount(stamenPixels, 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));
+  const sampleSignal = clamp012(sampleCount / 3);
+  const petalSignal = clamp012(petalPixels / 300);
+  const contextSignal = clamp012((leafPixels + stamenPixels) / 160);
+  return round4(clamp012(0.2 + sampleSignal * 0.25 + petalSignal * 0.35 + contextSignal * 0.2));
 }
 function deriveSubsurfaceRadius(hex) {
   const pixel = hexToPixel(hex);
@@ -2926,7 +3196,7 @@ function lumaAt(data, width, x, y) {
 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));
+  return clamp012(Math.max(dx, dy));
 }
 function rgbToHsv(r, g, b) {
   const max = Math.max(r, g, b);
@@ -2972,7 +3242,7 @@ function mixHex(a, b, amountB) {
     b: left.b * (1 - amountB) + right.b * amountB});
 }
 function byteToHex(value) {
-  return Math.round(clamp01(value) * 255).toString(16).padStart(2, "0");
+  return Math.round(clamp012(value) * 255).toString(16).padStart(2, "0");
 }
 function mean(items, selector, fallback) {
   if (items.length === 0) {
@@ -2980,7 +3250,7 @@ function mean(items, selector, fallback) {
   }
   return items.reduce((sum, item) => sum + selector(item), 0) / items.length;
 }
-function clamp01(value) {
+function clamp012(value) {
   return clamp2(value, 0, 1);
 }
 function clamp2(value, min, max) {
@@ -3085,6 +3355,7 @@ exports.HoloMeshProphecyTransport = HoloMeshProphecyTransport;
 exports.LIFSimulator = LIFSimulator;
 exports.LocalProphecyTransport = LocalProphecyTransport;
 exports.PAPER_2_CANONICAL_CONFIG = PAPER_2_CANONICAL_CONFIG;
+exports.PROPHECY_SPIKE_FEATURE_COUNT = PROPHECY_SPIKE_FEATURE_COUNT;
 exports.PipelineFactory = PipelineFactory;
 exports.ProphecyNotImplementedError = ProphecyNotImplementedError;
 exports.ProphecyOrchestrator = ProphecyOrchestrator;
@@ -3096,8 +3367,12 @@ exports.TropicalActivationTrait = TropicalActivationTrait;
 exports.TropicalShortestPaths = TropicalShortestPaths;
 exports.assertGraphShape = assertGraphShape;
 exports.computeDispatchSize = computeDispatchSize;
+exports.createTrainedSpikeRateProvider = createTrainedSpikeRateProvider;
 exports.csrToDense = csrToDense;
+exports.decodeProphecySpikeRates = decodeProphecySpikeRates;
+exports.decodeSpikeRateWindow = decodeSpikeRateWindow;
 exports.denseToCSR = denseToCSR;
+exports.encodeProphecySceneProbeFeatures = encodeProphecySceneProbeFeatures;
 exports.ensureNodeWebGpu = ensureNodeWebGpu;
 exports.ensureNodeWebGpuSync = ensureNodeWebGpuSync;
 exports.extractBotanicalLotusMaterial = extractBotanicalLotusMaterial;
@@ -3109,5 +3384,6 @@ exports.normalizeAdjacency = normalizeAdjacency;
 exports.normalizeBotanicalMaterialExtraction = normalizeBotanicalMaterialExtraction;
 exports.runLIFDeterminismProbe = runLIFDeterminismProbe;
 exports.toBotanicalLotusTrait = toBotanicalLotusTrait;
-//# sourceMappingURL=dist-ACXG6IH5.cjs.map
-//# sourceMappingURL=dist-ACXG6IH5.cjs.map
+exports.trainProphecySpikeRateModel = trainProphecySpikeRateModel;
+//# sourceMappingURL=dist-GRMOP2UL.cjs.map
+//# sourceMappingURL=dist-GRMOP2UL.cjs.map