@holoscript/core 8.0.8 → 8.0.10

package/dist/{dist-VD4L6V7Q.js → dist-ZBUKU2JG.js}

@@ -1,4 +1,4 @@
-import { __require } from './chunk-OL46QLBJ.js';
+import { __require } from './chunk-W4GABFCR.js';
 
 // ../snn-webgpu/dist/index.js
 var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -1171,26 +1171,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),
@@ -1760,7 +1791,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++) {
@@ -1841,7 +1874,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);
@@ -2204,7 +2239,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}`);
@@ -2217,11 +2254,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();
   }
@@ -2248,6 +2281,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;
@@ -2286,9 +2320,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. */
@@ -2403,7 +2435,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++,
@@ -2413,6 +2445,7 @@ var ProphecyOrchestrator = class {
       source: "local"
     };
     this.lastFrame = frame;
+    this.lastScene = scene;
     return frame;
   }
   /**
@@ -2445,17 +2478,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) {
@@ -2486,6 +2563,8 @@ var ProphecyOrchestrator = class {
     this.readbackBuffer = null;
     this.initialized = false;
     this.lastSpikeRatesShadow = null;
+    this.lastFrame = null;
+    this.lastScene = null;
   }
   assertInit() {
     if (!this.initialized) {
@@ -2498,8 +2577,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();
   }
@@ -2507,15 +2588,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);
@@ -2523,8 +2596,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");
@@ -2545,9 +2800,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("/");
@@ -2589,10 +2842,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;
@@ -2711,22 +2961,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";
@@ -2838,7 +3102,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) {
@@ -2849,7 +3115,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)),
@@ -2888,10 +3158,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);
@@ -2924,7 +3194,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);
@@ -2970,7 +3240,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) {
@@ -2978,7 +3248,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) {
@@ -3071,6 +3341,6 @@ function completenessStatus2(count, total) {
   return count === total ? "complete" : "partial";
 }
 
-export { BufferManager, CPUReferenceSimulator, DEFAULT_DECODE_PARAMS, DEFAULT_ENCODE_PARAMS, DEFAULT_LIF_PARAMS, DecodingMode, EncodingMode, GPUContext, HoloMeshProphecyTransport, LIFSimulator, LocalProphecyTransport, PAPER_2_CANONICAL_CONFIG, PipelineFactory, ProphecyNotImplementedError, ProphecyOrchestrator, SNNNetwork, SpikeDecoder, SpikeEncoder, TROPICAL_INF, TropicalActivationTrait, TropicalShortestPaths, assertGraphShape, computeDispatchSize, csrToDense, denseToCSR, ensureNodeWebGpu, ensureNodeWebGpuSync, extractBotanicalLotusMaterial, extractBotanicalMaterialFromPhotoFixtures, fromEdges, generateSynapticInput, generateWeightMatrix, normalizeAdjacency, normalizeBotanicalMaterialExtraction, runLIFDeterminismProbe, toBotanicalLotusTrait };
-//# sourceMappingURL=dist-VD4L6V7Q.js.map
-//# sourceMappingURL=dist-VD4L6V7Q.js.map
+export { BufferManager, CPUReferenceSimulator, DEFAULT_DECODE_PARAMS, DEFAULT_ENCODE_PARAMS, DEFAULT_LIF_PARAMS, DecodingMode, EncodingMode, GPUContext, HoloMeshProphecyTransport, LIFSimulator, LocalProphecyTransport, PAPER_2_CANONICAL_CONFIG, PROPHECY_SPIKE_FEATURE_COUNT, PipelineFactory, ProphecyNotImplementedError, ProphecyOrchestrator, SNNNetwork, SpikeDecoder, SpikeEncoder, TROPICAL_INF, TropicalActivationTrait, TropicalShortestPaths, assertGraphShape, computeDispatchSize, createTrainedSpikeRateProvider, csrToDense, decodeProphecySpikeRates, decodeSpikeRateWindow, denseToCSR, encodeProphecySceneProbeFeatures, ensureNodeWebGpu, ensureNodeWebGpuSync, extractBotanicalLotusMaterial, extractBotanicalMaterialFromPhotoFixtures, fromEdges, generateSynapticInput, generateWeightMatrix, normalizeAdjacency, normalizeBotanicalMaterialExtraction, runLIFDeterminismProbe, toBotanicalLotusTrait, trainProphecySpikeRateModel };
+//# sourceMappingURL=dist-ZBUKU2JG.js.map
+//# sourceMappingURL=dist-ZBUKU2JG.js.map

package/dist/entries/interop.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
 var chunkEXKSFGSX_cjs = require('../chunk-EXKSFGSX.cjs');
+var chunk37HHY7RH_cjs = require('../chunk-37HHY7RH.cjs');
 var chunkOSYNRVOV_cjs = require('../chunk-OSYNRVOV.cjs');
-var chunkSLU6UPJI_cjs = require('../chunk-SLU6UPJI.cjs');
-require('../chunk-E7JP3BS3.cjs');
-require('../chunk-HCCQLAA4.cjs');
+require('../chunk-Q47JEE2C.cjs');
+require('../chunk-ZHPMP447.cjs');
 
 
 
@@ -20,45 +20,45 @@ Object.defineProperty(exports, "getMCPCircuitBreaker", {
   enumerable: true,
   get: function () { return chunkEXKSFGSX_cjs.getMCPCircuitBreaker; }
 });
-Object.defineProperty(exports, "CircuitBreakerState", {
+Object.defineProperty(exports, "AsyncFunctionHandler", {
   enumerable: true,
-  get: function () { return chunkOSYNRVOV_cjs.CircuitBreakerState; }
+  get: function () { return chunk37HHY7RH_cjs.AsyncFunctionHandler; }
 });
-Object.defineProperty(exports, "ResilienceCircuitBreaker", {
+Object.defineProperty(exports, "ErrorBoundary", {
   enumerable: true,
-  get: function () { return chunkOSYNRVOV_cjs.CircuitBreaker; }
+  get: function () { return chunk37HHY7RH_cjs.ErrorBoundary; }
 });
-Object.defineProperty(exports, "retryWithBackoff", {
+Object.defineProperty(exports, "ExportImportHandler", {
   enumerable: true,
-  get: function () { return chunkOSYNRVOV_cjs.retryWithBackoff; }
+  get: function () { return chunk37HHY7RH_cjs.ExportImportHandler; }
 });
-Object.defineProperty(exports, "withTimeout", {
+Object.defineProperty(exports, "InteropContext", {
   enumerable: true,
-  get: function () { return chunkOSYNRVOV_cjs.withTimeout; }
+  get: function () { return chunk37HHY7RH_cjs.InteropContext; }
 });
-Object.defineProperty(exports, "AsyncFunctionHandler", {
+Object.defineProperty(exports, "ModuleResolver", {
   enumerable: true,
-  get: function () { return chunkSLU6UPJI_cjs.AsyncFunctionHandler; }
+  get: function () { return chunk37HHY7RH_cjs.ModuleResolver; }
 });
-Object.defineProperty(exports, "ErrorBoundary", {
+Object.defineProperty(exports, "TypeScriptTypeLoader", {
   enumerable: true,
-  get: function () { return chunkSLU6UPJI_cjs.ErrorBoundary; }
+  get: function () { return chunk37HHY7RH_cjs.TypeScriptTypeLoader; }
 });
-Object.defineProperty(exports, "ExportImportHandler", {
+Object.defineProperty(exports, "CircuitBreakerState", {
   enumerable: true,
-  get: function () { return chunkSLU6UPJI_cjs.ExportImportHandler; }
+  get: function () { return chunkOSYNRVOV_cjs.CircuitBreakerState; }
 });
-Object.defineProperty(exports, "InteropContext", {
+Object.defineProperty(exports, "ResilienceCircuitBreaker", {
   enumerable: true,
-  get: function () { return chunkSLU6UPJI_cjs.InteropContext; }
+  get: function () { return chunkOSYNRVOV_cjs.CircuitBreaker; }
 });
-Object.defineProperty(exports, "ModuleResolver", {
+Object.defineProperty(exports, "retryWithBackoff", {
   enumerable: true,
-  get: function () { return chunkSLU6UPJI_cjs.ModuleResolver; }
+  get: function () { return chunkOSYNRVOV_cjs.retryWithBackoff; }
 });
-Object.defineProperty(exports, "TypeScriptTypeLoader", {
+Object.defineProperty(exports, "withTimeout", {
   enumerable: true,
-  get: function () { return chunkSLU6UPJI_cjs.TypeScriptTypeLoader; }
+  get: function () { return chunkOSYNRVOV_cjs.withTimeout; }
 });
 //# sourceMappingURL=interop.cjs.map
 //# sourceMappingURL=interop.cjs.map

package/dist/entries/interop.js

@@ -1,7 +1,7 @@
 export { InteropBindingGenerator, MCPCircuitBreaker, getMCPCircuitBreaker } from '../chunk-FGGJQRLZ.js';
+export { AsyncFunctionHandler, ErrorBoundary, ExportImportHandler, InteropContext, ModuleResolver, TypeScriptTypeLoader } from '../chunk-TPZ3BN2D.js';
 export { CircuitBreakerState, CircuitBreaker as ResilienceCircuitBreaker, retryWithBackoff, withTimeout } from '../chunk-A6KINLZJ.js';
-export { AsyncFunctionHandler, ErrorBoundary, ExportImportHandler, InteropContext, ModuleResolver, TypeScriptTypeLoader } from '../chunk-5JEU52DW.js';
-import '../chunk-VVKVQZI6.js';
-import '../chunk-OL46QLBJ.js';
+import '../chunk-RAN3ECAS.js';
+import '../chunk-W4GABFCR.js';
 //# sourceMappingURL=interop.js.map
 //# sourceMappingURL=interop.js.map