@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-Q2XBVS2K.js

@@ -0,0 +1,1038 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/particles/index.ts
+var particles_exports = {};
+__export(particles_exports, {
+  ParticleAttractorSystem: () => ParticleAttractorSystem,
+  ParticleCollisionSystem: () => ParticleCollisionSystem,
+  ParticleEmitter: () => ParticleEmitter,
+  ParticleForceSystem: () => ParticleForceSystem,
+  ParticlePresets: () => ParticlePresets,
+  ParticleSystem: () => ParticleSystem,
+  ParticleTurbulence: () => ParticleTurbulence,
+  attractor: () => attractor,
+  drag: () => drag,
+  floorBounce: () => floorBounce,
+  getNodeParticleSystem: () => getNodeParticleSystem,
+  gravity: () => gravity,
+  particleTraitHandler: () => particleTraitHandler,
+  sizeOscillate: () => sizeOscillate,
+  turbulence: () => turbulence,
+  vortex: () => vortex,
+  wind: () => wind
+});
+
+// src/particles/ParticleSystem.ts
+function randRange(min, max) {
+  return min + Math.random() * (max - min);
+}
+function lerpColor(a, b, t) {
+  return {
+    r: a.r + (b.r - a.r) * t,
+    g: a.g + (b.g - a.g) * t,
+    b: a.b + (b.b - a.b) * t,
+    a: a.a + (b.a - a.a) * t
+  };
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+var ParticleSystem = class {
+  pool = [];
+  config;
+  emitAccumulator = 0;
+  activeCount = 0;
+  _isEmitting = true;
+  totalElapsed = 0;
+  /** External affectors applied each frame */
+  affectors = [];
+  constructor(config) {
+    this.config = config;
+    for (let i = 0; i < config.maxParticles; i++) {
+      this.pool.push(this.createDeadParticle());
+    }
+  }
+  createDeadParticle() {
+    return {
+      alive: false,
+      age: 0,
+      lifetime: 1,
+      x: 0,
+      y: 0,
+      z: 0,
+      vx: 0,
+      vy: 0,
+      vz: 0,
+      ax: 0,
+      ay: 0,
+      az: 0,
+      size: 1,
+      sizeStart: 1,
+      sizeEnd: 0,
+      color: { r: 1, g: 1, b: 1, a: 1 },
+      colorStart: { r: 1, g: 1, b: 1, a: 1 },
+      colorEnd: { r: 1, g: 1, b: 1, a: 0 },
+      rotation: 0,
+      rotationSpeed: 0
+    };
+  }
+  /**
+   * Add an affector function that runs on each particle per update.
+   */
+  addAffector(fn) {
+    this.affectors.push(fn);
+  }
+  /**
+   * Start/stop emitting new particles.
+   */
+  setEmitting(emitting) {
+    this._isEmitting = emitting;
+  }
+  isEmitting() {
+    return this._isEmitting;
+  }
+  /**
+   * Emit a burst of N particles immediately.
+   */
+  burst(count) {
+    for (let i = 0; i < count; i++) {
+      this.emitOne();
+    }
+  }
+  /**
+   * Update all particles. Call every frame.
+   */
+  update(delta) {
+    this.totalElapsed += delta;
+    if (this._isEmitting) {
+      this.emitAccumulator += this.config.rate * delta;
+      while (this.emitAccumulator >= 1) {
+        this.emitOne();
+        this.emitAccumulator -= 1;
+      }
+    }
+    this.activeCount = 0;
+    for (const p of this.pool) {
+      if (!p.alive) continue;
+      p.age += delta;
+      if (p.age >= p.lifetime) {
+        p.alive = false;
+        continue;
+      }
+      this.activeCount++;
+      const lifeT = p.age / p.lifetime;
+      for (const affector of this.affectors) {
+        affector(p, delta);
+      }
+      p.vx += p.ax * delta;
+      p.vy += p.ay * delta;
+      p.vz += p.az * delta;
+      p.x += p.vx * delta;
+      p.y += p.vy * delta;
+      p.z += p.vz * delta;
+      p.size = lerp(p.sizeStart, p.sizeEnd, lifeT);
+      p.color = lerpColor(p.colorStart, p.colorEnd, lifeT);
+      p.rotation += p.rotationSpeed * delta;
+    }
+  }
+  emitOne() {
+    const p = this.pool.find((particle) => !particle.alive);
+    if (!p) return;
+    const cfg = this.config;
+    const { px, py, pz, vx, vy, vz } = this.sampleEmitterShape();
+    p.alive = true;
+    p.age = 0;
+    p.lifetime = randRange(cfg.lifetime[0], cfg.lifetime[1]);
+    p[0] = cfg.position[0] + px;
+    p[1] = cfg.position[1] + py;
+    p[2] = cfg.position[2] + pz;
+    const speed = randRange(cfg.speed[0], cfg.speed[1]);
+    p.vx = vx * speed;
+    p.vy = vy * speed;
+    p.vz = vz * speed;
+    p.ax = 0;
+    p.ay = 0;
+    p.az = 0;
+    p.sizeStart = randRange(cfg.size[0], cfg.size[1]);
+    p.sizeEnd = randRange(cfg.sizeEnd[0], cfg.sizeEnd[1]);
+    p.size = p.sizeStart;
+    p.colorStart = { ...cfg.colorStart };
+    p.colorEnd = { ...cfg.colorEnd };
+    p.color = { ...cfg.colorStart };
+    const rotRange = cfg.rotationSpeed || [0, 0];
+    p.rotation = Math.random() * Math.PI * 2;
+    p.rotationSpeed = randRange(rotRange[0], rotRange[1]);
+  }
+  sampleEmitterShape() {
+    const dir = this.config.direction || { x: 0, y: 1, z: 0 };
+    switch (this.config.shape) {
+      case "point":
+        return { px: 0, py: 0, pz: 0, vx: dir.x, vy: dir.y, vz: dir.z };
+      case "sphere": {
+        const r = (this.config.radius || 0.1) * Math.random();
+        const theta = Math.random() * Math.PI * 2;
+        const phi = Math.acos(2 * Math.random() - 1);
+        const sx = Math.sin(phi) * Math.cos(theta);
+        const sy = Math.sin(phi) * Math.sin(theta);
+        const sz = Math.cos(phi);
+        return { px: sx * r, py: sy * r, pz: sz * r, vx: sx, vy: sy, vz: sz };
+      }
+      case "cone": {
+        const angle = this.config.coneAngle || Math.PI / 6;
+        const theta = Math.random() * Math.PI * 2;
+        const phi = Math.random() * angle;
+        const sx = Math.sin(phi) * Math.cos(theta);
+        const sy = Math.cos(phi);
+        const sz = Math.sin(phi) * Math.sin(theta);
+        return { px: 0, py: 0, pz: 0, vx: sx, vy: sy, vz: sz };
+      }
+      case "box": {
+        const r = this.config.radius || 0.5;
+        const px = (Math.random() - 0.5) * r * 2;
+        const py = (Math.random() - 0.5) * r * 2;
+        const pz = (Math.random() - 0.5) * r * 2;
+        return { px, py, pz, vx: dir.x, vy: dir.y, vz: dir.z };
+      }
+      default:
+        return { px: 0, py: 0, pz: 0, vx: 0, vy: 1, vz: 0 };
+    }
+  }
+  /**
+   * Get all alive particles (for rendering).
+   */
+  getAliveParticles() {
+    return this.pool.filter((p) => p.alive);
+  }
+  /**
+   * Get active particle count.
+   */
+  getActiveCount() {
+    return this.activeCount;
+  }
+  /**
+   * Get the config.
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Update emitter position.
+   */
+  setPosition(x, y, z) {
+    this.config.position = [x, y, z];
+  }
+};
+
+// src/particles/ParticleAffectors.ts
+function gravity(strength = -9.81) {
+  return (p, _delta) => {
+    p.ay = strength;
+  };
+}
+function wind(x, y, z) {
+  return (p, delta) => {
+    p.vx += x * delta;
+    p.vy += y * delta;
+    p.vz += z * delta;
+  };
+}
+function turbulence(strength = 1) {
+  return (p, delta) => {
+    p.vx += (Math.random() - 0.5) * strength * delta;
+    p.vy += (Math.random() - 0.5) * strength * delta;
+    p.vz += (Math.random() - 0.5) * strength * delta;
+  };
+}
+function drag(coefficient = 0.98) {
+  const factor = Math.pow(coefficient, 60);
+  return (p, delta) => {
+    const f = Math.pow(factor, delta * 60);
+    p.vx *= f;
+    p.vy *= f;
+    p.vz *= f;
+  };
+}
+function attractor(x, y, z, strength = 5, minDist = 0.1) {
+  return (p, delta) => {
+    const dx = x - p.x;
+    const dy = y - p.y;
+    const dz = z - p.z;
+    const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (dist < minDist) return;
+    const force = strength / (dist * dist);
+    p.vx += dx / dist * force * delta;
+    p.vy += dy / dist * force * delta;
+    p.vz += dz / dist * force * delta;
+  };
+}
+function vortex(axisX, axisY, axisZ, strength = 2) {
+  const len = Math.sqrt(axisX * axisX + axisY * axisY + axisZ * axisZ) || 1;
+  const ax = axisX / len, ay = axisY / len, az = axisZ / len;
+  return (p, delta) => {
+    const cx = ay * p.vz - az * p.vy;
+    const cy = az * p.vx - ax * p.vz;
+    const cz = ax * p.vy - ay * p.vx;
+    p.vx += cx * strength * delta;
+    p.vy += cy * strength * delta;
+    p.vz += cz * strength * delta;
+  };
+}
+function floorBounce(floorY = 0, bounciness = 0.6) {
+  return (p, _delta) => {
+    if (p.y <= floorY && p.vy < 0) {
+      p.y = floorY;
+      p.vy = -p.vy * bounciness;
+    }
+  };
+}
+function sizeOscillate(frequency = 3, amplitude = 0.3) {
+  return (p, _delta) => {
+    const pulse = Math.sin(p.age * frequency * Math.PI * 2) * amplitude;
+    p.size = Math.max(1e-3, p.size + pulse * p.size);
+  };
+}
+
+// src/particles/ParticlePresets.ts
+var ParticlePresets = {
+  /** Ambient floating dust motes */
+  dust: {
+    shape: "box",
+    rate: 5,
+    maxParticles: 80,
+    lifetime: [4, 8],
+    speed: [0.01, 0.03],
+    size: [3e-3, 8e-3],
+    sizeEnd: [1e-3, 3e-3],
+    colorStart: { r: 0.9, g: 0.85, b: 0.7, a: 0.4 },
+    colorEnd: { r: 0.9, g: 0.85, b: 0.7, a: 0 },
+    position: [0, 1, 0],
+    radius: 2,
+    direction: { x: 0, y: 0.2, z: 0 }
+  },
+  /** Sparks flying upward */
+  sparks: {
+    shape: "cone",
+    rate: 30,
+    maxParticles: 200,
+    lifetime: [0.3, 1],
+    speed: [1.5, 4],
+    size: [5e-3, 0.015],
+    sizeEnd: [1e-3, 3e-3],
+    colorStart: { r: 1, g: 0.8, b: 0.2, a: 1 },
+    colorEnd: { r: 1, g: 0.3, b: 0, a: 0 },
+    position: [0, 0, 0],
+    coneAngle: Math.PI / 8,
+    direction: { x: 0, y: 1, z: 0 }
+  },
+  /** Flame / fire effect */
+  fire: {
+    shape: "cone",
+    rate: 40,
+    maxParticles: 150,
+    lifetime: [0.5, 1.5],
+    speed: [0.3, 0.8],
+    size: [0.03, 0.08],
+    sizeEnd: [0.01, 0.02],
+    colorStart: { r: 1, g: 0.6, b: 0.1, a: 0.9 },
+    colorEnd: { r: 0.8, g: 0.1, b: 0, a: 0 },
+    position: [0, 0, 0],
+    coneAngle: Math.PI / 10,
+    direction: { x: 0, y: 1, z: 0 }
+  },
+  /** Confetti burst (use with burst() method) */
+  confetti: {
+    shape: "sphere",
+    rate: 0,
+    // Manual burst only
+    burst: 50,
+    maxParticles: 100,
+    lifetime: [2, 4],
+    speed: [2, 5],
+    size: [0.01, 0.025],
+    sizeEnd: [0.01, 0.025],
+    colorStart: { r: 1, g: 0.2, b: 0.5, a: 1 },
+    colorEnd: { r: 0.2, g: 0.5, b: 1, a: 0.5 },
+    position: [0, 1, 0],
+    radius: 0.1,
+    rotationSpeed: [-5, 5]
+  },
+  /** Snow */
+  snow: {
+    shape: "box",
+    rate: 15,
+    maxParticles: 300,
+    lifetime: [5, 10],
+    speed: [0.1, 0.3],
+    size: [5e-3, 0.015],
+    sizeEnd: [3e-3, 0.01],
+    colorStart: { r: 1, g: 1, b: 1, a: 0.8 },
+    colorEnd: { r: 1, g: 1, b: 1, a: 0 },
+    position: [0, 3, 0],
+    radius: 3,
+    direction: { x: 0, y: -1, z: 0 },
+    rotationSpeed: [-1, 1]
+  },
+  /** UI haptic feedback pulse (tiny, fast) */
+  hapticPulse: {
+    shape: "sphere",
+    rate: 0,
+    burst: 12,
+    maxParticles: 30,
+    lifetime: [0.15, 0.35],
+    speed: [0.3, 0.8],
+    size: [2e-3, 6e-3],
+    sizeEnd: [0, 0],
+    colorStart: { r: 0.3, g: 0.6, b: 1, a: 0.9 },
+    colorEnd: { r: 0.3, g: 0.6, b: 1, a: 0 },
+    position: [0, 0, 0],
+    radius: 0.01
+  },
+  /** Smoke */
+  smoke: {
+    shape: "cone",
+    rate: 10,
+    maxParticles: 100,
+    lifetime: [2, 5],
+    speed: [0.1, 0.4],
+    size: [0.03, 0.06],
+    sizeEnd: [0.08, 0.15],
+    colorStart: { r: 0.4, g: 0.4, b: 0.4, a: 0.5 },
+    colorEnd: { r: 0.6, g: 0.6, b: 0.6, a: 0 },
+    position: [0, 0, 0],
+    coneAngle: Math.PI / 12,
+    direction: { x: 0, y: 1, z: 0 }
+  }
+};
+
+// src/particles/ParticleAttractor.ts
+var ParticleAttractorSystem = class {
+  attractors = /* @__PURE__ */ new Map();
+  addAttractor(a) {
+    this.attractors.set(a.id, a);
+  }
+  removeAttractor(id) {
+    this.attractors.delete(id);
+  }
+  apply(particles, dt) {
+    for (const attractor2 of this.attractors.values()) {
+      for (const p of particles) {
+        if (!p.alive) continue;
+        const dx = attractor2.position[0] - p[0];
+        const dy = attractor2.position[1] - p[1];
+        const dz = attractor2.position[2] - p[2];
+        const distSq = dx * dx + dy * dy + dz * dz;
+        const dist = Math.sqrt(distSq);
+        if (dist > attractor2.radius) continue;
+        if (dist < attractor2.killRadius) {
+          p.alive = false;
+          continue;
+        }
+        const force = attractor2.strength / Math.max(distSq, 0.01);
+        const nx = dx / dist, ny = dy / dist, nz = dz / dist;
+        if (attractor2.orbit) {
+          const tx = ny * 0 - nz * 1 || nz;
+          const ty = nz * 0 - nx * 0 || -nx;
+          const tz = nx * 1 - ny * 0 || 0;
+          p.vx += tx * force * dt;
+          p.vy += ty * force * dt;
+          p.vz += tz * force * dt;
+        } else {
+          p.vx += nx * force * dt;
+          p.vy += ny * force * dt;
+          p.vz += nz * force * dt;
+        }
+      }
+    }
+  }
+  getAttractorCount() {
+    return this.attractors.size;
+  }
+};
+
+// src/particles/ParticleEmitter.ts
+function lerp2(a, b, t) {
+  return a + (b - a) * t;
+}
+function randomRange(min, max) {
+  return min + Math.random() * (max - min);
+}
+function sampleCurve(keyframes, t) {
+  if (keyframes.length === 0) return 1;
+  if (t <= keyframes[0].time) return keyframes[0].value;
+  if (t >= keyframes[keyframes.length - 1].time) return keyframes[keyframes.length - 1].value;
+  for (let i = 0; i < keyframes.length - 1; i++) {
+    if (t >= keyframes[i].time && t <= keyframes[i + 1].time) {
+      const segT = (t - keyframes[i].time) / (keyframes[i + 1].time - keyframes[i].time);
+      return lerp2(keyframes[i].value, keyframes[i + 1].value, segT);
+    }
+  }
+  return keyframes[keyframes.length - 1].value;
+}
+var ParticleEmitter = class {
+  config;
+  particles = [];
+  state;
+  constructor(config) {
+    this.config = { ...config };
+    this.state = {
+      id: config.id,
+      playing: false,
+      elapsed: 0,
+      emissionAccum: 0,
+      aliveCount: 0,
+      totalEmitted: 0
+    };
+    for (let i = 0; i < config.maxParticles; i++) {
+      this.particles.push(this.createDeadParticle());
+    }
+    if (config.prewarm) {
+      this.play();
+      this.update(2);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Controls
+  // ---------------------------------------------------------------------------
+  play() {
+    this.state.playing = true;
+  }
+  pause() {
+    this.state.playing = false;
+  }
+  stop() {
+    this.state.playing = false;
+    this.state.elapsed = 0;
+    this.state.emissionAccum = 0;
+    for (const p of this.particles) p.alive = false;
+    this.state.aliveCount = 0;
+  }
+  isPlaying() {
+    return this.state.playing;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    if (!this.state.playing) return this.getAliveParticles();
+    this.state.elapsed += dt;
+    this.state.emissionAccum += this.config.emissionRate * dt;
+    while (this.state.emissionAccum >= 1) {
+      this.emit();
+      this.state.emissionAccum -= 1;
+    }
+    this.state.aliveCount = 0;
+    for (const p of this.particles) {
+      if (!p.alive) continue;
+      p.age += dt;
+      if (p.age >= p.lifetime) {
+        p.alive = false;
+        continue;
+      }
+      const t = p.age / p.lifetime;
+      p.velocity.y -= this.config.gravity * dt;
+      if (this.config.speedOverLifetime) {
+        const speedMul = sampleCurve(this.config.speedOverLifetime, t);
+        const speed = Math.sqrt(p.velocity.x ** 2 + p.velocity.y ** 2 + p.velocity.z ** 2);
+        if (speed > 1e-3) {
+          const targetSpeed = p.startSpeed * speedMul;
+          const scale = targetSpeed / speed;
+          p.velocity.x *= scale;
+          p.velocity.y *= scale;
+          p.velocity.z *= scale;
+        }
+      }
+      p.position.x += p.velocity.x * dt;
+      p.position.y += p.velocity.y * dt;
+      p.position.z += p.velocity.z * dt;
+      if (this.config.sizeOverLifetime) {
+        p.size = sampleCurve(this.config.sizeOverLifetime, t);
+      }
+      if (this.config.alphaOverLifetime) {
+        p.color.a = sampleCurve(this.config.alphaOverLifetime, t);
+      }
+      if (this.config.endColor) {
+        p.color.r = lerp2(this.config.startColor.r, this.config.endColor.r, t);
+        p.color.g = lerp2(this.config.startColor.g, this.config.endColor.g, t);
+        p.color.b = lerp2(this.config.startColor.b, this.config.endColor.b, t);
+      }
+      this.state.aliveCount++;
+    }
+    return this.getAliveParticles();
+  }
+  // ---------------------------------------------------------------------------
+  // Emission
+  // ---------------------------------------------------------------------------
+  emit() {
+    const p = this.particles.find((p2) => !p2.alive);
+    if (!p) return;
+    p.alive = true;
+    p.age = 0;
+    p.lifetime = randomRange(this.config.lifetime.min, this.config.lifetime.max);
+    p.size = randomRange(this.config.startSize.min, this.config.startSize.max);
+    p.color = { ...this.config.startColor };
+    p.startSpeed = randomRange(this.config.startSpeed.min, this.config.startSpeed.max);
+    const { position, direction } = this.sampleShape();
+    p.position = position;
+    p.velocity = {
+      x: direction.x * p.startSpeed,
+      y: direction.y * p.startSpeed,
+      z: direction.z * p.startSpeed
+    };
+    this.state.totalEmitted++;
+  }
+  sampleShape() {
+    const shape = this.config.emissionShape;
+    const params = this.config.shapeParams;
+    switch (shape) {
+      case "point":
+        return { position: { x: 0, y: 0, z: 0 }, direction: this.randomDirection() };
+      case "sphere": {
+        const dir = this.randomDirection();
+        const r = (params.radius ?? 1) * Math.cbrt(Math.random());
+        return {
+          position: { x: dir.x * r, y: dir.y * r, z: dir.z * r },
+          direction: dir
+        };
+      }
+      case "box": {
+        const ext = params.extents ?? { x: 1, y: 1, z: 1 };
+        return {
+          position: {
+            x: randomRange(-ext.x, ext.x),
+            y: randomRange(-ext.y, ext.y),
+            z: randomRange(-ext.z, ext.z)
+          },
+          direction: { x: 0, y: 1, z: 0 }
+        };
+      }
+      case "cone": {
+        const angle = (params.angle ?? 30) * Math.PI / 180;
+        const phi = Math.random() * 2 * Math.PI;
+        const cosTheta = Math.cos(angle * Math.random());
+        const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
+        return {
+          position: { x: 0, y: 0, z: 0 },
+          direction: {
+            x: sinTheta * Math.cos(phi),
+            y: cosTheta,
+            z: sinTheta * Math.sin(phi)
+          }
+        };
+      }
+      case "circle": {
+        const r = (params.radius ?? 1) * Math.sqrt(Math.random());
+        const theta = Math.random() * 2 * Math.PI;
+        return {
+          position: { x: r * Math.cos(theta), y: 0, z: r * Math.sin(theta) },
+          direction: { x: 0, y: 1, z: 0 }
+        };
+      }
+      case "line": {
+        const len = params.length ?? 2;
+        return {
+          position: { x: randomRange(-len / 2, len / 2), y: 0, z: 0 },
+          direction: { x: 0, y: 1, z: 0 }
+        };
+      }
+    }
+  }
+  randomDirection() {
+    const theta = Math.acos(2 * Math.random() - 1);
+    const phi = 2 * Math.PI * Math.random();
+    return {
+      x: Math.sin(theta) * Math.cos(phi),
+      y: Math.sin(theta) * Math.sin(phi),
+      z: Math.cos(theta)
+    };
+  }
+  createDeadParticle() {
+    return {
+      position: { x: 0, y: 0, z: 0 },
+      velocity: { x: 0, y: 0, z: 0 },
+      color: { r: 1, g: 1, b: 1, a: 1 },
+      size: 1,
+      age: 0,
+      lifetime: 1,
+      alive: false,
+      startSpeed: 0
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getAliveParticles() {
+    return this.particles.filter((p) => p.alive);
+  }
+  getAliveCount() {
+    return this.state.aliveCount;
+  }
+  getCapacity() {
+    return this.config.maxParticles;
+  }
+};
+
+// src/particles/ParticleCollision.ts
+var ParticleCollisionSystem = class {
+  planes = [];
+  spheres = [];
+  subEmitCallback = null;
+  subEmitCount = 3;
+  collisionCount = 0;
+  // ---------------------------------------------------------------------------
+  // Collider Management
+  // ---------------------------------------------------------------------------
+  addPlane(plane) {
+    this.planes.push(plane);
+  }
+  addSphere(sphere) {
+    this.spheres.push(sphere);
+  }
+  onSubEmit(callback, count = 3) {
+    this.subEmitCallback = callback;
+    this.subEmitCount = count;
+  }
+  // ---------------------------------------------------------------------------
+  // Collision Detection & Response
+  // ---------------------------------------------------------------------------
+  resolve(particles) {
+    this.collisionCount = 0;
+    for (const p of particles) {
+      if (!p.alive) continue;
+      for (const plane of this.planes) {
+        const dist = plane.nx * p.x + plane.ny * p.y + plane.nz * p.z + plane.d;
+        if (dist < 0) {
+          p.x -= plane.nx * dist;
+          p.y -= plane.ny * dist;
+          p.z -= plane.nz * dist;
+          const vDotN = p.vx * plane.nx + p.vy * plane.ny + p.vz * plane.nz;
+          p.vx = (p.vx - 2 * vDotN * plane.nx) * plane.bounce;
+          p.vy = (p.vy - 2 * vDotN * plane.ny) * plane.bounce;
+          p.vz = (p.vz - 2 * vDotN * plane.nz) * plane.bounce;
+          p.vx *= 1 - plane.friction;
+          p.vy *= 1 - plane.friction;
+          p.vz *= 1 - plane.friction;
+          p.lifetime -= plane.lifetimeLoss;
+          if (p.lifetime <= 0) p.alive = false;
+          this.collisionCount++;
+          if (this.subEmitCallback) this.subEmitCallback(p.x, p.y, p.z, this.subEmitCount);
+        }
+      }
+      for (const sphere of this.spheres) {
+        const dx = p.x - sphere.cx, dy = p.y - sphere.cy, dz = p.z - sphere.cz;
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (dist < sphere.radius && dist > 0) {
+          const nx = dx / dist, ny = dy / dist, nz = dz / dist;
+          const pen = sphere.radius - dist;
+          p.x += nx * pen;
+          p.y += ny * pen;
+          p.z += nz * pen;
+          const vDotN = p.vx * nx + p.vy * ny + p.vz * nz;
+          p.vx = (p.vx - 2 * vDotN * nx) * sphere.bounce;
+          p.vy = (p.vy - 2 * vDotN * ny) * sphere.bounce;
+          p.vz = (p.vz - 2 * vDotN * nz) * sphere.bounce;
+          p.vx *= 1 - sphere.friction;
+          p.vy *= 1 - sphere.friction;
+          p.vz *= 1 - sphere.friction;
+          this.collisionCount++;
+        }
+      }
+    }
+  }
+  getCollisionCount() {
+    return this.collisionCount;
+  }
+};
+
+// src/particles/ParticleForces.ts
+function computeFalloff(distance, radius, type) {
+  if (type === "none" || radius <= 0) return 1;
+  if (distance >= radius) return 0;
+  const t = distance / radius;
+  return type === "linear" ? 1 - t : (1 - t) * (1 - t);
+}
+function simpleNoise3D(x, y, z) {
+  const px = Math.sin(x * 12.9898 + y * 78.233) * 43758.5453;
+  const py = Math.sin(y * 12.9898 + z * 78.233) * 43758.5453;
+  const pz = Math.sin(z * 12.9898 + x * 78.233) * 43758.5453;
+  return {
+    x: (px - Math.floor(px)) * 2 - 1,
+    y: (py - Math.floor(py)) * 2 - 1,
+    z: (pz - Math.floor(pz)) * 2 - 1
+  };
+}
+var ParticleForceSystem = class {
+  fields = /* @__PURE__ */ new Map();
+  time = 0;
+  // ---------------------------------------------------------------------------
+  // Management
+  // ---------------------------------------------------------------------------
+  addForce(config) {
+    this.fields.set(config.id, { config, enabled: true });
+  }
+  removeForce(id) {
+    this.fields.delete(id);
+  }
+  setEnabled(id, enabled) {
+    const f = this.fields.get(id);
+    if (f) f.enabled = enabled;
+  }
+  getForce(id) {
+    return this.fields.get(id);
+  }
+  getForceCount() {
+    return this.fields.size;
+  }
+  // ---------------------------------------------------------------------------
+  // Application
+  // ---------------------------------------------------------------------------
+  /**
+   * Apply all force fields to a set of particles.
+   */
+  apply(particles, dt) {
+    this.time += dt;
+    for (const particle of particles) {
+      if (!particle.alive) continue;
+      for (const field of this.fields.values()) {
+        if (!field.enabled) continue;
+        this.applyForce(particle, field.config, dt);
+      }
+    }
+  }
+  applyForce(p, cfg, dt) {
+    switch (cfg.type) {
+      case "gravity":
+        this.applyGravity(p, cfg, dt);
+        break;
+      case "wind":
+        this.applyWind(p, cfg, dt);
+        break;
+      case "turbulence":
+        this.applyTurbulence(p, cfg, dt);
+        break;
+      case "attractor":
+        this.applyAttractor(p, cfg, dt);
+        break;
+      case "vortex":
+        this.applyVortex(p, cfg, dt);
+        break;
+      case "drag":
+        this.applyDrag(p, cfg, dt);
+        break;
+    }
+  }
+  applyGravity(p, cfg, dt) {
+    const dir = cfg.direction ?? { x: 0, y: -1, z: 0 };
+    p.velocity.x += dir.x * cfg.strength * dt;
+    p.velocity.y += dir.y * cfg.strength * dt;
+    p.velocity.z += dir.z * cfg.strength * dt;
+  }
+  applyWind(p, cfg, dt) {
+    const dir = cfg.direction ?? { x: 1, y: 0, z: 0 };
+    const falloff = this.getPositionalFalloff(p, cfg);
+    p.velocity.x += dir.x * cfg.strength * falloff * dt;
+    p.velocity.y += dir.y * cfg.strength * falloff * dt;
+    p.velocity.z += dir.z * cfg.strength * falloff * dt;
+  }
+  applyTurbulence(p, cfg, dt) {
+    const freq = cfg.frequency ?? 1;
+    const noise = simpleNoise3D(
+      p.position.x * freq + this.time,
+      p.position.y * freq + this.time * 0.7,
+      p.position.z * freq + this.time * 1.3
+    );
+    const falloff = this.getPositionalFalloff(p, cfg);
+    p.velocity.x += noise.x * cfg.strength * falloff * dt;
+    p.velocity.y += noise.y * cfg.strength * falloff * dt;
+    p.velocity.z += noise.z * cfg.strength * falloff * dt;
+  }
+  applyAttractor(p, cfg, dt) {
+    const target = cfg.position ?? { x: 0, y: 0, z: 0 };
+    const dx = target.x - p.position.x;
+    const dy = target.y - p.position.y;
+    const dz = target.z - p.position.z;
+    const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (dist < 1e-3) return;
+    const falloff = this.getPositionalFalloff(p, cfg);
+    const force = cfg.strength * falloff / dist;
+    p.velocity.x += dx * force * dt;
+    p.velocity.y += dy * force * dt;
+    p.velocity.z += dz * force * dt;
+  }
+  applyVortex(p, cfg, dt) {
+    const center = cfg.position ?? { x: 0, y: 0, z: 0 };
+    const dx = p.position.x - center.x;
+    const dz = p.position.z - center.z;
+    const dist = Math.sqrt(dx * dx + dz * dz);
+    if (dist < 1e-3) return;
+    const falloff = this.getPositionalFalloff(p, cfg);
+    const force = cfg.strength * falloff / dist;
+    p.velocity.x += -dz * force * dt;
+    p.velocity.z += dx * force * dt;
+  }
+  applyDrag(p, cfg, dt) {
+    const drag2 = cfg.dragCoefficient ?? 0.1;
+    const factor = Math.max(0, 1 - drag2 * dt);
+    p.velocity.x *= factor;
+    p.velocity.y *= factor;
+    p.velocity.z *= factor;
+  }
+  getPositionalFalloff(p, cfg) {
+    if (!cfg.position || !cfg.radius) return 1;
+    const dx = p.position.x - cfg.position.x;
+    const dy = p.position.y - cfg.position.y;
+    const dz = p.position.z - cfg.position.z;
+    const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    return computeFalloff(dist, cfg.radius, cfg.falloff ?? "linear");
+  }
+};
+
+// src/particles/ParticleTurbulence.ts
+var ParticleTurbulence = class {
+  config;
+  constructor(config) {
+    this.config = { strength: 1, frequency: 1, octaves: 1, time: 0, ...config };
+  }
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setStrength(s) {
+    this.config.strength = s;
+  }
+  setFrequency(f) {
+    this.config.frequency = f;
+  }
+  setTime(t) {
+    this.config.time = t;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  // ---------------------------------------------------------------------------
+  // Curl Noise Approximation
+  // ---------------------------------------------------------------------------
+  sampleCurl(x, y, z) {
+    const f = this.config.frequency;
+    const t = this.config.time;
+    let fx = 0, fy = 0, fz = 0;
+    for (let o = 0; o < this.config.octaves; o++) {
+      const scale = Math.pow(2, o);
+      const amp = 1 / scale;
+      fx += Math.sin(y * f * scale + t) * amp - Math.cos(z * f * scale + t * 0.7) * amp;
+      fy += Math.sin(z * f * scale + t * 1.3) * amp - Math.cos(x * f * scale + t * 0.5) * amp;
+      fz += Math.sin(x * f * scale + t * 0.9) * amp - Math.cos(y * f * scale + t * 1.1) * amp;
+    }
+    return {
+      fx: fx * this.config.strength,
+      fy: fy * this.config.strength,
+      fz: fz * this.config.strength
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Application
+  // ---------------------------------------------------------------------------
+  apply(particles, dt) {
+    for (const p of particles) {
+      const curl = this.sampleCurl(p.x, p.y, p.z);
+      p.vx += curl.fx * dt;
+      p.vy += curl.fy * dt;
+      p.vz += curl.fz * dt;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Advance Time
+  // ---------------------------------------------------------------------------
+  tick(dt) {
+    this.config.time += dt;
+  }
+};
+
+// src/particles/ParticleTrait.ts
+var nodeSystems = /* @__PURE__ */ new Map();
+var defaultConfig = {
+  preset: "sparks",
+  followNode: true,
+  autoStart: true
+};
+var affectorRegistry = {
+  gravity: gravity(-9.81),
+  lightGravity: gravity(-2),
+  wind: wind(0.5, 0, 0),
+  turbulence: turbulence(1),
+  drag: drag(0.98),
+  floorBounce: floorBounce(0, 0.6)
+};
+var particleTraitHandler = {
+  name: "particles",
+  defaultConfig,
+  onAttach(node, config, _context) {
+    const nodeId = node.id;
+    const presetConfig = config.preset ? ParticlePresets[config.preset] : ParticlePresets.sparks;
+    if (!presetConfig) return;
+    const emitterConfig = {
+      ...presetConfig,
+      ...config.emitter || {}
+    };
+    if (config.followNode && node.properties?.position) {
+      const pos = node.properties.position;
+      emitterConfig.position = [pos.x || 0, pos.y || 0, pos.z || 0];
+    }
+    const system = new ParticleSystem(emitterConfig);
+    if (config.affectors) {
+      for (const name of config.affectors) {
+        if (affectorRegistry[name]) {
+          system.addAffector(affectorRegistry[name]);
+        }
+      }
+    }
+    system.setEmitting(config.autoStart !== false);
+    if (emitterConfig.burst && config.autoStart !== false) {
+      system.burst(emitterConfig.burst);
+    }
+    nodeSystems.set(nodeId, system);
+  },
+  onDetach(node, _config, _context) {
+    nodeSystems.delete(node.id);
+  },
+  onUpdate(node, config, _context, delta) {
+    const system = nodeSystems.get(node.id);
+    if (!system) return;
+    if (config.followNode && node.properties?.position) {
+      const pos = node.properties.position;
+      system.setPosition(pos.x || 0, pos.y || 0, pos.z || 0);
+    }
+    system.update(delta);
+    if (node.properties) {
+      node.properties._particles = system.getAliveParticles();
+      node.properties._particleCount = system.getActiveCount();
+    }
+  }
+};
+function getNodeParticleSystem(nodeId) {
+  return nodeSystems.get(nodeId);
+}
+
+export {
+  ParticleSystem,
+  gravity,
+  wind,
+  turbulence,
+  drag,
+  attractor,
+  vortex,
+  floorBounce,
+  sizeOscillate,
+  ParticlePresets,
+  ParticleAttractorSystem,
+  ParticleEmitter,
+  ParticleCollisionSystem,
+  ParticleForceSystem,
+  ParticleTurbulence,
+  particleTraitHandler,
+  getNodeParticleSystem,
+  particles_exports
+};