@holoscript/std 3.1.1 → 6.0.3

package/dist/index.cjs

@@ -0,0 +1,4101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AABB: () => AABB,
+  CountdownTimer: () => CountdownTimer,
+  DEFAULT_BONDING_CURVE: () => DEFAULT_BONDING_CURVE,
+  DEFAULT_DEPRECIATION: () => DEFAULT_DEPRECIATION,
+  DEFAULT_PID: () => DEFAULT_PID,
+  DEFAULT_WEALTH_TAX: () => DEFAULT_WEALTH_TAX,
+  DEG_TO_RAD: () => DEG_TO_RAD,
+  DateTime: () => DateTime,
+  EPSILON: () => EPSILON,
+  EconomicTraits: () => EconomicTraits,
+  EventBus: () => EventBus,
+  FrameTimer: () => FrameTimer,
+  HALF_PI: () => HALF_PI,
+  HoloMap: () => HoloMap,
+  HoloSet: () => HoloSet,
+  IntervalTimer: () => IntervalTimer,
+  List: () => List,
+  MATERIAL_PRESETS: () => MATERIAL_PRESETS,
+  Map: () => HoloMap,
+  PI: () => PI,
+  PriorityQueue: () => PriorityQueue,
+  Quaternion: () => Quaternion,
+  RAD_TO_DEG: () => RAD_TO_DEG,
+  Ray: () => Ray,
+  Set: () => HoloSet,
+  SimulationLabTraits: () => SimulationLabTraits,
+  SpatialGrid: () => SpatialGrid,
+  Stopwatch: () => Stopwatch,
+  TAU: () => TAU,
+  Transform: () => Transform,
+  Vec3: () => Vec3,
+  aabb: () => aabb,
+  aabbMath: () => aabbMath,
+  arrayToQuat: () => arrayToQuat,
+  arrayToVec3: () => arrayToVec3,
+  assert: () => assert,
+  assertDefined: () => assertDefined,
+  bondingCurveBuyCost: () => bondingCurveBuyCost,
+  bondingCurvePrice: () => bondingCurvePrice,
+  bondingCurveSellRefund: () => bondingCurveSellRefund,
+  calculateDepreciation: () => calculateDepreciation,
+  calculateRedistribution: () => calculateRedistribution,
+  calculateRepairCost: () => calculateRepairCost,
+  calculateTaxAmount: () => calculateTaxAmount,
+  calculateTaxRate: () => calculateTaxRate,
+  camelCase: () => camelCase,
+  capitalize: () => capitalize,
+  center: () => center,
+  chars: () => chars,
+  chiSquaredTest: () => chiSquaredTest,
+  clamp: () => clamp2,
+  clone: () => clone,
+  cohensD: () => cohensD,
+  collapseWhitespace: () => collapseWhitespace,
+  colorToHex: () => colorToHex,
+  compose: () => compose,
+  constant: () => constant,
+  constantCase: () => constantCase,
+  containsIgnoreCase: () => containsIgnoreCase,
+  count: () => count,
+  createBoxCollider: () => createBoxCollider,
+  createCapsuleCollider: () => createCapsuleCollider,
+  createDualLoopPIDState: () => createDualLoopPIDState,
+  createFaucetSinkMetrics: () => createFaucetSinkMetrics,
+  createPBRMaterial: () => createPBRMaterial,
+  createPIDState: () => createPIDState,
+  createRigidbody: () => createRigidbody,
+  createSphereCollider: () => createSphereCollider,
+  createTicker: () => createTicker,
+  debounce: () => debounce,
+  dedent: () => dedent,
+  degToRad: () => degToRad2,
+  depreciatedValue: () => depreciatedValue,
+  distance: () => distance,
+  endsWithIgnoreCase: () => endsWithIgnoreCase,
+  equals: () => equals,
+  escapeHtml: () => escapeHtml,
+  escapeRegex: () => escapeRegex,
+  executeTrade: () => executeTrade,
+  expandSweep: () => expandSweep,
+  extractMetric: () => extractMetric,
+  extractTraits: () => extractTraits,
+  format: () => format,
+  formatBytes: () => formatBytes,
+  formatDuration: () => formatDuration,
+  formatNumber: () => formatNumber,
+  fract: () => fract,
+  generateSweepCombinations: () => generateSweepCombinations,
+  generateTxHash: () => generateTxHash,
+  getEconomicTrait: () => getEconomicTrait,
+  getEconomicTraitNames: () => getEconomicTraitNames,
+  getRequiredPermissions: () => getRequiredPermissions,
+  getSimulationTrait: () => getSimulationTrait,
+  getSimulationTraitNames: () => getSimulationTraitNames,
+  groupByParameter: () => groupByParameter,
+  hrTime: () => hrTime,
+  hsl: () => hsl,
+  identity: () => identity,
+  indent: () => indent,
+  inverseLerp: () => inverseLerp,
+  isAlpha: () => isAlpha,
+  isAlphanumeric: () => isAlphanumeric,
+  isBlank: () => isBlank,
+  isDestroyed: () => isDestroyed,
+  isNotBlank: () => isNotBlank,
+  isNumeric: () => isNumeric,
+  isParameterRange: () => isParameterRange,
+  isValidIdentifier: () => isValidIdentifier,
+  join: () => join,
+  kebabCase: () => kebabCase,
+  lerp: () => lerp2,
+  levenshtein: () => levenshtein,
+  lines: () => lines,
+  mannWhitneyU: () => mannWhitneyU,
+  mean: () => mean,
+  measure: () => measure,
+  mod: () => mod,
+  noise: () => noise,
+  noop: () => noop,
+  now: () => now,
+  numberWithCommas: () => numberWithCommas,
+  oneSampleTTest: () => oneSampleTTest,
+  padLeft: () => padLeft,
+  padRight: () => padRight,
+  parseColor: () => parseColor,
+  pascalCase: () => pascalCase,
+  pipe: () => pipe,
+  print: () => print,
+  printError: () => printError,
+  printWarn: () => printWarn,
+  quat: () => quat,
+  quatMath: () => quatMath,
+  quatToArray: () => quatToArray,
+  radToDeg: () => radToDeg2,
+  random: () => random,
+  randomString: () => randomString,
+  ray: () => ray,
+  recordFaucet: () => recordFaucet,
+  recordSink: () => recordSink,
+  remap: () => remap,
+  removePrefix: () => removePrefix,
+  removeSuffix: () => removeSuffix,
+  removeWhitespace: () => removeWhitespace,
+  repeat: () => repeat,
+  resetMetricsPeriod: () => resetMetricsPeriod,
+  retry: () => retry,
+  reverse: () => reverse,
+  rgb: () => rgb,
+  rgba: () => rgba,
+  schedule: () => schedule,
+  scheduleFrame: () => scheduleFrame,
+  scheduleInterval: () => scheduleInterval,
+  sign: () => sign,
+  similarity: () => similarity,
+  sleep: () => sleep,
+  slugify: () => slugify,
+  smootherstep: () => smootherstep,
+  smoothstep: () => smoothstep,
+  snakeCase: () => snakeCase,
+  spatialClamp: () => clamp,
+  spatialDegToRad: () => degToRad,
+  spatialLerp: () => lerp,
+  spatialPrice: () => spatialPrice,
+  spatialRadToDeg: () => radToDeg,
+  standardDeviation: () => standardDeviation,
+  standardError: () => standardError,
+  startsWithIgnoreCase: () => startsWithIgnoreCase,
+  step: () => step,
+  summarizeMetrics: () => summarizeMetrics,
+  tTest: () => tTest,
+  throttle: () => throttle,
+  timed: () => timed,
+  titleCase: () => titleCase,
+  toDegrees: () => radToDeg2,
+  toRadians: () => degToRad2,
+  todo: () => todo,
+  transform: () => transform,
+  truncate: () => truncate,
+  truncateMiddle: () => truncateMiddle,
+  unescapeHtml: () => unescapeHtml,
+  unreachable: () => unreachable,
+  unwrap: () => unwrap,
+  updateDualLoopPID: () => updateDualLoopPID,
+  updatePID: () => updatePID,
+  uuid: () => uuid,
+  validateTraitComposition: () => validateTraitComposition,
+  variance: () => variance,
+  vec2: () => vec2,
+  vec2Math: () => vec2Math,
+  vec3: () => vec3,
+  vec3Math: () => vec3Math,
+  vec3ToArray: () => vec3ToArray,
+  vec4: () => vec4,
+  waitUntil: () => waitUntil,
+  withTimeout: () => withTimeout,
+  wordWrap: () => wordWrap,
+  words: () => words,
+  wrapString: () => wrap
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+function vec2(x = 0, y = 0) {
+  return { x, y };
+}
+function vec3(x = 0, y = 0, z = 0) {
+  return { x, y, z };
+}
+function vec4(x = 0, y = 0, z = 0, w = 0) {
+  return { x, y, z, w };
+}
+function quat(x = 0, y = 0, z = 0, w = 1) {
+  return { x, y, z, w };
+}
+function transform(position = vec3(), rotation = quat(), scale = vec3(1, 1, 1)) {
+  return { position, rotation, scale };
+}
+function rgb(r, g, b) {
+  return { r, g, b };
+}
+function rgba(r, g, b, a = 1) {
+  return { r, g, b, a };
+}
+function hsl(h, s, l) {
+  return { h, s, l };
+}
+function aabb(min = vec3(), max = vec3()) {
+  return { min, max };
+}
+function ray(origin, direction) {
+  return { origin, direction };
+}
+function vec3ToArray(v) {
+  return [v.x, v.y, v.z];
+}
+function arrayToVec3(arr) {
+  return { x: arr[0] || 0, y: arr[1] || 0, z: arr[2] || 0 };
+}
+function quatToArray(q) {
+  return [q.x, q.y, q.z, q.w];
+}
+function arrayToQuat(arr) {
+  return { x: arr[0] || 0, y: arr[1] || 0, z: arr[2] || 0, w: arr[3] ?? 1 };
+}
+function parseColor(color) {
+  if (typeof color === "string") {
+    if (color.startsWith("#")) {
+      const hex = color.slice(1);
+      if (hex.length === 3) {
+        return {
+          r: parseInt(hex[0] + hex[0], 16) / 255,
+          g: parseInt(hex[1] + hex[1], 16) / 255,
+          b: parseInt(hex[2] + hex[2], 16) / 255,
+          a: 1
+        };
+      } else if (hex.length === 6) {
+        return {
+          r: parseInt(hex.slice(0, 2), 16) / 255,
+          g: parseInt(hex.slice(2, 4), 16) / 255,
+          b: parseInt(hex.slice(4, 6), 16) / 255,
+          a: 1
+        };
+      } else if (hex.length === 8) {
+        return {
+          r: parseInt(hex.slice(0, 2), 16) / 255,
+          g: parseInt(hex.slice(2, 4), 16) / 255,
+          b: parseInt(hex.slice(4, 6), 16) / 255,
+          a: parseInt(hex.slice(6, 8), 16) / 255
+        };
+      }
+    }
+    const namedColors = {
+      white: { r: 1, g: 1, b: 1, a: 1 },
+      black: { r: 0, g: 0, b: 0, a: 1 },
+      red: { r: 1, g: 0, b: 0, a: 1 },
+      green: { r: 0, g: 1, b: 0, a: 1 },
+      blue: { r: 0, g: 0, b: 1, a: 1 },
+      yellow: { r: 1, g: 1, b: 0, a: 1 },
+      cyan: { r: 0, g: 1, b: 1, a: 1 },
+      magenta: { r: 1, g: 0, b: 1, a: 1 }
+    };
+    return namedColors[color.toLowerCase()] || { r: 1, g: 1, b: 1, a: 1 };
+  }
+  if (typeof color === "number") {
+    return {
+      r: (color >> 16 & 255) / 255,
+      g: (color >> 8 & 255) / 255,
+      b: (color & 255) / 255,
+      a: 1
+    };
+  }
+  if ("h" in color) {
+    const { h, s, l } = color;
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+    const m = l - c / 2;
+    let r = 0, g = 0, b = 0;
+    if (h < 60) {
+      r = c;
+      g = x;
+    } else if (h < 120) {
+      r = x;
+      g = c;
+    } else if (h < 180) {
+      g = c;
+      b = x;
+    } else if (h < 240) {
+      g = x;
+      b = c;
+    } else if (h < 300) {
+      r = x;
+      b = c;
+    } else {
+      r = c;
+      b = x;
+    }
+    return { r: r + m, g: g + m, b: b + m, a: 1 };
+  }
+  if ("a" in color) {
+    return color;
+  }
+  return { ...color, a: 1 };
+}
+function colorToHex(color) {
+  const r = Math.round(color.r * 255).toString(16).padStart(2, "0");
+  const g = Math.round(color.g * 255).toString(16).padStart(2, "0");
+  const b = Math.round(color.b * 255).toString(16).padStart(2, "0");
+  return `#${r}${g}${b}`;
+}
+
+// src/spatial.ts
+var Vec3 = class _Vec3 {
+  constructor(x = 0, y = 0, z = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  static zero() {
+    return new _Vec3(0, 0, 0);
+  }
+  static one() {
+    return new _Vec3(1, 1, 1);
+  }
+  static up() {
+    return new _Vec3(0, 1, 0);
+  }
+  static down() {
+    return new _Vec3(0, -1, 0);
+  }
+  static forward() {
+    return new _Vec3(0, 0, -1);
+  }
+  static right() {
+    return new _Vec3(1, 0, 0);
+  }
+  add(other) {
+    return new _Vec3(this.x + other.x, this.y + other.y, this.z + other.z);
+  }
+  sub(other) {
+    return new _Vec3(this.x - other.x, this.y - other.y, this.z - other.z);
+  }
+  mul(s) {
+    return new _Vec3(this.x * s, this.y * s, this.z * s);
+  }
+  div(s) {
+    return new _Vec3(this.x / s, this.y / s, this.z / s);
+  }
+  dot(other) {
+    return this.x * other.x + this.y * other.y + this.z * other.z;
+  }
+  cross(other) {
+    return new _Vec3(
+      this.y * other.z - this.z * other.y,
+      this.z * other.x - this.x * other.z,
+      this.x * other.y - this.y * other.x
+    );
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+  lengthSquared() {
+    return this.x * this.x + this.y * this.y + this.z * this.z;
+  }
+  normalize() {
+    const l = this.length();
+    return l > 0 ? this.div(l) : _Vec3.zero();
+  }
+  distanceTo(other) {
+    return this.sub(other).length();
+  }
+  lerp(other, t) {
+    return this.add(other.sub(this).mul(t));
+  }
+  toArray() {
+    return [this.x, this.y, this.z];
+  }
+  static fromArray(arr) {
+    return new _Vec3(arr[0] || 0, arr[1] || 0, arr[2] || 0);
+  }
+  equals(other, epsilon = 1e-6) {
+    return Math.abs(this.x - other.x) < epsilon && Math.abs(this.y - other.y) < epsilon && Math.abs(this.z - other.z) < epsilon;
+  }
+  toString() {
+    return `Vec3(${this.x}, ${this.y}, ${this.z})`;
+  }
+};
+var Quaternion = class _Quaternion {
+  constructor(x = 0, y = 0, z = 0, w = 1) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+  static identity() {
+    return new _Quaternion(0, 0, 0, 1);
+  }
+  static fromEuler(x, y, z) {
+    const cx = Math.cos(x * 0.5), sx = Math.sin(x * 0.5);
+    const cy = Math.cos(y * 0.5), sy = Math.sin(y * 0.5);
+    const cz = Math.cos(z * 0.5), sz = Math.sin(z * 0.5);
+    return new _Quaternion(
+      sx * cy * cz - cx * sy * sz,
+      cx * sy * cz + sx * cy * sz,
+      cx * cy * sz - sx * sy * cz,
+      cx * cy * cz + sx * sy * sz
+    );
+  }
+  static fromAxisAngle(axis, angle) {
+    const half = angle * 0.5;
+    const s = Math.sin(half);
+    const n = axis.normalize();
+    return new _Quaternion(n.x * s, n.y * s, n.z * s, Math.cos(half));
+  }
+  multiply(other) {
+    return new _Quaternion(
+      this.w * other.x + this.x * other.w + this.y * other.z - this.z * other.y,
+      this.w * other.y - this.x * other.z + this.y * other.w + this.z * other.x,
+      this.w * other.z + this.x * other.y - this.y * other.x + this.z * other.w,
+      this.w * other.w - this.x * other.x - this.y * other.y - this.z * other.z
+    );
+  }
+  rotateVec3(v) {
+    const u = new Vec3(this.x, this.y, this.z);
+    const s = this.w;
+    return u.mul(2 * u.dot(v)).add(v.mul(s * s - u.dot(u))).add(u.cross(v).mul(2 * s));
+  }
+  slerp(other, t) {
+    let dot = this.x * other.x + this.y * other.y + this.z * other.z + this.w * other.w;
+    const neg = dot < 0;
+    if (neg) dot = -dot;
+    if (dot > 0.9995) {
+      const r = new _Quaternion(
+        this.x + t * ((neg ? -other.x : other.x) - this.x),
+        this.y + t * ((neg ? -other.y : other.y) - this.y),
+        this.z + t * ((neg ? -other.z : other.z) - this.z),
+        this.w + t * ((neg ? -other.w : other.w) - this.w)
+      );
+      const len = Math.sqrt(r.x * r.x + r.y * r.y + r.z * r.z + r.w * r.w);
+      return new _Quaternion(r.x / len, r.y / len, r.z / len, r.w / len);
+    }
+    const theta = Math.acos(dot);
+    const sinTheta = Math.sin(theta);
+    const a = Math.sin((1 - t) * theta) / sinTheta;
+    const b = Math.sin(t * theta) / sinTheta * (neg ? -1 : 1);
+    return new _Quaternion(
+      a * this.x + b * other.x,
+      a * this.y + b * other.y,
+      a * this.z + b * other.z,
+      a * this.w + b * other.w
+    );
+  }
+  normalize() {
+    const len = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+    return new _Quaternion(this.x / len, this.y / len, this.z / len, this.w / len);
+  }
+  toEuler() {
+    const sinr = 2 * (this.w * this.x + this.y * this.z);
+    const cosr = 1 - 2 * (this.x * this.x + this.y * this.y);
+    const sinp = 2 * (this.w * this.y - this.z * this.x);
+    const siny = 2 * (this.w * this.z + this.x * this.y);
+    const cosy = 1 - 2 * (this.y * this.y + this.z * this.z);
+    return new Vec3(
+      Math.atan2(sinr, cosr),
+      Math.abs(sinp) >= 1 ? Math.sign(sinp) * Math.PI / 2 : Math.asin(sinp),
+      Math.atan2(siny, cosy)
+    );
+  }
+};
+var Transform = class _Transform {
+  constructor(position = Vec3.zero(), rotation = Quaternion.identity(), scale = Vec3.one()) {
+    this.position = position;
+    this.rotation = rotation;
+    this.scale = scale;
+  }
+  static identity() {
+    return new _Transform();
+  }
+  transformPoint(point) {
+    const scaled = new Vec3(point.x * this.scale.x, point.y * this.scale.y, point.z * this.scale.z);
+    return this.rotation.rotateVec3(scaled).add(this.position);
+  }
+  transformDirection(dir) {
+    return this.rotation.rotateVec3(dir);
+  }
+};
+var Ray = class {
+  constructor(origin, direction) {
+    this.origin = origin;
+    this.direction = direction;
+  }
+  pointAt(t) {
+    return this.origin.add(this.direction.mul(t));
+  }
+};
+var AABB = class {
+  constructor(min, max) {
+    this.min = min;
+    this.max = max;
+  }
+  contains(point) {
+    return point.x >= this.min.x && point.x <= this.max.x && point.y >= this.min.y && point.y <= this.max.y && point.z >= this.min.z && point.z <= this.max.z;
+  }
+  intersects(other) {
+    return this.min.x <= other.max.x && this.max.x >= other.min.x && this.min.y <= other.max.y && this.max.y >= other.min.y && this.min.z <= other.max.z && this.max.z >= other.min.z;
+  }
+  center() {
+    return this.min.add(this.max).div(2);
+  }
+  size() {
+    return this.max.sub(this.min);
+  }
+  intersectsRay(ray2) {
+    let tmin = (this.min.x - ray2.origin.x) / ray2.direction.x;
+    let tmax = (this.max.x - ray2.origin.x) / ray2.direction.x;
+    if (tmin > tmax) [tmin, tmax] = [tmax, tmin];
+    let tymin = (this.min.y - ray2.origin.y) / ray2.direction.y;
+    let tymax = (this.max.y - ray2.origin.y) / ray2.direction.y;
+    if (tymin > tymax) [tymin, tymax] = [tymax, tymin];
+    if (tmin > tymax || tymin > tmax) return null;
+    tmin = Math.max(tmin, tymin);
+    tmax = Math.min(tmax, tymax);
+    let tzmin = (this.min.z - ray2.origin.z) / ray2.direction.z;
+    let tzmax = (this.max.z - ray2.origin.z) / ray2.direction.z;
+    if (tzmin > tzmax) [tzmin, tzmax] = [tzmax, tzmin];
+    if (tmin > tzmax || tzmin > tmax) return null;
+    return Math.max(tmin, tzmin);
+  }
+};
+function distance(a, b) {
+  return a.distanceTo(b);
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function clamp(v, min, max) {
+  return Math.min(Math.max(v, min), max);
+}
+function degToRad(deg) {
+  return deg * (Math.PI / 180);
+}
+function radToDeg(rad) {
+  return rad * (180 / Math.PI);
+}
+
+// src/physics.ts
+function createBoxCollider(halfExtents, options) {
+  return {
+    shape: "box",
+    isTrigger: false,
+    friction: 0.5,
+    restitution: 0,
+    halfExtents,
+    ...options
+  };
+}
+function createSphereCollider(radius, options) {
+  return { shape: "sphere", isTrigger: false, friction: 0.5, restitution: 0, radius, ...options };
+}
+function createCapsuleCollider(radius, height, options) {
+  return {
+    shape: "capsule",
+    isTrigger: false,
+    friction: 0.5,
+    restitution: 0,
+    radius,
+    height,
+    ...options
+  };
+}
+function createRigidbody(mass, options) {
+  return {
+    mass,
+    useGravity: true,
+    linearDamping: 0,
+    angularDamping: 0.05,
+    freezePosition: [false, false, false],
+    freezeRotation: [false, false, false],
+    isKinematic: false,
+    ...options
+  };
+}
+
+// src/materials.ts
+var MATERIAL_PRESETS = {
+  metal: { roughness: 0.2, metallic: 1 },
+  wood: { roughness: 0.85, metallic: 0, baseColor: "#8B6914" },
+  glass: { roughness: 0.05, metallic: 0, opacity: 0.3, ior: 1.5 },
+  plastic: { roughness: 0.4, metallic: 0 },
+  concrete: { roughness: 0.95, metallic: 0, baseColor: "#808080" },
+  fabric: { roughness: 0.9, metallic: 0, subsurface: 0.2 },
+  water: { roughness: 0.05, metallic: 0, opacity: 0.7, ior: 1.33 },
+  rubber: { roughness: 0.95, metallic: 0, baseColor: "#222222" },
+  marble: { roughness: 0.3, metallic: 0, baseColor: "#f0f0f0" },
+  skin: { roughness: 0.6, metallic: 0, subsurface: 0.5 },
+  foliage: { roughness: 0.8, metallic: 0, baseColor: "#2d5a27", subsurface: 0.3 },
+  chrome: { roughness: 0.05, metallic: 1, baseColor: "#cccccc" },
+  gold: { roughness: 0.2, metallic: 1, baseColor: "#ffd700" },
+  copper: { roughness: 0.3, metallic: 1, baseColor: "#b87333" },
+  ice: { roughness: 0.1, metallic: 0, opacity: 0.8, ior: 1.31 }
+};
+function createPBRMaterial(name, preset, overrides) {
+  const base = preset ? MATERIAL_PRESETS[preset] : {};
+  return {
+    name,
+    baseColor: "#ffffff",
+    roughness: 0.5,
+    metallic: 0,
+    ...base,
+    ...overrides
+  };
+}
+
+// src/events.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  wildcardListeners = [];
+  /** Register an event listener. */
+  on(event, handler) {
+    if (!this.listeners.has(event)) this.listeners.set(event, []);
+    const listener = { handler, once: false };
+    this.listeners.get(event).push(listener);
+    return () => this.off(event, handler);
+  }
+  /** Register a one-time event listener. */
+  once(event, handler) {
+    if (!this.listeners.has(event)) this.listeners.set(event, []);
+    const listener = { handler, once: true };
+    this.listeners.get(event).push(listener);
+    return () => this.off(event, handler);
+  }
+  /** Remove an event listener. */
+  off(event, handler) {
+    const list = this.listeners.get(event);
+    if (!list) return;
+    this.listeners.set(
+      event,
+      list.filter((l) => l.handler !== handler)
+    );
+  }
+  /** Emit an event to all registered listeners. */
+  emit(event, data) {
+    const list = this.listeners.get(event);
+    if (list) {
+      const remaining = [];
+      for (const l of list) {
+        l.handler(data);
+        if (!l.once) remaining.push(l);
+      }
+      this.listeners.set(event, remaining);
+    }
+    for (const l of this.wildcardListeners) {
+      l.handler({ event, data });
+    }
+  }
+  /** Listen to all events. */
+  onAny(handler) {
+    const listener = { handler, once: false };
+    this.wildcardListeners.push(listener);
+    return () => {
+      this.wildcardListeners = this.wildcardListeners.filter((l) => l !== listener);
+    };
+  }
+  /** Remove all listeners. */
+  clear() {
+    this.listeners.clear();
+    this.wildcardListeners = [];
+  }
+  /** Get count of listeners for an event (or all events). */
+  listenerCount(event) {
+    if (event) return (this.listeners.get(event) || []).length;
+    let total = this.wildcardListeners.length;
+    for (const [, list] of this.listeners) total += list.length;
+    return total;
+  }
+};
+
+// src/math.ts
+var PI = Math.PI;
+var TAU = Math.PI * 2;
+var HALF_PI = Math.PI / 2;
+var DEG_TO_RAD = Math.PI / 180;
+var RAD_TO_DEG = 180 / Math.PI;
+var EPSILON = 1e-6;
+function clamp2(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function lerp2(a, b, t) {
+  return a + (b - a) * t;
+}
+function inverseLerp(a, b, value) {
+  return (value - a) / (b - a);
+}
+function remap(value, inMin, inMax, outMin, outMax) {
+  return lerp2(outMin, outMax, inverseLerp(inMin, inMax, value));
+}
+function smoothstep(edge0, edge1, x) {
+  const t = clamp2((x - edge0) / (edge1 - edge0), 0, 1);
+  return t * t * (3 - 2 * t);
+}
+function smootherstep(edge0, edge1, x) {
+  const t = clamp2((x - edge0) / (edge1 - edge0), 0, 1);
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function degToRad2(degrees) {
+  return degrees * DEG_TO_RAD;
+}
+function radToDeg2(radians) {
+  return radians * RAD_TO_DEG;
+}
+function mod(n, m) {
+  return (n % m + m) % m;
+}
+function fract(x) {
+  return x - Math.floor(x);
+}
+function sign(x) {
+  return x > 0 ? 1 : x < 0 ? -1 : 0;
+}
+function step(edge, x) {
+  return x < edge ? 0 : 1;
+}
+var vec2Math = {
+  add: (a, b) => ({ x: a.x + b.x, y: a.y + b.y }),
+  sub: (a, b) => ({ x: a.x - b.x, y: a.y - b.y }),
+  mul: (a, s) => ({ x: a.x * s, y: a.y * s }),
+  div: (a, s) => ({ x: a.x / s, y: a.y / s }),
+  dot: (a, b) => a.x * b.x + a.y * b.y,
+  length: (v) => Math.sqrt(v.x * v.x + v.y * v.y),
+  lengthSq: (v) => v.x * v.x + v.y * v.y,
+  normalize: (v) => {
+    const len = vec2Math.length(v);
+    return len > 0 ? vec2Math.div(v, len) : { x: 0, y: 0 };
+  },
+  distance: (a, b) => vec2Math.length(vec2Math.sub(a, b)),
+  lerp: (a, b, t) => ({
+    x: lerp2(a.x, b.x, t),
+    y: lerp2(a.y, b.y, t)
+  }),
+  rotate: (v, angle) => {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return { x: v.x * c - v.y * s, y: v.x * s + v.y * c };
+  },
+  angle: (v) => Math.atan2(v.y, v.x),
+  angleBetween: (a, b) => {
+    return Math.acos(clamp2(vec2Math.dot(vec2Math.normalize(a), vec2Math.normalize(b)), -1, 1));
+  }
+};
+var vec3Math = {
+  zero: () => vec3(0, 0, 0),
+  one: () => vec3(1, 1, 1),
+  up: () => vec3(0, 1, 0),
+  down: () => vec3(0, -1, 0),
+  forward: () => vec3(0, 0, -1),
+  back: () => vec3(0, 0, 1),
+  left: () => vec3(-1, 0, 0),
+  right: () => vec3(1, 0, 0),
+  add: (a, b) => ({ x: a.x + b.x, y: a.y + b.y, z: a.z + b.z }),
+  sub: (a, b) => ({ x: a.x - b.x, y: a.y - b.y, z: a.z - b.z }),
+  mul: (a, s) => ({ x: a.x * s, y: a.y * s, z: a.z * s }),
+  div: (a, s) => ({ x: a.x / s, y: a.y / s, z: a.z / s }),
+  mulVec: (a, b) => ({ x: a.x * b.x, y: a.y * b.y, z: a.z * b.z }),
+  dot: (a, b) => a.x * b.x + a.y * b.y + a.z * b.z,
+  cross: (a, b) => ({
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  }),
+  length: (v) => Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z),
+  lengthSq: (v) => v.x * v.x + v.y * v.y + v.z * v.z,
+  normalize: (v) => {
+    const len = vec3Math.length(v);
+    return len > EPSILON ? vec3Math.div(v, len) : vec3(0, 0, 0);
+  },
+  distance: (a, b) => vec3Math.length(vec3Math.sub(a, b)),
+  distanceSq: (a, b) => vec3Math.lengthSq(vec3Math.sub(a, b)),
+  lerp: (a, b, t) => ({
+    x: lerp2(a.x, b.x, t),
+    y: lerp2(a.y, b.y, t),
+    z: lerp2(a.z, b.z, t)
+  }),
+  slerp: (a, b, t) => {
+    const dot = clamp2(vec3Math.dot(a, b), -1, 1);
+    const theta = Math.acos(dot) * t;
+    const relative = vec3Math.normalize(vec3Math.sub(b, vec3Math.mul(a, dot)));
+    return vec3Math.add(vec3Math.mul(a, Math.cos(theta)), vec3Math.mul(relative, Math.sin(theta)));
+  },
+  negate: (v) => ({ x: -v.x, y: -v.y, z: -v.z }),
+  abs: (v) => ({ x: Math.abs(v.x), y: Math.abs(v.y), z: Math.abs(v.z) }),
+  min: (a, b) => ({
+    x: Math.min(a.x, b.x),
+    y: Math.min(a.y, b.y),
+    z: Math.min(a.z, b.z)
+  }),
+  max: (a, b) => ({
+    x: Math.max(a.x, b.x),
+    y: Math.max(a.y, b.y),
+    z: Math.max(a.z, b.z)
+  }),
+  clamp: (v, min, max) => ({
+    x: clamp2(v.x, min.x, max.x),
+    y: clamp2(v.y, min.y, max.y),
+    z: clamp2(v.z, min.z, max.z)
+  }),
+  floor: (v) => ({
+    x: Math.floor(v.x),
+    y: Math.floor(v.y),
+    z: Math.floor(v.z)
+  }),
+  ceil: (v) => ({
+    x: Math.ceil(v.x),
+    y: Math.ceil(v.y),
+    z: Math.ceil(v.z)
+  }),
+  round: (v) => ({
+    x: Math.round(v.x),
+    y: Math.round(v.y),
+    z: Math.round(v.z)
+  }),
+  reflect: (v, normal) => {
+    const dot = vec3Math.dot(v, normal);
+    return vec3Math.sub(v, vec3Math.mul(normal, 2 * dot));
+  },
+  project: (v, onto) => {
+    const dot = vec3Math.dot(v, onto);
+    const lenSq = vec3Math.lengthSq(onto);
+    return vec3Math.mul(onto, dot / lenSq);
+  },
+  angle: (a, b) => {
+    const dot = vec3Math.dot(vec3Math.normalize(a), vec3Math.normalize(b));
+    return Math.acos(clamp2(dot, -1, 1));
+  },
+  equals: (a, b, epsilon = EPSILON) => {
+    return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon && Math.abs(a.z - b.z) < epsilon;
+  }
+};
+var quatMath = {
+  identity: () => quat(0, 0, 0, 1),
+  fromAxisAngle: (axis, angle) => {
+    const halfAngle = angle / 2;
+    const s = Math.sin(halfAngle);
+    const normalized = vec3Math.normalize(axis);
+    return {
+      x: normalized.x * s,
+      y: normalized.y * s,
+      z: normalized.z * s,
+      w: Math.cos(halfAngle)
+    };
+  },
+  fromEuler: (euler) => {
+    const { x, y, z } = euler;
+    const c1 = Math.cos(degToRad2(x) / 2);
+    const c2 = Math.cos(degToRad2(y) / 2);
+    const c3 = Math.cos(degToRad2(z) / 2);
+    const s1 = Math.sin(degToRad2(x) / 2);
+    const s2 = Math.sin(degToRad2(y) / 2);
+    const s3 = Math.sin(degToRad2(z) / 2);
+    return {
+      x: s1 * c2 * c3 + c1 * s2 * s3,
+      y: c1 * s2 * c3 - s1 * c2 * s3,
+      z: c1 * c2 * s3 + s1 * s2 * c3,
+      w: c1 * c2 * c3 - s1 * s2 * s3
+    };
+  },
+  toEuler: (q) => {
+    const sinr_cosp = 2 * (q.w * q.x + q.y * q.z);
+    const cosr_cosp = 1 - 2 * (q.x * q.x + q.y * q.y);
+    const x = Math.atan2(sinr_cosp, cosr_cosp);
+    const sinp = 2 * (q.w * q.y - q.z * q.x);
+    let y;
+    if (Math.abs(sinp) >= 1) {
+      y = Math.PI / 2 * Math.sign(sinp);
+    } else {
+      y = Math.asin(sinp);
+    }
+    const siny_cosp = 2 * (q.w * q.z + q.x * q.y);
+    const cosy_cosp = 1 - 2 * (q.y * q.y + q.z * q.z);
+    const z = Math.atan2(siny_cosp, cosy_cosp);
+    return {
+      x: radToDeg2(x),
+      y: radToDeg2(y),
+      z: radToDeg2(z)
+    };
+  },
+  multiply: (a, b) => ({
+    x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+    y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+    z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+    w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+  }),
+  conjugate: (q) => ({ x: -q.x, y: -q.y, z: -q.z, w: q.w }),
+  inverse: (q) => {
+    const lenSq = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
+    return {
+      x: -q.x / lenSq,
+      y: -q.y / lenSq,
+      z: -q.z / lenSq,
+      w: q.w / lenSq
+    };
+  },
+  normalize: (q) => {
+    const len = Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
+    return { x: q.x / len, y: q.y / len, z: q.z / len, w: q.w / len };
+  },
+  dot: (a, b) => a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w,
+  slerp: (a, b, t) => {
+    let dot = quatMath.dot(a, b);
+    let bAdjusted = b;
+    if (dot < 0) {
+      bAdjusted = { x: -b.x, y: -b.y, z: -b.z, w: -b.w };
+      dot = -dot;
+    }
+    if (dot > 0.9995) {
+      return quatMath.normalize({
+        x: lerp2(a.x, bAdjusted.x, t),
+        y: lerp2(a.y, bAdjusted.y, t),
+        z: lerp2(a.z, bAdjusted.z, t),
+        w: lerp2(a.w, bAdjusted.w, t)
+      });
+    }
+    const theta0 = Math.acos(dot);
+    const theta = theta0 * t;
+    const sinTheta = Math.sin(theta);
+    const sinTheta0 = Math.sin(theta0);
+    const s0 = Math.cos(theta) - dot * sinTheta / sinTheta0;
+    const s1 = sinTheta / sinTheta0;
+    return {
+      x: a.x * s0 + bAdjusted.x * s1,
+      y: a.y * s0 + bAdjusted.y * s1,
+      z: a.z * s0 + bAdjusted.z * s1,
+      w: a.w * s0 + bAdjusted.w * s1
+    };
+  },
+  rotateVec3: (q, v) => {
+    const qv = { x: q.x, y: q.y, z: q.z };
+    const uv = vec3Math.cross(qv, v);
+    const uuv = vec3Math.cross(qv, uv);
+    return vec3Math.add(v, vec3Math.add(vec3Math.mul(uv, 2 * q.w), vec3Math.mul(uuv, 2)));
+  },
+  lookAt: (forward, up = vec3(0, 1, 0)) => {
+    const f = vec3Math.normalize(forward);
+    const r = vec3Math.normalize(vec3Math.cross(up, f));
+    const u = vec3Math.cross(f, r);
+    const trace = r.x + u.y + f.z;
+    let q;
+    if (trace > 0) {
+      const s = 0.5 / Math.sqrt(trace + 1);
+      q = {
+        w: 0.25 / s,
+        x: (u.z - f.y) * s,
+        y: (f.x - r.z) * s,
+        z: (r.y - u.x) * s
+      };
+    } else if (r.x > u.y && r.x > f.z) {
+      const s = 2 * Math.sqrt(1 + r.x - u.y - f.z);
+      q = {
+        w: (u.z - f.y) / s,
+        x: 0.25 * s,
+        y: (u.x + r.y) / s,
+        z: (f.x + r.z) / s
+      };
+    } else if (u.y > f.z) {
+      const s = 2 * Math.sqrt(1 + u.y - r.x - f.z);
+      q = {
+        w: (f.x - r.z) / s,
+        x: (u.x + r.y) / s,
+        y: 0.25 * s,
+        z: (f.y + u.z) / s
+      };
+    } else {
+      const s = 2 * Math.sqrt(1 + f.z - r.x - u.y);
+      q = {
+        w: (r.y - u.x) / s,
+        x: (f.x + r.z) / s,
+        y: (f.y + u.z) / s,
+        z: 0.25 * s
+      };
+    }
+    return quatMath.normalize(q);
+  }
+};
+var aabbMath = {
+  contains: (aabb2, point) => {
+    return point.x >= aabb2.min.x && point.x <= aabb2.max.x && point.y >= aabb2.min.y && point.y <= aabb2.max.y && point.z >= aabb2.min.z && point.z <= aabb2.max.z;
+  },
+  intersects: (a, b) => {
+    return a.min.x <= b.max.x && a.max.x >= b.min.x && a.min.y <= b.max.y && a.max.y >= b.min.y && a.min.z <= b.max.z && a.max.z >= b.min.z;
+  },
+  center: (aabb2) => vec3Math.mul(vec3Math.add(aabb2.min, aabb2.max), 0.5),
+  size: (aabb2) => vec3Math.sub(aabb2.max, aabb2.min),
+  expand: (aabb2, point) => ({
+    min: vec3Math.min(aabb2.min, point),
+    max: vec3Math.max(aabb2.max, point)
+  }),
+  merge: (a, b) => ({
+    min: vec3Math.min(a.min, b.min),
+    max: vec3Math.max(a.max, b.max)
+  })
+};
+var perm = new Uint8Array(512);
+for (let i = 0; i < 256; i++) perm[i] = perm[i + 256] = i;
+for (let i = 255; i > 0; i--) {
+  const j = Math.floor(Math.random() * (i + 1));
+  [perm[i], perm[j]] = [perm[j], perm[i]];
+  perm[i + 256] = perm[i];
+}
+function fade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function grad(hash, x, y, z) {
+  const h = hash & 15;
+  const u = h < 8 ? x : y;
+  const v = h < 4 ? y : h === 12 || h === 14 ? x : z;
+  return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
+}
+var noise = {
+  /**
+   * 3D Perlin noise (-1 to 1)
+   */
+  perlin3d: (x, y, z) => {
+    const X = Math.floor(x) & 255;
+    const Y = Math.floor(y) & 255;
+    const Z = Math.floor(z) & 255;
+    x -= Math.floor(x);
+    y -= Math.floor(y);
+    z -= Math.floor(z);
+    const u = fade(x);
+    const v = fade(y);
+    const w = fade(z);
+    const A = perm[X] + Y;
+    const AA = perm[A] + Z;
+    const AB = perm[A + 1] + Z;
+    const B = perm[X + 1] + Y;
+    const BA = perm[B] + Z;
+    const BB = perm[B + 1] + Z;
+    return lerp2(
+      lerp2(
+        lerp2(grad(perm[AA], x, y, z), grad(perm[BA], x - 1, y, z), u),
+        lerp2(grad(perm[AB], x, y - 1, z), grad(perm[BB], x - 1, y - 1, z), u),
+        v
+      ),
+      lerp2(
+        lerp2(grad(perm[AA + 1], x, y, z - 1), grad(perm[BA + 1], x - 1, y, z - 1), u),
+        lerp2(grad(perm[AB + 1], x, y - 1, z - 1), grad(perm[BB + 1], x - 1, y - 1, z - 1), u),
+        v
+      ),
+      w
+    );
+  },
+  /**
+   * 2D Perlin noise (-1 to 1)
+   */
+  perlin2d: (x, y) => {
+    return noise.perlin3d(x, y, 0);
+  },
+  /**
+   * Fractal Brownian Motion (fBm)
+   */
+  fbm: (x, y, z, octaves = 6, lacunarity = 2, gain = 0.5) => {
+    let value = 0;
+    let amplitude = 1;
+    let frequency = 1;
+    let maxValue = 0;
+    for (let i = 0; i < octaves; i++) {
+      value += amplitude * noise.perlin3d(x * frequency, y * frequency, z * frequency);
+      maxValue += amplitude;
+      amplitude *= gain;
+      frequency *= lacunarity;
+    }
+    return value / maxValue;
+  },
+  /**
+   * Simplex-like noise (approximation using perlin)
+   */
+  simplex: (x, y) => {
+    return noise.perlin2d(x * 1.2, y * 1.2);
+  },
+  /**
+   * Worley/Cellular noise
+   */
+  worley: (x, y, z) => {
+    const xi = Math.floor(x);
+    const yi = Math.floor(y);
+    const zi = Math.floor(z);
+    let minDist = Infinity;
+    for (let i = -1; i <= 1; i++) {
+      for (let j = -1; j <= 1; j++) {
+        for (let k = -1; k <= 1; k++) {
+          const cellX = xi + i;
+          const cellY = yi + j;
+          const cellZ = zi + k;
+          const hash = perm[perm[perm[cellX & 255] + cellY & 255] + cellZ & 255];
+          const px = cellX + hash / 255;
+          const py = cellY + hash * 7 % 255 / 255;
+          const pz = cellZ + hash * 13 % 255 / 255;
+          const dist = (x - px) * (x - px) + (y - py) * (y - py) + (z - pz) * (z - pz);
+          minDist = Math.min(minDist, dist);
+        }
+      }
+    }
+    return Math.sqrt(minDist);
+  }
+};
+var random = {
+  /**
+   * Random float between 0 and 1
+   */
+  float: () => Math.random(),
+  /**
+   * Random float in range [min, max)
+   */
+  range: (min, max) => min + Math.random() * (max - min),
+  /**
+   * Random integer in range [min, max]
+   */
+  int: (min, max) => Math.floor(min + Math.random() * (max - min + 1)),
+  /**
+   * Random boolean with probability
+   */
+  bool: (probability = 0.5) => Math.random() < probability,
+  /**
+   * Random element from array
+   */
+  pick: (array) => array[Math.floor(Math.random() * array.length)],
+  /**
+   * Shuffle array (Fisher-Yates)
+   */
+  shuffle: (array) => {
+    const result = [...array];
+    for (let i = result.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+  },
+  /**
+   * Random Vec3 in unit sphere
+   */
+  insideUnitSphere: () => {
+    const theta = Math.random() * TAU;
+    const phi = Math.acos(2 * Math.random() - 1);
+    const r = Math.cbrt(Math.random());
+    return {
+      x: r * Math.sin(phi) * Math.cos(theta),
+      y: r * Math.sin(phi) * Math.sin(theta),
+      z: r * Math.cos(phi)
+    };
+  },
+  /**
+   * Random Vec3 on unit sphere surface
+   */
+  onUnitSphere: () => {
+    const theta = Math.random() * TAU;
+    const phi = Math.acos(2 * Math.random() - 1);
+    return {
+      x: Math.sin(phi) * Math.cos(theta),
+      y: Math.sin(phi) * Math.sin(theta),
+      z: Math.cos(phi)
+    };
+  },
+  /**
+   * Random Vec2 in unit circle
+   */
+  insideUnitCircle: () => {
+    const theta = Math.random() * TAU;
+    const r = Math.sqrt(Math.random());
+    return {
+      x: r * Math.cos(theta),
+      y: r * Math.sin(theta)
+    };
+  },
+  /**
+   * Seeded random number generator
+   */
+  seeded: (seed) => {
+    let s = seed;
+    return () => {
+      s = s * 1103515245 + 12345 & 2147483647;
+      return s / 2147483647;
+    };
+  }
+};
+
+// src/collections.ts
+var List = class _List {
+  items;
+  constructor(items = []) {
+    this.items = Array.from(items);
+  }
+  static of(...items) {
+    return new _List(items);
+  }
+  static from(iterable) {
+    return new _List(iterable);
+  }
+  static range(start, end, step2 = 1) {
+    const items = [];
+    for (let i = start; step2 > 0 ? i < end : i > end; i += step2) {
+      items.push(i);
+    }
+    return new _List(items);
+  }
+  static repeat(value, count2) {
+    return new _List(Array(count2).fill(value));
+  }
+  get length() {
+    return this.items.length;
+  }
+  get isEmpty() {
+    return this.items.length === 0;
+  }
+  get(index) {
+    return index < 0 ? this.items[this.items.length + index] : this.items[index];
+  }
+  first() {
+    return this.items[0];
+  }
+  last() {
+    return this.items[this.items.length - 1];
+  }
+  map(fn) {
+    return new _List(this.items.map(fn));
+  }
+  flatMap(fn) {
+    const result = [];
+    this.items.forEach((item, index) => {
+      const mapped = fn(item, index);
+      if (mapped instanceof _List) {
+        result.push(...mapped.toArray());
+      } else {
+        result.push(...mapped);
+      }
+    });
+    return new _List(result);
+  }
+  filter(predicate) {
+    return new _List(this.items.filter(predicate));
+  }
+  reject(predicate) {
+    return this.filter((item, index) => !predicate(item, index));
+  }
+  reduce(fn, initial) {
+    return this.items.reduce(fn, initial);
+  }
+  fold(initial, fn) {
+    return this.items.reduce(fn, initial);
+  }
+  find(predicate) {
+    return this.items.find(predicate);
+  }
+  findIndex(predicate) {
+    return this.items.findIndex(predicate);
+  }
+  indexOf(item) {
+    return this.items.indexOf(item);
+  }
+  includes(item) {
+    return this.items.includes(item);
+  }
+  some(predicate) {
+    return this.items.some(predicate);
+  }
+  every(predicate) {
+    return this.items.every(predicate);
+  }
+  none(predicate) {
+    return !this.some(predicate);
+  }
+  count(predicate) {
+    return this.filter(predicate).length;
+  }
+  forEach(fn) {
+    this.items.forEach(fn);
+  }
+  concat(...lists) {
+    const arrays = lists.map((l) => l instanceof _List ? l.toArray() : l);
+    return new _List([...this.items, ...arrays.flat()]);
+  }
+  append(item) {
+    return new _List([...this.items, item]);
+  }
+  prepend(item) {
+    return new _List([item, ...this.items]);
+  }
+  insert(index, item) {
+    const arr = [...this.items];
+    arr.splice(index, 0, item);
+    return new _List(arr);
+  }
+  remove(index) {
+    const arr = [...this.items];
+    arr.splice(index, 1);
+    return new _List(arr);
+  }
+  update(index, item) {
+    const arr = [...this.items];
+    arr[index] = item;
+    return new _List(arr);
+  }
+  slice(start, end) {
+    return new _List(this.items.slice(start, end));
+  }
+  take(n) {
+    return this.slice(0, n);
+  }
+  takeLast(n) {
+    return this.slice(-n);
+  }
+  takeWhile(predicate) {
+    const result = [];
+    for (let i = 0; i < this.items.length; i++) {
+      if (!predicate(this.items[i], i)) break;
+      result.push(this.items[i]);
+    }
+    return new _List(result);
+  }
+  drop(n) {
+    return this.slice(n);
+  }
+  dropLast(n) {
+    return this.slice(0, -n);
+  }
+  dropWhile(predicate) {
+    let startIndex = 0;
+    for (let i = 0; i < this.items.length; i++) {
+      if (!predicate(this.items[i], i)) break;
+      startIndex = i + 1;
+    }
+    return this.slice(startIndex);
+  }
+  reverse() {
+    return new _List([...this.items].reverse());
+  }
+  sort(compareFn) {
+    return new _List([...this.items].sort(compareFn));
+  }
+  sortBy(fn) {
+    return this.sort((a, b) => {
+      const va = fn(a);
+      const vb = fn(b);
+      if (va < vb) return -1;
+      if (va > vb) return 1;
+      return 0;
+    });
+  }
+  shuffle() {
+    const arr = [...this.items];
+    for (let i = arr.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return new _List(arr);
+  }
+  unique() {
+    return new _List([...new Set(this.items)]);
+  }
+  uniqueBy(fn) {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const item of this.items) {
+      const key = fn(item);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(item);
+      }
+    }
+    return new _List(result);
+  }
+  groupBy(fn) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of this.items) {
+      const key = fn(item);
+      const group = groups.get(key) || [];
+      group.push(item);
+      groups.set(key, group);
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, items] of groups) {
+      result.set(key, new _List(items));
+    }
+    return new HoloMap(result);
+  }
+  partition(predicate) {
+    const pass = [];
+    const fail = [];
+    this.items.forEach((item, index) => {
+      if (predicate(item, index)) {
+        pass.push(item);
+      } else {
+        fail.push(item);
+      }
+    });
+    return [new _List(pass), new _List(fail)];
+  }
+  zip(other) {
+    const length = Math.min(this.length, other.length);
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      result.push([this.items[i], other.get(i)]);
+    }
+    return new _List(result);
+  }
+  zipWith(other, fn) {
+    return this.zip(other).map(([a, b]) => fn(a, b));
+  }
+  flatten() {
+    const result = [];
+    for (const item of this.items) {
+      if (item instanceof _List) {
+        result.push(...item.toArray());
+      } else if (Array.isArray(item)) {
+        result.push(...item);
+      }
+    }
+    return new _List(result);
+  }
+  sum() {
+    return this.reduce((acc, n) => acc + n, 0);
+  }
+  min() {
+    if (this.isEmpty) return void 0;
+    return Math.min(...this.items);
+  }
+  max() {
+    if (this.isEmpty) return void 0;
+    return Math.max(...this.items);
+  }
+  average() {
+    if (this.isEmpty) return void 0;
+    return this.sum() / this.length;
+  }
+  join(separator = ",") {
+    return this.items.join(separator);
+  }
+  toArray() {
+    return [...this.items];
+  }
+  toSet() {
+    return new HoloSet(this.items);
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  toString() {
+    return `List(${this.items.join(", ")})`;
+  }
+};
+var HoloMap = class _HoloMap {
+  _map;
+  constructor(entries) {
+    this._map = entries instanceof Map ? entries : new Map(entries);
+  }
+  static of(...entries) {
+    return new _HoloMap(entries);
+  }
+  static from(entries) {
+    return new _HoloMap(entries);
+  }
+  static fromObject(obj) {
+    return new _HoloMap(Object.entries(obj));
+  }
+  get size() {
+    return this._map.size;
+  }
+  get isEmpty() {
+    return this._map.size === 0;
+  }
+  get(key) {
+    return this._map.get(key);
+  }
+  getOrDefault(key, defaultValue) {
+    return this._map.has(key) ? this._map.get(key) : defaultValue;
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  set(key, value) {
+    const newMap = new Map(this._map);
+    newMap.set(key, value);
+    return new _HoloMap(newMap);
+  }
+  delete(key) {
+    const newMap = new Map(this._map);
+    newMap.delete(key);
+    return new _HoloMap(newMap);
+  }
+  update(key, fn) {
+    return this.set(key, fn(this.get(key)));
+  }
+  merge(other) {
+    const newMap = new Map(this._map);
+    for (const [key, value] of other) {
+      newMap.set(key, value);
+    }
+    return new _HoloMap(newMap);
+  }
+  keys() {
+    return new List(this._map.keys());
+  }
+  values() {
+    return new List(this._map.values());
+  }
+  entries() {
+    return new List(this._map.entries());
+  }
+  map(fn) {
+    const entries = [];
+    for (const [key, value] of this._map) {
+      entries.push([key, fn(value, key)]);
+    }
+    return new _HoloMap(entries);
+  }
+  mapKeys(fn) {
+    const entries = [];
+    for (const [key, value] of this._map) {
+      entries.push([fn(key, value), value]);
+    }
+    return new _HoloMap(entries);
+  }
+  filter(predicate) {
+    const entries = [];
+    for (const [key, value] of this._map) {
+      if (predicate(value, key)) {
+        entries.push([key, value]);
+      }
+    }
+    return new _HoloMap(entries);
+  }
+  reduce(fn, initial) {
+    let acc = initial;
+    for (const [key, value] of this._map) {
+      acc = fn(acc, value, key);
+    }
+    return acc;
+  }
+  forEach(fn) {
+    this._map.forEach(fn);
+  }
+  find(predicate) {
+    for (const [key, value] of this._map) {
+      if (predicate(value, key)) {
+        return [key, value];
+      }
+    }
+    return void 0;
+  }
+  some(predicate) {
+    for (const [key, value] of this._map) {
+      if (predicate(value, key)) return true;
+    }
+    return false;
+  }
+  every(predicate) {
+    for (const [key, value] of this._map) {
+      if (!predicate(value, key)) return false;
+    }
+    return true;
+  }
+  toObject() {
+    const obj = {};
+    for (const [key, value] of this._map) {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  toNativeMap() {
+    return new Map(this._map);
+  }
+  [Symbol.iterator]() {
+    return this._map[Symbol.iterator]();
+  }
+  toString() {
+    const entries = [...this._map].map(([k, v]) => `${k}: ${v}`).join(", ");
+    return `HoloMap { ${entries} }`;
+  }
+};
+var HoloSet = class _HoloSet {
+  set;
+  constructor(items) {
+    this.set = new Set(items);
+  }
+  static of(...items) {
+    return new _HoloSet(items);
+  }
+  static from(iterable) {
+    return new _HoloSet(iterable);
+  }
+  get size() {
+    return this.set.size;
+  }
+  get isEmpty() {
+    return this.set.size === 0;
+  }
+  has(item) {
+    return this.set.has(item);
+  }
+  add(item) {
+    const newSet = new Set(this.set);
+    newSet.add(item);
+    return new _HoloSet(newSet);
+  }
+  delete(item) {
+    const newSet = new Set(this.set);
+    newSet.delete(item);
+    return new _HoloSet(newSet);
+  }
+  addAll(items) {
+    const newSet = new Set(this.set);
+    for (const item of items) {
+      newSet.add(item);
+    }
+    return new _HoloSet(newSet);
+  }
+  union(other) {
+    return this.addAll(other);
+  }
+  intersection(other) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of this.set) {
+      if (other.has(item)) {
+        result.add(item);
+      }
+    }
+    return new _HoloSet(result);
+  }
+  difference(other) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of this.set) {
+      if (!other.has(item)) {
+        result.add(item);
+      }
+    }
+    return new _HoloSet(result);
+  }
+  symmetricDifference(other) {
+    return this.difference(other).union(other.difference(this));
+  }
+  isSubsetOf(other) {
+    for (const item of this.set) {
+      if (!other.has(item)) return false;
+    }
+    return true;
+  }
+  isSupersetOf(other) {
+    return other.isSubsetOf(this);
+  }
+  isDisjointFrom(other) {
+    return this.intersection(other).isEmpty;
+  }
+  map(fn) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of this.set) {
+      result.add(fn(item));
+    }
+    return new _HoloSet(result);
+  }
+  filter(predicate) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of this.set) {
+      if (predicate(item)) {
+        result.add(item);
+      }
+    }
+    return new _HoloSet(result);
+  }
+  reduce(fn, initial) {
+    let acc = initial;
+    for (const item of this.set) {
+      acc = fn(acc, item);
+    }
+    return acc;
+  }
+  forEach(fn) {
+    this.set.forEach(fn);
+  }
+  find(predicate) {
+    for (const item of this.set) {
+      if (predicate(item)) return item;
+    }
+    return void 0;
+  }
+  some(predicate) {
+    for (const item of this.set) {
+      if (predicate(item)) return true;
+    }
+    return false;
+  }
+  every(predicate) {
+    for (const item of this.set) {
+      if (!predicate(item)) return false;
+    }
+    return true;
+  }
+  toArray() {
+    return [...this.set];
+  }
+  toList() {
+    return new List(this.set);
+  }
+  toNativeSet() {
+    return new Set(this.set);
+  }
+  [Symbol.iterator]() {
+    return this.set[Symbol.iterator]();
+  }
+  toString() {
+    return `HoloSet { ${[...this.set].join(", ")} }`;
+  }
+};
+var SpatialGrid = class {
+  cellSize;
+  cells = /* @__PURE__ */ new Map();
+  constructor(cellSize) {
+    this.cellSize = cellSize;
+  }
+  getCellKey(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(position, item) {
+    const key = this.getCellKey(position.x, position.y, position.z);
+    if (!this.cells.has(key)) {
+      this.cells.set(key, []);
+    }
+    this.cells.get(key).push(item);
+  }
+  remove(position, item) {
+    const key = this.getCellKey(position.x, position.y, position.z);
+    const cell = this.cells.get(key);
+    if (!cell) return false;
+    const index = cell.indexOf(item);
+    if (index === -1) return false;
+    cell.splice(index, 1);
+    if (cell.length === 0) {
+      this.cells.delete(key);
+    }
+    return true;
+  }
+  query(center2, radius) {
+    const results = [];
+    const cellRadius = Math.ceil(radius / this.cellSize);
+    const cx = Math.floor(center2.x / this.cellSize);
+    const cy = Math.floor(center2.y / this.cellSize);
+    const cz = Math.floor(center2.z / this.cellSize);
+    for (let x = cx - cellRadius; x <= cx + cellRadius; x++) {
+      for (let y = cy - cellRadius; y <= cy + cellRadius; y++) {
+        for (let z = cz - cellRadius; z <= cz + cellRadius; z++) {
+          const cell = this.cells.get(`${x},${y},${z}`);
+          if (cell) {
+            results.push(...cell);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  queryBox(min, max) {
+    const results = [];
+    const minCx = Math.floor(min.x / this.cellSize);
+    const minCy = Math.floor(min.y / this.cellSize);
+    const minCz = Math.floor(min.z / this.cellSize);
+    const maxCx = Math.floor(max.x / this.cellSize);
+    const maxCy = Math.floor(max.y / this.cellSize);
+    const maxCz = Math.floor(max.z / this.cellSize);
+    for (let x = minCx; x <= maxCx; x++) {
+      for (let y = minCy; y <= maxCy; y++) {
+        for (let z = minCz; z <= maxCz; z++) {
+          const cell = this.cells.get(`${x},${y},${z}`);
+          if (cell) {
+            results.push(...cell);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  clear() {
+    this.cells.clear();
+  }
+  get cellCount() {
+    return this.cells.size;
+  }
+  get itemCount() {
+    let count2 = 0;
+    for (const cell of this.cells.values()) {
+      count2 += cell.length;
+    }
+    return count2;
+  }
+};
+var PriorityQueue = class _PriorityQueue {
+  constructor(compareFn = (a, b) => a - b) {
+    this.compareFn = compareFn;
+  }
+  heap = [];
+  static minHeap() {
+    return new _PriorityQueue((a, b) => a - b);
+  }
+  static maxHeap() {
+    return new _PriorityQueue((a, b) => b - a);
+  }
+  get size() {
+    return this.heap.length;
+  }
+  get isEmpty() {
+    return this.heap.length === 0;
+  }
+  enqueue(item, priority) {
+    this.heap.push({ item, priority });
+    this.bubbleUp(this.heap.length - 1);
+  }
+  dequeue() {
+    if (this.isEmpty) return void 0;
+    const result = this.heap[0].item;
+    const last = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last;
+      this.bubbleDown(0);
+    }
+    return result;
+  }
+  peek() {
+    return this.heap[0]?.item;
+  }
+  peekPriority() {
+    return this.heap[0]?.priority;
+  }
+  clear() {
+    this.heap = [];
+  }
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      if (this.compareFn(this.heap[index].priority, this.heap[parentIndex].priority) >= 0) break;
+      [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
+      index = parentIndex;
+    }
+  }
+  bubbleDown(index) {
+    while (true) {
+      const leftChild = 2 * index + 1;
+      const rightChild = 2 * index + 2;
+      let smallest = index;
+      if (leftChild < this.heap.length && this.compareFn(this.heap[leftChild].priority, this.heap[smallest].priority) < 0) {
+        smallest = leftChild;
+      }
+      if (rightChild < this.heap.length && this.compareFn(this.heap[rightChild].priority, this.heap[smallest].priority) < 0) {
+        smallest = rightChild;
+      }
+      if (smallest === index) break;
+      [this.heap[index], this.heap[smallest]] = [this.heap[smallest], this.heap[index]];
+      index = smallest;
+    }
+  }
+};
+
+// src/string.ts
+function isBlank(s) {
+  return s.trim().length === 0;
+}
+function isNotBlank(s) {
+  return s.trim().length > 0;
+}
+function capitalize(s) {
+  if (s.length === 0) return s;
+  return s[0].toUpperCase() + s.slice(1);
+}
+function titleCase(s) {
+  return s.split(/\s+/).map(capitalize).join(" ");
+}
+function camelCase(s) {
+  return s.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[A-Z]/, (c) => c.toLowerCase());
+}
+function pascalCase(s) {
+  const camel = camelCase(s);
+  return camel.length > 0 ? camel[0].toUpperCase() + camel.slice(1) : camel;
+}
+function snakeCase(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+function kebabCase(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+function constantCase(s) {
+  return snakeCase(s).toUpperCase();
+}
+function padLeft(s, length, char = " ") {
+  return s.padStart(length, char);
+}
+function padRight(s, length, char = " ") {
+  return s.padEnd(length, char);
+}
+function center(s, length, char = " ") {
+  if (s.length >= length) return s;
+  const totalPadding = length - s.length;
+  const leftPadding = Math.floor(totalPadding / 2);
+  const rightPadding = totalPadding - leftPadding;
+  return char.repeat(leftPadding) + s + char.repeat(rightPadding);
+}
+function truncate(s, maxLength, ellipsis = "...") {
+  if (s.length <= maxLength) return s;
+  return s.slice(0, maxLength - ellipsis.length) + ellipsis;
+}
+function truncateMiddle(s, maxLength, ellipsis = "...") {
+  if (s.length <= maxLength) return s;
+  const availableLength = maxLength - ellipsis.length;
+  const leftLength = Math.floor(availableLength / 2);
+  const rightLength = Math.ceil(availableLength / 2);
+  return s.slice(0, leftLength) + ellipsis + s.slice(-rightLength);
+}
+function repeat(s, count2) {
+  return s.repeat(count2);
+}
+function reverse(s) {
+  return [...s].reverse().join("");
+}
+function count(s, substring) {
+  if (substring.length === 0) return 0;
+  let count2 = 0;
+  let pos = 0;
+  while ((pos = s.indexOf(substring, pos)) !== -1) {
+    count2++;
+    pos += 1;
+  }
+  return count2;
+}
+function containsIgnoreCase(s, substring) {
+  return s.toLowerCase().includes(substring.toLowerCase());
+}
+function startsWithIgnoreCase(s, prefix) {
+  return s.toLowerCase().startsWith(prefix.toLowerCase());
+}
+function endsWithIgnoreCase(s, suffix) {
+  return s.toLowerCase().endsWith(suffix.toLowerCase());
+}
+function removeWhitespace(s) {
+  return s.replace(/\s+/g, "");
+}
+function collapseWhitespace(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function removePrefix(s, prefix) {
+  return s.startsWith(prefix) ? s.slice(prefix.length) : s;
+}
+function removeSuffix(s, suffix) {
+  return s.endsWith(suffix) ? s.slice(0, -suffix.length) : s;
+}
+function wrap(s, prefixOrWrapper, suffix) {
+  if (suffix === void 0) {
+    return prefixOrWrapper + s + prefixOrWrapper;
+  }
+  return prefixOrWrapper + s + suffix;
+}
+function unwrap(s, prefixOrWrapper, suffix) {
+  const prefix = prefixOrWrapper;
+  const actualSuffix = suffix ?? prefixOrWrapper;
+  if (s.startsWith(prefix) && s.endsWith(actualSuffix)) {
+    return s.slice(prefix.length, -actualSuffix.length || void 0);
+  }
+  return s;
+}
+function lines(s) {
+  return s.split(/\r?\n/);
+}
+function words(s) {
+  return s.split(/\s+/).filter((w) => w.length > 0);
+}
+function chars(s) {
+  return [...s];
+}
+function join(strings, separator = "") {
+  return strings.join(separator);
+}
+function format(template, values) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    return key in values ? String(values[key]) : match;
+  });
+}
+function formatNumber(n, options = {}) {
+  return n.toLocaleString("en-US", options);
+}
+function numberWithCommas(n) {
+  return n.toLocaleString("en-US");
+}
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  if (bytes < 0) return `${bytes} B`;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) + " " + sizes[i];
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  if (ms < 36e5) {
+    return `${(ms / 6e4).toFixed(1)}m`;
+  }
+  const hours = Math.floor(ms / 36e5);
+  const mins = Math.floor(ms % 36e5 / 6e4);
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
+function escapeHtml(s) {
+  const htmlEntities = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return s.replace(/[&<>"']/g, (c) => htmlEntities[c]);
+}
+function unescapeHtml(s) {
+  const htmlEntities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&#x27;": "'",
+    "&#x2F;": "/"
+  };
+  return s.replace(
+    /&(?:amp|lt|gt|quot|#39|#x27|#x2F);/g,
+    (entity) => htmlEntities[entity] || entity
+  );
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function slugify(s) {
+  return s.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isValidIdentifier(s) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(s);
+}
+function isNumeric(s) {
+  return !isNaN(parseFloat(s)) && isFinite(Number(s));
+}
+function isAlphanumeric(s) {
+  return /^[a-zA-Z0-9]+$/.test(s);
+}
+function isAlpha(s) {
+  return /^[a-zA-Z]+$/.test(s);
+}
+function randomString(length, charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += charset[Math.floor(Math.random() * charset.length)];
+  }
+  return result;
+}
+function uuid() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function indent(s, spaces, char = " ") {
+  const prefix = char.repeat(spaces);
+  return s.split("\n").map((line) => prefix + line).join("\n");
+}
+function dedent(s) {
+  const linesList = lines(s);
+  const nonEmptyLines = linesList.filter((l) => l.trim().length > 0);
+  if (nonEmptyLines.length === 0) return s;
+  const minIndent = Math.min(
+    ...nonEmptyLines.map((line) => {
+      const match = line.match(/^(\s*)/);
+      return match ? match[1].length : 0;
+    })
+  );
+  return linesList.map((line) => line.slice(minIndent)).join("\n");
+}
+function wordWrap(s, maxWidth) {
+  const wordsList = words(s);
+  const linesList = [];
+  let currentLine = "";
+  for (const word of wordsList) {
+    if (currentLine.length === 0) {
+      currentLine = word;
+    } else if (currentLine.length + 1 + word.length <= maxWidth) {
+      currentLine += " " + word;
+    } else {
+      linesList.push(currentLine);
+      currentLine = word;
+    }
+  }
+  if (currentLine.length > 0) {
+    linesList.push(currentLine);
+  }
+  return linesList.join("\n");
+}
+function levenshtein(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b[i - 1] === a[j - 1]) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function lcsLength(a, b) {
+  const n = b.length;
+  const dp = new Array(n + 1).fill(0);
+  for (let i = 0; i < a.length; i++) {
+    let prev = 0;
+    for (let j = 0; j < n; j++) {
+      const tmp = dp[j + 1];
+      dp[j + 1] = a[i] === b[j] ? prev + 1 : Math.max(dp[j + 1], dp[j]);
+      prev = tmp;
+    }
+  }
+  return dp[n];
+}
+function similarity(a, b) {
+  const total = a.length + b.length;
+  if (total === 0) return 1;
+  return 2 * lcsLength(a, b) / total;
+}
+function extractTraits(code) {
+  const traits = /* @__PURE__ */ new Set();
+  let m;
+  const atRe = /@([a-zA-Z_]\w*)/g;
+  while ((m = atRe.exec(code)) !== null) traits.add(`@${m[1]}`);
+  const tagRe = /<([A-Z][a-zA-Z0-9]*)\b/g;
+  while ((m = tagRe.exec(code)) !== null) traits.add(m[1]);
+  return [...traits];
+}
+
+// src/traits/EconomicPrimitives.ts
+function generateTxHash(from, to, price, timestamp) {
+  let hash = 2166136261;
+  const input = `${from}:${to}:${price}:${timestamp}`;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function executeTrade(record, buyer, price, timestamp) {
+  if (record.locked) {
+    return { ok: false, error: "TRANSFER_BLOCKED" };
+  }
+  if (price < 0) {
+    return { ok: false, error: "INVALID_AMOUNT" };
+  }
+  const txHash = generateTxHash(record.owner, buyer, price, timestamp);
+  const transfer = {
+    from: record.owner,
+    to: buyer,
+    price,
+    timestamp,
+    txHash
+  };
+  const history = [transfer, ...record.history].slice(0, 50);
+  return {
+    ok: true,
+    value: {
+      owner: buyer,
+      history,
+      locked: false
+    }
+  };
+}
+var DEFAULT_DEPRECIATION = {
+  decayRate: 1e-4,
+  // 0.01% per second (~36% per hour)
+  condition: 1,
+  destroyThreshold: 0.01,
+  repairable: true,
+  repairCostMultiplier: 0.5
+};
+function calculateDepreciation(initialCondition, decayRate, elapsedSeconds) {
+  if (decayRate <= 0) return initialCondition;
+  if (elapsedSeconds <= 0) return initialCondition;
+  return initialCondition * Math.exp(-decayRate * elapsedSeconds);
+}
+function depreciatedValue(baseValue, condition) {
+  return baseValue * Math.max(0, Math.min(1, condition));
+}
+function isDestroyed(condition, threshold) {
+  return condition <= threshold;
+}
+function calculateRepairCost(baseValue, currentCondition, repairCostMultiplier) {
+  const conditionDeficit = 1 - Math.max(0, Math.min(1, currentCondition));
+  return baseValue * conditionDeficit * repairCostMultiplier;
+}
+var DEFAULT_BONDING_CURVE = {
+  curveType: "exponential",
+  reserveRatio: 1,
+  curveSteepness: 2,
+  currentSupply: 0,
+  reserveBalance: 0,
+  transactionFee: 0.02,
+  // 2% hard sink
+  sigmoidK: 100,
+  spatialDistanceFactor: 0
+};
+function bondingCurvePrice(supply, reserveRatio, curveSteepness, curveType = "exponential", sigmoidK = 100) {
+  if (supply <= 0) return 0;
+  if (reserveRatio <= 0) return 0;
+  switch (curveType) {
+    case "linear":
+      return reserveRatio * supply;
+    case "exponential":
+      return reserveRatio * Math.pow(supply, 1 / curveSteepness);
+    case "logarithmic":
+      return reserveRatio * Math.log(supply + 1);
+    case "sigmoid": {
+      const sn = Math.pow(supply, curveSteepness);
+      const kn = Math.pow(sigmoidK, curveSteepness);
+      return reserveRatio * (sn / (kn + sn));
+    }
+    default:
+      return reserveRatio * Math.pow(supply, 1 / curveSteepness);
+  }
+}
+function bondingCurveBuyCost(config, amount) {
+  if (amount <= 0) return 0;
+  const n = Math.max(10, Math.ceil(amount));
+  const h = amount / n;
+  let sum = 0;
+  const s0 = config.currentSupply;
+  for (let i = 0; i <= n; i++) {
+    const s = s0 + i * h;
+    const p = bondingCurvePrice(
+      s,
+      config.reserveRatio,
+      config.curveSteepness,
+      config.curveType,
+      config.sigmoidK
+    );
+    if (i === 0 || i === n) {
+      sum += p;
+    } else if (i % 2 === 1) {
+      sum += 4 * p;
+    } else {
+      sum += 2 * p;
+    }
+  }
+  const cost = h / 3 * sum;
+  return cost * (1 + config.transactionFee);
+}
+function bondingCurveSellRefund(config, amount) {
+  if (amount <= 0) return 0;
+  if (amount > config.currentSupply) return 0;
+  const n = Math.max(10, Math.ceil(amount));
+  const h = amount / n;
+  let sum = 0;
+  const s0 = config.currentSupply - amount;
+  for (let i = 0; i <= n; i++) {
+    const s = s0 + i * h;
+    const p = bondingCurvePrice(
+      s,
+      config.reserveRatio,
+      config.curveSteepness,
+      config.curveType,
+      config.sigmoidK
+    );
+    if (i === 0 || i === n) {
+      sum += p;
+    } else if (i % 2 === 1) {
+      sum += 4 * p;
+    } else {
+      sum += 2 * p;
+    }
+  }
+  const refund = h / 3 * sum;
+  return refund * (1 - config.transactionFee);
+}
+function spatialPrice(basePrice, distanceToHub, distanceFactor) {
+  if (distanceFactor <= 0 || distanceToHub <= 0) return basePrice;
+  return basePrice * (1 + distanceFactor * distanceToHub);
+}
+var DEFAULT_WEALTH_TAX = {
+  threshold: 1e4,
+  baseRate: 0.01,
+  // 1% base
+  maxEffectiveRate: 0.05,
+  // 5% cap
+  collectionInterval: "daily",
+  enableRedistribution: true,
+  redistributionFraction: 0.7
+  // 70% redistributed, 30% burned as hard sink
+};
+function calculateTaxRate(wealth, threshold, baseRate, maxEffectiveRate) {
+  if (wealth <= threshold) return 0;
+  if (threshold <= 0) return 0;
+  const rate = Math.log(wealth / threshold) * baseRate;
+  return Math.min(rate, maxEffectiveRate);
+}
+function calculateTaxAmount(wealth, config) {
+  const rate = calculateTaxRate(wealth, config.threshold, config.baseRate, config.maxEffectiveRate);
+  return wealth * rate;
+}
+function calculateRedistribution(totalTaxCollected, recipientCount, redistributionFraction) {
+  if (recipientCount <= 0 || totalTaxCollected <= 0) {
+    return { perRecipient: 0, burned: totalTaxCollected };
+  }
+  const redistributed = totalTaxCollected * redistributionFraction;
+  const burned = totalTaxCollected - redistributed;
+  const perRecipient = redistributed / recipientCount;
+  return { perRecipient, burned };
+}
+var DEFAULT_PID = {
+  kp: 0.5,
+  ki: 0.01,
+  kd: 0.1,
+  setpoint: 0,
+  outputMin: -1,
+  outputMax: 1,
+  integralLimit: 10
+};
+function createPIDState() {
+  return {
+    previousError: 0,
+    integral: 0,
+    lastOutput: 0,
+    initialized: false
+  };
+}
+function updatePID(config, state, measurement, dt) {
+  if (dt <= 0) return state.lastOutput;
+  const error = config.setpoint - measurement;
+  const p = config.kp * error;
+  state.integral += error * dt;
+  state.integral = Math.max(-config.integralLimit, Math.min(config.integralLimit, state.integral));
+  const i = config.ki * state.integral;
+  let d = 0;
+  if (state.initialized) {
+    d = config.kd * ((error - state.previousError) / dt);
+  }
+  let output = p + i + d;
+  output = Math.max(config.outputMin, Math.min(config.outputMax, output));
+  state.previousError = error;
+  state.lastOutput = output;
+  state.initialized = true;
+  return output;
+}
+function createDualLoopPIDState() {
+  return {
+    innerState: createPIDState(),
+    outerState: createPIDState(),
+    faucetMultiplier: 1
+  };
+}
+function updateDualLoopPID(config, state, totalMoneySupply, currentFaucetRate, dt) {
+  const targetSupply = config.perCapitaTarget * config.activePlayerCount;
+  const outerConfig = { ...config.outerLoop, setpoint: targetSupply };
+  const outerOutput = updatePID(outerConfig, state.outerState, totalMoneySupply, dt);
+  const desiredFaucetRate = currentFaucetRate * (1 + outerOutput * 0.1);
+  const innerConfig = { ...config.innerLoop, setpoint: desiredFaucetRate };
+  const innerOutput = updatePID(innerConfig, state.innerState, currentFaucetRate, dt);
+  state.faucetMultiplier = Math.max(0, Math.min(2, 1 + innerOutput));
+  return state.faucetMultiplier;
+}
+function createFaucetSinkMetrics(timestamp) {
+  return {
+    totalFaucet: 0,
+    totalSink: 0,
+    ratio: 1,
+    velocity: 0,
+    periodStart: timestamp,
+    ratioHistory: []
+  };
+}
+function recordFaucet(metrics, amount) {
+  metrics.totalFaucet += amount;
+  metrics.ratio = metrics.totalSink > 0 ? metrics.totalFaucet / metrics.totalSink : metrics.totalFaucet > 0 ? Infinity : 1;
+}
+function recordSink(metrics, amount) {
+  metrics.totalSink += amount;
+  metrics.ratio = metrics.totalSink > 0 ? metrics.totalFaucet / metrics.totalSink : metrics.totalFaucet > 0 ? Infinity : 1;
+}
+function resetMetricsPeriod(metrics, timestamp) {
+  if (metrics.totalFaucet > 0 || metrics.totalSink > 0) {
+    metrics.ratioHistory.push(metrics.ratio);
+    if (metrics.ratioHistory.length > 100) {
+      metrics.ratioHistory.shift();
+    }
+  }
+  metrics.totalFaucet = 0;
+  metrics.totalSink = 0;
+  metrics.ratio = 1;
+  metrics.velocity = 0;
+  metrics.periodStart = timestamp;
+}
+
+// src/traits/EconomicTraits.ts
+var EconomicTraits = {
+  // ---------------------------------------------------------------------------
+  // 1. TRADEABLE
+  // ---------------------------------------------------------------------------
+  tradeable: {
+    name: "@tradeable",
+    description: "Makes a composition or node transferable between agents. Tracks ownership history with transaction hashes for integrity verification (P.030.04). Supports lock/unlock for escrow patterns and auction integration.",
+    params: {
+      initial_owner: {
+        type: "AgentID",
+        required: true,
+        description: "The agent who initially owns this entity."
+      },
+      transferable: {
+        type: "boolean",
+        required: false,
+        default: true,
+        description: "Whether transfers are currently allowed."
+      },
+      min_price: {
+        type: "number",
+        required: false,
+        default: 0,
+        description: "Minimum trade price (prevents value manipulation)."
+      },
+      max_history: {
+        type: "number",
+        required: false,
+        default: 50,
+        description: "Maximum ownership history entries retained."
+      },
+      requires_presence: {
+        type: "boolean",
+        required: false,
+        default: false,
+        description: "VR-specific: require spatial co-location for trade (anti-exploit, Layer 7)."
+      },
+      presence_radius: {
+        type: "number",
+        required: false,
+        default: 5,
+        description: "Maximum distance in meters for presence-based trades."
+      }
+    },
+    validator: (params) => {
+      if (!params.initial_owner || typeof params.initial_owner !== "string") return false;
+      if (params.min_price !== void 0 && params.min_price < 0) return false;
+      return true;
+    },
+    requiredPermissions: ["economy.trade"],
+    economicLayer: 0,
+    // Layer 0: Integrity
+    composesWith: ["@depreciating", "@bonding_curved", "@taxable_wealth"],
+    compiler_hints: {
+      requires_runtime: ["EconomicRuntime.executeTrade", "EconomicRuntime.verifyOwnership"],
+      thread_safety: "any"
+    }
+  },
+  // ---------------------------------------------------------------------------
+  // 2. DEPRECIATING
+  // ---------------------------------------------------------------------------
+  depreciating: {
+    name: "@depreciating",
+    description: "Applies time-based value decay to an entity (hard sink mechanic). Uses exponential decay: condition(t) = condition(0) * e^(-rate * t). When condition reaches destroy_threshold, the entity is consumed -- removing currency/value from circulation permanently (W.031).",
+    params: {
+      decay_rate: {
+        type: "number",
+        required: true,
+        description: "Per-second decay rate (0.0 - 1.0). E.g., 0.001 = 0.1% per second."
+      },
+      initial_condition: {
+        type: "number",
+        required: false,
+        default: 1,
+        description: "Starting condition (1.0 = mint, 0.0 = destroyed)."
+      },
+      destroy_threshold: {
+        type: "number",
+        required: false,
+        default: 0.01,
+        description: "Condition level at which the entity is destroyed."
+      },
+      repairable: {
+        type: "boolean",
+        required: false,
+        default: true,
+        description: "Whether the entity can be repaired to restore condition."
+      },
+      repair_cost_multiplier: {
+        type: "number",
+        required: false,
+        default: 0.5,
+        description: "Repair cost as a fraction of base value per unit condition."
+      },
+      emit_on_destroy: {
+        type: "string",
+        required: false,
+        default: "on_entity_destroyed",
+        description: "Event emitted when condition reaches destroy threshold."
+      }
+    },
+    validator: (params) => {
+      if (params.decay_rate === void 0 || params.decay_rate < 0 || params.decay_rate > 1)
+        return false;
+      if (params.initial_condition !== void 0 && (params.initial_condition < 0 || params.initial_condition > 1))
+        return false;
+      if (params.destroy_threshold !== void 0 && (params.destroy_threshold < 0 || params.destroy_threshold > 1))
+        return false;
+      return true;
+    },
+    requiredPermissions: ["economy.burn"],
+    economicLayer: 1,
+    // Layer 1: Flow Control (sink side)
+    composesWith: ["@tradeable", "@bonding_curved"],
+    compiler_hints: {
+      requires_runtime: ["EconomicRuntime.updateDepreciation", "EconomicRuntime.destroyEntity"],
+      thread_safety: "worker_thread",
+      performance_budget_ms: 0.1
+      // Must be fast -- called every tick
+    }
+  },
+  // ---------------------------------------------------------------------------
+  // 3. BONDING_CURVED
+  // ---------------------------------------------------------------------------
+  bonding_curved: {
+    name: "@bonding_curved",
+    description: "Attaches a bonding curve to a marketplace or item category for autonomous price discovery. Price is determined by P = f(supply) where f depends on curve_type. Provides continuous liquidity via reserve pool without order books (W.035, P.030.02). Supports spatial pricing for VR trade geography.",
+    params: {
+      curve_type: {
+        type: "string",
+        required: false,
+        default: "exponential",
+        description: "Curve shape: linear | exponential | logarithmic | sigmoid.",
+        validation: (val) => ["linear", "exponential", "logarithmic", "sigmoid"].includes(val)
+      },
+      reserve_ratio: {
+        type: "number",
+        required: true,
+        description: "Base price multiplier (R in the price formula)."
+      },
+      curve_steepness: {
+        type: "number",
+        required: false,
+        default: 2,
+        description: "Controls price sensitivity to supply changes (n in P = R * S^(1/n))."
+      },
+      transaction_fee: {
+        type: "number",
+        required: false,
+        default: 0.02,
+        description: "Fee percentage per transaction (hard sink). Range: 0.0 - 0.5."
+      },
+      initial_supply: {
+        type: "number",
+        required: false,
+        default: 0,
+        description: "Initial token/item supply on the curve."
+      },
+      initial_reserve: {
+        type: "number",
+        required: false,
+        default: 0,
+        description: "Initial reserve pool balance backing the curve."
+      },
+      sigmoid_k: {
+        type: "number",
+        required: false,
+        default: 100,
+        description: "Half-saturation constant for sigmoid curves."
+      },
+      spatial_distance_factor: {
+        type: "number",
+        required: false,
+        default: 0,
+        description: "VR spatial pricing: price multiplier per unit distance from hub. 0.0 = no spatial effect. Creates emergent trade routes (P.030.02 ENRICHED)."
+      }
+    },
+    validator: (params) => {
+      if (params.reserve_ratio === void 0 || params.reserve_ratio <= 0) return false;
+      if (params.curve_steepness !== void 0 && params.curve_steepness <= 0) return false;
+      if (params.transaction_fee !== void 0 && (params.transaction_fee < 0 || params.transaction_fee > 0.5))
+        return false;
+      if (params.curve_type !== void 0) {
+        if (!["linear", "exponential", "logarithmic", "sigmoid"].includes(params.curve_type))
+          return false;
+      }
+      return true;
+    },
+    requiredPermissions: ["economy.set_price", "economy.trade"],
+    economicLayer: 2,
+    // Layer 2: Price Discovery
+    composesWith: ["@tradeable", "@depreciating", "@pid_controlled"],
+    compiler_hints: {
+      requires_runtime: [
+        "EconomicRuntime.bondingCurveBuy",
+        "EconomicRuntime.bondingCurveSell",
+        "EconomicRuntime.getSpotPrice"
+      ],
+      thread_safety: "any",
+      performance_budget_ms: 1
+    }
+  },
+  // ---------------------------------------------------------------------------
+  // 4. TAXABLE_WEALTH
+  // ---------------------------------------------------------------------------
+  taxable_wealth: {
+    name: "@taxable_wealth",
+    description: "Applies progressive logarithmic wealth taxation with optional redistribution to the lowest-wealth quintile (P.030.03, W.034). Tax = 0 below threshold, then rate = min(max_rate, log(wealth/threshold) * base_rate). Collected taxes are partially redistributed (UBI) and partially burned (hard sink).",
+    params: {
+      threshold: {
+        type: "number",
+        required: true,
+        description: "Wealth level below which no tax is levied."
+      },
+      base_rate: {
+        type: "number",
+        required: false,
+        default: 0.01,
+        description: "Base tax rate multiplied by log(wealth/threshold). Range: 0.0 - 0.1."
+      },
+      max_effective_rate: {
+        type: "number",
+        required: false,
+        default: 0.05,
+        description: "Maximum effective tax rate cap (prevents punishing engagement)."
+      },
+      collection_interval: {
+        type: "string",
+        required: false,
+        default: "daily",
+        description: "How often taxes are collected: hourly | daily | weekly.",
+        validation: (val) => ["hourly", "daily", "weekly"].includes(val)
+      },
+      enable_redistribution: {
+        type: "boolean",
+        required: false,
+        default: true,
+        description: "Whether collected tax is redistributed to lowest-wealth players."
+      },
+      redistribution_fraction: {
+        type: "number",
+        required: false,
+        default: 0.7,
+        description: "Fraction of tax redistributed (remainder burned as hard sink). Range: 0.0 - 1.0."
+      },
+      emit_on_collection: {
+        type: "string",
+        required: false,
+        default: "on_tax_collected",
+        description: "Event emitted when taxes are collected."
+      },
+      public_ledger: {
+        type: "boolean",
+        required: false,
+        default: true,
+        description: "Whether tax collections and redistribution are visible in the economy dashboard (Layer 6: Transparency, W.038)."
+      }
+    },
+    validator: (params) => {
+      if (params.threshold === void 0 || params.threshold < 0) return false;
+      if (params.base_rate !== void 0 && (params.base_rate < 0 || params.base_rate > 0.1))
+        return false;
+      if (params.max_effective_rate !== void 0 && (params.max_effective_rate < 0 || params.max_effective_rate > 1))
+        return false;
+      if (params.redistribution_fraction !== void 0 && (params.redistribution_fraction < 0 || params.redistribution_fraction > 1))
+        return false;
+      return true;
+    },
+    requiredPermissions: ["economy.tax", "economy.redistribute"],
+    economicLayer: 4,
+    // Layer 4: Redistribution
+    composesWith: ["@tradeable", "@pid_controlled"],
+    compiler_hints: {
+      requires_runtime: [
+        "EconomicRuntime.collectTax",
+        "EconomicRuntime.redistribute",
+        "EconomicRuntime.getGiniCoefficient"
+      ],
+      thread_safety: "worker_thread",
+      performance_budget_ms: 5
+      // Runs on collection interval, not per-frame
+    }
+  },
+  // ---------------------------------------------------------------------------
+  // 5. PID_CONTROLLED
+  // ---------------------------------------------------------------------------
+  pid_controlled: {
+    name: "@pid_controlled",
+    description: "Attaches a dual-loop PID feedback controller to regulate economic flow (P.030.01, W.032). Inner loop adjusts per-source faucet rates (fast). Outer loop adjusts inner setpoint based on total money supply (slow). Achieves <10% currency variance long-term while preserving gameplay variance.",
+    params: {
+      target_per_capita: {
+        type: "number",
+        required: true,
+        description: "Target currency per active player (outer loop setpoint)."
+      },
+      inner_kp: {
+        type: "number",
+        required: false,
+        default: 0.5,
+        description: "Inner loop proportional gain."
+      },
+      inner_ki: {
+        type: "number",
+        required: false,
+        default: 0.01,
+        description: "Inner loop integral gain."
+      },
+      inner_kd: {
+        type: "number",
+        required: false,
+        default: 0.1,
+        description: "Inner loop derivative gain."
+      },
+      outer_kp: {
+        type: "number",
+        required: false,
+        default: 0.3,
+        description: "Outer loop proportional gain."
+      },
+      outer_ki: {
+        type: "number",
+        required: false,
+        default: 5e-3,
+        description: "Outer loop integral gain."
+      },
+      outer_kd: {
+        type: "number",
+        required: false,
+        default: 0.05,
+        description: "Outer loop derivative gain."
+      },
+      update_interval: {
+        type: "number",
+        required: false,
+        default: 1,
+        description: "Controller update interval in seconds."
+      },
+      faucet_min_multiplier: {
+        type: "number",
+        required: false,
+        default: 0.1,
+        description: "Minimum faucet rate multiplier (never fully stop rewards)."
+      },
+      faucet_max_multiplier: {
+        type: "number",
+        required: false,
+        default: 2,
+        description: "Maximum faucet rate multiplier."
+      },
+      track_faucet_sink_ratio: {
+        type: "boolean",
+        required: false,
+        default: true,
+        description: "Whether to track and emit faucet/sink ratio metrics (W.031)."
+      },
+      emit_on_adjustment: {
+        type: "string",
+        required: false,
+        default: "on_faucet_adjusted",
+        description: "Event emitted when faucet rate is adjusted."
+      }
+    },
+    validator: (params) => {
+      if (params.target_per_capita === void 0 || params.target_per_capita <= 0) return false;
+      const gains = [
+        params.inner_kp,
+        params.inner_ki,
+        params.inner_kd,
+        params.outer_kp,
+        params.outer_ki,
+        params.outer_kd
+      ];
+      for (const g of gains) {
+        if (g !== void 0 && (typeof g !== "number" || isNaN(g))) return false;
+      }
+      if (params.update_interval !== void 0 && params.update_interval <= 0) return false;
+      return true;
+    },
+    requiredPermissions: ["economy.tune_pid", "economy.mint", "economy.burn"],
+    economicLayer: 1,
+    // Layer 1: Flow Control
+    composesWith: ["@bonding_curved", "@taxable_wealth"],
+    compiler_hints: {
+      requires_runtime: [
+        "EconomicRuntime.updatePID",
+        "EconomicRuntime.getFaucetMultiplier",
+        "EconomicRuntime.getFaucetSinkMetrics"
+      ],
+      thread_safety: "worker_thread",
+      performance_budget_ms: 0.5
+    }
+  }
+};
+function getEconomicTraitNames() {
+  return Object.keys(EconomicTraits).map((k) => EconomicTraits[k].name);
+}
+function getEconomicTrait(name) {
+  const key = name.startsWith("@") ? name.slice(1) : name;
+  return EconomicTraits[key];
+}
+function validateTraitComposition(traitNames) {
+  for (const name of traitNames) {
+    const trait = getEconomicTrait(name);
+    if (!trait) {
+      return `Unknown economic trait: ${name}`;
+    }
+  }
+  for (const name of traitNames) {
+    const trait = getEconomicTrait(name);
+    for (const other of traitNames) {
+      if (other === name) continue;
+      const otherPrefixed = other.startsWith("@") ? other : `@${other}`;
+      if (!trait.composesWith.includes(otherPrefixed)) {
+        return `Trait ${trait.name} does not compose with ${otherPrefixed}`;
+      }
+    }
+  }
+  return null;
+}
+function getRequiredPermissions(traitNames) {
+  const permissions = /* @__PURE__ */ new Set();
+  for (const name of traitNames) {
+    const trait = getEconomicTrait(name);
+    if (trait) {
+      for (const perm2 of trait.requiredPermissions) {
+        permissions.add(perm2);
+      }
+    }
+  }
+  return Array.from(permissions).sort();
+}
+
+// src/traits/SimulationLabPrimitives.ts
+function isParameterRange(sweep) {
+  return "min" in sweep && "max" in sweep && "step" in sweep;
+}
+function expandSweep(sweep) {
+  if (!isParameterRange(sweep)) {
+    return sweep.values.slice();
+  }
+  const range = sweep;
+  if (range.step <= 0) return [range.min];
+  if (range.min > range.max) return [];
+  const values = [];
+  for (let v = range.min; v <= range.max + range.step * 1e-3; v += range.step) {
+    values.push(Math.round(v * 1e10) / 1e10);
+  }
+  return values;
+}
+function generateSweepCombinations(sweeps) {
+  if (sweeps.length === 0) return [{}];
+  const expanded = sweeps.map((s) => ({
+    name: s.name,
+    values: expandSweep(s)
+  }));
+  let combinations = [{}];
+  for (const { name, values } of expanded) {
+    const newCombinations = [];
+    for (const combo of combinations) {
+      for (const val of values) {
+        newCombinations.push({ ...combo, [name]: val });
+      }
+    }
+    combinations = newCombinations;
+  }
+  return combinations;
+}
+function mean(data) {
+  if (data.length === 0) return 0;
+  return data.reduce((sum, v) => sum + v, 0) / data.length;
+}
+function variance(data) {
+  if (data.length < 2) return 0;
+  const m = mean(data);
+  const squaredDiffs = data.reduce((sum, v) => sum + (v - m) ** 2, 0);
+  return squaredDiffs / (data.length - 1);
+}
+function standardDeviation(data) {
+  return Math.sqrt(variance(data));
+}
+function standardError(data) {
+  if (data.length === 0) return 0;
+  return standardDeviation(data) / Math.sqrt(data.length);
+}
+function cohensD(group1, group2) {
+  if (group1.length < 2 || group2.length < 2) return 0;
+  const m1 = mean(group1);
+  const m2 = mean(group2);
+  const v1 = variance(group1);
+  const v2 = variance(group2);
+  const n1 = group1.length;
+  const n2 = group2.length;
+  const pooledVar = ((n1 - 1) * v1 + (n2 - 1) * v2) / (n1 + n2 - 2);
+  const pooledStd = Math.sqrt(pooledVar);
+  if (pooledStd === 0) return 0;
+  return (m1 - m2) / pooledStd;
+}
+function tTest(group1, group2, alpha = 0.05, direction = "different") {
+  const n1 = group1.length;
+  const n2 = group2.length;
+  if (n1 < 2 || n2 < 2) {
+    return {
+      statistic: 0,
+      pValue: 1,
+      significant: false,
+      confidenceInterval: [0, 0],
+      effectSize: 0,
+      testName: "welch_t_test",
+      sampleSize: n1 + n2
+    };
+  }
+  const m1 = mean(group1);
+  const m2 = mean(group2);
+  const v1 = variance(group1);
+  const v2 = variance(group2);
+  const se = Math.sqrt(v1 / n1 + v2 / n2);
+  if (se === 0) {
+    return {
+      statistic: 0,
+      pValue: m1 === m2 ? 1 : 0,
+      significant: m1 !== m2,
+      confidenceInterval: [m1 - m2, m1 - m2],
+      effectSize: 0,
+      testName: "welch_t_test",
+      sampleSize: n1 + n2
+    };
+  }
+  const t = (m1 - m2) / se;
+  const num = (v1 / n1 + v2 / n2) ** 2;
+  const den = (v1 / n1) ** 2 / (n1 - 1) + (v2 / n2) ** 2 / (n2 - 1);
+  const df = num / den;
+  const pTwoTailed = tDistPValue(Math.abs(t), df);
+  let pValue;
+  switch (direction) {
+    case "greater":
+      pValue = t > 0 ? pTwoTailed / 2 : 1 - pTwoTailed / 2;
+      break;
+    case "less":
+      pValue = t < 0 ? pTwoTailed / 2 : 1 - pTwoTailed / 2;
+      break;
+    case "equal":
+      pValue = 1 - pTwoTailed;
+      break;
+    default:
+      pValue = pTwoTailed;
+  }
+  const tCrit = tDistCritical(alpha, df);
+  const diff = m1 - m2;
+  const ci = [diff - tCrit * se, diff + tCrit * se];
+  return {
+    statistic: t,
+    pValue,
+    significant: pValue < alpha,
+    confidenceInterval: ci,
+    effectSize: cohensD(group1, group2),
+    testName: "welch_t_test",
+    sampleSize: n1 + n2
+  };
+}
+function oneSampleTTest(data, populationMean, alpha = 0.05, direction = "different") {
+  const n = data.length;
+  if (n < 2) {
+    return {
+      statistic: 0,
+      pValue: 1,
+      significant: false,
+      confidenceInterval: [0, 0],
+      effectSize: 0,
+      testName: "one_sample_t_test",
+      sampleSize: n
+    };
+  }
+  const m = mean(data);
+  const se = standardError(data);
+  if (se === 0) {
+    return {
+      statistic: 0,
+      pValue: m === populationMean ? 1 : 0,
+      significant: m !== populationMean,
+      confidenceInterval: [m, m],
+      effectSize: 0,
+      testName: "one_sample_t_test",
+      sampleSize: n
+    };
+  }
+  const t = (m - populationMean) / se;
+  const df = n - 1;
+  const pTwoTailed = tDistPValue(Math.abs(t), df);
+  let pValue;
+  switch (direction) {
+    case "greater":
+      pValue = t > 0 ? pTwoTailed / 2 : 1 - pTwoTailed / 2;
+      break;
+    case "less":
+      pValue = t < 0 ? pTwoTailed / 2 : 1 - pTwoTailed / 2;
+      break;
+    default:
+      pValue = pTwoTailed;
+  }
+  const tCrit = tDistCritical(alpha, df);
+  const ci = [m - tCrit * se, m + tCrit * se];
+  const sd = standardDeviation(data);
+  const effectSize = sd > 0 ? (m - populationMean) / sd : 0;
+  return {
+    statistic: t,
+    pValue,
+    significant: pValue < alpha,
+    confidenceInterval: ci,
+    effectSize,
+    testName: "one_sample_t_test",
+    sampleSize: n
+  };
+}
+function mannWhitneyU(group1, group2, alpha = 0.05) {
+  const n1 = group1.length;
+  const n2 = group2.length;
+  if (n1 === 0 || n2 === 0) {
+    return {
+      statistic: 0,
+      pValue: 1,
+      significant: false,
+      confidenceInterval: [0, 0],
+      effectSize: 0,
+      testName: "mann_whitney_u",
+      sampleSize: n1 + n2
+    };
+  }
+  let u1 = 0;
+  for (const a of group1) {
+    for (const b of group2) {
+      if (a > b) u1++;
+      else if (a === b) u1 += 0.5;
+    }
+  }
+  const u2 = n1 * n2 - u1;
+  const u = Math.min(u1, u2);
+  const meanU = n1 * n2 / 2;
+  const sigmaU = Math.sqrt(n1 * n2 * (n1 + n2 + 1) / 12);
+  if (sigmaU === 0) {
+    return {
+      statistic: u,
+      pValue: 1,
+      significant: false,
+      confidenceInterval: [0, 0],
+      effectSize: 0,
+      testName: "mann_whitney_u",
+      sampleSize: n1 + n2
+    };
+  }
+  const z = (u - meanU) / sigmaU;
+  const pValue = 2 * normalCDF(-Math.abs(z));
+  const effectSize = 1 - 2 * u / (n1 * n2);
+  return {
+    statistic: u,
+    pValue,
+    significant: pValue < alpha,
+    confidenceInterval: [0, 0],
+    // CI not standard for U-test
+    effectSize,
+    testName: "mann_whitney_u",
+    sampleSize: n1 + n2
+  };
+}
+function chiSquaredTest(observed, expected, alpha = 0.05) {
+  if (observed.length !== expected.length || observed.length === 0) {
+    return {
+      statistic: 0,
+      pValue: 1,
+      significant: false,
+      confidenceInterval: [0, 0],
+      effectSize: 0,
+      testName: "chi_squared",
+      sampleSize: 0
+    };
+  }
+  let chiSq = 0;
+  let totalObserved = 0;
+  for (let i = 0; i < observed.length; i++) {
+    if (expected[i] <= 0) continue;
+    chiSq += (observed[i] - expected[i]) ** 2 / expected[i];
+    totalObserved += observed[i];
+  }
+  const df = observed.length - 1;
+  if (df <= 0) {
+    return {
+      statistic: chiSq,
+      pValue: 1,
+      significant: false,
+      confidenceInterval: [0, 0],
+      effectSize: 0,
+      testName: "chi_squared",
+      sampleSize: totalObserved
+    };
+  }
+  const pValue = chiSquaredPValue(chiSq, df);
+  const k = observed.length;
+  const effectSize = totalObserved > 0 ? Math.sqrt(chiSq / (totalObserved * (k - 1))) : 0;
+  return {
+    statistic: chiSq,
+    pValue,
+    significant: pValue < alpha,
+    confidenceInterval: [0, 0],
+    effectSize,
+    testName: "chi_squared",
+    sampleSize: totalObserved
+  };
+}
+function extractMetric(results, metricName) {
+  return results.filter((r) => metricName in r.values).map((r) => r.values[metricName]);
+}
+function groupByParameter(results, paramName) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    const val = r.params[paramName];
+    if (val === void 0) continue;
+    if (!groups.has(val)) groups.set(val, []);
+    groups.get(val).push(r);
+  }
+  return groups;
+}
+function summarizeMetrics(results, metricName) {
+  const values = extractMetric(results, metricName);
+  if (values.length === 0) {
+    return { mean: 0, std: 0, min: 0, max: 0, n: 0 };
+  }
+  return {
+    mean: mean(values),
+    std: standardDeviation(values),
+    min: Math.min(...values),
+    max: Math.max(...values),
+    n: values.length
+  };
+}
+function normalCDF(x) {
+  if (x < -8) return 0;
+  if (x > 8) return 1;
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const sign2 = x < 0 ? -1 : 1;
+  const absX = Math.abs(x);
+  const t = 1 / (1 + p * absX);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX / 2);
+  return 0.5 * (1 + sign2 * y);
+}
+function tDistPValue(absT, df) {
+  if (df <= 0) return 1;
+  const z = absT * (1 - 1 / (4 * df)) / Math.sqrt(1 + absT * absT / (2 * df));
+  return 2 * (1 - normalCDF(z));
+}
+function tDistCritical(alpha, df) {
+  const p = 1 - alpha / 2;
+  const a = p - 0.5;
+  const r = a * a;
+  let z = a * (2.50662823884 + r * (-18.61500062529 + r * (41.39119773534 + r * -25.44106049637))) / (1 + r * (-8.4735109309 + r * (23.08336743743 + r * (-21.06224101826 + r * 3.13082909833))));
+  const g1 = (z ** 3 + z) / (4 * df);
+  const g2 = (5 * z ** 5 + 16 * z ** 3 + 3 * z) / (96 * df * df);
+  z = z + g1 + g2;
+  return Math.abs(z);
+}
+function chiSquaredPValue(chiSq, df) {
+  if (df <= 0) return 1;
+  if (chiSq <= 0) return 1;
+  const z = Math.pow(chiSq / df, 1 / 3) - (1 - 2 / (9 * df));
+  const denom = Math.sqrt(2 / (9 * df));
+  return 1 - normalCDF(z / denom);
+}
+
+// src/traits/SimulationLabTraits.ts
+var SimulationLabTraits = {
+  simulation_lab: {
+    name: "@simulation_lab",
+    description: "Attaches scientific hypothesis testing to any HoloScript composition. Enables parameter sweeps, multi-epoch execution, statistical analysis, and exportable results. The universe gets one sample \u2014 HoloScript gives you infinite. Results are marketplace-sellable as verified simulation data.",
+    params: {
+      hypothesis: {
+        type: "string",
+        required: true,
+        description: "Human-readable hypothesis description."
+      },
+      null_hypothesis: {
+        type: "string",
+        required: false,
+        default: "",
+        description: "Formal null hypothesis (H0). Auto-generated if empty."
+      },
+      alternative_hypothesis: {
+        type: "string",
+        required: false,
+        default: "",
+        description: "Formal alternative hypothesis (H1). Auto-generated if empty."
+      },
+      direction: {
+        type: "string",
+        required: false,
+        default: "different",
+        description: "Expected direction of effect: greater | less | different | equal."
+      },
+      epochs: {
+        type: "number",
+        required: false,
+        default: 1e3,
+        description: "Number of simulation runs per parameter combination. More = higher power."
+      },
+      seed_start: {
+        type: "number",
+        required: false,
+        default: 0,
+        description: "Starting seed for reproducibility. Seeds increment per epoch."
+      },
+      confidence_level: {
+        type: "number",
+        required: false,
+        default: 0.95,
+        description: "Confidence level for statistical tests (0.0 - 1.0). Default 0.95 = \u03B1=0.05."
+      },
+      metrics: {
+        type: "string[]",
+        required: true,
+        description: "List of metric names to collect each epoch. Must match emitted metric events."
+      },
+      statistical_test: {
+        type: "string",
+        required: false,
+        default: "auto",
+        description: "Statistical test to use: t_test | mann_whitney_u | chi_squared | auto. Auto selects based on data distribution."
+      },
+      export_training_data: {
+        type: "boolean",
+        required: false,
+        default: false,
+        description: "Whether to export results as training data for DataForge pipeline."
+      },
+      marketplace_publishable: {
+        type: "boolean",
+        required: false,
+        default: false,
+        description: "Whether to package results for marketplace listing as verified simulation data."
+      },
+      max_duration_ms: {
+        type: "number",
+        required: false,
+        default: 3e5,
+        description: "Maximum wall-clock time for the entire experiment (5 min default). Prevents runaway simulations."
+      },
+      worker_count: {
+        type: "number",
+        required: false,
+        default: 4,
+        description: "Number of parallel workers for epoch execution."
+      }
+    },
+    validator: (params) => {
+      if (!params.hypothesis || typeof params.hypothesis !== "string") return false;
+      if (!params.metrics || !Array.isArray(params.metrics) || params.metrics.length === 0)
+        return false;
+      if (params.epochs !== void 0 && (params.epochs < 1 || params.epochs > 1e6))
+        return false;
+      if (params.confidence_level !== void 0 && (params.confidence_level <= 0 || params.confidence_level >= 1))
+        return false;
+      if (params.direction !== void 0) {
+        if (!["greater", "less", "different", "equal"].includes(params.direction)) return false;
+      }
+      if (params.statistical_test !== void 0) {
+        if (!["t_test", "mann_whitney_u", "chi_squared", "auto"].includes(params.statistical_test))
+          return false;
+      }
+      return true;
+    },
+    composesWith: [
+      "@tradeable",
+      "@depreciating",
+      "@bonding_curved",
+      "@taxable_wealth",
+      "@pid_controlled"
+    ],
+    compiler_hints: {
+      requires_runtime: [
+        "SimulationRuntime.runExperiment",
+        "SimulationRuntime.collectMetrics",
+        "SimulationRuntime.runStatisticalTest",
+        "SimulationRuntime.exportResults"
+      ],
+      thread_safety: "worker_thread",
+      performance_budget_ms: 3e5,
+      // Experiment budget, not per-frame
+      batch_mode: true
+    }
+  }
+};
+function getSimulationTraitNames() {
+  return Object.keys(SimulationLabTraits).map((k) => SimulationLabTraits[k].name);
+}
+function getSimulationTrait(name) {
+  const key = name.startsWith("@") ? name.slice(1) : name;
+  return SimulationLabTraits[key];
+}
+
+// src/time.ts
+function now() {
+  return Date.now();
+}
+function hrTime() {
+  if (typeof performance !== "undefined") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitUntil(condition, options = {}) {
+  const { timeout = 3e4, interval = 100 } = options;
+  const startTime = now();
+  while (true) {
+    if (await condition()) return;
+    if (now() - startTime > timeout) {
+      throw new Error("waitUntil timeout");
+    }
+    await sleep(interval);
+  }
+}
+async function withTimeout(fn, ms) {
+  return Promise.race([
+    fn(),
+    new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), ms))
+  ]);
+}
+async function retry(fn, options = {}) {
+  const { maxAttempts = 3, initialDelay = 1e3, maxDelay = 3e4, factor = 2, onRetry } = options;
+  let lastError;
+  let delay = initialDelay;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt === maxAttempts) break;
+      onRetry?.(lastError, attempt);
+      await sleep(delay);
+      delay = Math.min(delay * factor, maxDelay);
+    }
+  }
+  throw lastError;
+}
+function debounce(fn, ms) {
+  let timeoutId = null;
+  return ((...args) => {
+    if (timeoutId) clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      fn(...args);
+    }, ms);
+  });
+}
+function throttle(fn, ms) {
+  let lastCall = 0;
+  let timeoutId = null;
+  return ((...args) => {
+    const elapsed = now() - lastCall;
+    if (elapsed >= ms) {
+      lastCall = now();
+      fn(...args);
+    } else if (!timeoutId) {
+      timeoutId = setTimeout(() => {
+        lastCall = now();
+        timeoutId = null;
+        fn(...args);
+      }, ms - elapsed);
+    }
+  });
+}
+async function measure(fn) {
+  const start = hrTime();
+  const result = await fn();
+  const duration = hrTime() - start;
+  return { result, duration };
+}
+async function timed(label, fn) {
+  const start = hrTime();
+  try {
+    return await fn();
+  } finally {
+    const duration = hrTime() - start;
+    void duration;
+  }
+}
+var Stopwatch = class {
+  startTime = 0;
+  pausedTime = 0;
+  running = false;
+  start() {
+    if (!this.running) {
+      this.startTime = hrTime() - this.pausedTime;
+      this.running = true;
+    }
+    return this;
+  }
+  stop() {
+    if (this.running) {
+      this.pausedTime = hrTime() - this.startTime;
+      this.running = false;
+    }
+    return this.pausedTime;
+  }
+  reset() {
+    this.startTime = 0;
+    this.pausedTime = 0;
+    this.running = false;
+    return this;
+  }
+  restart() {
+    return this.reset().start();
+  }
+  get elapsed() {
+    if (this.running) {
+      return hrTime() - this.startTime;
+    }
+    return this.pausedTime;
+  }
+  get isRunning() {
+    return this.running;
+  }
+  lap() {
+    const elapsed = this.elapsed;
+    this.restart();
+    return elapsed;
+  }
+};
+var IntervalTimer = class {
+  intervalId = null;
+  callback;
+  intervalMs;
+  isPaused = false;
+  constructor(callback, intervalMs) {
+    this.callback = callback;
+    this.intervalMs = intervalMs;
+  }
+  start() {
+    if (!this.intervalId && !this.isPaused) {
+      this.intervalId = setInterval(this.callback, this.intervalMs);
+    }
+    return this;
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.isPaused = false;
+    return this;
+  }
+  pause() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      this.isPaused = true;
+    }
+    return this;
+  }
+  resume() {
+    if (this.isPaused) {
+      this.isPaused = false;
+      this.intervalId = setInterval(this.callback, this.intervalMs);
+    }
+    return this;
+  }
+  get running() {
+    return this.intervalId !== null;
+  }
+  get paused() {
+    return this.isPaused;
+  }
+};
+var CountdownTimer = class {
+  remainingMs;
+  startTime = 0;
+  running = false;
+  onTick;
+  onComplete;
+  tickIntervalId = null;
+  constructor(durationMs, options = {}) {
+    this.remainingMs = durationMs;
+    this.onTick = options.onTick;
+    this.onComplete = options.onComplete;
+    if (options.onTick && options.tickInterval) {
+      this.tickIntervalId = setInterval(() => {
+        if (this.running) {
+          this.onTick?.(this.remaining);
+        }
+      }, options.tickInterval);
+    }
+  }
+  start() {
+    if (!this.running && this.remainingMs > 0) {
+      this.startTime = hrTime();
+      this.running = true;
+      this.scheduleCompletion();
+    }
+    return this;
+  }
+  pause() {
+    if (this.running) {
+      this.remainingMs = Math.max(0, this.remainingMs - (hrTime() - this.startTime));
+      this.running = false;
+    }
+    return this;
+  }
+  resume() {
+    return this.start();
+  }
+  reset(durationMs) {
+    this.running = false;
+    this.remainingMs = durationMs ?? this.remainingMs;
+    return this;
+  }
+  stop() {
+    this.running = false;
+    if (this.tickIntervalId) {
+      clearInterval(this.tickIntervalId);
+      this.tickIntervalId = null;
+    }
+    return this;
+  }
+  get remaining() {
+    if (this.running) {
+      return Math.max(0, this.remainingMs - (hrTime() - this.startTime));
+    }
+    return this.remainingMs;
+  }
+  get isRunning() {
+    return this.running;
+  }
+  get isComplete() {
+    return this.remaining <= 0;
+  }
+  scheduleCompletion() {
+    setTimeout(() => {
+      if (this.running && this.remaining <= 0) {
+        this.running = false;
+        this.onComplete?.();
+      }
+    }, this.remainingMs);
+  }
+};
+var FrameTimer = class {
+  lastFrameTime = 0;
+  deltaTime = 0;
+  frameCount = 0;
+  fps = 0;
+  fpsUpdateInterval = 1e3;
+  lastFpsUpdate = 0;
+  framesSinceLastFpsUpdate = 0;
+  /**
+   * Call at the start of each frame
+   */
+  update() {
+    const currentTime = hrTime();
+    if (this.lastFrameTime > 0) {
+      this.deltaTime = (currentTime - this.lastFrameTime) / 1e3;
+    }
+    this.lastFrameTime = currentTime;
+    this.frameCount++;
+    this.framesSinceLastFpsUpdate++;
+    if (currentTime - this.lastFpsUpdate >= this.fpsUpdateInterval) {
+      this.fps = this.framesSinceLastFpsUpdate * 1e3 / (currentTime - this.lastFpsUpdate);
+      this.lastFpsUpdate = currentTime;
+      this.framesSinceLastFpsUpdate = 0;
+    }
+  }
+  /**
+   * Get delta time in seconds since last frame
+   */
+  get delta() {
+    return this.deltaTime;
+  }
+  /**
+   * Get delta time in milliseconds since last frame
+   */
+  get deltaMs() {
+    return this.deltaTime * 1e3;
+  }
+  /**
+   * Get total frame count
+   */
+  get frames() {
+    return this.frameCount;
+  }
+  /**
+   * Get current FPS (frames per second)
+   */
+  get currentFps() {
+    return this.fps;
+  }
+  /**
+   * Get total elapsed time in seconds
+   */
+  get totalTime() {
+    return this.lastFrameTime / 1e3;
+  }
+  /**
+   * Reset the timer
+   */
+  reset() {
+    this.lastFrameTime = 0;
+    this.deltaTime = 0;
+    this.frameCount = 0;
+    this.fps = 0;
+    this.lastFpsUpdate = 0;
+    this.framesSinceLastFpsUpdate = 0;
+  }
+};
+function schedule(callback, delayMs) {
+  const timeoutId = setTimeout(callback, delayMs);
+  return () => clearTimeout(timeoutId);
+}
+function scheduleInterval(callback, intervalMs) {
+  const intervalId = setInterval(callback, intervalMs);
+  return () => clearInterval(intervalId);
+}
+function scheduleFrame(callback) {
+  if (typeof requestAnimationFrame !== "undefined") {
+    const id2 = requestAnimationFrame(callback);
+    return () => cancelAnimationFrame(id2);
+  }
+  const id = setTimeout(() => callback(hrTime()), 16);
+  return () => clearTimeout(id);
+}
+function createTicker(callback, targetFps = 60) {
+  const frameTime = 1e3 / targetFps;
+  let lastTime = 0;
+  let running = false;
+  let animationId;
+  const tick = (currentTime) => {
+    if (!running) return;
+    if (lastTime > 0) {
+      const delta = (currentTime - lastTime) / 1e3;
+      callback(delta);
+    }
+    lastTime = currentTime;
+    if (typeof requestAnimationFrame !== "undefined") {
+      animationId = requestAnimationFrame(tick);
+    } else {
+      animationId = setTimeout(() => tick(hrTime()), frameTime);
+    }
+  };
+  return {
+    start: () => {
+      if (!running) {
+        running = true;
+        lastTime = 0;
+        if (typeof requestAnimationFrame !== "undefined") {
+          animationId = requestAnimationFrame(tick);
+        } else {
+          tick(hrTime());
+        }
+      }
+    },
+    stop: () => {
+      running = false;
+      if (typeof cancelAnimationFrame !== "undefined") {
+        cancelAnimationFrame(animationId);
+      } else {
+        clearTimeout(animationId);
+      }
+    }
+  };
+}
+var DateTime = {
+  /**
+   * Format a date as ISO string
+   */
+  toISO(date = /* @__PURE__ */ new Date()) {
+    return date.toISOString();
+  },
+  /**
+   * Format a date as local string
+   */
+  toLocal(date = /* @__PURE__ */ new Date()) {
+    return date.toLocaleString();
+  },
+  /**
+   * Format a date using a pattern
+   * Supports: YYYY, MM, DD, HH, mm, ss, SSS
+   */
+  format(date, pattern) {
+    const pad = (n, width) => String(n).padStart(width, "0");
+    return pattern.replace("YYYY", String(date.getFullYear())).replace("MM", pad(date.getMonth() + 1, 2)).replace("DD", pad(date.getDate(), 2)).replace("HH", pad(date.getHours(), 2)).replace("mm", pad(date.getMinutes(), 2)).replace("ss", pad(date.getSeconds(), 2)).replace("SSS", pad(date.getMilliseconds(), 3));
+  },
+  /**
+   * Parse a date string
+   */
+  parse(dateString) {
+    return new Date(dateString);
+  },
+  /**
+   * Get difference between two dates in various units
+   */
+  diff(date1, date2, unit = "ms") {
+    const diffMs = date1.getTime() - date2.getTime();
+    switch (unit) {
+      case "ms":
+        return diffMs;
+      case "s":
+        return diffMs / 1e3;
+      case "m":
+        return diffMs / 6e4;
+      case "h":
+        return diffMs / 36e5;
+      case "d":
+        return diffMs / 864e5;
+    }
+  },
+  /**
+   * Add time to a date
+   */
+  add(date, amount, unit) {
+    const _ms = DateTime.diff(new Date(amount), /* @__PURE__ */ new Date(0), "ms");
+    const multipliers = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+    return new Date(date.getTime() + amount * multipliers[unit]);
+  },
+  /**
+   * Check if a date is today
+   */
+  isToday(date) {
+    const today = /* @__PURE__ */ new Date();
+    return date.getDate() === today.getDate() && date.getMonth() === today.getMonth() && date.getFullYear() === today.getFullYear();
+  },
+  /**
+   * Get start of day
+   */
+  startOfDay(date = /* @__PURE__ */ new Date()) {
+    const result = new Date(date);
+    result.setHours(0, 0, 0, 0);
+    return result;
+  },
+  /**
+   * Get end of day
+   */
+  endOfDay(date = /* @__PURE__ */ new Date()) {
+    const result = new Date(date);
+    result.setHours(23, 59, 59, 999);
+    return result;
+  }
+};
+
+// src/index.ts
+function print(...args) {
+  console.log(...args);
+}
+function printError(...args) {
+  console.error(...args);
+}
+function printWarn(...args) {
+  console.warn(...args);
+}
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message ?? "Assertion failed");
+  }
+}
+function assertDefined(value, message) {
+  if (value === null || value === void 0) {
+    throw new Error(message ?? "Value is null or undefined");
+  }
+}
+function unreachable(message) {
+  throw new Error(message ?? "Unreachable code reached");
+}
+function todo(message) {
+  throw new Error(`TODO: ${message ?? "Not implemented"}`);
+}
+function clone(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(clone);
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof Map) {
+    return new Map([...value].map(([k, v]) => [clone(k), clone(v)]));
+  }
+  if (value instanceof Set) {
+    return new Set([...value].map(clone));
+  }
+  const result = {};
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      result[key] = clone(value[key]);
+    }
+  }
+  return result;
+}
+function equals(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, i) => equals(item, b[i]));
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [key, value] of a) {
+      if (!b.has(key) || !equals(value, b.get(key))) return false;
+    }
+    return true;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const value of a) {
+      if (!b.has(value)) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every(
+    (key) => equals(a[key], b[key])
+  );
+}
+function pipe(value, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), value);
+}
+function compose(...fns) {
+  return (value) => fns.reduceRight((acc, fn) => fn(acc), value);
+}
+function identity(value) {
+  return value;
+}
+function noop() {
+}
+function constant(value) {
+  return () => value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AABB,
+  CountdownTimer,
+  DEFAULT_BONDING_CURVE,
+  DEFAULT_DEPRECIATION,
+  DEFAULT_PID,
+  DEFAULT_WEALTH_TAX,
+  DEG_TO_RAD,
+  DateTime,
+  EPSILON,
+  EconomicTraits,
+  EventBus,
+  FrameTimer,
+  HALF_PI,
+  HoloMap,
+  HoloSet,
+  IntervalTimer,
+  List,
+  MATERIAL_PRESETS,
+  Map,
+  PI,
+  PriorityQueue,
+  Quaternion,
+  RAD_TO_DEG,
+  Ray,
+  Set,
+  SimulationLabTraits,
+  SpatialGrid,
+  Stopwatch,
+  TAU,
+  Transform,
+  Vec3,
+  aabb,
+  aabbMath,
+  arrayToQuat,
+  arrayToVec3,
+  assert,
+  assertDefined,
+  bondingCurveBuyCost,
+  bondingCurvePrice,
+  bondingCurveSellRefund,
+  calculateDepreciation,
+  calculateRedistribution,
+  calculateRepairCost,
+  calculateTaxAmount,
+  calculateTaxRate,
+  camelCase,
+  capitalize,
+  center,
+  chars,
+  chiSquaredTest,
+  clamp,
+  clone,
+  cohensD,
+  collapseWhitespace,
+  colorToHex,
+  compose,
+  constant,
+  constantCase,
+  containsIgnoreCase,
+  count,
+  createBoxCollider,
+  createCapsuleCollider,
+  createDualLoopPIDState,
+  createFaucetSinkMetrics,
+  createPBRMaterial,
+  createPIDState,
+  createRigidbody,
+  createSphereCollider,
+  createTicker,
+  debounce,
+  dedent,
+  degToRad,
+  depreciatedValue,
+  distance,
+  endsWithIgnoreCase,
+  equals,
+  escapeHtml,
+  escapeRegex,
+  executeTrade,
+  expandSweep,
+  extractMetric,
+  extractTraits,
+  format,
+  formatBytes,
+  formatDuration,
+  formatNumber,
+  fract,
+  generateSweepCombinations,
+  generateTxHash,
+  getEconomicTrait,
+  getEconomicTraitNames,
+  getRequiredPermissions,
+  getSimulationTrait,
+  getSimulationTraitNames,
+  groupByParameter,
+  hrTime,
+  hsl,
+  identity,
+  indent,
+  inverseLerp,
+  isAlpha,
+  isAlphanumeric,
+  isBlank,
+  isDestroyed,
+  isNotBlank,
+  isNumeric,
+  isParameterRange,
+  isValidIdentifier,
+  join,
+  kebabCase,
+  lerp,
+  levenshtein,
+  lines,
+  mannWhitneyU,
+  mean,
+  measure,
+  mod,
+  noise,
+  noop,
+  now,
+  numberWithCommas,
+  oneSampleTTest,
+  padLeft,
+  padRight,
+  parseColor,
+  pascalCase,
+  pipe,
+  print,
+  printError,
+  printWarn,
+  quat,
+  quatMath,
+  quatToArray,
+  radToDeg,
+  random,
+  randomString,
+  ray,
+  recordFaucet,
+  recordSink,
+  remap,
+  removePrefix,
+  removeSuffix,
+  removeWhitespace,
+  repeat,
+  resetMetricsPeriod,
+  retry,
+  reverse,
+  rgb,
+  rgba,
+  schedule,
+  scheduleFrame,
+  scheduleInterval,
+  sign,
+  similarity,
+  sleep,
+  slugify,
+  smootherstep,
+  smoothstep,
+  snakeCase,
+  spatialClamp,
+  spatialDegToRad,
+  spatialLerp,
+  spatialPrice,
+  spatialRadToDeg,
+  standardDeviation,
+  standardError,
+  startsWithIgnoreCase,
+  step,
+  summarizeMetrics,
+  tTest,
+  throttle,
+  timed,
+  titleCase,
+  toDegrees,
+  toRadians,
+  todo,
+  transform,
+  truncate,
+  truncateMiddle,
+  unescapeHtml,
+  unreachable,
+  unwrap,
+  updateDualLoopPID,
+  updatePID,
+  uuid,
+  validateTraitComposition,
+  variance,
+  vec2,
+  vec2Math,
+  vec3,
+  vec3Math,
+  vec3ToArray,
+  vec4,
+  waitUntil,
+  withTimeout,
+  wordWrap,
+  words,
+  wrapString
+});
+//# sourceMappingURL=index.cjs.map