@holoscript/core 8.0.13 → 8.0.15

package/dist/{chunk-IFW5IW4L.cjs → chunk-X5ZLSPU2.cjs}

@@ -7,7 +7,7 @@ var chunkENZCIQZC_cjs = require('./chunk-ENZCIQZC.cjs');
 var chunk4PDEPEQW_cjs = require('./chunk-4PDEPEQW.cjs');
 var chunkVHORVGCG_cjs = require('./chunk-VHORVGCG.cjs');
 var chunkYP5CHEYU_cjs = require('./chunk-YP5CHEYU.cjs');
-var chunkSJIRCTIS_cjs = require('./chunk-SJIRCTIS.cjs');
+var chunkHSGJFCVJ_cjs = require('./chunk-HSGJFCVJ.cjs');
 var chunkILRBGFVD_cjs = require('./chunk-ILRBGFVD.cjs');
 var chunkQ47JEE2C_cjs = require('./chunk-Q47JEE2C.cjs');
 var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
@@ -2727,6 +2727,44 @@ var evolveProgramHandler = {
   }
 };
 
+// src/traits/FreezeWhenTrait.ts
+var DEFAULT_EXEMPT = ["fix", "native-format", "infra-repair"];
+var freezeWhenHandler = {
+  name: "freeze_when",
+  defaultConfig: {
+    id: "",
+    scope: "",
+    signal: "",
+    unfreeze: "",
+    exempt: DEFAULT_EXEMPT,
+    severity: "advisory",
+    reason: "",
+    repair: ""
+  },
+  onAttach(node, config, context) {
+    node.__freezeWhen = {
+      id: config.id,
+      scope: config.scope,
+      signal: config.signal,
+      unfreeze: config.unfreeze,
+      exempt: config.exempt ?? DEFAULT_EXEMPT,
+      severity: config.severity ?? "advisory",
+      reason: config.reason ?? "",
+      repair: config.repair ?? ""
+    };
+    context.emit?.("freeze_declared", {
+      node,
+      rule: node.__freezeWhen,
+      derived: true,
+      nativeExempt: true
+    });
+  },
+  onDetach(node, _config, context) {
+    delete node.__freezeWhen;
+    context.emit?.("freeze_when_detached", { node });
+  }
+};
+
 // src/traits/AiUpscalingTrait.ts
 var aiUpscalingHandler = {
   name: "ai_upscaling",
@@ -21115,6 +21153,33 @@ var NetworkedTrait = class {
   lerpVector3(a, b, t) {
     return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
   }
+  /**
+   * SLERP for networked rotation interpolation (tuple-in / tuple-out).
+   *
+   * DO NOT "dedup" this into `../math/Quaternion.slerp` without reading this first.
+   * It is a near-duplicate of that function — same shortest-arc flip, same
+   * `dot > 0.9995` normalize-lerp fallback, same s0/s1 coefficients — but it is
+   * deliberately NOT bit-identical: the main branch below returns the raw
+   * `s0*a + s1*b` combination, whereas `Quaternion.slerp` wraps its result in
+   * `normalize(...)`. For exact unit inputs the two agree analytically; in floating
+   * point they differ in the last ULPs.
+   *
+   * That matters here because this is a netcode path: rotations interpolated by two
+   * clients on different builds must agree, and a last-ULP change is a *behavior*
+   * change that no single-version test can catch (the failure mode is version-skew
+   * divergence, which only reproduces with two builds live). Migrating this requires
+   * either bit-exactness proven against golden values for every branch, or a
+   * cross-version replay test — neither exists today.
+   *
+   * Also note `Quaternion.slerp` is currently package-private (not in core's
+   * package.json `exports`) and returns a hybrid `{x,y,z,w}` object with
+   * NON-enumerable numeric indices — it indexes like a tuple but `JSON.stringify`
+   * drops the indices and spreading it throws. It is not a drop-in for a real tuple
+   * on a serialization path.
+   *
+   * Analysis: ai-ecosystem `research/2026-07-15_interpolation.md` +
+   * `research/2026-07-15_native-interpolate-trait-feasibility.md`.
+   */
   slerpQuat(a, b, t) {
     let dot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
     const bNorm = dot < 0 ? [-b[0], -b[1], -b[2], -b[3]] : [...b];
@@ -24325,6 +24390,200 @@ export default IframeSandbox;`;
   }
 };
 
+// src/traits/RetryTrait.ts
+function computeDelay(config, attempt) {
+  let delay;
+  switch (config.backoff) {
+    case "exponential":
+      delay = config.base_delay_ms * Math.pow(2, attempt);
+      break;
+    case "linear":
+      delay = config.base_delay_ms * (attempt + 1);
+      break;
+    case "constant":
+    default:
+      delay = config.base_delay_ms;
+      break;
+  }
+  delay = Math.min(delay, config.max_delay_ms);
+  if (config.jitter > 0) {
+    const jitterAmount = delay * config.jitter;
+    delay += Math.random() * jitterAmount * 2 - jitterAmount;
+  }
+  return Math.max(0, Math.round(delay));
+}
+var retryHandler = {
+  name: "retry",
+  defaultConfig: {
+    max_retries: 3,
+    base_delay_ms: 1e3,
+    max_delay_ms: 3e4,
+    backoff: "exponential",
+    jitter: 0.1,
+    circuit_threshold: 5,
+    circuit_reset_ms: 6e4
+  },
+  onAttach(node, _config, _context) {
+    const state = {
+      circuit: "closed",
+      consecutiveFailures: 0,
+      circuitOpenedAt: 0,
+      totalAttempts: 0,
+      totalSuccesses: 0,
+      totalFailures: 0,
+      pendingActions: /* @__PURE__ */ new Map(),
+      actionCounter: 0
+    };
+    node.__retryState = state;
+  },
+  onDetach(node, _config, _context) {
+    delete node.__retryState;
+  },
+  onUpdate(node, config, context, _delta) {
+    const state = node.__retryState;
+    if (!state) return;
+    if (state.circuit === "open") {
+      const elapsed = Date.now() - state.circuitOpenedAt;
+      if (elapsed >= config.circuit_reset_ms) {
+        state.circuit = "half-open";
+        context.emit?.("retry:circuit_half", {
+          testAttempt: state.totalAttempts + 1
+        });
+      }
+    }
+  },
+  onEvent(node, config, context, event) {
+    const state = node.__retryState;
+    if (!state) return;
+    const eventType = typeof event === "string" ? event : event.type;
+    const payload = extractPayload(event);
+    switch (eventType) {
+      case "retry:execute": {
+        const actionName = payload.action;
+        if (!actionName) break;
+        if (state.circuit === "open") {
+          context.emit?.("retry:failure", {
+            actionName,
+            attempt: 0,
+            error: "Circuit breaker is OPEN"
+          });
+          break;
+        }
+        const retryId = `retry_${state.actionCounter++}`;
+        state.pendingActions.set(retryId, {
+          actionName,
+          attempt: 0,
+          startedAt: Date.now()
+        });
+        state.totalAttempts++;
+        context.emit?.("retry:attempt", {
+          retryId,
+          actionName,
+          attempt: 0,
+          maxRetries: config.max_retries
+        });
+        context.emit?.(actionName, {
+          ...payload.params,
+          __retryId: retryId
+        });
+        break;
+      }
+      case "retry:action_result": {
+        const retryId = payload.retryId;
+        const success = payload.success;
+        const error = payload.error;
+        const pending = state.pendingActions.get(retryId);
+        if (!pending) break;
+        if (success) {
+          state.totalSuccesses++;
+          state.consecutiveFailures = 0;
+          state.pendingActions.delete(retryId);
+          if (state.circuit === "half-open") {
+            state.circuit = "closed";
+            context.emit?.("retry:circuit_close", {
+              recoveredAfterMs: Date.now() - state.circuitOpenedAt
+            });
+          }
+          context.emit?.("retry:success", {
+            actionName: pending.actionName,
+            attempt: pending.attempt,
+            elapsed: Date.now() - pending.startedAt
+          });
+        } else {
+          state.totalFailures++;
+          state.consecutiveFailures++;
+          pending.attempt++;
+          context.emit?.("retry:failure", {
+            actionName: pending.actionName,
+            attempt: pending.attempt,
+            error: error ?? "unknown"
+          });
+          if (state.consecutiveFailures >= config.circuit_threshold) {
+            state.circuit = "open";
+            state.circuitOpenedAt = Date.now();
+            state.pendingActions.delete(retryId);
+            context.emit?.("retry:circuit_open", {
+              consecutiveFailures: state.consecutiveFailures,
+              resetMs: config.circuit_reset_ms
+            });
+            break;
+          }
+          if (state.circuit === "half-open") {
+            state.circuit = "open";
+            state.circuitOpenedAt = Date.now();
+            state.pendingActions.delete(retryId);
+            context.emit?.("retry:circuit_open", {
+              consecutiveFailures: state.consecutiveFailures,
+              resetMs: config.circuit_reset_ms
+            });
+            break;
+          }
+          if (pending.attempt > config.max_retries) {
+            state.pendingActions.delete(retryId);
+            context.emit?.("retry:exhausted", {
+              actionName: pending.actionName,
+              totalAttempts: pending.attempt
+            });
+          } else {
+            const delay = computeDelay(config, pending.attempt - 1);
+            state.totalAttempts++;
+            setTimeout(() => {
+              if (!node.__retryState) return;
+              context.emit?.("retry:attempt", {
+                retryId,
+                actionName: pending.actionName,
+                attempt: pending.attempt,
+                maxRetries: config.max_retries
+              });
+              context.emit?.(pending.actionName, {
+                __retryId: retryId
+              });
+            }, delay);
+          }
+        }
+        break;
+      }
+      case "retry:reset_circuit": {
+        state.circuit = "closed";
+        state.consecutiveFailures = 0;
+        context.emit?.("retry:circuit_close", { recoveredAfterMs: 0 });
+        break;
+      }
+      case "retry:get_status": {
+        context.emit?.("retry:status", {
+          circuit: state.circuit,
+          consecutiveFailures: state.consecutiveFailures,
+          totalAttempts: state.totalAttempts,
+          totalSuccesses: state.totalSuccesses,
+          totalFailures: state.totalFailures,
+          pending: state.pendingActions.size
+        });
+        break;
+      }
+    }
+  }
+};
+
 // src/traits/SchedulerTrait.ts
 var schedulerHandler = {
   name: "scheduler",
@@ -25414,6 +25673,110 @@ function addEntry(state, config, context, level, payload) {
   }
 }
 
+// src/traits/CacheTrait.ts
+var cacheHandler = {
+  name: "cache",
+  defaultConfig: {
+    max_size: 1e3,
+    default_ttl_ms: 6e4,
+    eviction_policy: "lru"
+  },
+  onAttach(node, _config, _context) {
+    node.__cacheState = {
+      entries: /* @__PURE__ */ new Map(),
+      hits: 0,
+      misses: 0,
+      evictions: 0
+    };
+  },
+  onDetach(node) {
+    delete node.__cacheState;
+  },
+  onUpdate(node, config, _context, _delta) {
+    const state = node.__cacheState;
+    if (!state) return;
+    const now = Date.now();
+    for (const [key, entry] of state.entries) {
+      if (entry.expiresAt > 0 && now >= entry.expiresAt) {
+        state.entries.delete(key);
+        state.evictions++;
+      }
+    }
+  },
+  onEvent(node, config, context, event) {
+    const state = node.__cacheState;
+    if (!state) return;
+    const eventType = typeof event === "string" ? event : event.type;
+    switch (eventType) {
+      case "cache:set": {
+        const key = event.key;
+        if (!key) break;
+        const ttl = event.ttl ?? config.default_ttl_ms;
+        if (state.entries.size >= config.max_size && !state.entries.has(key)) {
+          evictOne(state, config, context);
+        }
+        const now = Date.now();
+        state.entries.set(key, {
+          value: event.value,
+          expiresAt: ttl > 0 ? now + ttl : 0,
+          accessedAt: now,
+          createdAt: now
+        });
+        break;
+      }
+      case "cache:get": {
+        const key = event.key;
+        if (!key) break;
+        const entry = state.entries.get(key);
+        if (entry && (entry.expiresAt === 0 || Date.now() < entry.expiresAt)) {
+          state.hits++;
+          entry.accessedAt = Date.now();
+          context.emit?.("cache:result", { key, value: entry.value, hit: true });
+        } else {
+          state.misses++;
+          if (entry) state.entries.delete(key);
+          context.emit?.("cache:result", { key, value: void 0, hit: false });
+        }
+        break;
+      }
+      case "cache:invalidate": {
+        const key = event.key;
+        if (key) state.entries.delete(key);
+        break;
+      }
+      case "cache:clear": {
+        state.entries.clear();
+        break;
+      }
+      case "cache:get_stats": {
+        context.emit?.("cache:stats", {
+          hits: state.hits,
+          misses: state.misses,
+          size: state.entries.size,
+          evictions: state.evictions,
+          hitRate: state.hits + state.misses > 0 ? state.hits / (state.hits + state.misses) : 0
+        });
+        break;
+      }
+    }
+  }
+};
+function evictOne(state, config, context) {
+  if (state.entries.size === 0) return;
+  let oldest = null;
+  for (const [key, entry] of state.entries) {
+    const time = config.eviction_policy === "lru" ? entry.accessedAt : entry.createdAt;
+    if (!oldest || time < oldest.time) {
+      oldest = { key, time };
+    }
+  }
+  if (oldest) {
+    state.entries.delete(oldest.key);
+    state.evictions++;
+    context.emit?.("cache:evict", { key: oldest.key, reason: config.eviction_policy });
+  }
+}
+
 // src/traits/FairnessMonitorTrait.ts
 var DEFAULT_POSITIVE_DECISION_VALUES = ["true", "approved", "approve", "pass", "1", "yes"];
 var DEFAULT_CONFIG5 = {
@@ -40457,7 +40820,7 @@ function sampleTrack(keyframes, t, defaultEasing = "linear") {
     if (t >= a.time && t <= b.time) {
       const span = b.time - a.time;
       const localT = span <= 0 ? 0 : (t - a.time) / span;
-      const eased = chunkSJIRCTIS_cjs.applyEasing(localT, b.easing ?? defaultEasing);
+      const eased = chunkHSGJFCVJ_cjs.applyEasing(localT, b.easing ?? defaultEasing);
       return a.value + (b.value - a.value) * eased;
     }
   }
@@ -40690,7 +41053,7 @@ var AnimationStateMachine = class {
         emit({ type: "transition-end", toState: crossfade.to.state, timestamp: Date.now() });
         emit({ type: "state-enter", state: crossfade.to.state, timestamp: Date.now() });
       } else {
-        const eased = chunkSJIRCTIS_cjs.applyEasing(crossfade.progress, crossfade.easing ?? "linear");
+        const eased = chunkHSGJFCVJ_cjs.applyEasing(crossfade.progress, crossfade.easing ?? "linear");
         crossfade.from.weight = 1 - eased;
         crossfade.to.weight = eased;
         if (!crossfade.pauseWhenExiting) {
@@ -41047,7 +41410,7 @@ var AnimationTrait = class {
         fromState: crossfade.from.state,
         toState: crossfade.to.state,
         progress: crossfade.progress,
-        easedProgress: chunkSJIRCTIS_cjs.applyEasing(crossfade.progress, crossfade.easing ?? "linear"),
+        easedProgress: chunkHSGJFCVJ_cjs.applyEasing(crossfade.progress, crossfade.easing ?? "linear"),
         duration: crossfade.duration,
         easing: crossfade.easing,
         pauseWhenExiting: crossfade.pauseWhenExiting
@@ -44490,6 +44853,333 @@ var environmentalAudioHandler = {
   }
 };
 
+// src/traits/FluidSimulationTrait.ts
+function poly6Kernel(r, h) {
+  if (r < 0 || r > h) return 0;
+  const coeff = 315 / (64 * Math.PI * h ** 9);
+  return coeff * (h * h - r * r) ** 3;
+}
+function spikyKernelGradient(dx, dy, dz, h) {
+  const r = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  if (r > h || r < 1e-5) return [0, 0, 0];
+  const coeff = -45 / (Math.PI * h ** 6) * (h - r) ** 2;
+  return [coeff * (dx / r), coeff * (dy / r), coeff * (dz / r)];
+}
+function viscosityKernelLaplacian(r, h) {
+  if (r < 0 || r > h) return 0;
+  return 45 / (Math.PI * h ** 6) * (h - r);
+}
+var SpatialHash = class {
+  constructor(cellSize) {
+    this.cells = /* @__PURE__ */ new Map();
+    this.cellSize = cellSize;
+  }
+  key(x, y, z) {
+    const cx = Math.floor(x / this.cellSize);
+    const cy = Math.floor(y / this.cellSize);
+    const cz = Math.floor(z / this.cellSize);
+    return `${cx},${cy},${cz}`;
+  }
+  insert(id, pos) {
+    const k = this.key(pos[0], pos[1], pos[2]);
+    if (!this.cells.has(k)) this.cells.set(k, []);
+    this.cells.get(k).push(id);
+  }
+  getNeighbors(pos) {
+    const cx = Math.floor(pos[0] / this.cellSize);
+    const cy = Math.floor(pos[1] / this.cellSize);
+    const cz = Math.floor(pos[2] / this.cellSize);
+    const result = [];
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        for (let dz = -1; dz <= 1; dz++) {
+          const k = `${cx + dx},${cy + dy},${cz + dz}`;
+          const cell = this.cells.get(k);
+          if (cell) result.push(...cell);
+        }
+      }
+    }
+    return result;
+  }
+  clear() {
+    this.cells.clear();
+  }
+};
+var FluidSimulationSystem = class {
+  constructor(config = {}) {
+    this.particles = /* @__PURE__ */ new Map();
+    this.nextId = 0;
+    this.boundaries = [];
+    this.cfg = {
+      restDensity: config.restDensity ?? 1e3,
+      viscosity: config.viscosity ?? 1e-3,
+      gravity: config.gravity ?? [0, -9.81, 0],
+      solverType: config.solverType ?? "sph",
+      timeStep: config.timeStep ?? 0.016,
+      maxVelocity: config.maxVelocity ?? 100,
+      smoothingRadius: config.smoothingRadius ?? 0.04,
+      gridCellSize: config.gridCellSize ?? 0.04,
+      particleRadius: config.particleRadius ?? 0.01,
+      gasConstant: config.gasConstant ?? 8.314,
+      surfaceTension: config.surfaceTension ?? 0.072
+    };
+    this.spatialHash = new SpatialHash(this.cfg.gridCellSize);
+  }
+  // ── Particle Management ────────────────────────────────────────────────
+  addParticle(position, velocity) {
+    const id = this.nextId++;
+    this.particles.set(id, {
+      id,
+      position: [...position],
+      velocity: velocity ? [...velocity] : [0, 0, 0],
+      force: [0, 0, 0],
+      density: this.cfg.restDensity,
+      pressure: 0,
+      mass: 1
+    });
+    return id;
+  }
+  getParticle(id) {
+    return this.particles.get(id);
+  }
+  getParticles() {
+    return Array.from(this.particles.values());
+  }
+  getParticleCount() {
+    return this.particles.size;
+  }
+  removeParticle(id) {
+    return this.particles.delete(id);
+  }
+  clearParticles() {
+    this.particles.clear();
+    this.nextId = 0;
+  }
+  // ── Boundary Management ────────────────────────────────────────────────
+  addBoundary(boundary) {
+    this.boundaries.push(boundary);
+  }
+  getBoundaries() {
+    return [...this.boundaries];
+  }
+  clearBoundaries() {
+    this.boundaries.length = 0;
+  }
+  // ── Configuration ──────────────────────────────────────────────────────
+  getConfig() {
+    return { ...this.cfg };
+  }
+  setConfig(partial) {
+    Object.assign(this.cfg, partial);
+    if (partial.gridCellSize !== void 0) {
+      this.spatialHash = new SpatialHash(this.cfg.gridCellSize);
+    }
+  }
+  // ── Simulation Step ────────────────────────────────────────────────────
+  step(dt) {
+    const h = this.cfg.smoothingRadius;
+    const deltaT = dt ?? this.cfg.timeStep;
+    const particles = Array.from(this.particles.values());
+    this.spatialHash.clear();
+    for (const p of particles) {
+      this.spatialHash.insert(p.id, p.position);
+    }
+    for (const pi of particles) {
+      let density = 0;
+      for (const pj of particles) {
+        const r = this.dist(pi.position, pj.position);
+        density += pj.mass * poly6Kernel(r, h);
+      }
+      pi.density = Math.max(density, this.cfg.restDensity * 0.01);
+      pi.pressure = this.cfg.gasConstant * (pi.density - this.cfg.restDensity);
+    }
+    for (const pi of particles) {
+      pi.force = [
+        this.cfg.gravity[0] * pi.mass,
+        this.cfg.gravity[1] * pi.mass,
+        this.cfg.gravity[2] * pi.mass
+      ];
+      for (const pj of particles) {
+        if (pi.id === pj.id) continue;
+        const dx = pi.position[0] - pj.position[0];
+        const dy = pi.position[1] - pj.position[1];
+        const dz = pi.position[2] - pj.position[2];
+        const r = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (r < h && r > 1e-5) {
+          const grad = spikyKernelGradient(dx, dy, dz, h);
+          const pScale = -pj.mass * ((pi.pressure + pj.pressure) / (2 * pj.density));
+          pi.force[0] += pScale * grad[0];
+          pi.force[1] += pScale * grad[1];
+          pi.force[2] += pScale * grad[2];
+          const viscLap = viscosityKernelLaplacian(r, h);
+          const vScale = this.cfg.viscosity * pj.mass * (1 / pj.density) * viscLap;
+          pi.force[0] += vScale * (pj.velocity[0] - pi.velocity[0]);
+          pi.force[1] += vScale * (pj.velocity[1] - pi.velocity[1]);
+          pi.force[2] += vScale * (pj.velocity[2] - pi.velocity[2]);
+        }
+      }
+    }
+    for (const p of particles) {
+      p.velocity[0] += p.force[0] / p.mass * deltaT;
+      p.velocity[1] += p.force[1] / p.mass * deltaT;
+      p.velocity[2] += p.force[2] / p.mass * deltaT;
+      const speed = Math.sqrt(p.velocity[0] ** 2 + p.velocity[1] ** 2 + p.velocity[2] ** 2);
+      if (speed > this.cfg.maxVelocity) {
+        const scale = this.cfg.maxVelocity / speed;
+        p.velocity[0] *= scale;
+        p.velocity[1] *= scale;
+        p.velocity[2] *= scale;
+      }
+      p.position[0] += p.velocity[0] * deltaT;
+      p.position[1] += p.velocity[1] * deltaT;
+      p.position[2] += p.velocity[2] * deltaT;
+    }
+    for (const p of particles) {
+      this.applyBoundaries(p);
+    }
+  }
+  // ── Density Queries ────────────────────────────────────────────────────
+  getDensityAt(position) {
+    const h = this.cfg.smoothingRadius;
+    let density = 0;
+    for (const p of this.particles.values()) {
+      const r = this.dist(position, p.position);
+      density += p.mass * poly6Kernel(r, h);
+    }
+    return density;
+  }
+  isInsideFluid(position) {
+    return this.getDensityAt(position) > this.cfg.restDensity * 0.5;
+  }
+  // ── Statistics ─────────────────────────────────────────────────────────
+  getKineticEnergy() {
+    let energy = 0;
+    for (const p of this.particles.values()) {
+      energy += 0.5 * p.mass * (p.velocity[0] ** 2 + p.velocity[1] ** 2 + p.velocity[2] ** 2);
+    }
+    return energy;
+  }
+  getAverageDensity() {
+    if (this.particles.size === 0) return 0;
+    let total = 0;
+    for (const p of this.particles.values()) total += p.density;
+    return total / this.particles.size;
+  }
+  reset() {
+    this.particles.clear();
+    this.spatialHash.clear();
+    this.boundaries.length = 0;
+    this.nextId = 0;
+  }
+  // ── Private Helpers ────────────────────────────────────────────────────
+  dist(a, b) {
+    return Math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2);
+  }
+  applyBoundaries(p) {
+    const pr = this.cfg.particleRadius;
+    for (const b of this.boundaries) {
+      if (b.type === "plane") {
+        const dx = p.position[0] - b.position[0];
+        const dy = p.position[1] - b.position[1];
+        const dz = p.position[2] - b.position[2];
+        const d = dx * b.normal[0] + dy * b.normal[1] + dz * b.normal[2];
+        if (d < pr) {
+          p.position[0] += b.normal[0] * (pr - d);
+          p.position[1] += b.normal[1] * (pr - d);
+          p.position[2] += b.normal[2] * (pr - d);
+          const vn = p.velocity[0] * b.normal[0] + p.velocity[1] * b.normal[1] + p.velocity[2] * b.normal[2];
+          if (vn < 0) {
+            p.velocity[0] -= (1 + b.restitution) * vn * b.normal[0];
+            p.velocity[1] -= (1 + b.restitution) * vn * b.normal[1];
+            p.velocity[2] -= (1 + b.restitution) * vn * b.normal[2];
+          }
+        }
+      } else if (b.type === "sphere") {
+        const dx = p.position[0] - b.position[0];
+        const dy = p.position[1] - b.position[1];
+        const dz = p.position[2] - b.position[2];
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        const maxDist = b.radius - pr;
+        if (dist > maxDist && dist > 1e-6) {
+          const nx = dx / dist;
+          const ny = dy / dist;
+          const nz = dz / dist;
+          p.position[0] = b.position[0] + nx * maxDist;
+          p.position[1] = b.position[1] + ny * maxDist;
+          p.position[2] = b.position[2] + nz * maxDist;
+          const vn = p.velocity[0] * nx + p.velocity[1] * ny + p.velocity[2] * nz;
+          if (vn > 0) {
+            p.velocity[0] -= (1 + b.restitution) * vn * nx;
+            p.velocity[1] -= (1 + b.restitution) * vn * ny;
+            p.velocity[2] -= (1 + b.restitution) * vn * nz;
+          }
+        }
+      } else if (b.type === "box") {
+        const halfX = b.size[0] / 2;
+        const halfY = b.size[1] / 2;
+        const halfZ = b.size[2] / 2;
+        const limit = pr;
+        if (p.position[0] > b.position[0] + halfX - limit) {
+          p.position[0] = b.position[0] + halfX - limit;
+          p.velocity[0] *= -b.restitution;
+        } else if (p.position[0] < b.position[0] - halfX + limit) {
+          p.position[0] = b.position[0] - halfX + limit;
+          p.velocity[0] *= -b.restitution;
+        }
+        if (p.position[1] > b.position[1] + halfY - limit) {
+          p.position[1] = b.position[1] + halfY - limit;
+          p.velocity[1] *= -b.restitution;
+        } else if (p.position[1] < b.position[1] - halfY + limit) {
+          p.position[1] = b.position[1] - halfY + limit;
+          p.velocity[1] *= -b.restitution;
+        }
+        if (p.position[2] > b.position[2] + halfZ - limit) {
+          p.position[2] = b.position[2] + halfZ - limit;
+          p.velocity[2] *= -b.restitution;
+        } else if (p.position[2] < b.position[2] - halfZ + limit) {
+          p.position[2] = b.position[2] - halfZ + limit;
+          p.velocity[2] *= -b.restitution;
+        }
+      }
+    }
+  }
+};
+var fluidSimulationHandler = {
+  name: "fluid_simulation",
+  defaultConfig: {},
+  onAttach(node, config, ctx) {
+    const instance = new FluidSimulationSystem(config);
+    node.__fluid_simulation_instance = instance;
+    ctx.emit("fluid_simulation_attached", { node, config });
+  },
+  onDetach(node, _config, ctx) {
+    const instance = node.__fluid_simulation_instance;
+    if (instance) {
+      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
+      else if (typeof instance.dispose === "function") instance.dispose();
+      else if (typeof instance.cleanup === "function") instance.cleanup();
+    }
+    ctx.emit("fluid_simulation_detached", { node });
+    delete node.__fluid_simulation_instance;
+  },
+  onEvent(node, _config, ctx, event) {
+    const instance = node.__fluid_simulation_instance;
+    if (!instance) return;
+    if (typeof instance.onEvent === "function") instance.onEvent(event);
+    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
+    if (event.type === "fluid_simulation_configure" && event.payload) {
+      Object.assign(instance, event.payload);
+      ctx.emit("fluid_simulation_configured", { node });
+    }
+  },
+  onUpdate(node, _config, ctx, dt) {
+    const instance = node.__fluid_simulation_instance;
+    if (!instance) return;
+    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
+    else if (typeof instance.step === "function") instance.step(dt);
+  }
+};
+
 // src/traits/GranularMaterialTrait.ts
 function toVec3(v) {
   if (Array.isArray(v)) {
@@ -52337,7 +53027,7 @@ var eventTraitHandler = {
   name: "events",
   defaultConfig: {},
   onAttach(node, config, _context) {
-    const bus = chunkSJIRCTIS_cjs.getSharedEventBus();
+    const bus = chunkHSGJFCVJ_cjs.getSharedEventBus();
     const nodeId = node.id;
     const ids = [];
     if (config.listen) {
@@ -52356,7 +53046,7 @@ var eventTraitHandler = {
     }
   },
   onDetach(node, config, _context) {
-    const bus = chunkSJIRCTIS_cjs.getSharedEventBus();
+    const bus = chunkHSGJFCVJ_cjs.getSharedEventBus();
     const nodeId = node.id;
     const ids = nodeListenerIds.get(nodeId) || [];
     for (const id of ids) bus.off(id);
@@ -53790,200 +54480,6 @@ var httpClientHandler = {
   }
 };
 
-// src/traits/RetryTrait.ts
-function computeDelay(config, attempt) {
-  let delay;
-  switch (config.backoff) {
-    case "exponential":
-      delay = config.base_delay_ms * Math.pow(2, attempt);
-      break;
-    case "linear":
-      delay = config.base_delay_ms * (attempt + 1);
-      break;
-    case "constant":
-    default:
-      delay = config.base_delay_ms;
-      break;
-  }
-  delay = Math.min(delay, config.max_delay_ms);
-  if (config.jitter > 0) {
-    const jitterAmount = delay * config.jitter;
-    delay += Math.random() * jitterAmount * 2 - jitterAmount;
-  }
-  return Math.max(0, Math.round(delay));
-}
-var retryHandler = {
-  name: "retry",
-  defaultConfig: {
-    max_retries: 3,
-    base_delay_ms: 1e3,
-    max_delay_ms: 3e4,
-    backoff: "exponential",
-    jitter: 0.1,
-    circuit_threshold: 5,
-    circuit_reset_ms: 6e4
-  },
-  onAttach(node, _config, _context) {
-    const state = {
-      circuit: "closed",
-      consecutiveFailures: 0,
-      circuitOpenedAt: 0,
-      totalAttempts: 0,
-      totalSuccesses: 0,
-      totalFailures: 0,
-      pendingActions: /* @__PURE__ */ new Map(),
-      actionCounter: 0
-    };
-    node.__retryState = state;
-  },
-  onDetach(node, _config, _context) {
-    delete node.__retryState;
-  },
-  onUpdate(node, config, context, _delta) {
-    const state = node.__retryState;
-    if (!state) return;
-    if (state.circuit === "open") {
-      const elapsed = Date.now() - state.circuitOpenedAt;
-      if (elapsed >= config.circuit_reset_ms) {
-        state.circuit = "half-open";
-        context.emit?.("retry:circuit_half", {
-          testAttempt: state.totalAttempts + 1
-        });
-      }
-    }
-  },
-  onEvent(node, config, context, event) {
-    const state = node.__retryState;
-    if (!state) return;
-    const eventType = typeof event === "string" ? event : event.type;
-    const payload = extractPayload(event);
-    switch (eventType) {
-      case "retry:execute": {
-        const actionName = payload.action;
-        if (!actionName) break;
-        if (state.circuit === "open") {
-          context.emit?.("retry:failure", {
-            actionName,
-            attempt: 0,
-            error: "Circuit breaker is OPEN"
-          });
-          break;
-        }
-        const retryId = `retry_${state.actionCounter++}`;
-        state.pendingActions.set(retryId, {
-          actionName,
-          attempt: 0,
-          startedAt: Date.now()
-        });
-        state.totalAttempts++;
-        context.emit?.("retry:attempt", {
-          retryId,
-          actionName,
-          attempt: 0,
-          maxRetries: config.max_retries
-        });
-        context.emit?.(actionName, {
-          ...payload.params,
-          __retryId: retryId
-        });
-        break;
-      }
-      case "retry:action_result": {
-        const retryId = payload.retryId;
-        const success = payload.success;
-        const error = payload.error;
-        const pending = state.pendingActions.get(retryId);
-        if (!pending) break;
-        if (success) {
-          state.totalSuccesses++;
-          state.consecutiveFailures = 0;
-          state.pendingActions.delete(retryId);
-          if (state.circuit === "half-open") {
-            state.circuit = "closed";
-            context.emit?.("retry:circuit_close", {
-              recoveredAfterMs: Date.now() - state.circuitOpenedAt
-            });
-          }
-          context.emit?.("retry:success", {
-            actionName: pending.actionName,
-            attempt: pending.attempt,
-            elapsed: Date.now() - pending.startedAt
-          });
-        } else {
-          state.totalFailures++;
-          state.consecutiveFailures++;
-          pending.attempt++;
-          context.emit?.("retry:failure", {
-            actionName: pending.actionName,
-            attempt: pending.attempt,
-            error: error ?? "unknown"
-          });
-          if (state.consecutiveFailures >= config.circuit_threshold) {
-            state.circuit = "open";
-            state.circuitOpenedAt = Date.now();
-            state.pendingActions.delete(retryId);
-            context.emit?.("retry:circuit_open", {
-              consecutiveFailures: state.consecutiveFailures,
-              resetMs: config.circuit_reset_ms
-            });
-            break;
-          }
-          if (state.circuit === "half-open") {
-            state.circuit = "open";
-            state.circuitOpenedAt = Date.now();
-            state.pendingActions.delete(retryId);
-            context.emit?.("retry:circuit_open", {
-              consecutiveFailures: state.consecutiveFailures,
-              resetMs: config.circuit_reset_ms
-            });
-            break;
-          }
-          if (pending.attempt > config.max_retries) {
-            state.pendingActions.delete(retryId);
-            context.emit?.("retry:exhausted", {
-              actionName: pending.actionName,
-              totalAttempts: pending.attempt
-            });
-          } else {
-            const delay = computeDelay(config, pending.attempt - 1);
-            state.totalAttempts++;
-            setTimeout(() => {
-              if (!node.__retryState) return;
-              context.emit?.("retry:attempt", {
-                retryId,
-                actionName: pending.actionName,
-                attempt: pending.attempt,
-                maxRetries: config.max_retries
-              });
-              context.emit?.(pending.actionName, {
-                __retryId: retryId
-              });
-            }, delay);
-          }
-        }
-        break;
-      }
-      case "retry:reset_circuit": {
-        state.circuit = "closed";
-        state.consecutiveFailures = 0;
-        context.emit?.("retry:circuit_close", { recoveredAfterMs: 0 });
-        break;
-      }
-      case "retry:get_status": {
-        context.emit?.("retry:status", {
-          circuit: state.circuit,
-          consecutiveFailures: state.consecutiveFailures,
-          totalAttempts: state.totalAttempts,
-          totalSuccesses: state.totalSuccesses,
-          totalFailures: state.totalFailures,
-          pending: state.pendingActions.size
-        });
-        break;
-      }
-    }
-  }
-};
-
 // src/traits/DatabaseTrait.ts
 var databaseHandler = {
   name: "database",
@@ -54085,110 +54581,6 @@ var databaseHandler = {
   }
 };
 
-// src/traits/CacheTrait.ts
-var cacheHandler = {
-  name: "cache",
-  defaultConfig: {
-    max_size: 1e3,
-    default_ttl_ms: 6e4,
-    eviction_policy: "lru"
-  },
-  onAttach(node, _config, _context) {
-    node.__cacheState = {
-      entries: /* @__PURE__ */ new Map(),
-      hits: 0,
-      misses: 0,
-      evictions: 0
-    };
-  },
-  onDetach(node) {
-    delete node.__cacheState;
-  },
-  onUpdate(node, config, _context, _delta) {
-    const state = node.__cacheState;
-    if (!state) return;
-    const now = Date.now();
-    for (const [key, entry] of state.entries) {
-      if (entry.expiresAt > 0 && now >= entry.expiresAt) {
-        state.entries.delete(key);
-        state.evictions++;
-      }
-    }
-  },
-  onEvent(node, config, context, event) {
-    const state = node.__cacheState;
-    if (!state) return;
-    const eventType = typeof event === "string" ? event : event.type;
-    switch (eventType) {
-      case "cache:set": {
-        const key = event.key;
-        if (!key) break;
-        const ttl = event.ttl ?? config.default_ttl_ms;
-        if (state.entries.size >= config.max_size && !state.entries.has(key)) {
-          evictOne(state, config, context);
-        }
-        const now = Date.now();
-        state.entries.set(key, {
-          value: event.value,
-          expiresAt: ttl > 0 ? now + ttl : 0,
-          accessedAt: now,
-          createdAt: now
-        });
-        break;
-      }
-      case "cache:get": {
-        const key = event.key;
-        if (!key) break;
-        const entry = state.entries.get(key);
-        if (entry && (entry.expiresAt === 0 || Date.now() < entry.expiresAt)) {
-          state.hits++;
-          entry.accessedAt = Date.now();
-          context.emit?.("cache:result", { key, value: entry.value, hit: true });
-        } else {
-          state.misses++;
-          if (entry) state.entries.delete(key);
-          context.emit?.("cache:result", { key, value: void 0, hit: false });
-        }
-        break;
-      }
-      case "cache:invalidate": {
-        const key = event.key;
-        if (key) state.entries.delete(key);
-        break;
-      }
-      case "cache:clear": {
-        state.entries.clear();
-        break;
-      }
-      case "cache:get_stats": {
-        context.emit?.("cache:stats", {
-          hits: state.hits,
-          misses: state.misses,
-          size: state.entries.size,
-          evictions: state.evictions,
-          hitRate: state.hits + state.misses > 0 ? state.hits / (state.hits + state.misses) : 0
-        });
-        break;
-      }
-    }
-  }
-};
-function evictOne(state, config, context) {
-  if (state.entries.size === 0) return;
-  let oldest = null;
-  for (const [key, entry] of state.entries) {
-    const time = config.eviction_policy === "lru" ? entry.accessedAt : entry.createdAt;
-    if (!oldest || time < oldest.time) {
-      oldest = { key, time };
-    }
-  }
-  if (oldest) {
-    state.entries.delete(oldest.key);
-    state.evictions++;
-    context.emit?.("cache:evict", { key: oldest.key, reason: config.eviction_policy });
-  }
-}
-
 // src/traits/StreamTrait.ts
 var streamHandler = {
   name: "stream",
@@ -55010,6 +55402,19 @@ var discordHandler = {
   }
 };
 
+// src/traits/unwired.ts
+function emitUnwired(context, errorEvent, detail) {
+  const payload = {
+    ok: false,
+    error: "not_implemented",
+    capability: detail.capability,
+    reason: "trait declared but its backend is not wired \u2014 no external effect was performed"
+  };
+  if (detail.wiring) payload.wiring = detail.wiring;
+  if (detail.requested) payload.requested = detail.requested;
+  context.emit?.(errorEvent, payload);
+}
+
 // src/traits/MqttPubTrait.ts
 var mqttPubHandler = {
   name: "mqtt_pub",
@@ -55027,10 +55432,10 @@ var mqttPubHandler = {
     if (!state) return;
     if ((typeof event === "string" ? event : event.type) === "mqtt:publish") {
       state.published++;
-      context.emit?.("mqtt:published", {
-        topic: event.topic,
-        messageId: `mqtt_${Date.now()}`,
-        qos: event.qos ?? config.default_qos
+      emitUnwired(context, "mqtt:error", {
+        capability: "mqtt",
+        wiring: "mqtt npm client + persistent broker connection + QoS 1/2 PUBACK",
+        requested: { topic: event.topic, qos: event.qos ?? config.default_qos }
       });
     }
   }
@@ -56113,11 +56518,10 @@ var stripeHandler = {
     if (t === "stripe:charge") {
       state.charges++;
       state.totalAmount += event.amount ?? 0;
-      context.emit?.("stripe:charged", {
-        chargeId: `ch_${Date.now()}`,
-        amount: event.amount,
-        currency: config.currency,
-        customerId: event.customerId
+      emitUnwired(context, "stripe:error", {
+        capability: "stripe",
+        wiring: "Stripe SDK + vault secret_key + per-charge idempotency key",
+        requested: { amount: event.amount, currency: config.currency, customerId: event.customerId }
       });
     } else if (t === "stripe:get_stats") {
       context.emit?.("stripe:stats", {
@@ -57410,10 +57814,10 @@ var s3UploadHandler = {
     if ((typeof event === "string" ? event : event.type) === "s3:upload") {
       state.uploads++;
       state.totalBytes += event.size ?? 0;
-      context.emit?.("s3:uploaded", {
-        key: event.key,
-        bucket: event.bucket ?? config.bucket,
-        uploads: state.uploads
+      emitUnwired(context, "s3:error", {
+        capability: "s3",
+        wiring: "@aws-sdk/client-s3 (or MinIO/R2) + credentials + multipart for large files",
+        requested: { key: event.key, bucket: event.bucket ?? config.bucket }
       });
     }
   }
@@ -57612,11 +58016,10 @@ var restEndpointHandler = {
         break;
       case "rest:request":
         state.requests++;
-        context.emit?.("rest:response", {
-          method: event.method,
-          path: event.path,
-          status: 200,
-          requestCount: state.requests
+        emitUnwired(context, "rest:error", {
+          capability: "rest_endpoint",
+          wiring: "express/fastify route dispatch to the registered handler",
+          requested: { method: event.method, path: event.path }
         });
         break;
     }
@@ -59989,333 +60392,6 @@ var gotchaHandler = {
   }
 };
 
-// src/traits/FluidSimulationTrait.ts
-function poly6Kernel(r, h) {
-  if (r < 0 || r > h) return 0;
-  const coeff = 315 / (64 * Math.PI * h ** 9);
-  return coeff * (h * h - r * r) ** 3;
-}
-function spikyKernelGradient(dx, dy, dz, h) {
-  const r = Math.sqrt(dx * dx + dy * dy + dz * dz);
-  if (r > h || r < 1e-5) return [0, 0, 0];
-  const coeff = -45 / (Math.PI * h ** 6) * (h - r) ** 2;
-  return [coeff * (dx / r), coeff * (dy / r), coeff * (dz / r)];
-}
-function viscosityKernelLaplacian(r, h) {
-  if (r < 0 || r > h) return 0;
-  return 45 / (Math.PI * h ** 6) * (h - r);
-}
-var SpatialHash = class {
-  constructor(cellSize) {
-    this.cells = /* @__PURE__ */ new Map();
-    this.cellSize = cellSize;
-  }
-  key(x, y, z) {
-    const cx = Math.floor(x / this.cellSize);
-    const cy = Math.floor(y / this.cellSize);
-    const cz = Math.floor(z / this.cellSize);
-    return `${cx},${cy},${cz}`;
-  }
-  insert(id, pos) {
-    const k = this.key(pos[0], pos[1], pos[2]);
-    if (!this.cells.has(k)) this.cells.set(k, []);
-    this.cells.get(k).push(id);
-  }
-  getNeighbors(pos) {
-    const cx = Math.floor(pos[0] / this.cellSize);
-    const cy = Math.floor(pos[1] / this.cellSize);
-    const cz = Math.floor(pos[2] / this.cellSize);
-    const result = [];
-    for (let dx = -1; dx <= 1; dx++) {
-      for (let dy = -1; dy <= 1; dy++) {
-        for (let dz = -1; dz <= 1; dz++) {
-          const k = `${cx + dx},${cy + dy},${cz + dz}`;
-          const cell = this.cells.get(k);
-          if (cell) result.push(...cell);
-        }
-      }
-    }
-    return result;
-  }
-  clear() {
-    this.cells.clear();
-  }
-};
-var FluidSimulationSystem = class {
-  constructor(config = {}) {
-    this.particles = /* @__PURE__ */ new Map();
-    this.nextId = 0;
-    this.boundaries = [];
-    this.cfg = {
-      restDensity: config.restDensity ?? 1e3,
-      viscosity: config.viscosity ?? 1e-3,
-      gravity: config.gravity ?? [0, -9.81, 0],
-      solverType: config.solverType ?? "sph",
-      timeStep: config.timeStep ?? 0.016,
-      maxVelocity: config.maxVelocity ?? 100,
-      smoothingRadius: config.smoothingRadius ?? 0.04,
-      gridCellSize: config.gridCellSize ?? 0.04,
-      particleRadius: config.particleRadius ?? 0.01,
-      gasConstant: config.gasConstant ?? 8.314,
-      surfaceTension: config.surfaceTension ?? 0.072
-    };
-    this.spatialHash = new SpatialHash(this.cfg.gridCellSize);
-  }
-  // ── Particle Management ────────────────────────────────────────────────
-  addParticle(position, velocity) {
-    const id = this.nextId++;
-    this.particles.set(id, {
-      id,
-      position: [...position],
-      velocity: velocity ? [...velocity] : [0, 0, 0],
-      force: [0, 0, 0],
-      density: this.cfg.restDensity,
-      pressure: 0,
-      mass: 1
-    });
-    return id;
-  }
-  getParticle(id) {
-    return this.particles.get(id);
-  }
-  getParticles() {
-    return Array.from(this.particles.values());
-  }
-  getParticleCount() {
-    return this.particles.size;
-  }
-  removeParticle(id) {
-    return this.particles.delete(id);
-  }
-  clearParticles() {
-    this.particles.clear();
-    this.nextId = 0;
-  }
-  // ── Boundary Management ────────────────────────────────────────────────
-  addBoundary(boundary) {
-    this.boundaries.push(boundary);
-  }
-  getBoundaries() {
-    return [...this.boundaries];
-  }
-  clearBoundaries() {
-    this.boundaries.length = 0;
-  }
-  // ── Configuration ──────────────────────────────────────────────────────
-  getConfig() {
-    return { ...this.cfg };
-  }
-  setConfig(partial) {
-    Object.assign(this.cfg, partial);
-    if (partial.gridCellSize !== void 0) {
-      this.spatialHash = new SpatialHash(this.cfg.gridCellSize);
-    }
-  }
-  // ── Simulation Step ────────────────────────────────────────────────────
-  step(dt) {
-    const h = this.cfg.smoothingRadius;
-    const deltaT = dt ?? this.cfg.timeStep;
-    const particles = Array.from(this.particles.values());
-    this.spatialHash.clear();
-    for (const p of particles) {
-      this.spatialHash.insert(p.id, p.position);
-    }
-    for (const pi of particles) {
-      let density = 0;
-      for (const pj of particles) {
-        const r = this.dist(pi.position, pj.position);
-        density += pj.mass * poly6Kernel(r, h);
-      }
-      pi.density = Math.max(density, this.cfg.restDensity * 0.01);
-      pi.pressure = this.cfg.gasConstant * (pi.density - this.cfg.restDensity);
-    }
-    for (const pi of particles) {
-      pi.force = [
-        this.cfg.gravity[0] * pi.mass,
-        this.cfg.gravity[1] * pi.mass,
-        this.cfg.gravity[2] * pi.mass
-      ];
-      for (const pj of particles) {
-        if (pi.id === pj.id) continue;
-        const dx = pi.position[0] - pj.position[0];
-        const dy = pi.position[1] - pj.position[1];
-        const dz = pi.position[2] - pj.position[2];
-        const r = Math.sqrt(dx * dx + dy * dy + dz * dz);
-        if (r < h && r > 1e-5) {
-          const grad = spikyKernelGradient(dx, dy, dz, h);
-          const pScale = -pj.mass * ((pi.pressure + pj.pressure) / (2 * pj.density));
-          pi.force[0] += pScale * grad[0];
-          pi.force[1] += pScale * grad[1];
-          pi.force[2] += pScale * grad[2];
-          const viscLap = viscosityKernelLaplacian(r, h);
-          const vScale = this.cfg.viscosity * pj.mass * (1 / pj.density) * viscLap;
-          pi.force[0] += vScale * (pj.velocity[0] - pi.velocity[0]);
-          pi.force[1] += vScale * (pj.velocity[1] - pi.velocity[1]);
-          pi.force[2] += vScale * (pj.velocity[2] - pi.velocity[2]);
-        }
-      }
-    }
-    for (const p of particles) {
-      p.velocity[0] += p.force[0] / p.mass * deltaT;
-      p.velocity[1] += p.force[1] / p.mass * deltaT;
-      p.velocity[2] += p.force[2] / p.mass * deltaT;
-      const speed = Math.sqrt(p.velocity[0] ** 2 + p.velocity[1] ** 2 + p.velocity[2] ** 2);
-      if (speed > this.cfg.maxVelocity) {
-        const scale = this.cfg.maxVelocity / speed;
-        p.velocity[0] *= scale;
-        p.velocity[1] *= scale;
-        p.velocity[2] *= scale;
-      }
-      p.position[0] += p.velocity[0] * deltaT;
-      p.position[1] += p.velocity[1] * deltaT;
-      p.position[2] += p.velocity[2] * deltaT;
-    }
-    for (const p of particles) {
-      this.applyBoundaries(p);
-    }
-  }
-  // ── Density Queries ────────────────────────────────────────────────────
-  getDensityAt(position) {
-    const h = this.cfg.smoothingRadius;
-    let density = 0;
-    for (const p of this.particles.values()) {
-      const r = this.dist(position, p.position);
-      density += p.mass * poly6Kernel(r, h);
-    }
-    return density;
-  }
-  isInsideFluid(position) {
-    return this.getDensityAt(position) > this.cfg.restDensity * 0.5;
-  }
-  // ── Statistics ─────────────────────────────────────────────────────────
-  getKineticEnergy() {
-    let energy = 0;
-    for (const p of this.particles.values()) {
-      energy += 0.5 * p.mass * (p.velocity[0] ** 2 + p.velocity[1] ** 2 + p.velocity[2] ** 2);
-    }
-    return energy;
-  }
-  getAverageDensity() {
-    if (this.particles.size === 0) return 0;
-    let total = 0;
-    for (const p of this.particles.values()) total += p.density;
-    return total / this.particles.size;
-  }
-  reset() {
-    this.particles.clear();
-    this.spatialHash.clear();
-    this.boundaries.length = 0;
-    this.nextId = 0;
-  }
-  // ── Private Helpers ────────────────────────────────────────────────────
-  dist(a, b) {
-    return Math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2);
-  }
-  applyBoundaries(p) {
-    const pr = this.cfg.particleRadius;
-    for (const b of this.boundaries) {
-      if (b.type === "plane") {
-        const dx = p.position[0] - b.position[0];
-        const dy = p.position[1] - b.position[1];
-        const dz = p.position[2] - b.position[2];
-        const d = dx * b.normal[0] + dy * b.normal[1] + dz * b.normal[2];
-        if (d < pr) {
-          p.position[0] += b.normal[0] * (pr - d);
-          p.position[1] += b.normal[1] * (pr - d);
-          p.position[2] += b.normal[2] * (pr - d);
-          const vn = p.velocity[0] * b.normal[0] + p.velocity[1] * b.normal[1] + p.velocity[2] * b.normal[2];
-          if (vn < 0) {
-            p.velocity[0] -= (1 + b.restitution) * vn * b.normal[0];
-            p.velocity[1] -= (1 + b.restitution) * vn * b.normal[1];
-            p.velocity[2] -= (1 + b.restitution) * vn * b.normal[2];
-          }
-        }
-      } else if (b.type === "sphere") {
-        const dx = p.position[0] - b.position[0];
-        const dy = p.position[1] - b.position[1];
-        const dz = p.position[2] - b.position[2];
-        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
-        const maxDist = b.radius - pr;
-        if (dist > maxDist && dist > 1e-6) {
-          const nx = dx / dist;
-          const ny = dy / dist;
-          const nz = dz / dist;
-          p.position[0] = b.position[0] + nx * maxDist;
-          p.position[1] = b.position[1] + ny * maxDist;
-          p.position[2] = b.position[2] + nz * maxDist;
-          const vn = p.velocity[0] * nx + p.velocity[1] * ny + p.velocity[2] * nz;
-          if (vn > 0) {
-            p.velocity[0] -= (1 + b.restitution) * vn * nx;
-            p.velocity[1] -= (1 + b.restitution) * vn * ny;
-            p.velocity[2] -= (1 + b.restitution) * vn * nz;
-          }
-        }
-      } else if (b.type === "box") {
-        const halfX = b.size[0] / 2;
-        const halfY = b.size[1] / 2;
-        const halfZ = b.size[2] / 2;
-        const limit = pr;
-        if (p.position[0] > b.position[0] + halfX - limit) {
-          p.position[0] = b.position[0] + halfX - limit;
-          p.velocity[0] *= -b.restitution;
-        } else if (p.position[0] < b.position[0] - halfX + limit) {
-          p.position[0] = b.position[0] - halfX + limit;
-          p.velocity[0] *= -b.restitution;
-        }
-        if (p.position[1] > b.position[1] + halfY - limit) {
-          p.position[1] = b.position[1] + halfY - limit;
-          p.velocity[1] *= -b.restitution;
-        } else if (p.position[1] < b.position[1] - halfY + limit) {
-          p.position[1] = b.position[1] - halfY + limit;
-          p.velocity[1] *= -b.restitution;
-        }
-        if (p.position[2] > b.position[2] + halfZ - limit) {
-          p.position[2] = b.position[2] + halfZ - limit;
-          p.velocity[2] *= -b.restitution;
-        } else if (p.position[2] < b.position[2] - halfZ + limit) {
-          p.position[2] = b.position[2] - halfZ + limit;
-          p.velocity[2] *= -b.restitution;
-        }
-      }
-    }
-  }
-};
-var fluidSimulationHandler = {
-  name: "fluid_simulation",
-  defaultConfig: {},
-  onAttach(node, config, ctx) {
-    const instance = new FluidSimulationSystem(config);
-    node.__fluid_simulation_instance = instance;
-    ctx.emit("fluid_simulation_attached", { node, config });
-  },
-  onDetach(node, _config, ctx) {
-    const instance = node.__fluid_simulation_instance;
-    if (instance) {
-      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
-      else if (typeof instance.dispose === "function") instance.dispose();
-      else if (typeof instance.cleanup === "function") instance.cleanup();
-    }
-    ctx.emit("fluid_simulation_detached", { node });
-    delete node.__fluid_simulation_instance;
-  },
-  onEvent(node, _config, ctx, event) {
-    const instance = node.__fluid_simulation_instance;
-    if (!instance) return;
-    if (typeof instance.onEvent === "function") instance.onEvent(event);
-    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
-    if (event.type === "fluid_simulation_configure" && event.payload) {
-      Object.assign(instance, event.payload);
-      ctx.emit("fluid_simulation_configured", { node });
-    }
-  },
-  onUpdate(node, _config, ctx, dt) {
-    const instance = node.__fluid_simulation_instance;
-    if (!instance) return;
-    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
-    else if (typeof instance.step === "function") instance.step(dt);
-  }
-};
-
 // src/traits/VRTraitSystem.ts
 function vec3ToTuple(v) {
   return v;
@@ -61139,6 +61215,7 @@ var VRTraitRegistry = class {
     this.register(provenanceHandler);
     this.register(provenanceDensifyHandler);
     this.register(evolveProgramHandler);
+    this.register(freezeWhenHandler);
     this.register(bodyHandler);
     this.register(proactiveHandler);
     this.register(eventTraitHandler);
@@ -61146,7 +61223,7 @@ var VRTraitRegistry = class {
     this.register(hapticHandler);
     this.register(eyeTrackedHandler);
     this.register(roadmapNodeHandler);
-    this.register(chunkSJIRCTIS_cjs.mitosisHandler);
+    this.register(chunkHSGJFCVJ_cjs.mitosisHandler);
     this.register(formationControlHandler);
     this.register(planeDetectionHandler);
     this.register(meshDetectionHandler);
@@ -61317,8 +61394,8 @@ var VRTraitRegistry = class {
     this.register(sseHandler);
     this.register(modelLoadHandler);
     this.register(inferenceHandler);
-    this.register(chunkSJIRCTIS_cjs.embeddingHandler);
-    this.register(chunkSJIRCTIS_cjs.jepObjectiveHandler);
+    this.register(chunkHSGJFCVJ_cjs.embeddingHandler);
+    this.register(chunkHSGJFCVJ_cjs.jepObjectiveHandler);
     this.register(fineTuneHandler);
     this.register(vectorSearchHandler);
     this.register(promptTemplateHandler);
@@ -61401,8 +61478,8 @@ var VRTraitRegistry = class {
     this.register(trainingLoopHandler);
     this.register(modelLoadHandler);
     this.register(inferenceHandler);
-    this.register(chunkSJIRCTIS_cjs.embeddingHandler);
-    this.register(chunkSJIRCTIS_cjs.jepObjectiveHandler);
+    this.register(chunkHSGJFCVJ_cjs.embeddingHandler);
+    this.register(chunkHSGJFCVJ_cjs.jepObjectiveHandler);
     this.register(sqlQueryHandler);
     this.register(ormEntityHandler);
     this.register(offlineSyncHandler);
@@ -61454,7 +61531,7 @@ var VRTraitRegistry = class {
     this.register(npcAIHandler);
     this.register(objectTrackingHandler);
     this.register(openXRHALHandler);
-    this.register(chunkSJIRCTIS_cjs.orbitalHandler);
+    this.register(chunkHSGJFCVJ_cjs.orbitalHandler);
     this.register(partnerSDKHandler);
     this.register(poseEstimationHandler);
     this.register(ragKnowledgeHandler);
@@ -61673,6 +61750,7 @@ exports.DraftManager = DraftManager;
 exports.ECSWorld = ECSWorld;
 exports.EmotionDirectiveTrait = EmotionDirectiveTrait;
 exports.EnvironmentalAudioSystem = EnvironmentalAudioSystem;
+exports.ExpressionParseError = ExpressionParseError;
 exports.GEM_RESONANCE_ELEMENT_FREQUENCIES = GEM_RESONANCE_ELEMENT_FREQUENCIES;
 exports.GOAPPlanner = GOAPPlanner;
 exports.GOLDEN_ANGLE_DEG = GOLDEN_ANGLE_DEG;
@@ -61757,6 +61835,7 @@ exports.bufferHandler = bufferHandler;
 exports.buildBehaviorFactDisclosure = buildBehaviorFactDisclosure;
 exports.buoyancyHandler = buoyancyHandler;
 exports.cRDTRoomHandler = cRDTRoomHandler;
+exports.cacheHandler = cacheHandler;
 exports.careEthicsHandler = careEthicsHandler;
 exports.chainHandler = chainHandler;
 exports.characterHandler = characterHandler;
@@ -61833,6 +61912,7 @@ exports.economyPrimitivesHandler = economyPrimitivesHandler;
 exports.effectiveWeight = effectiveWeight;
 exports.embeddingSearchHandler = embeddingSearchHandler;
 exports.emissiveAt = emissiveAt;
+exports.emitUnwired = emitUnwired;
 exports.emotionDirectiveHandler = emotionDirectiveHandler;
 exports.emotionHandler = emotionHandler;
 exports.emotionalVoiceHandler = emotionalVoiceHandler;
@@ -61841,6 +61921,7 @@ exports.environmentalAudioHandler = environmentalAudioHandler;
 exports.evaluateAction = evaluateAction;
 exports.evaluateAutonomyGuard = evaluateAutonomyGuard;
 exports.evaluateCareEthicsTurn = evaluateCareEthicsTurn;
+exports.evaluateExpressionIR = evaluateExpressionIR;
 exports.evolveProgramHandler = evolveProgramHandler;
 exports.extractLotusGenesisAnchorHash = extractLotusGenesisAnchorHash;
 exports.extractPayload = extractPayload;
@@ -61854,8 +61935,10 @@ exports.findReachablePath = findReachablePath;
 exports.findWalkableNodeAt = findWalkableNodeAt;
 exports.flowFieldHandler = flowFieldHandler;
 exports.fluidHandler = fluidHandler;
+exports.fluidSimulationHandler = fluidSimulationHandler;
 exports.forgetPolicyHandler = forgetPolicyHandler;
 exports.formationControlHandler = formationControlHandler;
+exports.freezeWhenHandler = freezeWhenHandler;
 exports.gardenerPulseJitter = gardenerPulseJitter;
 exports.gaussianSplatHandler = gaussianSplatHandler;
 exports.gazeFocusAnalyticsHandler = gazeFocusAnalyticsHandler;
@@ -61985,6 +62068,7 @@ exports.onboardingHandler = onboardingHandler;
 exports.openXRHALHandler = openXRHALHandler;
 exports.parseCRDTRoomEntityConfig = parseCRDTRoomEntityConfig;
 exports.parseCRDTRoomTraitConfig = parseCRDTRoomTraitConfig;
+exports.parseExpressionToIR = parseExpressionToIR;
 exports.partnerSDKHandler = partnerSDKHandler;
 exports.passthroughCameraHandler = passthroughCameraHandler;
 exports.patrolHandler = patrolHandler;
@@ -62023,6 +62107,7 @@ exports.resolveBloomStage = resolveBloomStage;
 exports.resolveCRDTRoomTraitConfig = resolveCRDTRoomTraitConfig;
 exports.resolvePulseHz = resolvePulseHz;
 exports.resourceAccountingHandler = resourceAccountingHandler;
+exports.retryHandler = retryHandler;
 exports.reverbZoneHandler = reverbZoneHandler;
 exports.rigidbodyHandler = rigidbodyHandler;
 exports.roadmapNodeHandler = roadmapNodeHandler;
@@ -62105,5 +62190,5 @@ exports.withNegotiation = withNegotiation;
 exports.worldPortalHandler = worldPortalHandler;
 exports.wotThingHandler = wotThingHandler;
 exports.zkPrivateHandler = zkPrivateHandler;
-//# sourceMappingURL=chunk-IFW5IW4L.cjs.map
-//# sourceMappingURL=chunk-IFW5IW4L.cjs.map
+//# sourceMappingURL=chunk-X5ZLSPU2.cjs.map
+//# sourceMappingURL=chunk-X5ZLSPU2.cjs.map