@holoscript/core 8.0.13 → 8.0.14

package/dist/{chunk-IFW5IW4L.cjs → chunk-ML4V5PVU.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",
@@ -24325,6 +24363,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 +25646,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 = {
@@ -44490,6 +44826,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)) {
@@ -53790,200 +54453,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 +54554,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",
@@ -59989,333 +60354,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 +61177,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);
@@ -61757,6 +61796,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;
@@ -61854,8 +61894,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;
@@ -62023,6 +62065,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 +62148,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-ML4V5PVU.cjs.map
+//# sourceMappingURL=chunk-ML4V5PVU.cjs.map