@holoscript/std 2.1.0 → 6.0.3

package/dist/index.js

@@ -1,177 +1,1290 @@
-/**
- * @holoscript/std - Standard Library for HoloScript Plus
- *
- * Provides core types, math utilities, collections, string operations,
- * and time management for HoloScript Plus programs.
- *
- * @example
- * ```hsplus
- * import { Vec3, List, sleep } from "@holoscript/std";
- *
- * let position = Vec3(0, 1, 0);
- * let items = List.of(1, 2, 3).map(n => n * 2);
- *
- * async fn main() {
- *   await sleep(1000);
- *   print("Done!");
- * }
- * ```
- */
-// Re-export everything from types.js
-export * from './types.js';
-// Math utilities - export objects from math.ts
-export { 
-// Constants
-PI, TAU, HALF_PI, EPSILON, DEG_TO_RAD, RAD_TO_DEG, 
-// Basic math functions
-clamp, lerp, inverseLerp, remap, smoothstep, smootherstep, sign, fract, mod, step, degToRad, radToDeg, 
-// Math utility objects (access methods like vec2Math.add(), vec3Math.cross(), etc.)
-vec2Math, vec3Math, quatMath, aabbMath, noise, random, } from './math.js';
-// Re-export with alternate names for convenience
-export { degToRad as toRadians, radToDeg as toDegrees } from './math.js';
-// Collections
-export { List, HoloMap, HoloSet, HoloMap as Map, HoloSet as Set, SpatialGrid, PriorityQueue, } from './collections.js';
-// String utilities
-export { isBlank, isNotBlank, capitalize, titleCase, camelCase, pascalCase, snakeCase, kebabCase, constantCase, padLeft, padRight, center, truncate, truncateMiddle, repeat, reverse, count, containsIgnoreCase, startsWithIgnoreCase, endsWithIgnoreCase, removeWhitespace, collapseWhitespace, removePrefix, removeSuffix, wrap as wrapString, unwrap, lines, words, chars, join, format, formatNumber, numberWithCommas, formatBytes, formatDuration, escapeHtml, unescapeHtml, escapeRegex, slugify, isValidIdentifier, isNumeric, isAlphanumeric, isAlpha, randomString, uuid, indent, dedent, wordWrap, levenshtein, similarity, } from './string.js';
-// Time utilities
-export { now, hrTime, sleep, waitUntil, withTimeout, retry, debounce, throttle, measure, timed, Stopwatch, IntervalTimer, CountdownTimer, FrameTimer, schedule, scheduleInterval, scheduleFrame, createTicker, DateTime, } from './time.js';
-/**
- * Print to console (HoloScript standard output)
- */
-export function print(...args) {
-    console.log(...args);
-}
-/**
- * Print error to console
- */
-export function printError(...args) {
-    console.error(...args);
-}
-/**
- * Print warning to console
- */
-export function printWarn(...args) {
-    console.warn(...args);
-}
-/**
- * Assert a condition is true
- */
-export function assert(condition, message) {
-    if (!condition) {
-        throw new Error(message ?? 'Assertion failed');
+import {
+  HoloMap,
+  HoloSet,
+  List,
+  PriorityQueue,
+  SpatialGrid
+} from "./chunk-PFX2JM4X.js";
+import {
+  DEG_TO_RAD,
+  EPSILON,
+  HALF_PI,
+  PI,
+  RAD_TO_DEG,
+  TAU,
+  aabb,
+  aabbMath,
+  arrayToQuat,
+  arrayToVec3,
+  clamp,
+  colorToHex,
+  degToRad,
+  fract,
+  hsl,
+  inverseLerp,
+  lerp,
+  mod,
+  noise,
+  parseColor,
+  quat,
+  quatMath,
+  quatToArray,
+  radToDeg,
+  random,
+  ray,
+  remap,
+  rgb,
+  rgba,
+  sign,
+  smootherstep,
+  smoothstep,
+  step,
+  transform,
+  vec2,
+  vec2Math,
+  vec3,
+  vec3Math,
+  vec3ToArray,
+  vec4
+} from "./chunk-7HVUYGPS.js";
+import {
+  camelCase,
+  capitalize,
+  center,
+  chars,
+  collapseWhitespace,
+  constantCase,
+  containsIgnoreCase,
+  count,
+  dedent,
+  endsWithIgnoreCase,
+  escapeHtml,
+  escapeRegex,
+  extractTraits,
+  format,
+  formatBytes,
+  formatDuration,
+  formatNumber,
+  indent,
+  isAlpha,
+  isAlphanumeric,
+  isBlank,
+  isNotBlank,
+  isNumeric,
+  isValidIdentifier,
+  join,
+  kebabCase,
+  levenshtein,
+  lines,
+  numberWithCommas,
+  padLeft,
+  padRight,
+  pascalCase,
+  randomString,
+  removePrefix,
+  removeSuffix,
+  removeWhitespace,
+  repeat,
+  reverse,
+  similarity,
+  slugify,
+  snakeCase,
+  startsWithIgnoreCase,
+  titleCase,
+  truncate,
+  truncateMiddle,
+  unescapeHtml,
+  unwrap,
+  uuid,
+  wordWrap,
+  words,
+  wrap
+} from "./chunk-W2Q3LUCM.js";
+import {
+  CountdownTimer,
+  DateTime,
+  FrameTimer,
+  IntervalTimer,
+  Stopwatch,
+  createTicker,
+  debounce,
+  hrTime,
+  measure,
+  now,
+  retry,
+  schedule,
+  scheduleFrame,
+  scheduleInterval,
+  sleep,
+  throttle,
+  timed,
+  waitUntil,
+  withTimeout
+} from "./chunk-ZXVZAQCZ.js";
+import {
+  DEFAULT_BONDING_CURVE,
+  DEFAULT_DEPRECIATION,
+  DEFAULT_PID,
+  DEFAULT_WEALTH_TAX,
+  bondingCurveBuyCost,
+  bondingCurvePrice,
+  bondingCurveSellRefund,
+  calculateDepreciation,
+  calculateRedistribution,
+  calculateRepairCost,
+  calculateTaxAmount,
+  calculateTaxRate,
+  createDualLoopPIDState,
+  createFaucetSinkMetrics,
+  createPIDState,
+  depreciatedValue,
+  executeTrade,
+  generateTxHash,
+  isDestroyed,
+  recordFaucet,
+  recordSink,
+  resetMetricsPeriod,
+  spatialPrice,
+  updateDualLoopPID,
+  updatePID
+} from "./chunk-P4O3WNG2.js";
+import {
+  EconomicTraits,
+  getEconomicTrait,
+  getEconomicTraitNames,
+  getRequiredPermissions,
+  validateTraitComposition
+} from "./chunk-WS6W35YC.js";
+
+// 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);
 }
-/**
- * Assert a value is not null or undefined
- */
-export function assertDefined(value, message) {
-    if (value === null || value === undefined) {
-        throw new Error(message ?? 'Value is null or undefined');
-    }
+function lerp2(a, b, t) {
+  return a + (b - a) * t;
 }
-/**
- * Unreachable code marker (for exhaustiveness checking)
- */
-export function unreachable(message) {
-    throw new Error(message ?? 'Unreachable code reached');
-}
-/**
- * Todo marker (throws at runtime)
- */
-export function todo(message) {
-    throw new Error(`TODO: ${message ?? 'Not implemented'}`);
-}
-/**
- * Deep clone an object
- */
-export 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());
+function clamp2(v, min, max) {
+  return Math.min(Math.max(v, min), max);
+}
+function degToRad2(deg) {
+  return deg * (Math.PI / 180);
+}
+function radToDeg2(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);
     }
-    if (value instanceof Map) {
-        return new Map([...value].map(([k, v]) => [clone(k), clone(v)]));
+    for (const l of this.wildcardListeners) {
+      l.handler({ event, data });
     }
-    if (value instanceof Set) {
-        return new Set([...value].map(clone));
+  }
+  /** 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/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 });
+      }
     }
-    const result = {};
-    for (const key in value) {
-        if (Object.prototype.hasOwnProperty.call(value, key)) {
-            result[key] = clone(value[key]);
-        }
+    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;
     }
-    return result;
-}
-/**
- * Deep equality check
- */
-export function equals(a, b) {
-    if (a === b)
-        return true;
-    if (a === null || b === null)
+  }
+  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 (typeof a !== typeof b)
+      if (params.epochs !== void 0 && (params.epochs < 1 || params.epochs > 1e6))
         return false;
-    if (typeof a !== 'object')
+      if (params.confidence_level !== void 0 && (params.confidence_level <= 0 || params.confidence_level >= 1))
         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 (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
     }
-    if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime();
+  }
+};
+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/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]);
     }
-    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;
+  }
+  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;
     }
-    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;
+    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;
     }
-    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]));
+    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])
+  );
 }
-export function pipe(value, ...fns) {
-    return fns.reduce((acc, fn) => fn(acc), value);
+function pipe(value, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), value);
 }
-export function compose(...fns) {
-    return (value) => fns.reduceRight((acc, fn) => fn(acc), value);
+function compose(...fns) {
+  return (value) => fns.reduceRight((acc, fn) => fn(acc), value);
 }
-/**
- * Identity function
- */
-export function identity(value) {
-    return value;
+function identity(value) {
+  return value;
+}
+function noop() {
 }
-/**
- * No-operation function
- */
-export function noop() { }
-/**
- * Create a constant function
- */
-export function constant(value) {
-    return () => value;
+function constant(value) {
+  return () => value;
 }
+export {
+  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,
+  HoloMap as Map,
+  PI,
+  PriorityQueue,
+  Quaternion,
+  RAD_TO_DEG,
+  Ray,
+  HoloSet as 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,
+  clamp2 as spatialClamp,
+  degToRad2 as spatialDegToRad,
+  lerp2 as spatialLerp,
+  spatialPrice,
+  radToDeg2 as spatialRadToDeg,
+  standardDeviation,
+  standardError,
+  startsWithIgnoreCase,
+  step,
+  summarizeMetrics,
+  tTest,
+  throttle,
+  timed,
+  titleCase,
+  radToDeg as toDegrees,
+  degToRad as toRadians,
+  todo,
+  transform,
+  truncate,
+  truncateMiddle,
+  unescapeHtml,
+  unreachable,
+  unwrap,
+  updateDualLoopPID,
+  updatePID,
+  uuid,
+  validateTraitComposition,
+  variance,
+  vec2,
+  vec2Math,
+  vec3,
+  vec3Math,
+  vec3ToArray,
+  vec4,
+  waitUntil,
+  withTimeout,
+  wordWrap,
+  words,
+  wrap as wrapString
+};
 //# sourceMappingURL=index.js.map