@zylem/behaviors 0.2.0

package/dist/chunk-GYURWCIQ.js

@@ -0,0 +1,1985 @@
+// src/lib/behaviors/particle-emitter/presets/electricity/arc.ts
+import { RenderMode as RenderMode2 } from "three.quarks";
+
+// src/lib/behaviors/particle-emitter/preset-builder.ts
+import {
+  AdditiveBlending,
+  Color,
+  MeshBasicMaterial
+} from "three";
+import {
+  Bezier,
+  ColorOverLife,
+  ConeEmitter,
+  ConstantColor,
+  ConstantValue,
+  ForceOverLife,
+  Gradient,
+  IntervalValue,
+  Noise,
+  OrbitOverLife,
+  ParticleSystem,
+  PiecewiseBezier,
+  PointEmitter,
+  RenderMode,
+  RotationOverLife,
+  SizeOverLife,
+  SpeedOverLife,
+  SphereEmitter,
+  Vector3,
+  Vector4
+} from "three.quarks";
+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 createRangeValue(value, defaultValue) {
+  if (Array.isArray(value)) {
+    const min = value[0] ?? defaultValue[0];
+    const max = value[1] ?? defaultValue[1];
+    return min === max ? new ConstantValue(min) : new IntervalValue(min, max);
+  }
+  return new ConstantValue(value);
+}
+function toColorVector(color) {
+  const parsed = new Color(color);
+  return new Vector4(parsed.r, parsed.g, parsed.b, 1);
+}
+function createParticleMaterial(color, options, defaultOpacity) {
+  const materialOptions = {
+    color,
+    transparent: true
+  };
+  if (options.texture) {
+    materialOptions.map = options.texture;
+    materialOptions.depthWrite = options.depthWrite ?? false;
+    materialOptions.alphaTest = options.alphaTest ?? 0.01;
+  } else {
+    if (options.depthWrite !== void 0) {
+      materialOptions.depthWrite = options.depthWrite;
+    }
+    if (options.alphaTest !== void 0) {
+      materialOptions.alphaTest = options.alphaTest;
+    }
+  }
+  const opacity = options.opacity ?? defaultOpacity;
+  if (opacity !== void 0) {
+    materialOptions.opacity = opacity;
+  }
+  if (options.blending !== void 0) {
+    materialOptions.blending = options.blending;
+  }
+  return new MeshBasicMaterial(materialOptions);
+}
+function createTextureSystemOptions(options) {
+  const systemOptions = {};
+  if (options.uTileCount !== void 0) {
+    systemOptions.uTileCount = options.uTileCount;
+  }
+  if (options.vTileCount !== void 0) {
+    systemOptions.vTileCount = options.vTileCount;
+  }
+  if (options.blendTiles !== void 0) {
+    systemOptions.blendTiles = options.blendTiles;
+  }
+  return systemOptions;
+}
+function createSemanticParticleEffect(preset, options = {}) {
+  return particleEffect(() => {
+    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 ?? preset.system.defaults.color;
+    const resolvedColor = magic ? mixColors(baseColor, MAGIC_PALETTES[magic.alignment].start, 0.2) : baseColor;
+    const resolvedBehaviors = magic ? applyMagicBehaviors(baseBehaviors, resolvedColor, magic) : baseBehaviors;
+    const resolvedBlending = options.blending ?? (magic ? AdditiveBlending : void 0);
+    const materialOptions = {
+      ...options,
+      blending: resolvedBlending
+    };
+    const resolvedRendererEmitterSettings = {
+      ...preset.system.rendererEmitterSettings,
+      ...options.rendererEmitterSettings
+    };
+    return new ParticleSystem({
+      duration: options.duration ?? preset.system.defaults.duration,
+      looping: options.looping ?? preset.system.defaults.looping ?? preset.system.emission.type === "rate",
+      worldSpace: options.worldSpace ?? preset.system.defaults.worldSpace ?? false,
+      startLife: createRangeValue(
+        options.life ?? preset.system.defaults.life,
+        toRange(preset.system.defaults.life)
+      ),
+      startSpeed: createRangeValue(
+        options.speed ?? preset.system.defaults.speed,
+        toRange(preset.system.defaults.speed)
+      ),
+      startSize: createRangeValue(
+        options.size ?? preset.system.defaults.size,
+        toRange(preset.system.defaults.size)
+      ),
+      startRotation: options.rotation !== void 0 || preset.system.defaults.rotation !== void 0 ? createRangeValue(
+        options.rotation ?? preset.system.defaults.rotation ?? 0,
+        toRange(preset.system.defaults.rotation ?? 0)
+      ) : void 0,
+      startColor: new ConstantColor(toColorVector(resolvedColor)),
+      emissionOverTime: preset.system.emission.type === "rate" ? new ConstantValue(
+        options.emissionRate ?? preset.system.emission.rate
+      ) : new ConstantValue(0),
+      emissionBursts: preset.system.emission.type === "burst" ? [
+        {
+          time: 0,
+          count: new ConstantValue(
+            options.count ?? preset.system.emission.count
+          ),
+          cycle: 1,
+          interval: 0,
+          probability: 1
+        }
+      ] : void 0,
+      shape: createEmitterShape(resolvedShape),
+      material: createParticleMaterial(
+        resolvedColor,
+        materialOptions,
+        preset.system.defaults.opacity
+      ),
+      behaviors: createBehaviors(resolvedBehaviors),
+      ...createTextureSystemOptions(materialOptions),
+      renderMode: options.renderMode ?? (magic && magic.agency === "seeking" ? RenderMode.StretchedBillBoard : void 0) ?? preset.system.defaults.renderMode ?? RenderMode.BillBoard,
+      rendererEmitterSettings: resolvedRendererEmitterSettings
+    });
+  });
+}
+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 createBehaviors(config) {
+  if (!config) {
+    return void 0;
+  }
+  const behaviors = [];
+  if (config.colorOverLife) {
+    behaviors.push(
+      new ColorOverLife(
+        new Gradient(
+          config.colorOverLife.colors.map(
+            ([color, stop]) => [toColorVector3(color), stop]
+          ),
+          config.colorOverLife.alpha.map(
+            ([value, stop]) => [value, stop]
+          )
+        )
+      )
+    );
+  }
+  if (config.sizeOverLife) {
+    behaviors.push(new SizeOverLife(createCurve(config.sizeOverLife)));
+  }
+  if (config.speedOverLife) {
+    behaviors.push(new SpeedOverLife(createCurve(config.speedOverLife)));
+  }
+  if (config.rotationOverLife !== void 0) {
+    behaviors.push(
+      new RotationOverLife(
+        createRangeValue(config.rotationOverLife, toRange(config.rotationOverLife))
+      )
+    );
+  }
+  if (config.forceOverLife) {
+    behaviors.push(
+      new ForceOverLife(
+        createRangeValue(config.forceOverLife.x ?? 0, toRange(config.forceOverLife.x ?? 0)),
+        createRangeValue(config.forceOverLife.y ?? 0, toRange(config.forceOverLife.y ?? 0)),
+        createRangeValue(config.forceOverLife.z ?? 0, toRange(config.forceOverLife.z ?? 0))
+      )
+    );
+  }
+  if (config.noise) {
+    behaviors.push(
+      new Noise(
+        createRangeValue(config.noise.frequency, toRange(config.noise.frequency)),
+        createRangeValue(config.noise.power, toRange(config.noise.power)),
+        createRangeValue(
+          config.noise.positionAmount ?? 0,
+          toRange(config.noise.positionAmount ?? 0)
+        ),
+        createRangeValue(
+          config.noise.rotationAmount ?? 0,
+          toRange(config.noise.rotationAmount ?? 0)
+        )
+      )
+    );
+  }
+  if (config.orbitOverLife) {
+    const axis = config.orbitOverLife.axis ?? [0, 1, 0];
+    behaviors.push(
+      new OrbitOverLife(
+        createRangeValue(
+          config.orbitOverLife.speed,
+          toRange(config.orbitOverLife.speed)
+        ),
+        new Vector3(axis[0], axis[1], axis[2])
+      )
+    );
+  }
+  return behaviors.length > 0 ? behaviors : void 0;
+}
+function createEmitterShape(shape) {
+  if (!shape || shape.type === "point") {
+    return new PointEmitter();
+  }
+  if (shape.type === "cone") {
+    return new ConeEmitter({
+      radius: shape.radius,
+      thickness: shape.thickness,
+      angle: shape.angle,
+      speed: shape.speed !== void 0 ? createRangeValue(shape.speed, toRange(shape.speed)) : void 0
+    });
+  }
+  return new SphereEmitter({
+    radius: shape.radius,
+    thickness: shape.thickness,
+    speed: shape.speed !== void 0 ? createRangeValue(shape.speed, toRange(shape.speed)) : void 0
+  });
+}
+function createCurve(points) {
+  return new PiecewiseBezier([[new Bezier(...points), 0]]);
+}
+function toColorVector3(color) {
+  const parsed = new Color(color);
+  return new Vector3(parsed.r, parsed.g, parsed.b);
+}
+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, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// 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: RenderMode2.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
+import { RenderMode as RenderMode3 } from "three.quarks";
+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: RenderMode3.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
+import { RenderMode as RenderMode4 } from "three.quarks";
+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: RenderMode4.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
+import { RenderMode as RenderMode5 } from "three.quarks";
+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: RenderMode5.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
+import { RenderMode as RenderMode6 } from "three.quarks";
+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: RenderMode6.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
+import { RenderMode as RenderMode7 } from "three.quarks";
+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: RenderMode7.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
+import { RenderMode as RenderMode8 } from "three.quarks";
+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: RenderMode8.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
+import { RenderMode as RenderMode9 } from "three.quarks";
+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: RenderMode9.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
+import { RenderMode as RenderMode10 } from "three.quarks";
+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: RenderMode10.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
+import { RenderMode as RenderMode11 } from "three.quarks";
+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: RenderMode11.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
+import { RenderMode as RenderMode12 } from "three.quarks";
+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: RenderMode12.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 {
+  particleEffect,
+  createRangeValue,
+  toColorVector,
+  createParticleMaterial,
+  createTextureSystemOptions,
+  electricityPresets,
+  firePresets,
+  gasPresets,
+  magicPresets,
+  waterPresets
+};
+//# sourceMappingURL=chunk-GYURWCIQ.js.map