@holoscript/core 8.0.7 → 8.0.9

package/dist/{chunk-F5LKJ6F5.cjs → chunk-IJU6AS67.cjs}

@@ -1,28 +1,28 @@
 'use strict';
 
-var chunkEBS32AJI_cjs = require('./chunk-EBS32AJI.cjs');
-var chunkGH6C2QGW_cjs = require('./chunk-GH6C2QGW.cjs');
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkTZCFKZ6Z_cjs = require('./chunk-TZCFKZ6Z.cjs');
+var chunkQEDMOGF3_cjs = require('./chunk-QEDMOGF3.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 var ans = require('@holoscript/core-types/ans');
 
 // src/compiler/UnrealCompiler.ts
 var UnrealCompiler_exports = {};
-chunkHCCQLAA4_cjs.__export(UnrealCompiler_exports, {
+chunkZHPMP447_cjs.__export(UnrealCompiler_exports, {
   UnrealCompiler: () => exports.UnrealCompiler,
   compileToUnreal: () => compileToUnreal
 });
 function compileToUnreal(composition, options) {
   const compiler = new exports.UnrealCompiler(options);
-  return compiler.compile(composition, chunkLODTHGST_cjs.createTestCompilerToken());
+  return compiler.compile(composition, chunkZK7KX5CD_cjs.createTestCompilerToken());
 }
 exports.UnrealCompiler = void 0;
-var init_UnrealCompiler = chunkHCCQLAA4_cjs.__esm({
+var init_UnrealCompiler = chunkZHPMP447_cjs.__esm({
   "src/compiler/UnrealCompiler.ts"() {
-    chunkLODTHGST_cjs.init_CompilerBase();
-    chunkGH6C2QGW_cjs.init_DomainBlockCompilerMixin();
-    chunkEBS32AJI_cjs.init_PlatformConditionalCompilerMixin();
-    exports.UnrealCompiler = class extends chunkLODTHGST_cjs.CompilerBase {
+    chunkZK7KX5CD_cjs.init_CompilerBase();
+    chunkQEDMOGF3_cjs.init_DomainBlockCompilerMixin();
+    chunkTZCFKZ6Z_cjs.init_PlatformConditionalCompilerMixin();
+    exports.UnrealCompiler = class extends chunkZK7KX5CD_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "UnrealCompiler";
@@ -41,7 +41,7 @@ var init_UnrealCompiler = chunkHCCQLAA4_cjs.__esm({
           platformTarget: options.platformTarget ?? ""
         };
         if (options.platformTarget) {
-          this._platformTarget = typeof options.platformTarget === "string" ? chunkEBS32AJI_cjs.createPlatformTarget(options.platformTarget) : options.platformTarget;
+          this._platformTarget = typeof options.platformTarget === "string" ? chunkTZCFKZ6Z_cjs.createPlatformTarget(options.platformTarget) : options.platformTarget;
         }
       }
       getRequiredCapability() {
@@ -50,7 +50,7 @@ var init_UnrealCompiler = chunkHCCQLAA4_cjs.__esm({
       compile(composition, agentToken, outputPath) {
         this.validateCompilerAccess(agentToken, outputPath);
         if (this._platformTarget) {
-          const platformMixin = new chunkEBS32AJI_cjs.PlatformConditionalCompilerMixin();
+          const platformMixin = new chunkTZCFKZ6Z_cjs.PlatformConditionalCompilerMixin();
           composition = platformMixin.filterForPlatform(composition, this._platformTarget);
         }
         this.headerLines = [];
@@ -656,32 +656,36 @@ var init_UnrealCompiler = chunkHCCQLAA4_cjs.__esm({
         this.emitS("");
         this.emitS("// === v4.2 Domain Blocks ===");
         let blockIdx = 0;
-        const compiled = chunkGH6C2QGW_cjs.compileDomainBlocks(
+        const compiled = chunkQEDMOGF3_cjs.compileDomainBlocks(
           domainBlocks,
           {
             material: (block) => {
-              const mat = chunkGH6C2QGW_cjs.compileMaterialBlock(block);
-              return chunkGH6C2QGW_cjs.materialToUnreal(mat, `DB${blockIdx++}`);
+              const mat = chunkQEDMOGF3_cjs.compileMaterialBlock(block);
+              return chunkQEDMOGF3_cjs.materialToUnreal(mat, `DB${blockIdx++}`);
             },
             physics: (block) => {
-              const phys = chunkGH6C2QGW_cjs.compilePhysicsBlock(block);
-              return chunkGH6C2QGW_cjs.physicsToUnreal(phys, `DB${blockIdx++}`);
+              const phys = chunkQEDMOGF3_cjs.compilePhysicsBlock(block);
+              return chunkQEDMOGF3_cjs.physicsToUnreal(phys, `DB${blockIdx++}`);
             },
             vfx: (block) => {
-              const ps = chunkGH6C2QGW_cjs.compileParticleBlock(block);
-              return chunkGH6C2QGW_cjs.particlesToUnreal(ps, `DB${blockIdx++}`);
+              const ps = chunkQEDMOGF3_cjs.compileParticleBlock(block);
+              return chunkQEDMOGF3_cjs.particlesToUnreal(ps, `DB${blockIdx++}`);
             },
             postfx: (block) => {
-              const pp = chunkGH6C2QGW_cjs.compilePostProcessingBlock(block);
-              return chunkGH6C2QGW_cjs.postProcessingToUnreal(pp, `DB${blockIdx++}`);
+              const pp = chunkQEDMOGF3_cjs.compilePostProcessingBlock(block);
+              return chunkQEDMOGF3_cjs.postProcessingToUnreal(pp, `DB${blockIdx++}`);
             },
             audio: (block) => {
-              const audio = chunkGH6C2QGW_cjs.compileAudioSourceBlock(block);
-              return chunkGH6C2QGW_cjs.audioSourceToUnreal(audio, `DB${blockIdx++}`);
+              const audio = chunkQEDMOGF3_cjs.compileAudioSourceBlock(block);
+              return chunkQEDMOGF3_cjs.audioSourceToUnreal(audio, `DB${blockIdx++}`);
             },
             weather: (block) => {
-              const weather = chunkGH6C2QGW_cjs.compileWeatherBlock(block);
-              return chunkGH6C2QGW_cjs.weatherToUnreal(weather);
+              const weather = chunkQEDMOGF3_cjs.compileWeatherBlock(block);
+              return chunkQEDMOGF3_cjs.weatherToUnreal(weather);
+            },
+            dataviz: (block) => {
+              const dv = chunkQEDMOGF3_cjs.compileDataVizBlock(block);
+              return chunkQEDMOGF3_cjs.datavizToUnreal(dv, `DB${blockIdx++}`);
             }
           },
           (block) => `// Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "TypeScript")}"`
@@ -726,5 +730,5 @@ var init_UnrealCompiler = chunkHCCQLAA4_cjs.__esm({
 exports.UnrealCompiler_exports = UnrealCompiler_exports;
 exports.compileToUnreal = compileToUnreal;
 exports.init_UnrealCompiler = init_UnrealCompiler;
-//# sourceMappingURL=chunk-F5LKJ6F5.cjs.map
-//# sourceMappingURL=chunk-F5LKJ6F5.cjs.map
+//# sourceMappingURL=chunk-IJU6AS67.cjs.map
+//# sourceMappingURL=chunk-IJU6AS67.cjs.map

package/dist/{chunk-TVANHNJ7.js → chunk-IK6Z2HNC.js}

@@ -1,5 +1,117 @@
 import { logger } from './chunk-PHENW4MQ.js';
 
+// src/events/EventBus.ts
+var EventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+    this.history = [];
+    this.maxHistory = 100;
+    this.nextId = 0;
+    this.paused = false;
+  }
+  /**
+   * Subscribe to an event.
+   */
+  on(event, callback, priority = 0) {
+    const id = this.nextId++;
+    const list = this.listeners.get(event) || [];
+    list.push({ callback, priority, once: false, id });
+    list.sort((a, b) => b.priority - a.priority);
+    this.listeners.set(event, list);
+    return id;
+  }
+  /**
+   * Subscribe to an event once (auto-removes after first fire).
+   */
+  once(event, callback, priority = 0) {
+    const id = this.nextId++;
+    const list = this.listeners.get(event) || [];
+    list.push({ callback, priority, once: true, id });
+    list.sort((a, b) => b.priority - a.priority);
+    this.listeners.set(event, list);
+    return id;
+  }
+  /**
+   * Unsubscribe by listener ID.
+   */
+  off(listenerId) {
+    for (const [event, list] of this.listeners) {
+      const idx = list.findIndex((l) => l.id === listenerId);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+        return;
+      }
+    }
+  }
+  /**
+   * Unsubscribe all listeners for an event.
+   */
+  offAll(event) {
+    this.listeners.delete(event);
+  }
+  /**
+   * Emit an event to all subscribers.
+   */
+  emit(event, data) {
+    if (this.paused) return;
+    this.history.push({ event, data, timestamp: Date.now() });
+    if (this.history.length > this.maxHistory) this.history.shift();
+    const list = this.listeners.get(event);
+    if (list) {
+      const toRemove = [];
+      for (const listener of list) {
+        listener.callback(data);
+        if (listener.once) toRemove.push(listener.id);
+      }
+      for (const id of toRemove) {
+        const idx = list.findIndex((l) => l.id === id);
+        if (idx !== -1) list.splice(idx, 1);
+      }
+    }
+    if (event !== "*") {
+      const wildcardList = this.listeners.get("*");
+      if (wildcardList) {
+        for (const listener of wildcardList) {
+          listener.callback({ event, data });
+        }
+      }
+    }
+  }
+  /**
+   * Get event history.
+   */
+  getHistory() {
+    return [...this.history];
+  }
+  /**
+   * Get listener count for an event.
+   */
+  listenerCount(event) {
+    return this.listeners.get(event)?.length || 0;
+  }
+  /**
+   * Pause/resume event emission.
+   */
+  setPaused(paused) {
+    this.paused = paused;
+  }
+  /**
+   * Clear all listeners and history.
+   */
+  clear() {
+    this.listeners.clear();
+    this.history = [];
+  }
+};
+var sharedBus = null;
+function getSharedEventBus() {
+  if (!sharedBus) sharedBus = new EventBus();
+  return sharedBus;
+}
+function setSharedEventBus(bus) {
+  sharedBus = bus;
+}
+
 // src/traits/MitosisTrait.ts
 var mitosisHandler = {
   name: "mitosis",
@@ -602,6 +714,64 @@ var orbitalHandler = {
   }
 };
 
-export { JEPAPredictor, embeddingHandler, jepObjectiveHandler, mitosisHandler, orbitalHandler };
-//# sourceMappingURL=chunk-TVANHNJ7.js.map
-//# sourceMappingURL=chunk-TVANHNJ7.js.map
+// src/runtime/easing.ts
+var SPRING_ZETA = 0.35;
+var SPRING_OMEGA = 8.38;
+var SPRING_OMEGA_D = SPRING_OMEGA * Math.sqrt(1 - SPRING_ZETA * SPRING_ZETA);
+function springStepResponse(t) {
+  const decay = Math.exp(-SPRING_ZETA * SPRING_OMEGA * t);
+  const osc = Math.cos(SPRING_OMEGA_D * t) + SPRING_ZETA * SPRING_OMEGA / SPRING_OMEGA_D * Math.sin(SPRING_OMEGA_D * t);
+  return 1 - decay * osc;
+}
+var SPRING_RESIDUAL = 1 - springStepResponse(1);
+function springEasing(t) {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  return springStepResponse(t) + t * SPRING_RESIDUAL;
+}
+function bounceEasing(t) {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (t < 1 / d1) {
+    return n1 * t * t;
+  } else if (t < 2 / d1) {
+    const u2 = t - 1.5 / d1;
+    return n1 * u2 * u2 + 0.75;
+  } else if (t < 2.5 / d1) {
+    const u2 = t - 2.25 / d1;
+    return n1 * u2 * u2 + 0.9375;
+  }
+  const u = t - 2.625 / d1;
+  return n1 * u * u + 0.984375;
+}
+function applyEasing(t, easing) {
+  switch (easing) {
+    case "easeIn":
+      return t * t;
+    case "easeOut":
+      return t * (2 - t);
+    case "easeInOut":
+      return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    case "easeInQuad":
+      return t * t;
+    case "easeOutQuad":
+      return t * (2 - t);
+    case "easeInOutQuad":
+      return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    case "spring":
+      return springEasing(t);
+    case "bounce":
+      return bounceEasing(t);
+    case "smoothstep":
+      return t * t * (3 - 2 * t);
+    case "linear":
+    default:
+      return t;
+  }
+}
+
+export { EventBus, JEPAPredictor, applyEasing, embeddingHandler, getSharedEventBus, jepObjectiveHandler, mitosisHandler, orbitalHandler, setSharedEventBus };
+//# sourceMappingURL=chunk-IK6Z2HNC.js.map
+//# sourceMappingURL=chunk-IK6Z2HNC.js.map

package/dist/{chunk-QGMUTVVH.cjs → chunk-IS7NTKY5.cjs}

@@ -1,23 +1,23 @@
 'use strict';
 
-var chunkEBS32AJI_cjs = require('./chunk-EBS32AJI.cjs');
-var chunkGH6C2QGW_cjs = require('./chunk-GH6C2QGW.cjs');
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkTZCFKZ6Z_cjs = require('./chunk-TZCFKZ6Z.cjs');
+var chunkQEDMOGF3_cjs = require('./chunk-QEDMOGF3.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 var ans = require('@holoscript/core-types/ans');
 
 // src/compiler/OpenXRCompiler.ts
 var OpenXRCompiler_exports = {};
-chunkHCCQLAA4_cjs.__export(OpenXRCompiler_exports, {
+chunkZHPMP447_cjs.__export(OpenXRCompiler_exports, {
   OpenXRCompiler: () => exports.OpenXRCompiler
 });
 exports.OpenXRCompiler = void 0;
-var init_OpenXRCompiler = chunkHCCQLAA4_cjs.__esm({
+var init_OpenXRCompiler = chunkZHPMP447_cjs.__esm({
   "src/compiler/OpenXRCompiler.ts"() {
-    chunkLODTHGST_cjs.init_CompilerBase();
-    chunkEBS32AJI_cjs.init_PlatformConditionalCompilerMixin();
-    chunkGH6C2QGW_cjs.init_DomainBlockCompilerMixin();
-    exports.OpenXRCompiler = class extends chunkLODTHGST_cjs.CompilerBase {
+    chunkZK7KX5CD_cjs.init_CompilerBase();
+    chunkTZCFKZ6Z_cjs.init_PlatformConditionalCompilerMixin();
+    chunkQEDMOGF3_cjs.init_DomainBlockCompilerMixin();
+    exports.OpenXRCompiler = class extends chunkZK7KX5CD_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "OpenXRCompiler";
@@ -36,7 +36,7 @@ var init_OpenXRCompiler = chunkHCCQLAA4_cjs.__esm({
       }
       compile(composition, agentToken, outputPath) {
         this.validateCompilerAccess(agentToken, outputPath);
-        composition = chunkEBS32AJI_cjs.filterCompositionForPlatform(composition, "quest3");
+        composition = chunkTZCFKZ6Z_cjs.filterCompositionForPlatform(composition, "quest3");
         this.lines = [];
         this.indentLevel = 0;
         this.emit("// Auto-generated by HoloScript OpenXRCompiler");
@@ -136,32 +136,32 @@ var init_OpenXRCompiler = chunkHCCQLAA4_cjs.__esm({
         if (domainBlocks.length > 0) {
           this.emit("");
           this.emit("// === v4.2 Domain Blocks ===");
-          const compiled = chunkGH6C2QGW_cjs.compileDomainBlocks(
+          const compiled = chunkQEDMOGF3_cjs.compileDomainBlocks(
             // @ts-expect-error During migration
             domainBlocks,
             {
               material: (block) => {
-                const m = chunkGH6C2QGW_cjs.compileMaterialBlock(block);
+                const m = chunkQEDMOGF3_cjs.compileMaterialBlock(block);
                 return `// Material: "${this.escapeStringValue(m.name, "TypeScript")}" type=${m.type} baseColor=${m.baseColor || "none"} roughness=${m.roughness ?? "default"} metallic=${m.metallic ?? "default"}`;
               },
               physics: (block) => {
-                const p = chunkGH6C2QGW_cjs.compilePhysicsBlock(block);
+                const p = chunkQEDMOGF3_cjs.compilePhysicsBlock(block);
                 return `// Physics: ${p.keyword} "${p.name || ""}" colliders=${p.colliders?.length || 0} rigidbody=${!!p.rigidbody}`;
               },
               vfx: (block) => {
-                const ps = chunkGH6C2QGW_cjs.compileParticleBlock(block);
+                const ps = chunkQEDMOGF3_cjs.compileParticleBlock(block);
                 return `// Particles: "${this.escapeStringValue(ps.name, "TypeScript")}" rate=${ps.properties.rate || "default"} modules=${ps.modules.length}`;
               },
               postfx: (block) => {
-                const pp = chunkGH6C2QGW_cjs.compilePostProcessingBlock(block);
+                const pp = chunkQEDMOGF3_cjs.compilePostProcessingBlock(block);
                 return `// PostFX: ${pp.keyword} effects=[${pp.effects.map((e) => e.type).join(", ")}]`;
               },
               audio: (block) => {
-                const a = chunkGH6C2QGW_cjs.compileAudioSourceBlock(block);
+                const a = chunkQEDMOGF3_cjs.compileAudioSourceBlock(block);
                 return `// Audio: "${this.escapeStringValue(a.name, "TypeScript")}" (${a.keyword}) clip=${a.properties.clip || "none"}`;
               },
               weather: (block) => {
-                const w = chunkGH6C2QGW_cjs.compileWeatherBlock(block);
+                const w = chunkQEDMOGF3_cjs.compileWeatherBlock(block);
                 return `// Weather: ${w.keyword} layers=[${w.layers.map((l) => l.type).join(", ")}]`;
               }
             },
@@ -1045,5 +1045,5 @@ var init_OpenXRCompiler = chunkHCCQLAA4_cjs.__esm({
 
 exports.OpenXRCompiler_exports = OpenXRCompiler_exports;
 exports.init_OpenXRCompiler = init_OpenXRCompiler;
-//# sourceMappingURL=chunk-QGMUTVVH.cjs.map
-//# sourceMappingURL=chunk-QGMUTVVH.cjs.map
+//# sourceMappingURL=chunk-IS7NTKY5.cjs.map
+//# sourceMappingURL=chunk-IS7NTKY5.cjs.map

package/dist/{chunk-YFVQWSNJ.js → chunk-IXWGYWH6.js}

@@ -1,4 +1,4 @@
-import { HOLOMAP_SIMULATION_CONTRACT_KIND } from './chunk-47RUFYKR.js';
+import { HOLOMAP_SIMULATION_CONTRACT_KIND } from './chunk-K56UVEXV.js';
 
 // src/reconstruction/simulationContractBinding.ts
 function assertHoloMapManifestContract(m) {
@@ -14,5 +14,5 @@ function assertHoloMapManifestContract(m) {
 }
 
 export { assertHoloMapManifestContract };
-//# sourceMappingURL=chunk-YFVQWSNJ.js.map
-//# sourceMappingURL=chunk-YFVQWSNJ.js.map
+//# sourceMappingURL=chunk-IXWGYWH6.js.map
+//# sourceMappingURL=chunk-IXWGYWH6.js.map

package/dist/chunk-J2DAS2PL.js

@@ -0,0 +1,148 @@
+// src/traits/SensorSamplingTrait.ts
+function boxMuller(u1, u2) {
+  return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+function applyNoise(raw, noise) {
+  switch (noise.type) {
+    case "none":
+      return raw;
+    case "gaussian": {
+      const n = boxMuller(1 - Math.random(), Math.random());
+      return raw + noise.sigma * n;
+    }
+    case "uniform":
+      return raw + (Math.random() * 2 - 1) * noise.range;
+    case "quantized": {
+      const q = Math.round(raw / noise.step) * noise.step;
+      if (!noise.residualSigma) return q;
+      const n = boxMuller(1 - Math.random(), Math.random());
+      return q + noise.residualSigma * n;
+    }
+  }
+}
+var SensorRingBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.head = 0;
+    this._size = 0;
+    this.buf = new Array(capacity);
+  }
+  push(r) {
+    this.buf[this.head] = r;
+    this.head = (this.head + 1) % this.capacity;
+    if (this._size < this.capacity) this._size++;
+  }
+  get size() {
+    return this._size;
+  }
+  /** Returns readings oldest-first. */
+  toArray() {
+    if (this._size === 0) return [];
+    const out = [];
+    const start = this._size < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this._size; i++) {
+      out.push(this.buf[(start + i) % this.capacity]);
+    }
+    return out;
+  }
+  latest() {
+    if (this._size === 0) return void 0;
+    const idx = (this.head - 1 + this.capacity) % this.capacity;
+    return this.buf[idx];
+  }
+  clear() {
+    this.head = 0;
+    this._size = 0;
+  }
+};
+function recordReading(rawValue, noise, sensorId, timestamp) {
+  return {
+    sensorId,
+    rawValue,
+    noisyValue: applyNoise(rawValue, noise),
+    timestamp
+  };
+}
+function computeWindowStats(sensorId, buffer) {
+  const readings = buffer.toArray();
+  const count = readings.length;
+  if (count === 0) {
+    return { sensorId, readings, count: 0, mean: NaN, variance: NaN, min: Infinity, max: -Infinity };
+  }
+  let sum = 0;
+  let min = Infinity;
+  let max = -Infinity;
+  for (const r of readings) {
+    sum += r.noisyValue;
+    if (r.noisyValue < min) min = r.noisyValue;
+    if (r.noisyValue > max) max = r.noisyValue;
+  }
+  const mean = sum / count;
+  if (count < 2) {
+    return { sensorId, readings, count, mean, variance: NaN, min, max };
+  }
+  let ss = 0;
+  for (const r of readings) ss += (r.noisyValue - mean) ** 2;
+  const variance = ss / (count - 1);
+  return { sensorId, readings, count, mean, variance, min, max };
+}
+var NO_NOISE = { type: "none" };
+function getOrCreateState(node, config) {
+  if (!(node.__sensor_state instanceof Map)) {
+    const m = /* @__PURE__ */ new Map();
+    for (const ch of config.sensors) {
+      m.set(ch.id, {
+        buffer: new SensorRingBuffer(ch.bufferSize ?? 32),
+        config: ch
+      });
+    }
+    node.__sensor_state = m;
+  }
+  return node.__sensor_state;
+}
+var sensorSamplingHandler = {
+  name: "sensor_sampling",
+  defaultConfig: { sensors: [] },
+  onAttach(node, config) {
+    const n = node;
+    getOrCreateState(n, config);
+    n.__sensor_last = {};
+    n.__sensor_window = {};
+  },
+  onEvent(node, config, _ctx, event) {
+    const n = node;
+    const state = getOrCreateState(n, config);
+    if (event.type === "sensor.record") {
+      const req = event;
+      const id = req.sensorId ?? config.sensors[0]?.id;
+      if (!id) return;
+      const entry = state.get(id);
+      if (!entry) return;
+      const noise = req.noise ?? entry.config.noise ?? NO_NOISE;
+      const reading = recordReading(req.rawValue, noise, id, req.timestamp ?? 0);
+      entry.buffer.push(reading);
+      n.__sensor_last[id] = reading;
+      return;
+    }
+    if (event.type === "sensor.read_window") {
+      const req = event;
+      const id = req.sensorId ?? config.sensors[0]?.id;
+      if (!id) return;
+      const entry = state.get(id);
+      if (!entry) return;
+      const result = computeWindowStats(id, entry.buffer);
+      n.__sensor_window[id] = result;
+      return;
+    }
+    if (event.type === "sensor.reset") {
+      for (const entry of state.values()) entry.buffer.clear();
+      n.__sensor_last = {};
+      n.__sensor_window = {};
+      return;
+    }
+  }
+};
+
+export { SensorRingBuffer, applyNoise, boxMuller, computeWindowStats, recordReading, sensorSamplingHandler };
+//# sourceMappingURL=chunk-J2DAS2PL.js.map
+//# sourceMappingURL=chunk-J2DAS2PL.js.map