@zylem/behaviors 0.2.0 → 0.3.1

package/dist/chunk-7JJEIADR.js

@@ -0,0 +1,2631 @@
+// src/lib/behaviors/particle-emitter/preset-builder.ts
+import {
+  AdditiveBlending as AdditiveBlending2,
+  Color
+} from "three";
+
+// src/lib/behaviors/particle-emitter/gpu/particles.ts
+import * as THREE3 from "three/webgpu";
+import { texture as texture2, uniform, instancedArray } from "three/tsl";
+
+// src/lib/behaviors/particle-emitter/gpu/types.ts
+var EASE_FUNCTIONS = [
+  "easeLinear",
+  "easeInPower1",
+  "easeOutPower1",
+  "easeInOutPower1",
+  "easeInPower2",
+  "easeOutPower2",
+  "easeInOutPower2",
+  "easeInPower3",
+  "easeOutPower3",
+  "easeInOutPower3",
+  "easeInPower4",
+  "easeOutPower4",
+  "easeInOutPower4",
+  "easeInQuad",
+  "easeOutQuad",
+  "easeInOutQuad",
+  "easeInCubic",
+  "easeOutCubic",
+  "easeInOutCubic",
+  "easeInQuart",
+  "easeOutQuart",
+  "easeInOutQuart",
+  "easeInQuint",
+  "easeOutQuint",
+  "easeInOutQuint",
+  "easeInSine",
+  "easeOutSine",
+  "easeInOutSine",
+  "easeInExpo",
+  "easeOutExpo",
+  "easeInOutExpo",
+  "easeInCirc",
+  "easeOutCirc",
+  "easeInOutCirc",
+  "easeInElastic",
+  "easeOutElastic",
+  "easeInOutElastic",
+  "easeInBack",
+  "easeOutBack",
+  "easeInOutBack"
+];
+
+// src/lib/behaviors/particle-emitter/gpu/textures.ts
+import * as THREE from "three/webgpu";
+function createTextureAtlas(textures, onLoad, size = 512, filter) {
+  if (!textures || textures.length === 0) return null;
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  const count = textures.length;
+  canvas.width = size * count;
+  canvas.height = size;
+  let loadedCount = 0;
+  let imagesLoaded = 0;
+  textures.forEach((texture3, i) => {
+    const img = texture3.image;
+    if (img && img.complete && img.width > 0) {
+      ctx.drawImage(img, i * size, 0, size, size);
+      imagesLoaded++;
+    } else {
+      const checkAndDraw = () => {
+        const ready = texture3.image;
+        if (ready && ready.complete && ready.width > 0) {
+          ctx.drawImage(ready, i * size, 0, size, size);
+          loadedCount++;
+          if (loadedCount === count - imagesLoaded) {
+            atlasTexture.needsUpdate = true;
+            if (onLoad) onLoad();
+          }
+        } else {
+          setTimeout(checkAndDraw, 100);
+        }
+      };
+      checkAndDraw();
+    }
+  });
+  const atlasTexture = new THREE.CanvasTexture(canvas);
+  if (filter !== void 0) {
+    atlasTexture.minFilter = filter;
+    atlasTexture.magFilter = filter;
+  }
+  atlasTexture.needsUpdate = true;
+  return atlasTexture;
+}
+function createColorGradientTexture(rows, width = 512) {
+  let safeRows = rows;
+  if (!safeRows || safeRows.length === 0) safeRows = [[{ color: "white", stop: 0 }]];
+  const normalized = safeRows.map((row) => {
+    const sorted = [...row].sort((a, b) => a.stop - b.stop);
+    if (sorted[0].stop > 0) sorted.unshift({ color: sorted[0].color, stop: 0 });
+    if (sorted[sorted.length - 1].stop < 1)
+      sorted.push({ color: sorted[sorted.length - 1].color, stop: 1 });
+    return sorted;
+  });
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  canvas.width = width;
+  canvas.height = normalized.length;
+  for (let y = 0; y < normalized.length; y++) {
+    const stops = normalized[y];
+    const g = ctx.createLinearGradient(0, 0, width, 0);
+    for (const s of stops) g.addColorStop(THREE.MathUtils.clamp(s.stop, 0, 1), s.color);
+    ctx.fillStyle = g;
+    ctx.fillRect(0, y, width, 1);
+  }
+  const tex = new THREE.CanvasTexture(canvas);
+  tex.minFilter = THREE.LinearFilter;
+  tex.magFilter = THREE.LinearFilter;
+  tex.wrapS = THREE.ClampToEdgeWrapping;
+  tex.wrapT = THREE.ClampToEdgeWrapping;
+  tex.needsUpdate = true;
+  return tex;
+}
+
+// src/lib/behaviors/particle-emitter/gpu/nodes.ts
+import * as THREE2 from "three/webgpu";
+import {
+  normalize,
+  max,
+  varying,
+  If as If2,
+  distance,
+  Discard,
+  select as select2,
+  length,
+  range,
+  instanceIndex,
+  vec3,
+  float as float2,
+  mix,
+  vec4,
+  Fn as Fn2,
+  vec2,
+  smoothstep,
+  uv,
+  uint,
+  modelWorldMatrix,
+  transpose,
+  mat3,
+  bool
+} from "three/tsl";
+
+// src/lib/behaviors/particle-emitter/gpu/easing.ts
+import { PI, float, mul, sub, pow, add, cos, sin, sqrt, select, Fn, If, Switch } from "three/tsl";
+var easeLinear = /* @__PURE__ */ Fn(([t]) => t, { t: "float", return: "float" });
+var easeInPower1 = /* @__PURE__ */ Fn(([t]) => t, { t: "float", return: "float" });
+var easeOutPower1 = /* @__PURE__ */ Fn(([t]) => sub(1, sub(1, t)), {
+  t: "float",
+  return: "float"
+});
+var easeInOutPower1 = /* @__PURE__ */ Fn(([t]) => t, { t: "float", return: "float" });
+var easeInPower2 = /* @__PURE__ */ Fn(([t]) => t.mul(t), { t: "float", return: "float" });
+var easeOutPower2 = /* @__PURE__ */ Fn(([t]) => sub(1, pow(sub(1, t), 2)), {
+  t: "float",
+  return: "float"
+});
+var easeInOutPower2 = /* @__PURE__ */ Fn(
+  ([t]) => select(
+    t.lessThan(0.5),
+    mul(2, t).mul(t),
+    sub(1, pow(float(-2).mul(t).add(2), 2).div(2))
+  ),
+  { t: "float", return: "float" }
+);
+var easeInPower3 = /* @__PURE__ */ Fn(([t]) => t.mul(t).mul(t), {
+  t: "float",
+  return: "float"
+});
+var easeOutPower3 = /* @__PURE__ */ Fn(([t]) => sub(1, pow(sub(1, t), 3)), {
+  t: "float",
+  return: "float"
+});
+var easeInOutPower3 = /* @__PURE__ */ Fn(
+  ([t]) => select(
+    t.lessThan(0.5),
+    mul(4, t).mul(t).mul(t),
+    sub(1, pow(float(-2).mul(t).add(2), 3).div(2))
+  ),
+  { t: "float", return: "float" }
+);
+var easeInPower4 = /* @__PURE__ */ Fn(([t]) => t.mul(t).mul(t).mul(t), {
+  t: "float",
+  return: "float"
+});
+var easeOutPower4 = /* @__PURE__ */ Fn(([t]) => sub(1, pow(sub(1, t), 4)), {
+  t: "float",
+  return: "float"
+});
+var easeInOutPower4 = /* @__PURE__ */ Fn(
+  ([t]) => select(
+    t.lessThan(0.5),
+    mul(8, t).mul(t).mul(t).mul(t),
+    sub(1, pow(float(-2).mul(t).add(2), 4).div(2))
+  ),
+  { t: "float", return: "float" }
+);
+var easeInQuad = /* @__PURE__ */ Fn(([t]) => t.mul(t), { t: "float", return: "float" });
+var easeOutQuad = /* @__PURE__ */ Fn(([t]) => t.mul(sub(2, t)), {
+  t: "float",
+  return: "float"
+});
+var easeInOutQuad = /* @__PURE__ */ Fn(
+  ([t]) => select(t.lessThan(0.5), mul(2, t).mul(t), float(-1).add(sub(4, mul(2, t)).mul(t))),
+  { t: "float", return: "float" }
+);
+var easeInCubic = /* @__PURE__ */ Fn(([t]) => t.mul(t).mul(t), {
+  t: "float",
+  return: "float"
+});
+var easeOutCubic = /* @__PURE__ */ Fn(
+  ([t]) => {
+    const t1 = t.sub(1);
+    return add(1, t1.mul(t1).mul(t1));
+  },
+  { t: "float", return: "float" }
+);
+var easeInOutCubic = /* @__PURE__ */ Fn(
+  ([t]) => select(
+    t.lessThan(0.5),
+    mul(4, t).mul(t).mul(t),
+    t.sub(1).mul(mul(2, t).sub(2)).mul(mul(2, t).sub(2)).add(1)
+  ),
+  { t: "float", return: "float" }
+);
+var easeInQuart = /* @__PURE__ */ Fn(([t]) => t.mul(t).mul(t).mul(t), {
+  t: "float",
+  return: "float"
+});
+var easeOutQuart = /* @__PURE__ */ Fn(
+  ([t]) => {
+    const t1 = t.sub(1);
+    return sub(1, t1.mul(t1).mul(t1).mul(t1));
+  },
+  { t: "float", return: "float" }
+);
+var easeInOutQuart = /* @__PURE__ */ Fn(
+  ([t]) => {
+    const t1 = t.sub(1);
+    return select(
+      t.lessThan(0.5),
+      mul(8, t).mul(t).mul(t).mul(t),
+      sub(1, mul(8, t1).mul(t1).mul(t1).mul(t1))
+    );
+  },
+  { t: "float", return: "float" }
+);
+var easeInQuint = /* @__PURE__ */ Fn(([t]) => t.mul(t).mul(t).mul(t).mul(t), {
+  t: "float",
+  return: "float"
+});
+var easeOutQuint = /* @__PURE__ */ Fn(
+  ([t]) => {
+    const t1 = t.sub(1);
+    return add(1, t1.mul(t1).mul(t1).mul(t1).mul(t1));
+  },
+  { t: "float", return: "float" }
+);
+var easeInOutQuint = /* @__PURE__ */ Fn(
+  ([t]) => {
+    const t1 = t.sub(1);
+    return select(
+      t.lessThan(0.5),
+      mul(16, t).mul(t).mul(t).mul(t).mul(t),
+      add(1, mul(16, t1).mul(t1).mul(t1).mul(t1).mul(t1))
+    );
+  },
+  { t: "float", return: "float" }
+);
+var easeInSine = /* @__PURE__ */ Fn(
+  ([t]) => float(-1).mul(cos(t.mul(PI).mul(0.5))).add(1),
+  { t: "float", return: "float" }
+);
+var easeOutSine = /* @__PURE__ */ Fn(([t]) => sin(t.mul(PI).mul(0.5)), {
+  t: "float",
+  return: "float"
+});
+var easeInOutSine = /* @__PURE__ */ Fn(([t]) => float(-0.5).mul(cos(PI.mul(t)).sub(1)), {
+  t: "float",
+  return: "float"
+});
+var easeInExpo = /* @__PURE__ */ Fn(
+  ([t]) => select(t.equal(0), 0, pow(2, mul(10, t.sub(1)))),
+  { t: "float", return: "float" }
+);
+var easeOutExpo = /* @__PURE__ */ Fn(
+  ([t]) => select(t.equal(1), 1, sub(1, pow(2, float(-10).mul(t)))),
+  { t: "float", return: "float" }
+);
+var easeInOutExpo = /* @__PURE__ */ Fn(
+  ([t]) => {
+    If(t.equal(0).or(t.equal(1)), () => t);
+    return select(
+      t.lessThan(0.5),
+      mul(0.5, pow(2, mul(20, t).sub(10))),
+      mul(0.5, pow(2, float(-20).mul(t).add(10)).negate().add(2))
+    );
+  },
+  { t: "float", return: "float" }
+);
+var easeInCirc = /* @__PURE__ */ Fn(
+  ([t]) => float(-1).mul(sqrt(sub(1, t.mul(t))).sub(1)),
+  { t: "float", return: "float" }
+);
+var easeOutCirc = /* @__PURE__ */ Fn(
+  ([t]) => {
+    const t1 = t.sub(1);
+    return sqrt(sub(1, t1.mul(t1)));
+  },
+  { t: "float", return: "float" }
+);
+var easeInOutCirc = /* @__PURE__ */ Fn(
+  ([t]) => {
+    const t1 = mul(2, t);
+    const t2 = t1.sub(2);
+    return select(
+      t.lessThan(0.5),
+      float(-0.5).mul(sqrt(sub(1, t1.mul(t1))).sub(1)),
+      mul(0.5, sqrt(sub(1, t2.mul(t2))).add(1))
+    );
+  },
+  { t: "float", return: "float" }
+);
+var easeInElastic = /* @__PURE__ */ Fn(
+  ([t]) => {
+    If(t.equal(0).or(t.equal(1)), () => t);
+    return pow(2, mul(10, t.sub(1))).negate().mul(sin(t.sub(1.075).mul(mul(2, PI)).div(0.3)));
+  },
+  { t: "float", return: "float" }
+);
+var easeOutElastic = /* @__PURE__ */ Fn(
+  ([t]) => {
+    If(t.equal(0).or(t.equal(1)), () => t);
+    return pow(2, float(-10).mul(t)).mul(sin(t.sub(0.075).mul(mul(2, PI)).div(0.3))).add(1);
+  },
+  { t: "float", return: "float" }
+);
+var easeInOutElastic = /* @__PURE__ */ Fn(
+  ([t]) => {
+    If(
+      t.lessThan(0.5),
+      () => float(-0.5).mul(pow(2, mul(20, t).sub(10))).mul(sin(mul(20, t).sub(11.125).mul(mul(2, PI)).div(4.5)))
+    );
+    return pow(2, float(-20).mul(t).add(10)).mul(sin(mul(20, t).sub(11.125).mul(mul(2, PI)).div(4.5))).mul(0.5).add(1);
+  },
+  { t: "float", return: "float" }
+);
+var easeInBack = /* @__PURE__ */ Fn(
+  ([t]) => {
+    const s = float(1.70158);
+    return t.mul(t).mul(s.add(1).mul(t).sub(s));
+  },
+  { t: "float", return: "float" }
+);
+var easeOutBack = /* @__PURE__ */ Fn(
+  ([t]) => {
+    const s = float(1.70158);
+    const t1 = t.sub(1);
+    return t1.mul(t1).mul(s.add(1).mul(t1).add(s)).add(1);
+  },
+  { t: "float", return: "float" }
+);
+var easeInOutBack = /* @__PURE__ */ Fn(
+  ([t_immutable]) => {
+    const t = t_immutable.toVar();
+    const s = float(1.70158 * 1.525);
+    t.mulAssign(2);
+    If(t.lessThan(1), () => mul(0.5, t.mul(t).mul(s.add(1).mul(t).sub(s))));
+    t.subAssign(2);
+    return mul(0.5, t.mul(t).mul(s.add(1).mul(t).add(s)).add(2));
+  },
+  { t: "float", return: "float" }
+);
+var applyEasing = /* @__PURE__ */ Fn(
+  ([t, easingId]) => {
+    Switch(easingId).Case(0, () => easeLinear(t)).Case(1, () => easeInPower1(t)).Case(2, () => easeOutPower1(t)).Case(3, () => easeInOutPower1(t)).Case(4, () => easeInPower2(t)).Case(5, () => easeOutPower2(t)).Case(6, () => easeInOutPower2(t)).Case(7, () => easeInPower3(t)).Case(8, () => easeOutPower3(t)).Case(9, () => easeInOutPower3(t)).Case(10, () => easeInPower4(t)).Case(11, () => easeOutPower4(t)).Case(12, () => easeInOutPower4(t)).Case(13, () => easeInQuad(t)).Case(14, () => easeOutQuad(t)).Case(15, () => easeInOutQuad(t)).Case(16, () => easeInCubic(t)).Case(17, () => easeOutCubic(t)).Case(18, () => easeInOutCubic(t)).Case(19, () => easeInQuart(t)).Case(20, () => easeOutQuart(t)).Case(21, () => easeInOutQuart(t)).Case(22, () => easeInQuint(t)).Case(23, () => easeOutQuint(t)).Case(24, () => easeInOutQuint(t)).Case(25, () => easeInSine(t)).Case(26, () => easeOutSine(t)).Case(27, () => easeInOutSine(t)).Case(28, () => easeInExpo(t)).Case(29, () => easeOutExpo(t)).Case(30, () => easeInOutExpo(t)).Case(31, () => easeInCirc(t)).Case(32, () => easeOutCirc(t)).Case(33, () => easeInOutCirc(t)).Case(34, () => easeInElastic(t)).Case(35, () => easeOutElastic(t)).Case(36, () => easeInOutElastic(t)).Case(37, () => easeInBack(t)).Case(38, () => easeOutBack(t)).Case(39, () => easeInOutBack(t));
+    return t;
+  },
+  { t: "float", easingId: "int", return: "float" }
+);
+
+// src/lib/behaviors/particle-emitter/gpu/nodes.ts
+var idx7 = instanceIndex.mul(7);
+var idx3 = instanceIndex.mul(3);
+var idx2 = instanceIndex.mul(2);
+var vProgress = varying(float2(0), "vProgress");
+var positionNode = /* @__PURE__ */ Fn2(
+  ([pos, age, duration, vProgress2, uGravity, dir, speed, worldUpRight, easingIndex]) => {
+    const progress = age.div(duration);
+    const _pos = vec3(pos);
+    If2(progress.lessThan(0).or(progress.greaterThan(1)), () => {
+      vProgress2.assign(1);
+      _pos.assign(vec3(0, 9999, 0));
+    }).Else(() => {
+      vProgress2.assign(applyEasing(progress, easingIndex));
+      const normalizedDirection = select2(length(dir).greaterThan(0), normalize(dir), vec3(0));
+      const gravityForce = uGravity.mul(0.5).mul(age.mul(age));
+      const easedAge = vProgress2.mul(duration);
+      const offset = normalizedDirection.mul(easedAge).mul(speed).add(gravityForce);
+      If2(worldUpRight, () => {
+        const m = mat3(modelWorldMatrix);
+        const rot = mat3(normalize(m[0]), normalize(m[1]), normalize(m[2]));
+        const inverseRotation = transpose(rot);
+        const worldOffset = inverseRotation.mul(offset);
+        const blendedOffset = mix(offset, worldOffset, vProgress2);
+        _pos.addAssign(blendedOffset);
+      }).Else(() => {
+        _pos.addAssign(offset);
+      });
+    });
+    return _pos;
+  }
+);
+var rotationNode = /* @__PURE__ */ Fn2(([rot, rotSpeed, age]) => {
+  const tau = float2(Math.PI * 2).toConst();
+  const init = rot.z.add(1).mul(0.5).mul(tau);
+  const angle = init.add(rotSpeed.z.mul(age));
+  const wrapped = angle.mod(tau);
+  return wrapped.add(tau).mod(tau);
+});
+var scaleNode = /* @__PURE__ */ Fn2(([fadeSize, scale, vProgress2]) => {
+  const uFadeSize = vec2(fadeSize[0], fadeSize[1]).toVar();
+  return smoothstep(0, uFadeSize.x, vProgress2).mul(smoothstep(1.01, uFadeSize.y, vProgress2)).mul(scale);
+});
+var colorNode = /* @__PURE__ */ Fn2(
+  ([
+    colors,
+    intensity,
+    fadeAlpha,
+    fadeAlphaMap,
+    vProgress2,
+    uColorGradient,
+    uAlphaMapCount,
+    vAlphaMapUVOffsetX,
+    vAlphaMapUVOffsetY,
+    alphaMap
+  ]) => {
+    const vColorGradientRow = range(0, colors.length - 1).toVar();
+    const uColorGradientRows = float2(colors.length).toVar();
+    const uIntensity = float2(intensity).toVar();
+    const uFadeAlpha = vec2(fadeAlpha[0], fadeAlpha[1]).toVar();
+    const uFadeAlphaMap = vec2(fadeAlphaMap[0], fadeAlphaMap[1]).toVar();
+    const u = vProgress2;
+    const v = vColorGradientRow.add(0.5).div(max(uColorGradientRows, 1));
+    const finalColor = uColorGradient.sample(vec2(u, v)).rgb;
+    finalColor.mulAssign(uIntensity);
+    const alpha = smoothstep(0, uFadeAlpha.x, vProgress2).mul(
+      smoothstep(1.01, uFadeAlpha.y, vProgress2)
+    );
+    const vUv = uv();
+    If2(uAlphaMapCount.equal(0), () => {
+      const center = vec2(0.5).toVar();
+      const dist = distance(vUv, center);
+      const radius = float2(0.5);
+      const feather = float2(0.98);
+      const _alpha = float2(1).sub(smoothstep(radius.sub(feather), radius, dist));
+      alpha.assign(_alpha.mul(alpha));
+      If2(_alpha.lessThan(0.01), () => Discard());
+    }).ElseIf(uAlphaMapCount.greaterThan(0), () => {
+      const startU = vAlphaMapUVOffsetX.add(vUv.x).div(uAlphaMapCount);
+      const startUV = vec2(startU, vUv.y);
+      const startAlpha = alphaMap.sample(startUV).a;
+      If2(uAlphaMapCount.greaterThan(1), () => {
+        const endU = vAlphaMapUVOffsetY.add(vUv.x).div(uAlphaMapCount);
+        const endUV = vec2(endU, vUv.y);
+        const endAlpha = alphaMap.sample(endUV).a;
+        const morphProgress = smoothstep(uFadeAlphaMap.x, uFadeAlphaMap.y, vProgress2);
+        const morphedAlpha = mix(startAlpha, endAlpha, morphProgress);
+        alpha.assign(morphedAlpha.mul(alpha));
+      }).Else(() => {
+        alpha.assign(startAlpha.mul(alpha));
+      });
+    });
+    return vec4(finalColor, alpha);
+  }
+);
+var InstancePositionNode = class extends THREE2.Node {
+  constructor() {
+    super("vec3");
+    this.updateType = THREE2.NodeUpdateType.OBJECT;
+  }
+  setup(frame) {
+    const mesh = frame.object;
+    const { attributes, uniforms, config, easingIndex } = mesh.userData;
+    const uPosition = uniforms.uPosition;
+    const _static = float2(config.emitter.static).toVar();
+    const posX = attributes.instance.element(idx7.add(0));
+    const posY = attributes.instance.element(idx7.add(1));
+    const posZ = attributes.instance.element(idx7.add(2));
+    const pos = vec3(posX, posY, posZ).add(uPosition.mul(_static));
+    const dirX = attributes.instanceDirection.element(idx3.add(0));
+    const dirY = attributes.instanceDirection.element(idx3.add(1));
+    const dirZ = attributes.instanceDirection.element(idx3.add(2));
+    const dir = vec3(dirX, dirY, dirZ);
+    const time = uniforms.uTime;
+    const uGravity = vec3(...config.particles.gravity);
+    const worldUpRight = bool(config.emitter.worldUpRight);
+    const startTime = attributes.instanceLifetime.element(idx2.add(0));
+    const duration = attributes.instanceLifetime.element(idx2.add(1));
+    const speed = attributes.instanceSpeed.element(instanceIndex).toVar();
+    const age = select2(speed.lessThan(0), duration.sub(time.sub(startTime)), time.sub(startTime));
+    return positionNode(pos, age, duration, vProgress, uGravity, dir, speed, worldUpRight, easingIndex);
+  }
+};
+var InstanceRotationNode = class extends THREE2.Node {
+  constructor() {
+    super("vec3");
+    this.updateType = THREE2.NodeUpdateType.OBJECT;
+  }
+  setup(frame) {
+    const mesh = frame.object;
+    const { attributes, uniforms } = mesh.userData;
+    const rotX = attributes.instance.element(idx7.add(3));
+    const rotY = attributes.instance.element(idx7.add(4));
+    const rotZ = attributes.instance.element(idx7.add(5));
+    const rot = vec3(rotX, rotY, rotZ);
+    const rotSpeedX = attributes.instanceRotationSpeed.element(idx3.add(0));
+    const rotSpeedY = attributes.instanceRotationSpeed.element(idx3.add(1));
+    const rotSpeedZ = attributes.instanceRotationSpeed.element(idx3.add(2));
+    const rotSpeed = vec3(rotSpeedX, rotSpeedY, rotSpeedZ);
+    const time = uniforms.uTime;
+    const startTime = attributes.instanceLifetime.element(idx2.add(0));
+    const duration = attributes.instanceLifetime.element(idx2.add(1));
+    const speed = attributes.instanceSpeed.element(instanceIndex).toVar();
+    const age = select2(speed.lessThan(0), duration.sub(time.sub(startTime)), time.sub(startTime));
+    return rotationNode(rot, rotSpeed, age);
+  }
+};
+var InstanceScaleNode = class extends THREE2.Node {
+  constructor() {
+    super("vec3");
+    this.updateType = THREE2.NodeUpdateType.OBJECT;
+  }
+  setup(frame) {
+    const mesh = frame.object;
+    const { attributes, config } = mesh.userData;
+    const scale = attributes.instance.element(idx7.add(6));
+    return scaleNode(config.particles.fadeSize, scale, vProgress);
+  }
+};
+var InstanceColorNode = class extends THREE2.Node {
+  constructor() {
+    super("vec3");
+    this.updateType = THREE2.NodeUpdateType.OBJECT;
+  }
+  setup(frame) {
+    const mesh = frame.object;
+    const { attributes, uniforms, config, alphaMapCount } = mesh.userData;
+    const uAlphaMapCount = uint(alphaMapCount).toVar();
+    const vAlphaMapUVOffsetX = attributes.instanceAlphaMapUVOffset.element(idx2.add(0));
+    const vAlphaMapUVOffsetY = attributes.instanceAlphaMapUVOffset.element(idx2.add(1));
+    return colorNode(
+      config.particles.colors,
+      config.particles.intensity,
+      config.particles.fadeAlpha,
+      config.particles.fadeAlphaMap,
+      vProgress,
+      uniforms.uColorGradient,
+      uAlphaMapCount,
+      vAlphaMapUVOffsetX,
+      vAlphaMapUVOffsetY,
+      uniforms.alphaMap
+    );
+  }
+};
+function createParticleMaterialTemplate() {
+  const mat = new THREE2.SpriteNodeMaterial();
+  mat.positionNode = new InstancePositionNode();
+  mat.rotationNode = new InstanceRotationNode();
+  mat.scaleNode = new InstanceScaleNode();
+  mat.colorNode = new InstanceColorNode();
+  return mat;
+}
+
+// src/lib/behaviors/particle-emitter/gpu/utils.ts
+function randFloat(min, max2) {
+  return Math.random() * (max2 - min) + min;
+}
+function randInt(min, max2) {
+  return Math.floor(Math.random() * (max2 - min + 1)) + min;
+}
+
+// src/lib/behaviors/particle-emitter/gpu/particles.ts
+var Particles = class extends THREE3.Object3D {
+  mesh;
+  /** Base object for positioning the emitter. */
+  base;
+  debugMesh;
+  material;
+  config;
+  uniforms;
+  buffers;
+  attributes;
+  easingIndex = 0;
+  alphaMapCount = 0;
+  emitted = 0;
+  cursor = 0;
+  /** Whether the particle system is currently running. */
+  running = false;
+  constructor(config, geometry) {
+    super();
+    this.name = "Particles";
+    this.type = "Particles";
+    this.base = new THREE3.Object3D();
+    this.base.name = "Base";
+    this.add(this.base);
+    this.debugMesh = new THREE3.Mesh(
+      new THREE3.BoxGeometry(0.2, 0.2, 0.2),
+      new THREE3.MeshBasicMaterial({ color: 16777215, wireframe: true })
+    );
+    this.debugMesh.name = "Debug";
+    this.base.add(this.debugMesh);
+    const p = config.particles;
+    const r = config.render ?? {};
+    const e = config.emitter ?? {};
+    this.config = {
+      particles: {
+        count: p.count ?? 1e3,
+        intensity: p.intensity ?? 1,
+        fadeSize: p.fadeSize ?? [0.1, 0.9],
+        fadeAlpha: p.fadeAlpha ?? [0, 1],
+        fadeAlphaMap: p.fadeAlphaMap ?? [0, 1],
+        gravity: p.gravity ?? [0, 0, 0],
+        alphaMapsStart: p.alphaMapsStart ?? [],
+        alphaMapsEnd: p.alphaMapsEnd ?? [],
+        colors: p.colors ?? [[{ color: "#ffffff", stop: 0 }]],
+        appearance: p.appearance ?? 0,
+        easeFunction: p.easeFunction ?? "easeLinear"
+      },
+      render: {
+        alphaMapSize: r.alphaMapSize ?? 256,
+        alphaMapFilter: r.alphaMapFilter ?? THREE3.LinearFilter,
+        frustumCulled: r.frustumCulled ?? true,
+        blendingMode: r.blendingMode ?? THREE3.AdditiveBlending,
+        side: r.side ?? THREE3.FrontSide,
+        depthTest: r.depthTest ?? true
+      },
+      emitter: {
+        duration: e.duration ?? 1,
+        rate: e.rate ?? 1e3,
+        spawnMode: e.spawnMode ?? "time",
+        static: e.static ?? 0,
+        worldUpRight: e.worldUpRight ?? false,
+        loop: e.loop ?? false,
+        delay: e.delay ?? 0,
+        debug: e.debug ?? false,
+        lifetime: e.lifetime ?? [0.1, 1],
+        speed: e.speed ?? [5, 20],
+        size: e.size ?? [0.1, 1],
+        startPositionMin: e.startPositionMin ?? [0, 0, 0],
+        startPositionMax: e.startPositionMax ?? [0, 0, 0],
+        startRotationMin: e.startRotationMin ?? [0, 0, 0],
+        startRotationMax: e.startRotationMax ?? [0, 0, 0],
+        rotationSpeedMin: e.rotationSpeedMin ?? [0, 0, 0],
+        rotationSpeedMax: e.rotationSpeedMax ?? [0, 0, 0],
+        directionMin: e.directionMin ?? [0, 0, 0],
+        directionMax: e.directionMax ?? [0, 0, 0]
+      }
+    };
+    this.debugMesh.visible = this.config.emitter.debug;
+    this.easingIndex = EASE_FUNCTIONS.indexOf(this.config.particles.easeFunction);
+    if (this.easingIndex < 0) this.easingIndex = 0;
+    const alphaMaps = [
+      ...this.config.particles.alphaMapsStart ?? [],
+      ...this.config.particles.alphaMapsEnd ?? []
+    ];
+    this.alphaMapCount = alphaMaps.length;
+    let atlas = null;
+    if (alphaMaps.length > 0) {
+      atlas = createTextureAtlas(
+        alphaMaps,
+        void 0,
+        this.config.render.alphaMapSize,
+        this.config.render.alphaMapFilter
+      );
+    } else {
+      const canvas = document.createElement("canvas");
+      atlas = new THREE3.CanvasTexture(canvas);
+    }
+    const colorGradientTexture = createColorGradientTexture(this.config.particles.colors, 128);
+    this.uniforms = {
+      cursor: uniform(0),
+      rate: uniform(0),
+      uTime: uniform(0),
+      uPosition: uniform(this.base.position),
+      alphaMap: texture2(atlas),
+      uColorGradient: texture2(colorGradientTexture)
+    };
+    const defaultGeometry = geometry ?? new THREE3.PlaneGeometry(0.5, 0.5);
+    const count = this.config.particles.count;
+    this.buffers = {
+      instanceLifetime: new Float32Array(count * 2),
+      instance: new Float32Array(count * 7),
+      instanceDirection: new Float32Array(count * 3),
+      instanceRotationSpeed: new Float32Array(count * 3),
+      instanceAlphaMapUVOffset: new Float32Array(count * 2),
+      instanceSpeed: new Float32Array(count)
+    };
+    this.attributes = {
+      instanceLifetime: instancedArray(this.buffers.instanceLifetime, "float"),
+      instance: instancedArray(this.buffers.instance, "float"),
+      instanceDirection: instancedArray(this.buffers.instanceDirection, "float"),
+      instanceRotationSpeed: instancedArray(this.buffers.instanceRotationSpeed, "float"),
+      instanceAlphaMapUVOffset: instancedArray(this.buffers.instanceAlphaMapUVOffset, "float"),
+      instanceSpeed: instancedArray(this.buffers.instanceSpeed, "float")
+    };
+    this.material = this.createMaterial();
+    this.mesh = new THREE3.InstancedMesh(defaultGeometry, this.material, count);
+    this.mesh.userData = {
+      attributes: this.attributes,
+      uniforms: this.uniforms,
+      config: this.config,
+      alphaMapCount: this.alphaMapCount,
+      easingIndex: this.easingIndex
+    };
+    this.add(this.mesh);
+    this.mesh.frustumCulled = this.config.render.frustumCulled ?? false;
+  }
+  createMaterial() {
+    const _mat = createParticleMaterialTemplate();
+    _mat.blending = this.config.render.blendingMode;
+    _mat.premultipliedAlpha = this.config.render.blendingMode === THREE3.SubtractiveBlending || this.config.render.blendingMode === THREE3.MultiplyBlending;
+    _mat.depthWrite = false;
+    _mat.side = this.config.render.side;
+    _mat.depthTest = this.config.render.depthTest;
+    _mat.transparent = true;
+    return _mat;
+  }
+  /** Starts the particle system from the beginning. */
+  start() {
+    this.running = true;
+    this.uniforms.uTime.value = 0;
+    this.cursor = 0;
+    this.emitted = 0;
+    this.visible = true;
+    this.mesh.visible = true;
+    this.attributes.instanceLifetime.value.array.fill(0);
+  }
+  /** Restarts (alias for start). */
+  restart() {
+    this.start();
+  }
+  /** Pauses the particle system, keeping current state. */
+  pause() {
+    this.running = false;
+  }
+  /** Resumes a paused system without resetting its state. */
+  resume() {
+    this.running = true;
+    this.visible = true;
+    this.mesh.visible = true;
+  }
+  /** Stops the particle system and hides it. */
+  stop() {
+    this.running = false;
+    this.visible = false;
+    this.mesh.visible = false;
+  }
+  /** Whether emission loops continuously. */
+  get looping() {
+    return this.config.emitter.loop;
+  }
+  /**
+   * For non-looping systems, whether all emitted particles have aged past
+   * their maximum lifetime (so the effect is visually finished).
+   */
+  isComplete() {
+    if (this.config.emitter.loop) return false;
+    const e = this.config.emitter;
+    const maxLifetime = e.lifetime[1];
+    const endTime = e.delay + e.duration + maxLifetime;
+    return this.emitted >= e.rate && this.uniforms.uTime.value > endTime;
+  }
+  /** Updates the particle system. Call each frame. */
+  update(delta) {
+    this.mesh.visible = this.visible;
+    if (!this.running) return;
+    this._update();
+    this.uniforms.uTime.value += delta;
+  }
+  _compute(i) {
+    const { emitter } = this.config;
+    const pos = this.uniforms.uPosition.value;
+    const dynamicFactor = 1 - emitter.static;
+    const inst = this.attributes.instance.value.array;
+    const i7 = i * 7;
+    inst[i7 + 0] = randFloat(emitter.startPositionMin[0], emitter.startPositionMax[0]) + pos.x * dynamicFactor;
+    inst[i7 + 1] = randFloat(emitter.startPositionMin[1], emitter.startPositionMax[1]) + pos.y * dynamicFactor;
+    inst[i7 + 2] = randFloat(emitter.startPositionMin[2], emitter.startPositionMax[2]) + pos.z * dynamicFactor;
+    inst[i7 + 3] = randFloat(emitter.startRotationMin[0], emitter.startRotationMax[0]);
+    inst[i7 + 4] = randFloat(emitter.startRotationMin[1], emitter.startRotationMax[1]);
+    inst[i7 + 5] = randFloat(emitter.startRotationMin[2], emitter.startRotationMax[2]);
+    inst[i7 + 6] = randFloat(emitter.size[0], emitter.size[1]);
+    const i3 = i * 3;
+    const dir = this.attributes.instanceDirection.value.array;
+    dir[i3 + 0] = randFloat(emitter.directionMin[0], emitter.directionMax[0]);
+    dir[i3 + 1] = randFloat(emitter.directionMin[1], emitter.directionMax[1]);
+    dir[i3 + 2] = randFloat(emitter.directionMin[2], emitter.directionMax[2]);
+    const rotSpeed = this.attributes.instanceRotationSpeed.value.array;
+    rotSpeed[i3 + 0] = randFloat(emitter.rotationSpeedMin[0], emitter.rotationSpeedMax[0]);
+    rotSpeed[i3 + 1] = randFloat(emitter.rotationSpeedMin[1], emitter.rotationSpeedMax[1]);
+    rotSpeed[i3 + 2] = randFloat(emitter.rotationSpeedMin[2], emitter.rotationSpeedMax[2]);
+    const i2 = i * 2;
+    const lifetime = this.attributes.instanceLifetime.value.array;
+    lifetime[i2 + 0] = this.uniforms.uTime.value;
+    lifetime[i2 + 1] = randFloat(emitter.lifetime[0], emitter.lifetime[1]);
+    const startCount = this.config.particles.alphaMapsStart?.length ?? 0;
+    const endCount = this.config.particles.alphaMapsEnd?.length ?? 0;
+    const startIdx = startCount > 0 ? randInt(0, startCount - 1) : 0;
+    let endIdx = 0;
+    if (endCount > 0) {
+      endIdx = startCount + randInt(0, endCount - 1);
+    } else if (startCount > 0) {
+      endIdx = randInt(0, startCount - 1);
+    }
+    const alphaOffset = this.attributes.instanceAlphaMapUVOffset.value.array;
+    alphaOffset[i2 + 0] = startIdx;
+    alphaOffset[i2 + 1] = endIdx;
+    this.attributes.instanceSpeed.value.array[i] = randFloat(emitter.speed[0], emitter.speed[1]);
+  }
+  _update() {
+    const loop = this.config.emitter.loop;
+    const spawnMode = this.config.emitter.spawnMode;
+    const maxParticlesTotal = this.config.particles.count;
+    const maxParticles = this.config.emitter.rate;
+    const duration = this.config.emitter.duration;
+    const delay = this.config.emitter.delay;
+    const amount = spawnMode === "burst" ? maxParticles : Math.max(
+      0,
+      Math.floor((this.uniforms.uTime.value - delay) / duration * maxParticles)
+    );
+    const rate = amount - this.emitted;
+    if (this.emitted >= maxParticles && !loop) return;
+    if (spawnMode === "time") {
+      if (this.cursor >= maxParticlesTotal) this.cursor = 0;
+      this.uniforms.cursor.value = this.cursor;
+      this.uniforms.rate.value = rate;
+    }
+    for (let _i = this.cursor; _i < this.cursor + rate; _i++) {
+      this._compute(_i % maxParticlesTotal);
+    }
+    this.attributes.instance.value.needsUpdate = true;
+    this.attributes.instanceDirection.value.needsUpdate = true;
+    this.attributes.instanceRotationSpeed.value.needsUpdate = true;
+    this.attributes.instanceLifetime.value.needsUpdate = true;
+    this.attributes.instanceAlphaMapUVOffset.value.needsUpdate = true;
+    this.attributes.instanceSpeed.value.needsUpdate = true;
+    if (spawnMode === "time") {
+      this.cursor += rate;
+      this.cursor = this.cursor % maxParticlesTotal;
+    }
+    this.emitted += rate;
+  }
+  /** Updates configuration at runtime (shallow per-section merge). */
+  updateConfig(config) {
+    if (config.particles) Object.assign(this.config.particles, config.particles);
+    if (config.render) Object.assign(this.config.render, config.render);
+    if (config.emitter) Object.assign(this.config.emitter, config.emitter);
+  }
+  /** Disposes of all resources used by the particle system. */
+  dispose() {
+    this.stop();
+    this.mesh.geometry.dispose();
+    this.material.dispose();
+  }
+};
+
+// src/lib/behaviors/particle-emitter/preset-builder.ts
+var DEFAULT_MAGIC_BEHAVIOR_BY_ALIGNMENT = {
+  arcane: {
+    temperament: "regal",
+    agency: "reactive",
+    order: "geometric",
+    realityEffect: "warping",
+    intensity: 1
+  },
+  holy: {
+    temperament: "calm",
+    agency: "passive",
+    order: "geometric",
+    realityEffect: "illuminating",
+    intensity: 1
+  },
+  corrupted: {
+    temperament: "ominous",
+    agency: "seeking",
+    order: "chaotic",
+    realityEffect: "decaying",
+    intensity: 1.05
+  },
+  nature: {
+    temperament: "calm",
+    agency: "reactive",
+    order: "organic",
+    realityEffect: "healing",
+    intensity: 0.9
+  },
+  void: {
+    temperament: "ominous",
+    agency: "seeking",
+    order: "chaotic",
+    realityEffect: "warping",
+    intensity: 1.15
+  },
+  psychic: {
+    temperament: "predatory",
+    agency: "sentient-feeling",
+    order: "organic",
+    realityEffect: "binding",
+    intensity: 1
+  }
+};
+var MAGIC_PALETTES = {
+  arcane: { start: "#dbeafe", mid: "#60a5fa", end: "#1d4ed8" },
+  holy: { start: "#fff7d1", mid: "#fde68a", end: "#f59e0b" },
+  corrupted: { start: "#bef264", mid: "#84cc16", end: "#4d7c0f" },
+  nature: { start: "#dcfce7", mid: "#4ade80", end: "#15803d" },
+  void: { start: "#c4b5fd", mid: "#475569", end: "#0f172a" },
+  psychic: { start: "#fce7f3", mid: "#f472b6", end: "#db2777" }
+};
+function particleEffect(create) {
+  return { create };
+}
+function defineSemanticParticlePreset(preset) {
+  return preset;
+}
+function createMagicModifier(alignment, overrides = {}) {
+  return {
+    alignment,
+    ...DEFAULT_MAGIC_BEHAVIOR_BY_ALIGNMENT[alignment],
+    ...overrides
+  };
+}
+function createSemanticParticleEffect(preset, options = {}) {
+  const config = buildParticlesConfig(preset, options);
+  return particleEffect(() => new Particles(config));
+}
+function buildParticlesConfig(preset, options = {}) {
+  const defaults = preset.system.defaults;
+  const magic = normalizeMagicModifier(options.magic);
+  const resolvedShape = mergeShapeConfig(preset.system.shape, options.shape);
+  const baseBehaviors = mergeBehaviorConfig(preset.system.behaviors, options.behaviors);
+  const baseColor = options.color ?? defaults.color;
+  const resolvedColor = magic ? mixColors(baseColor, MAGIC_PALETTES[magic.alignment].start, 0.2) : baseColor;
+  const behaviors = magic ? applyMagicBehaviors(baseBehaviors, resolvedColor, magic) : baseBehaviors;
+  const duration = options.duration ?? defaults.duration;
+  const looping = options.looping ?? defaults.looping ?? preset.system.emission.type === "rate";
+  const life = toRange(options.life ?? defaults.life);
+  const size = toRange(options.size ?? defaults.size);
+  const baseSpeed = toRange(options.speed ?? defaults.speed);
+  const shapeSpeed = resolvedShape && "speed" in resolvedShape ? resolvedShape.speed : void 0;
+  const speed = shapeSpeed !== void 0 ? toRange(addRanges(baseSpeed, shapeSpeed)) : baseSpeed;
+  const intensity = magic ? clamp(magic.intensity ?? 1, 0.5, 1.5) : defaults.opacity ?? 1;
+  const colors = behaviors?.colorOverLife ? [behaviors.colorOverLife.colors.map(([color, stop]) => toGpuColorStop(color, stop))] : [
+    [
+      { color: toHexColor(resolvedColor), stop: 0 },
+      { color: toHexColor(resolvedColor), stop: 1 }
+    ]
+  ];
+  const fadeAlpha = behaviors?.colorOverLife ? deriveFadeFromAlpha(behaviors.colorOverLife.alpha) : [0.1, 0.85];
+  const fadeSize = behaviors?.sizeOverLife ? deriveFadeFromSizeCurve(behaviors.sizeOverLife) : [0.15, 0.9];
+  const gravity = behaviors?.forceOverLife ? forceToGravity(behaviors.forceOverLife) : [0, 0, 0];
+  const easeFunction = behaviors?.speedOverLife ? speedCurveToEase(behaviors.speedOverLife) : "easeLinear";
+  const emission = resolveEmission(preset.system.emission, options, duration, life[1]);
+  const direction = shapeToDirection(resolvedShape);
+  const startPosition = shapeToStartPosition(resolvedShape);
+  const startRotation = rotationToStart(options.rotation ?? defaults.rotation);
+  const rotationSpeed = behaviors?.rotationOverLife ? rangeToRotationSpeedZ(behaviors.rotationOverLife) : { min: [0, 0, 0], max: [0, 0, 0] };
+  const blending = options.blending ?? AdditiveBlending2;
+  const particles = {
+    count: emission.count,
+    intensity,
+    fadeSize,
+    fadeAlpha,
+    gravity,
+    colors,
+    easeFunction
+  };
+  if (options.texture) {
+    particles.alphaMapsStart = [options.texture];
+  }
+  const emitter = {
+    duration,
+    rate: emission.rate,
+    spawnMode: emission.spawnMode,
+    loop: looping,
+    static: 0,
+    worldUpRight: false,
+    lifetime: life,
+    speed,
+    size,
+    directionMin: direction.min,
+    directionMax: direction.max,
+    startPositionMin: startPosition.min,
+    startPositionMax: startPosition.max,
+    startRotationMin: startRotation.min,
+    startRotationMax: startRotation.max,
+    rotationSpeedMin: rotationSpeed.min,
+    rotationSpeedMax: rotationSpeed.max
+  };
+  return {
+    particles,
+    emitter,
+    render: { blendingMode: blending }
+  };
+}
+function resolveEmission(emission, options, duration, maxLifetime) {
+  if (emission.type === "burst") {
+    const count2 = Math.max(1, Math.round(options.count ?? emission.count));
+    return { spawnMode: "burst", rate: count2, count: count2 };
+  }
+  const perSecond = Math.max(0, options.emissionRate ?? emission.rate);
+  const rate = Math.max(1, Math.round(perSecond * Math.max(duration, 1e-4)));
+  const simultaneous = Math.ceil(perSecond * Math.max(maxLifetime, 1e-4) * 1.5);
+  const count = Math.min(2e5, Math.max(rate, simultaneous, 8));
+  return { spawnMode: "time", rate, count };
+}
+function deriveFadeFromAlpha(alpha) {
+  if (!alpha || alpha.length === 0) return [0.1, 0.85];
+  const sorted = [...alpha].sort((a, b) => a[1] - b[1]);
+  const maxAlpha = Math.max(...sorted.map(([value]) => value), 1e-4);
+  let fadeIn = 0.15;
+  for (const [value, stop] of sorted) {
+    if (value >= maxAlpha * 0.6) {
+      fadeIn = stop;
+      break;
+    }
+  }
+  let fadeOut = 0.85;
+  for (const [value, stop] of sorted) {
+    if (value >= maxAlpha * 0.4) fadeOut = stop;
+  }
+  fadeIn = clamp(fadeIn, 0.02, 0.45);
+  fadeOut = clamp(fadeOut, 0.55, 0.99);
+  if (fadeOut <= fadeIn) fadeOut = Math.min(0.99, fadeIn + 0.3);
+  return [fadeIn, fadeOut];
+}
+function deriveFadeFromSizeCurve(points) {
+  const start = points[0];
+  const end = points[3];
+  const fadeIn = start < 0.5 ? 0.25 : 0.02;
+  const fadeOut = end < 0.5 ? 0.75 : 0.98;
+  return [fadeIn, fadeOut];
+}
+function forceToGravity(force) {
+  const mid = (range2) => {
+    if (range2 === void 0) return 0;
+    const [min, max2] = toRange(range2);
+    return (min + max2) * 0.5;
+  };
+  return [mid(force.x), mid(force.y), mid(force.z)];
+}
+function speedCurveToEase(points) {
+  const start = points[0];
+  const end = points[3];
+  if (end < start - 0.05) return "easeOutCubic";
+  if (end > start + 0.05) return "easeInCubic";
+  return "easeLinear";
+}
+function shapeToDirection(shape) {
+  if (!shape || shape.type === "point" || shape.type === "sphere") {
+    return { min: [-1, -1, -1], max: [1, 1, 1] };
+  }
+  const angle = shape.angle ?? 0.3;
+  const spread = Math.tan(clamp(angle, 0, 1.4));
+  return { min: [-spread, 1, -spread], max: [spread, 1, spread] };
+}
+function shapeToStartPosition(shape) {
+  if (!shape || shape.type === "point") {
+    return { min: [0, 0, 0], max: [0, 0, 0] };
+  }
+  const r = shape.radius ?? 0;
+  if (shape.type === "sphere") {
+    return { min: [-r, -r, -r], max: [r, r, r] };
+  }
+  return { min: [-r, 0, -r], max: [r, 0, r] };
+}
+function rotationToStart(rotation) {
+  if (rotation === void 0) {
+    return { min: [0, 0, 0], max: [0, 0, 0] };
+  }
+  const [min, max2] = toRange(rotation);
+  const norm = (theta) => theta / Math.PI - 1;
+  return { min: [0, 0, norm(min)], max: [0, 0, norm(max2)] };
+}
+function rangeToRotationSpeedZ(rotation) {
+  const [min, max2] = toRange(rotation);
+  return { min: [0, 0, min], max: [0, 0, max2] };
+}
+function toGpuColorStop(color, stop) {
+  return { color: toHexColor(color), stop };
+}
+function normalizeMagicModifier(input) {
+  if (!input) return null;
+  if (typeof input === "string") return createMagicModifier(input);
+  return createMagicModifier(input.alignment, input);
+}
+function applyMagicBehaviors(base, baseColor, magic) {
+  const intensity = clamp(magic.intensity ?? 1, 0.25, 1.5);
+  const palette = MAGIC_PALETTES[magic.alignment];
+  return {
+    ...base,
+    colorOverLife: tintColorOverLife(base?.colorOverLife, baseColor, palette, intensity),
+    rotationOverLife: addRanges(base?.rotationOverLife, resolveMagicRotation(magic, intensity)),
+    forceOverLife: mergeForce(base?.forceOverLife, resolveMagicForce(magic, intensity)),
+    noise: mergeNoise(base?.noise, resolveMagicNoise(magic, intensity)),
+    orbitOverLife: resolveMagicOrbit(magic, intensity) ?? base?.orbitOverLife
+  };
+}
+function resolveMagicRotation(magic, intensity) {
+  const amount = 0.7 + intensity * 1.4;
+  switch (magic.order) {
+    case "geometric":
+      return [amount * 0.45, amount];
+    case "organic":
+      return [-amount * 0.55, amount * 0.55];
+    case "chaotic":
+      return [-amount * 2.4, amount * 2.4];
+    default:
+      return void 0;
+  }
+}
+function resolveMagicForce(magic, intensity) {
+  const amount = 0.2 + intensity * 0.55;
+  switch (magic.realityEffect) {
+    case "illuminating":
+    case "healing":
+      return { y: [amount * 0.6, amount] };
+    case "decaying":
+      return { y: [-amount, -amount * 0.5] };
+    case "binding":
+      return { y: [-amount * 0.35, amount * 0.15] };
+    case "warping":
+      return { x: [-amount * 0.35, amount * 0.35], z: [-amount * 0.35, amount * 0.35] };
+    default:
+      return void 0;
+  }
+}
+function resolveMagicNoise(magic, intensity) {
+  const calmMultiplier = magic.temperament === "calm" ? 0.6 : 1;
+  const ominousBoost = magic.temperament === "ominous" ? 1.25 : 1;
+  const basePower = (0.08 + intensity * 0.1) * calmMultiplier * ominousBoost;
+  switch (magic.order) {
+    case "geometric":
+      return {
+        frequency: [1.5, 3.5],
+        power: [basePower * 0.4, basePower * 0.8],
+        positionAmount: [0.08, 0.2],
+        rotationAmount: [0.1, 0.2]
+      };
+    case "organic":
+      return {
+        frequency: [2.5, 5.5],
+        power: [basePower * 0.7, basePower * 1.2],
+        positionAmount: [0.12, 0.3],
+        rotationAmount: [0.14, 0.26]
+      };
+    case "chaotic":
+    default:
+      return {
+        frequency: [4, 8],
+        power: [basePower, basePower * 1.7],
+        positionAmount: [0.18, 0.38],
+        rotationAmount: [0.18, 0.34]
+      };
+  }
+}
+function resolveMagicOrbit(magic, intensity) {
+  if (magic.order === "geometric") {
+    return { speed: [3 + intensity * 2, 6 + intensity * 3], axis: [0, 1, 0] };
+  }
+  if (magic.agency === "sentient-feeling") {
+    return { speed: [1 + intensity, 2.5 + intensity * 1.2], axis: [0, 1, 0] };
+  }
+  return void 0;
+}
+function tintColorOverLife(base, baseColor, palette, intensity) {
+  if (!base) {
+    return {
+      colors: [
+        [mixColors(baseColor, palette.start, 0.25), 0],
+        [mixColors(baseColor, palette.mid, 0.55), 0.45],
+        [mixColors(baseColor, palette.end, 0.75), 1]
+      ],
+      alpha: [
+        [0.22, 0],
+        [1, 0.12],
+        [0.52 + intensity * 0.08, 0.64],
+        [0, 1]
+      ]
+    };
+  }
+  return {
+    colors: base.colors.map(([color, stop], index) => {
+      const target = index === 0 ? palette.start : index === base.colors.length - 1 ? palette.end : palette.mid;
+      const amount = index === 0 ? 0.18 : 0.3 + intensity * 0.15;
+      return [mixColors(color, target, amount), stop];
+    }),
+    alpha: base.alpha
+  };
+}
+function mergeNoise(base, overlay) {
+  if (!base) return overlay;
+  if (!overlay) return base;
+  return {
+    frequency: addRanges(base.frequency, overlay.frequency) ?? base.frequency,
+    power: addRanges(base.power, overlay.power) ?? base.power,
+    positionAmount: addRanges(base.positionAmount, overlay.positionAmount),
+    rotationAmount: addRanges(base.rotationAmount, overlay.rotationAmount)
+  };
+}
+function mergeForce(base, overlay) {
+  if (!base) return overlay;
+  if (!overlay) return base;
+  return {
+    x: addRanges(base.x, overlay.x),
+    y: addRanges(base.y, overlay.y),
+    z: addRanges(base.z, overlay.z)
+  };
+}
+function mergeBehaviorConfig(base, overrides) {
+  if (!base && !overrides) return void 0;
+  const merged = {};
+  assignIfDefined(merged, "colorOverLife", resolveOverrideValue(base?.colorOverLife, overrides?.colorOverLife));
+  assignIfDefined(merged, "sizeOverLife", resolveOverrideValue(base?.sizeOverLife, overrides?.sizeOverLife));
+  assignIfDefined(merged, "speedOverLife", resolveOverrideValue(base?.speedOverLife, overrides?.speedOverLife));
+  assignIfDefined(merged, "rotationOverLife", resolveOverrideValue(base?.rotationOverLife, overrides?.rotationOverLife));
+  assignIfDefined(merged, "forceOverLife", resolvePartialOverride(base?.forceOverLife, overrides?.forceOverLife));
+  assignIfDefined(merged, "noise", resolveNoiseOverride(base?.noise, overrides?.noise));
+  assignIfDefined(merged, "orbitOverLife", resolveOrbitOverride(base?.orbitOverLife, overrides?.orbitOverLife));
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeShapeConfig(base, override) {
+  if (!override) return base;
+  if (!base || override.type !== base.type) return override;
+  if (override.type === "point") return override;
+  if (override.type === "cone" && base.type === "cone") return { ...base, ...override };
+  if (override.type === "sphere" && base.type === "sphere") return { ...base, ...override };
+  return override;
+}
+function addRanges(base, overlay) {
+  if (base === void 0) return overlay;
+  if (overlay === void 0) return base;
+  const [baseMin, baseMax] = toRange(base);
+  const [overlayMin, overlayMax] = toRange(overlay);
+  return [baseMin + overlayMin, baseMax + overlayMax];
+}
+function resolveOverrideValue(base, override) {
+  if (override === null) return void 0;
+  return override ?? base;
+}
+function resolvePartialOverride(base, override) {
+  if (override === null) return void 0;
+  if (!override) return base;
+  const resolved = { ...base, ...override };
+  return Object.keys(resolved).length > 0 ? resolved : void 0;
+}
+function resolveNoiseOverride(base, override) {
+  if (override === null) return void 0;
+  if (!override) return base;
+  const frequency = override.frequency ?? base?.frequency;
+  const power = override.power ?? base?.power;
+  if (frequency === void 0 || power === void 0) return void 0;
+  return { ...base, ...override, frequency, power };
+}
+function resolveOrbitOverride(base, override) {
+  if (override === null) return void 0;
+  if (!override) return base;
+  const speed = override.speed ?? base?.speed;
+  if (speed === void 0) return void 0;
+  return { ...base, ...override, speed };
+}
+function assignIfDefined(target, key, value) {
+  if (value !== void 0) target[key] = value;
+}
+function toHexColor(color) {
+  return `#${new Color(color).getHexString()}`;
+}
+function toRange(value) {
+  if (Array.isArray(value)) {
+    return [value[0] ?? 0, value[1] ?? value[0] ?? 0];
+  }
+  return [value, value];
+}
+function mixColors(base, overlay, amount) {
+  const color = new Color(base);
+  color.lerp(new Color(overlay), clamp(amount, 0, 1));
+  return `#${color.getHexString()}`;
+}
+function clamp(value, min, max2) {
+  return Math.min(Math.max(value, min), max2);
+}
+
+// src/lib/behaviors/particle-emitter/presets/electricity/arc.ts
+var electricityArcPreset = defineSemanticParticlePreset({
+  family: "electricity",
+  variant: "arc",
+  description: "directed snapping bridge of charge",
+  axes: {
+    "continuity vs discontinuity": "semi-continuous",
+    "branching tendency": "medium",
+    "snap/crackle quality": "high",
+    "seeking behavior": "medium",
+    "charge buildup": "medium",
+    "rhythmic pulsing": "low"
+  },
+  system: {
+    defaults: {
+      duration: 0.7,
+      looping: true,
+      color: "#60a5fa",
+      life: [0.12, 0.26],
+      size: [0.06, 0.14],
+      speed: [2.4, 4],
+      rotation: [-0.3, 0.3],
+      opacity: 0.96,
+      renderMode: 1 /* StretchedBillBoard */
+    },
+    emission: { type: "rate", rate: 28 },
+    shape: {
+      type: "cone",
+      radius: 0.06,
+      thickness: 1,
+      angle: 0.05,
+      speed: [1.2, 2.4]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#ffffff", 0],
+          ["#7dd3fc", 0.3],
+          ["#2563eb", 1]
+        ],
+        alpha: [
+          [0.2, 0],
+          [1, 0.05],
+          [0.46, 0.5],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.7, 0.96, 0.82, 0.26],
+      speedOverLife: [1.08, 0.94, 0.7, 0.38],
+      noise: {
+        frequency: [2.4, 4.8],
+        power: [0.05, 0.12],
+        positionAmount: [0.14, 0.28],
+        rotationAmount: [0.04, 0.12]
+      }
+    },
+    rendererEmitterSettings: {
+      speedFactor: 0.62,
+      lengthFactor: 1.16
+    }
+  }
+});
+function arc(options = {}) {
+  return createSemanticParticleEffect(electricityArcPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/electricity/pulse.ts
+var electricityPulsePreset = defineSemanticParticlePreset({
+  family: "electricity",
+  variant: "pulse",
+  description: "rhythmic swelling packet of charge",
+  axes: {
+    "continuity vs discontinuity": "discrete rhythmic",
+    "branching tendency": "low",
+    "snap/crackle quality": "medium",
+    "seeking behavior": "low",
+    "charge buildup": "medium",
+    "rhythmic pulsing": "high"
+  },
+  system: {
+    defaults: {
+      duration: 0.28,
+      color: "#a5f3fc",
+      life: [0.14, 0.3],
+      size: [0.18, 0.34],
+      speed: [0.18, 0.42],
+      opacity: 0.88
+    },
+    emission: { type: "burst", count: 10 },
+    shape: {
+      type: "sphere",
+      radius: 0.04,
+      thickness: 0.5,
+      speed: [0.02, 0.08]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#ffffff", 0],
+          ["#a5f3fc", 0.4],
+          ["#0891b2", 1]
+        ],
+        alpha: [
+          [0.14, 0],
+          [0.92, 0.08],
+          [0.42, 0.54],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.2, 0.92, 1.26, 0.18]
+    }
+  }
+});
+function pulse(options = {}) {
+  return createSemanticParticleEffect(electricityPulsePreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/electricity/spark.ts
+var electricitySparkPreset = defineSemanticParticlePreset({
+  family: "electricity",
+  variant: "spark",
+  description: "tiny discontinuous discharge",
+  axes: {
+    "continuity vs discontinuity": "highly discontinuous",
+    "branching tendency": "low",
+    "snap/crackle quality": "high",
+    "seeking behavior": "low",
+    "charge buildup": "low",
+    "rhythmic pulsing": "low"
+  },
+  system: {
+    defaults: {
+      duration: 0.2,
+      color: "#7dd3fc",
+      life: [0.08, 0.18],
+      size: [0.08, 0.16],
+      speed: [2.2, 4.2],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.92,
+      renderMode: 1 /* StretchedBillBoard */
+    },
+    emission: { type: "burst", count: 12 },
+    shape: {
+      type: "sphere",
+      radius: 0.06,
+      thickness: 0.95,
+      speed: [0.8, 1.6]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#ffffff", 0],
+          ["#bae6fd", 0.3],
+          ["#38bdf8", 1]
+        ],
+        alpha: [
+          [0.22, 0],
+          [1, 0.06],
+          [0.48, 0.4],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.44, 0.98, 0.7, 0.04],
+      speedOverLife: [1.24, 0.9, 0.36, 0.04]
+    },
+    rendererEmitterSettings: {
+      speedFactor: 0.46,
+      lengthFactor: 1.02
+    }
+  }
+});
+function spark(options = {}) {
+  return createSemanticParticleEffect(electricitySparkPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/electricity/storm.ts
+var electricityStormPreset = defineSemanticParticlePreset({
+  family: "electricity",
+  variant: "storm",
+  description: "restless volume of crackling atmospheric charge",
+  axes: {
+    "continuity vs discontinuity": "mixed",
+    "branching tendency": "high",
+    "snap/crackle quality": "high",
+    "seeking behavior": "medium-high",
+    "charge buildup": "high",
+    "rhythmic pulsing": "medium"
+  },
+  system: {
+    defaults: {
+      duration: 1.2,
+      looping: true,
+      color: "#38bdf8",
+      life: [0.32, 0.82],
+      size: [0.08, 0.2],
+      speed: [2.2, 4.8],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.94,
+      renderMode: 1 /* StretchedBillBoard */
+    },
+    emission: { type: "rate", rate: 34 },
+    shape: {
+      type: "sphere",
+      radius: 0.16,
+      thickness: 0.98,
+      speed: [1, 2]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#ffffff", 0],
+          ["#67e8f9", 0.25],
+          ["#2563eb", 1]
+        ],
+        alpha: [
+          [0.18, 0],
+          [0.98, 0.06],
+          [0.5, 0.5],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.62, 0.96, 0.84, 0.26],
+      speedOverLife: [1.18, 0.94, 0.66, 0.32],
+      noise: {
+        frequency: [4.8, 8.4],
+        power: [0.08, 0.18],
+        positionAmount: [0.18, 0.38],
+        rotationAmount: [0.08, 0.18]
+      }
+    },
+    rendererEmitterSettings: {
+      speedFactor: 0.66,
+      lengthFactor: 1.18
+    }
+  }
+});
+function storm(options = {}) {
+  return createSemanticParticleEffect(electricityStormPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/electricity/surge.ts
+var electricitySurgePreset = defineSemanticParticlePreset({
+  family: "electricity",
+  variant: "surge",
+  description: "charge-rich spike that overwhelms the space",
+  axes: {
+    "continuity vs discontinuity": "bursting",
+    "branching tendency": "medium",
+    "snap/crackle quality": "high",
+    "seeking behavior": "medium",
+    "charge buildup": "high",
+    "rhythmic pulsing": "medium"
+  },
+  system: {
+    defaults: {
+      duration: 0.34,
+      color: "#38bdf8",
+      life: [0.18, 0.36],
+      size: [0.12, 0.26],
+      speed: [2.8, 5.2],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.98,
+      renderMode: 1 /* StretchedBillBoard */
+    },
+    emission: { type: "burst", count: 24 },
+    shape: {
+      type: "sphere",
+      radius: 0.08,
+      thickness: 0.98,
+      speed: [1.1, 2.2]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#ffffff", 0],
+          ["#67e8f9", 0.22],
+          ["#0ea5e9", 1]
+        ],
+        alpha: [
+          [0.22, 0],
+          [1, 0.04],
+          [0.52, 0.44],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.32, 0.9, 0.84, 0.08],
+      speedOverLife: [1.22, 0.88, 0.42, 0.06],
+      noise: {
+        frequency: [4.5, 8],
+        power: [0.08, 0.18],
+        positionAmount: [0.22, 0.42],
+        rotationAmount: [0.08, 0.16]
+      }
+    },
+    rendererEmitterSettings: {
+      speedFactor: 0.68,
+      lengthFactor: 1.2
+    }
+  }
+});
+function surge(options = {}) {
+  return createSemanticParticleEffect(electricitySurgePreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/electricity/index.ts
+var electricityPresets = {
+  spark,
+  arc,
+  surge,
+  pulse,
+  storm
+};
+
+// src/lib/behaviors/particle-emitter/presets/fire/blaze.ts
+var fireBlazePreset = defineSemanticParticlePreset({
+  family: "fire",
+  variant: "blaze",
+  description: "sustained, strong open burning",
+  axes: {
+    "heat feel": "intense",
+    "hunger/spread tendency": "high",
+    "smoke affinity": "medium",
+    turbulence: "high",
+    residuality: "medium"
+  },
+  system: {
+    defaults: {
+      duration: 1.8,
+      looping: true,
+      color: "#f97316",
+      life: [0.55, 1.1],
+      size: [0.32, 0.62],
+      speed: [0.55, 1.4],
+      rotation: [-0.24, 0.24],
+      opacity: 0.96,
+      renderMode: 3 /* VerticalBillBoard */
+    },
+    emission: { type: "rate", rate: 42 },
+    shape: {
+      type: "cone",
+      radius: 0.18,
+      thickness: 1,
+      angle: 0.28,
+      speed: [0.35, 0.95]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#ffffff", 0],
+          ["#fde68a", 0.18],
+          ["#fb923c", 0.5],
+          ["#ef4444", 1]
+        ],
+        alpha: [
+          [0.18, 0],
+          [1, 0.08],
+          [0.56, 0.54],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.45, 0.92, 1.14, 0.22],
+      speedOverLife: [1.08, 0.96, 0.62, 0.16],
+      forceOverLife: {
+        y: [0.38, 0.72]
+      },
+      noise: {
+        frequency: [4.5, 6.5],
+        power: [0.1, 0.18],
+        positionAmount: [0.32, 0.55],
+        rotationAmount: [0.18, 0.3]
+      }
+    }
+  }
+});
+function blaze(options = {}) {
+  return createSemanticParticleEffect(fireBlazePreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/fire/ember.ts
+var fireEmberPreset = defineSemanticParticlePreset({
+  family: "fire",
+  variant: "ember",
+  description: "lingering, warm, residual, drifting",
+  axes: {
+    "heat feel": "warm",
+    "hunger/spread tendency": "low",
+    "smoke affinity": "medium",
+    turbulence: "low",
+    residuality: "high"
+  },
+  system: {
+    defaults: {
+      duration: 2.2,
+      looping: true,
+      color: "#fb923c",
+      life: [1.1, 2.2],
+      size: [0.05, 0.14],
+      speed: [0.08, 0.32],
+      rotation: [-0.45, 0.45],
+      opacity: 0.9
+    },
+    emission: { type: "rate", rate: 8 },
+    shape: {
+      type: "cone",
+      radius: 0.12,
+      thickness: 1,
+      angle: 0.22,
+      speed: [0.08, 0.26]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#fff7d1", 0],
+          ["#fb923c", 0.35],
+          ["#b45309", 1]
+        ],
+        alpha: [
+          [0.12, 0],
+          [0.9, 0.12],
+          [0.42, 0.7],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.42, 0.9, 0.72, 0.18],
+      forceOverLife: {
+        y: [0.18, 0.42]
+      },
+      noise: {
+        frequency: [1.2, 2.6],
+        power: [0.02, 0.08],
+        positionAmount: [0.06, 0.14],
+        rotationAmount: [0.04, 0.1]
+      }
+    }
+  }
+});
+function ember(options = {}) {
+  return createSemanticParticleEffect(fireEmberPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/fire/flamelet.ts
+var fireFlameletPreset = defineSemanticParticlePreset({
+  family: "fire",
+  variant: "flamelet",
+  description: "small coherent tongue of flame",
+  axes: {
+    "heat feel": "hot",
+    "hunger/spread tendency": "medium",
+    "smoke affinity": "low",
+    turbulence: "medium",
+    residuality: "low"
+  },
+  system: {
+    defaults: {
+      duration: 1.2,
+      looping: true,
+      color: "#fb923c",
+      life: [0.48, 0.9],
+      size: [0.2, 0.38],
+      speed: [0.35, 0.9],
+      rotation: [-0.18, 0.18],
+      opacity: 0.94,
+      renderMode: 3 /* VerticalBillBoard */
+    },
+    emission: { type: "rate", rate: 22 },
+    shape: {
+      type: "cone",
+      radius: 0.1,
+      thickness: 1,
+      angle: 0.18,
+      speed: [0.3, 0.72]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#fff7d1", 0],
+          ["#fbbf24", 0.24],
+          ["#fb923c", 0.62],
+          ["#ef4444", 1]
+        ],
+        alpha: [
+          [0.16, 0],
+          [0.94, 0.1],
+          [0.48, 0.58],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.44, 0.92, 1.08, 0.16],
+      speedOverLife: [1.08, 0.95, 0.62, 0.18],
+      forceOverLife: {
+        y: [0.3, 0.55]
+      },
+      noise: {
+        frequency: [3, 5],
+        power: [0.08, 0.14],
+        positionAmount: [0.24, 0.42],
+        rotationAmount: [0.16, 0.24]
+      }
+    }
+  }
+});
+function flamelet(options = {}) {
+  return createSemanticParticleEffect(fireFlameletPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/fire/smolder.ts
+var fireSmolderPreset = defineSemanticParticlePreset({
+  family: "fire",
+  variant: "smolder",
+  description: "low-oxygen, persistent, smoky heat",
+  axes: {
+    "heat feel": "buried-hot",
+    "hunger/spread tendency": "low",
+    "smoke affinity": "high",
+    turbulence: "low",
+    residuality: "high"
+  },
+  system: {
+    defaults: {
+      duration: 2.6,
+      looping: true,
+      color: "#c2410c",
+      life: [1.4, 2.8],
+      size: [0.28, 0.58],
+      speed: [0.06, 0.22],
+      rotation: [-0.35, 0.35],
+      opacity: 0.76
+    },
+    emission: { type: "rate", rate: 14 },
+    shape: {
+      type: "cone",
+      radius: 0.16,
+      thickness: 1,
+      angle: 0.12,
+      speed: [0.04, 0.16]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#fed7aa", 0],
+          ["#c2410c", 0.28],
+          ["#525252", 1]
+        ],
+        alpha: [
+          [0.14, 0],
+          [0.76, 0.12],
+          [0.4, 0.68],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.34, 0.86, 1.08, 0.46],
+      forceOverLife: {
+        y: [0.08, 0.2]
+      },
+      noise: {
+        frequency: [1.6, 3.1],
+        power: [0.04, 0.12],
+        positionAmount: [0.12, 0.26],
+        rotationAmount: [0.06, 0.14]
+      }
+    }
+  }
+});
+function smolder(options = {}) {
+  return createSemanticParticleEffect(fireSmolderPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/fire/spark.ts
+var fireSparkPreset = defineSemanticParticlePreset({
+  family: "fire",
+  variant: "spark",
+  description: "tiny, sudden, energetic, fleeting",
+  axes: {
+    "heat feel": "sharp-hot",
+    "hunger/spread tendency": "low",
+    "smoke affinity": "low",
+    turbulence: "high",
+    residuality: "low"
+  },
+  system: {
+    defaults: {
+      duration: 0.24,
+      color: "#ffd166",
+      life: [0.12, 0.24],
+      size: [0.08, 0.16],
+      speed: [1.8, 4.6],
+      rotation: [-Math.PI, Math.PI],
+      renderMode: 1 /* StretchedBillBoard */
+    },
+    emission: { type: "burst", count: 10 },
+    shape: {
+      type: "sphere",
+      radius: 0.05,
+      thickness: 0.92,
+      speed: [0.45, 1.2]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#ffffff", 0],
+          ["#fde68a", 0.2],
+          ["#fb923c", 0.62],
+          ["#ef4444", 1]
+        ],
+        alpha: [
+          [0.18, 0],
+          [1, 0.08],
+          [0.52, 0.5],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.48, 1.08, 0.88, 0.06],
+      speedOverLife: [1.18, 0.88, 0.42, 0.04]
+    },
+    rendererEmitterSettings: {
+      speedFactor: 0.55,
+      lengthFactor: 1.08
+    }
+  }
+});
+function spark2(options = {}) {
+  return createSemanticParticleEffect(fireSparkPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/fire/index.ts
+var firePresets = {
+  spark: spark2,
+  ember,
+  flamelet,
+  blaze,
+  smolder
+};
+
+// src/lib/behaviors/particle-emitter/presets/gas/haze.ts
+var gasHazePreset = defineSemanticParticlePreset({
+  family: "gas",
+  variant: "haze",
+  description: "broad, thin atmospheric contamination",
+  axes: {
+    "opacity feel": "low",
+    toxicity: "low-medium",
+    buoyancy: "neutral",
+    "spread tendency": "high",
+    thickness: "thin",
+    "staining / contaminating character": "low"
+  },
+  system: {
+    defaults: {
+      duration: 4.4,
+      looping: true,
+      color: "#cbd5e1",
+      life: [3.4, 5.4],
+      size: [0.9, 1.7],
+      speed: [0.02, 0.08],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.18
+    },
+    emission: { type: "rate", rate: 10 },
+    shape: {
+      type: "cone",
+      radius: 0.64,
+      thickness: 1,
+      angle: 0.5,
+      speed: [0.01, 0.04]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#f8fafc", 0],
+          ["#cbd5e1", 0.4],
+          ["#94a3b8", 1]
+        ],
+        alpha: [
+          [0.04, 0],
+          [0.2, 0.24],
+          [0.08, 0.88],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.88, 1.08, 1.28, 1.42],
+      noise: {
+        frequency: [0.6, 1.4],
+        power: [0.02, 0.06],
+        positionAmount: [0.08, 0.16],
+        rotationAmount: [0.06, 0.1]
+      }
+    }
+  }
+});
+function haze(options = {}) {
+  return createSemanticParticleEffect(gasHazePreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/gas/miasma.ts
+var gasMiasmaPreset = defineSemanticParticlePreset({
+  family: "gas",
+  variant: "miasma",
+  description: "thick, toxic, contaminating exhalation",
+  axes: {
+    "opacity feel": "medium",
+    toxicity: "high",
+    buoyancy: "low-medium",
+    "spread tendency": "high",
+    thickness: "sticky",
+    "staining / contaminating character": "high"
+  },
+  system: {
+    defaults: {
+      duration: 3.8,
+      looping: true,
+      color: "#84cc16",
+      life: [2.8, 4.6],
+      size: [0.52, 1.08],
+      speed: [0.03, 0.16],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.5
+    },
+    emission: { type: "rate", rate: 16 },
+    shape: {
+      type: "cone",
+      radius: 0.3,
+      thickness: 1,
+      angle: 0.3,
+      speed: [0.02, 0.08]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#ecfccb", 0],
+          ["#84cc16", 0.4],
+          ["#3f6212", 1]
+        ],
+        alpha: [
+          [0.08, 0],
+          [0.58, 0.14],
+          [0.24, 0.8],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.4, 0.92, 1.3, 1.9],
+      noise: {
+        frequency: [1.8, 3.8],
+        power: [0.08, 0.18],
+        positionAmount: [0.16, 0.34],
+        rotationAmount: [0.08, 0.18]
+      }
+    }
+  }
+});
+function miasma(options = {}) {
+  return createSemanticParticleEffect(gasMiasmaPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/gas/plume.ts
+var gasPlumePreset = defineSemanticParticlePreset({
+  family: "gas",
+  variant: "plume",
+  description: "columnar rising release with strong lift",
+  axes: {
+    "opacity feel": "medium",
+    toxicity: "medium",
+    buoyancy: "very-high",
+    "spread tendency": "medium",
+    thickness: "medium",
+    "staining / contaminating character": "medium"
+  },
+  system: {
+    defaults: {
+      duration: 2.8,
+      looping: true,
+      color: "#94a3b8",
+      life: [1.8, 3.2],
+      size: [0.32, 0.72],
+      speed: [0.16, 0.52],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.48
+    },
+    emission: { type: "rate", rate: 22 },
+    shape: {
+      type: "cone",
+      radius: 0.18,
+      thickness: 1,
+      angle: 0.18,
+      speed: [0.08, 0.24]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#e2e8f0", 0],
+          ["#94a3b8", 0.36],
+          ["#475569", 1]
+        ],
+        alpha: [
+          [0.06, 0],
+          [0.54, 0.14],
+          [0.2, 0.84],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.42, 0.92, 1.36, 1.84],
+      forceOverLife: {
+        y: [0.28, 0.6]
+      },
+      noise: {
+        frequency: [1.6, 3.4],
+        power: [0.08, 0.14],
+        positionAmount: [0.14, 0.28],
+        rotationAmount: [0.08, 0.16]
+      }
+    }
+  }
+});
+function plume(options = {}) {
+  return createSemanticParticleEffect(gasPlumePreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/gas/smoke.ts
+var gasSmokePreset = defineSemanticParticlePreset({
+  family: "gas",
+  variant: "smoke",
+  description: "opaque, buoyant, lingering combustion residue",
+  axes: {
+    "opacity feel": "medium-high",
+    toxicity: "medium",
+    buoyancy: "high",
+    "spread tendency": "medium",
+    thickness: "medium",
+    "staining / contaminating character": "medium"
+  },
+  system: {
+    defaults: {
+      duration: 3.2,
+      looping: true,
+      color: "#737373",
+      life: [2.4, 4.2],
+      size: [0.45, 0.92],
+      speed: [0.08, 0.3],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.58
+    },
+    emission: { type: "rate", rate: 14 },
+    shape: {
+      type: "cone",
+      radius: 0.24,
+      thickness: 1,
+      angle: 0.28,
+      speed: [0.04, 0.14]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#d4d4d8", 0],
+          ["#737373", 0.4],
+          ["#404040", 1]
+        ],
+        alpha: [
+          [0.08, 0],
+          [0.68, 0.14],
+          [0.24, 0.84],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.38, 0.88, 1.4, 2.08],
+      forceOverLife: {
+        y: [0.12, 0.28]
+      },
+      noise: {
+        frequency: [1.2, 2.8],
+        power: [0.08, 0.16],
+        positionAmount: [0.12, 0.26],
+        rotationAmount: [0.08, 0.18]
+      }
+    }
+  }
+});
+function smoke(options = {}) {
+  return createSemanticParticleEffect(gasSmokePreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/gas/vapor.ts
+var gasVaporPreset = defineSemanticParticlePreset({
+  family: "gas",
+  variant: "vapor",
+  description: "visible gaseous release with light buoyancy",
+  axes: {
+    "opacity feel": "light",
+    toxicity: "neutral",
+    buoyancy: "high",
+    "spread tendency": "medium",
+    thickness: "thin",
+    "staining / contaminating character": "low"
+  },
+  system: {
+    defaults: {
+      duration: 3,
+      looping: true,
+      color: "#e2e8f0",
+      life: [2.2, 3.6],
+      size: [0.38, 0.78],
+      speed: [0.04, 0.18],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.28
+    },
+    emission: { type: "rate", rate: 18 },
+    shape: {
+      type: "cone",
+      radius: 0.28,
+      thickness: 1,
+      angle: 0.36,
+      speed: [0.02, 0.08]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#f8fafc", 0],
+          ["#e2e8f0", 0.36],
+          ["#cbd5e1", 1]
+        ],
+        alpha: [
+          [0.06, 0],
+          [0.34, 0.22],
+          [0.12, 0.84],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.42, 0.9, 1.38, 1.98],
+      forceOverLife: {
+        y: [0.06, 0.18]
+      },
+      noise: {
+        frequency: [1, 2],
+        power: [0.04, 0.08],
+        positionAmount: [0.1, 0.2],
+        rotationAmount: [0.08, 0.14]
+      }
+    }
+  }
+});
+function vapor(options = {}) {
+  return createSemanticParticleEffect(gasVaporPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/gas/index.ts
+var gasPresets = {
+  vapor,
+  smoke,
+  haze,
+  plume,
+  miasma
+};
+
+// src/lib/behaviors/particle-emitter/presets/magic/arcane.ts
+function arcane(options = {}) {
+  return createMagicModifier("arcane", options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/magic/corrupted.ts
+function corrupted(options = {}) {
+  return createMagicModifier("corrupted", options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/magic/holy.ts
+function holy(options = {}) {
+  return createMagicModifier("holy", options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/magic/nature.ts
+function nature(options = {}) {
+  return createMagicModifier("nature", options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/magic/psychic.ts
+function psychic(options = {}) {
+  return createMagicModifier("psychic", options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/magic/void.ts
+function voidMagic(options = {}) {
+  return createMagicModifier("void", options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/magic/index.ts
+var magicPresets = {
+  arcane,
+  holy,
+  corrupted,
+  nature,
+  void: voidMagic,
+  psychic
+};
+
+// src/lib/behaviors/particle-emitter/presets/water/drizzle.ts
+var waterDrizzlePreset = defineSemanticParticlePreset({
+  family: "water",
+  variant: "drizzle",
+  description: "soft, continuous, light fall",
+  axes: {
+    pressure: "low",
+    "surface tension feel": "light",
+    aeration: "low",
+    coherence: "discrete",
+    "gravitational obedience": "very-high"
+  },
+  system: {
+    defaults: {
+      duration: 1.4,
+      looping: true,
+      color: "#e0f2fe",
+      life: [0.6, 1.05],
+      size: [0.05, 0.1],
+      speed: [2.8, 4.4],
+      opacity: 0.62,
+      renderMode: 1 /* StretchedBillBoard */
+    },
+    emission: { type: "rate", rate: 26 },
+    shape: {
+      type: "cone",
+      radius: 0.46,
+      thickness: 1,
+      angle: 0.04,
+      speed: [1.8, 2.6]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#f8fafc", 0],
+          ["#e0f2fe", 0.45],
+          ["#7dd3fc", 1]
+        ],
+        alpha: [
+          [0.12, 0],
+          [0.78, 0.08],
+          [0.52, 0.58],
+          [0, 1]
+        ]
+      },
+      speedOverLife: [1.02, 1, 0.94, 0.88],
+      forceOverLife: {
+        y: [-8.2, -6.4]
+      }
+    },
+    rendererEmitterSettings: {
+      speedFactor: 0.42,
+      lengthFactor: 1.24
+    }
+  }
+});
+function drizzle(options = {}) {
+  return createSemanticParticleEffect(waterDrizzlePreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/water/mist.ts
+var waterMistPreset = defineSemanticParticlePreset({
+  family: "water",
+  variant: "mist",
+  description: "diffuse suspended moisture",
+  axes: {
+    pressure: "low",
+    "surface tension feel": "soft",
+    aeration: "low",
+    coherence: "diffuse",
+    "gravitational obedience": "low"
+  },
+  system: {
+    defaults: {
+      duration: 3.2,
+      looping: true,
+      color: "#dbeafe",
+      life: [2.4, 3.8],
+      size: [0.4, 0.82],
+      speed: [0.05, 0.2],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.36
+    },
+    emission: { type: "rate", rate: 16 },
+    shape: {
+      type: "cone",
+      radius: 0.32,
+      thickness: 1,
+      angle: 0.42,
+      speed: [0.02, 0.08]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#f8fafc", 0],
+          ["#dbeafe", 0.35],
+          ["#bfdbfe", 1]
+        ],
+        alpha: [
+          [0.08, 0],
+          [0.44, 0.2],
+          [0.18, 0.82],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.38, 0.86, 1.42, 2.02],
+      forceOverLife: {
+        y: [0.02, 0.12]
+      },
+      noise: {
+        frequency: [0.8, 1.8],
+        power: [0.04, 0.1],
+        positionAmount: [0.1, 0.18],
+        rotationAmount: [0.08, 0.14]
+      }
+    }
+  }
+});
+function mist(options = {}) {
+  return createSemanticParticleEffect(waterMistPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/water/splash.ts
+var waterSplashPreset = defineSemanticParticlePreset({
+  family: "water",
+  variant: "splash",
+  description: "sudden impact-driven burst",
+  axes: {
+    pressure: "impact-driven",
+    "surface tension feel": "beaded",
+    aeration: "medium",
+    coherence: "shattering",
+    "gravitational obedience": "high"
+  },
+  system: {
+    defaults: {
+      duration: 0.34,
+      color: "#7dd3fc",
+      life: [0.26, 0.55],
+      size: [0.1, 0.22],
+      speed: [1.4, 3.1],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.82,
+      renderMode: 1 /* StretchedBillBoard */
+    },
+    emission: { type: "burst", count: 18 },
+    shape: {
+      type: "sphere",
+      radius: 0.08,
+      thickness: 0.96,
+      speed: [0.7, 1.4]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#ffffff", 0],
+          ["#bae6fd", 0.4],
+          ["#38bdf8", 1]
+        ],
+        alpha: [
+          [0.18, 0],
+          [0.88, 0.08],
+          [0.42, 0.54],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.32, 0.86, 0.92, 0.08],
+      speedOverLife: [1.12, 0.88, 0.46, 0.08],
+      forceOverLife: {
+        y: [-4.4, -2.6]
+      }
+    },
+    rendererEmitterSettings: {
+      speedFactor: 0.36,
+      lengthFactor: 0.88
+    }
+  }
+});
+function splash(options = {}) {
+  return createSemanticParticleEffect(waterSplashPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/water/spray.ts
+var waterSprayPreset = defineSemanticParticlePreset({
+  family: "water",
+  variant: "spray",
+  description: "fine ejected droplets",
+  axes: {
+    pressure: "medium-high",
+    "surface tension feel": "light",
+    aeration: "medium",
+    coherence: "broken",
+    "gravitational obedience": "high"
+  },
+  system: {
+    defaults: {
+      duration: 1,
+      looping: true,
+      color: "#93c5fd",
+      life: [0.45, 0.9],
+      size: [0.08, 0.16],
+      speed: [1.1, 2.3],
+      rotation: [-Math.PI, Math.PI],
+      opacity: 0.72,
+      renderMode: 1 /* StretchedBillBoard */
+    },
+    emission: { type: "rate", rate: 38 },
+    shape: {
+      type: "cone",
+      radius: 0.12,
+      thickness: 1,
+      angle: 0.24,
+      speed: [0.85, 1.8]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#eff6ff", 0],
+          ["#93c5fd", 0.45],
+          ["#60a5fa", 1]
+        ],
+        alpha: [
+          [0.16, 0],
+          [0.82, 0.08],
+          [0.52, 0.58],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.72, 0.96, 0.82, 0.28],
+      speedOverLife: [1.04, 0.92, 0.68, 0.38],
+      forceOverLife: {
+        y: [-5.8, -3.8]
+      },
+      noise: {
+        frequency: [1.2, 2.2],
+        power: [0.04, 0.08],
+        positionAmount: [0.08, 0.16],
+        rotationAmount: [0.04, 0.08]
+      }
+    },
+    rendererEmitterSettings: {
+      speedFactor: 0.5,
+      lengthFactor: 0.95
+    }
+  }
+});
+function spray(options = {}) {
+  return createSemanticParticleEffect(waterSprayPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/water/torrent.ts
+var waterTorrentPreset = defineSemanticParticlePreset({
+  family: "water",
+  variant: "torrent",
+  description: "strong, forceful, dense flow",
+  axes: {
+    pressure: "high",
+    "surface tension feel": "driven",
+    aeration: "medium",
+    coherence: "strong",
+    "gravitational obedience": "high"
+  },
+  system: {
+    defaults: {
+      duration: 1,
+      looping: true,
+      color: "#38bdf8",
+      life: [0.35, 0.75],
+      size: [0.1, 0.22],
+      speed: [2.6, 4.9],
+      rotation: [-0.3, 0.3],
+      opacity: 0.84,
+      renderMode: 1 /* StretchedBillBoard */
+    },
+    emission: { type: "rate", rate: 60 },
+    shape: {
+      type: "cone",
+      radius: 0.18,
+      thickness: 1,
+      angle: 0.12,
+      speed: [1.8, 3.1]
+    },
+    behaviors: {
+      colorOverLife: {
+        colors: [
+          ["#f0f9ff", 0],
+          ["#7dd3fc", 0.35],
+          ["#0ea5e9", 1]
+        ],
+        alpha: [
+          [0.18, 0],
+          [0.92, 0.08],
+          [0.56, 0.52],
+          [0, 1]
+        ]
+      },
+      sizeOverLife: [0.72, 0.94, 0.84, 0.28],
+      speedOverLife: [1.04, 0.92, 0.68, 0.34],
+      forceOverLife: {
+        y: [-6.8, -4.8]
+      },
+      noise: {
+        frequency: [1.4, 2.6],
+        power: [0.04, 0.09],
+        positionAmount: [0.08, 0.14],
+        rotationAmount: [0.06, 0.1]
+      }
+    },
+    rendererEmitterSettings: {
+      speedFactor: 0.56,
+      lengthFactor: 1.08
+    }
+  }
+});
+function torrent(options = {}) {
+  return createSemanticParticleEffect(waterTorrentPreset, options);
+}
+
+// src/lib/behaviors/particle-emitter/presets/water/index.ts
+var waterPresets = {
+  mist,
+  spray,
+  splash,
+  drizzle,
+  torrent
+};
+
+export {
+  Particles,
+  particleEffect,
+  electricityPresets,
+  firePresets,
+  gasPresets,
+  magicPresets,
+  waterPresets
+};
+//# sourceMappingURL=chunk-7JJEIADR.js.map