paperlab 0.6.0 → 0.7.0

package/dist/fx.js

@@ -0,0 +1,3194 @@
+import {
+  CHAR,
+  DamageField,
+  FIELD_SIZE,
+  FIRE_CONTRAST,
+  FIRE_GLOW,
+  FIRE_HEAT_SCALE,
+  FIRE_OPACITY,
+  FIRE_SOOT_SCALE,
+  FIRE_THIN,
+  FIRE_ZONES,
+  FIXED_DT,
+  FLAME_HEIGHT,
+  FX_BLOOM,
+  FX_BLOOM_THRESHOLD,
+  FX_INITIAL_TIER,
+  FX_TIER_ORDER,
+  HEAT,
+  PAPER_WHITE,
+  PRESENCE,
+  SATURATION,
+  emit,
+  emitHex,
+  fireZones,
+  flameAnchors,
+  flamePuff,
+  fxQualityFor,
+  fxQualityNames,
+  fxQualityTiers,
+  hexToLinear,
+  luminance,
+  srgbToLinear,
+  timesPaperWhite
+} from "./chunk-GB6BMHC3.js";
+import {
+  DAMAGE_CHANNELS,
+  DAMAGE_LOOK_DEFAULTS
+} from "./chunk-7TLIWPGM.js";
+
+// src/fx/particles.ts
+var particlePresets = {
+  /**
+   * A spark off the burning line. Short-lived, shrinking as it cools, carried
+   * up and sideways by the heat.
+   *
+   * Authored through `emission.ts`, in multiples of paper white, which is what
+   * caught the bug in the version before this one. That version said "the hot
+   * end is now ~5.6, well over the bloom threshold" — and 5.6 was an ABSOLUTE
+   * luminance, while paper white under `window` is 1.6. So the hottest spark
+   * in the frame was **3.5× paper, under the spec's own 4× floor**, and its
+   * own comment said otherwise. A number that cannot be compared to anything
+   * is a number nobody can check.
+   *
+   * It was also too red. `[12, 4.2, 0.9]` is a saturated red at high
+   * intensity, and the tone curve takes a bright red-dominant colour to
+   * SALMON — which is `Never_this.png`. The hue is now a blackbody's: a spark
+   * leaving the fire is yellow-orange, about 2200 K, and cools to a deep
+   * orange-red as it dies. Hue and brightness are separate arguments now, and
+   * `emit` keeps them that way.
+   */
+  ember: {
+    life: [0.5, 1.4],
+    speed: [0.15, 0.5],
+    direction: [0, 1, 0],
+    spread: 0.6,
+    lift: 0.6,
+    drag: 0.8,
+    jitter: 1.5,
+    windCatch: 0.8,
+    // 0.3-1 mm of core (§5). A sheet is one world unit across, 210 mm, so
+    // 0.0035 is 0.7 mm. It was 0.005 — a full millimetre wide before the
+    // streak stretched it, which is where "wide bars" started.
+    size: [35e-4, 12e-4],
+    color: [
+      // 6× paper white: inside §4.3's 4–8 band, so it blooms.
+      emitHex("#FFC271", 6),
+      // 0.7× — UNDER the bloom threshold on purpose, so a dying spark stops
+      // glowing rather than merely fading.
+      emitHex("#FF5512", 0.7)
+    ],
+    alpha: [1, 0],
+    spin: 0,
+    blend: "additive",
+    shape: "soft",
+    flicker: 0.35
+  },
+  /**
+   * What a paper fire mostly makes. Thin, slow, growing as it rises and
+   * spreads, and gone well before it could read as a volume — no fluid
+   * simulation, on purpose; see the fx plan.
+   */
+  smoke: {
+    life: [1.8, 3.5],
+    speed: [0.05, 0.15],
+    direction: [0, 1, 0],
+    spread: 0.3,
+    lift: 0.25,
+    drag: 0.9,
+    jitter: 0.3,
+    windCatch: 1,
+    size: [0.05, 0.35],
+    // #6B6560 grey-brown, linear, and thin — the background stays clear.
+    color: [
+      [0.147, 0.13, 0.117],
+      [0.2, 0.19, 0.18]
+    ],
+    alpha: [0.08, 0],
+    spin: 0.4,
+    blend: "normal",
+    shape: "soft",
+    flicker: 0
+  },
+  /**
+   * Burnt-through paper, leaving. Lifted a little by the heat it came from,
+   * then heavier than the air: it tumbles, flutters and falls — the part of a
+   * burn that proves paper was there.
+   */
+  ash: {
+    life: [2.5, 5],
+    // Thrown UP by the heat it came off, before it is heavier than the air.
+    // It used to leave at almost nothing (0.02–0.1) with a lift of −0.35, so
+    // every flake began falling the moment it was born — straight through the
+    // hole it came from, onto the black stage, dark on dark.
+    speed: [0.14, 0.3],
+    direction: [0, 1, 0],
+    spread: 0.55,
+    lift: -0.22,
+    drag: 1.6,
+    jitter: 1.2,
+    windCatch: 1,
+    // 5–10 mm across (§8.3). A sheet is 210 mm, so 0.03 is 6.3 mm. They were
+    // 3.8 mm and there were far too many of them: a shower of specks rather
+    // than a few flakes you would notice.
+    size: [0.03, 0.026],
+    color: [
+      [0.07, 0.065, 0.06],
+      [0.12, 0.115, 0.11]
+    ],
+    alpha: [0.95, 0],
+    spin: 4,
+    blend: "normal",
+    shape: "flake",
+    flicker: 0
+  }
+};
+var PRESET_NAMES = Object.keys(particlePresets);
+var PRESETS = PRESET_NAMES.map((name) => particlePresets[name]);
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var ParticlePool = class {
+  capacity;
+  /**
+   * The air's own velocity, world units a second. A blow on `/hands` is a
+   * wind, and smoke that ignores it is smoke painted on the glass.
+   */
+  wind = [0, 0, 0];
+  kind;
+  position;
+  velocity;
+  age;
+  life;
+  angle;
+  spin;
+  seed;
+  live = 0;
+  /** Live particles of each preset, kept as they come and go, so a cap costs nothing to check. */
+  perKind = new Int32Array(PRESET_NAMES.length);
+  /** Embers that popped in the air since the last `takePops` — the sound follows the picture. */
+  pops = 0;
+  random;
+  constructor(capacity, seed = 1) {
+    this.capacity = Math.max(0, Math.floor(capacity));
+    const n = this.capacity;
+    this.kind = new Uint8Array(n);
+    this.position = new Float32Array(n * 3);
+    this.velocity = new Float32Array(n * 3);
+    this.age = new Float32Array(n);
+    this.life = new Float32Array(n);
+    this.angle = new Float32Array(n);
+    this.spin = new Float32Array(n);
+    this.seed = new Float32Array(n);
+    this.random = mulberry32(seed);
+  }
+  /** Particles in the air. */
+  get count() {
+    return this.live;
+  }
+  /** How many live particles are of one preset. For tests and for a HUD. */
+  countOf(name) {
+    return this.perKind[PRESET_NAMES.indexOf(name)];
+  }
+  /** Launch one particle from a point. Never allocates; at capacity it takes the most-spent slot. */
+  spawn(name, x, y, z) {
+    if (this.capacity === 0) return;
+    const preset = particlePresets[name];
+    let i = this.live;
+    if (i < this.capacity) {
+      this.live++;
+    } else {
+      i = 0;
+      let spent = -1;
+      for (let j = 0; j < this.live; j++) {
+        const f = this.age[j] / this.life[j];
+        if (f > spent) {
+          spent = f;
+          i = j;
+        }
+      }
+      this.perKind[this.kind[i]] = this.perKind[this.kind[i]] - 1;
+    }
+    const r = this.random;
+    this.kind[i] = PRESET_NAMES.indexOf(name);
+    this.perKind[this.kind[i]] = this.perKind[this.kind[i]] + 1;
+    const i3 = i * 3;
+    this.position[i3] = x;
+    this.position[i3 + 1] = y;
+    this.position[i3 + 2] = z;
+    const [dx, dy, dz] = preset.direction;
+    let rx = r() * 2 - 1;
+    let ry = r() * 2 - 1;
+    let rz = r() * 2 - 1;
+    const rl = Math.hypot(rx, ry, rz) || 1;
+    rx /= rl;
+    ry /= rl;
+    rz /= rl;
+    let ox = dx * (1 - preset.spread) + rx * preset.spread;
+    let oy = dy * (1 - preset.spread) + ry * preset.spread;
+    let oz = dz * (1 - preset.spread) + rz * preset.spread;
+    if (ox * dx + oy * dy + oz * dz < 0) {
+      ox = -ox;
+      oy = -oy;
+      oz = -oz;
+    }
+    const ol = Math.hypot(ox, oy, oz) || 1;
+    const speed = preset.speed[0] + (preset.speed[1] - preset.speed[0]) * r();
+    this.velocity[i3] = ox / ol * speed;
+    this.velocity[i3 + 1] = oy / ol * speed;
+    this.velocity[i3 + 2] = oz / ol * speed;
+    this.age[i] = 0;
+    this.life[i] = preset.life[0] + (preset.life[1] - preset.life[0]) * r();
+    this.angle[i] = r() * Math.PI * 2;
+    this.spin[i] = (r() * 2 - 1) * preset.spin;
+    this.seed[i] = r();
+  }
+  /** Advance every particle by `dt` seconds; the dead leave the pool. */
+  step(dt) {
+    if (dt <= 0) return;
+    const r = this.random;
+    const [wx, wy, wz] = this.wind;
+    for (let i = 0; i < this.live; i++) {
+      const before = this.age[i] / this.life[i];
+      this.age[i] = this.age[i] + dt;
+      if (this.seed[i] < 0.1 && before < 0.86 && this.age[i] / this.life[i] >= 0.86) {
+        if (PRESETS[this.kind[i]].blend === "additive") this.pops++;
+      }
+      if (this.age[i] >= this.life[i]) {
+        this.remove(i);
+        i--;
+        continue;
+      }
+      const preset = PRESETS[this.kind[i]];
+      const i3 = i * 3;
+      const drag = Math.min(1, preset.drag * dt);
+      const catchWind = preset.windCatch;
+      const jitter = preset.jitter;
+      let vx = this.velocity[i3];
+      let vy = this.velocity[i3 + 1];
+      let vz = this.velocity[i3 + 2];
+      vx += (wx * catchWind - vx) * drag + (r() * 2 - 1) * jitter * dt;
+      vy += (wy * catchWind - vy) * drag + (preset.lift + (r() * 2 - 1) * jitter) * dt;
+      vz += (wz * catchWind - vz) * drag + (r() * 2 - 1) * jitter * dt;
+      this.velocity[i3] = vx;
+      this.velocity[i3 + 1] = vy;
+      this.velocity[i3 + 2] = vz;
+      this.position[i3] = this.position[i3] + vx * dt;
+      this.position[i3 + 1] = this.position[i3 + 1] + vy * dt;
+      this.position[i3 + 2] = this.position[i3 + 2] + vz * dt;
+      this.angle[i] = this.angle[i] + this.spin[i] * dt;
+    }
+  }
+  /**
+   * Write every live particle into the target for its blend mode. Returns how
+   * many went into each — the draw ranges.
+   */
+  write(additive, normal, flakes) {
+    let a = 0;
+    let n = 0;
+    let f = 0;
+    for (let i = 0; i < this.live; i++) {
+      const preset = PRESETS[this.kind[i]];
+      const flake = flakes !== void 0 && preset.shape === "flake";
+      const target2 = preset.blend === "additive" ? additive : flake ? flakes : normal;
+      const k = preset.blend === "additive" ? a++ : flake ? f++ : n++;
+      const t = this.age[i] / this.life[i];
+      const i3 = i * 3;
+      const k3 = k * 3;
+      target2.position[k3] = this.position[i3];
+      target2.position[k3 + 1] = this.position[i3 + 1];
+      target2.position[k3 + 2] = this.position[i3 + 2];
+      if (target2.velocity) {
+        target2.velocity[k3] = this.velocity[i3];
+        target2.velocity[k3 + 1] = this.velocity[i3 + 1];
+        target2.velocity[k3 + 2] = this.velocity[i3 + 2];
+      }
+      const [c0, c1] = preset.color;
+      const fadeIn = Math.min(1, t / 0.1);
+      const flicker = preset.flicker > 0 ? 1 - preset.flicker * (0.5 + 0.5 * Math.sin(this.age[i] * 41 + this.seed[i] * 97)) : 1;
+      const k4 = k * 4;
+      const pop = preset.blend === "additive" && this.seed[i] < 0.1 && t > 0.86 ? 2.6 : 1;
+      target2.color[k4] = (c0[0] + (c1[0] - c0[0]) * t) * pop;
+      target2.color[k4 + 1] = (c0[1] + (c1[1] - c0[1]) * t) * pop;
+      target2.color[k4 + 2] = (c0[2] + (c1[2] - c0[2]) * t) * pop;
+      target2.color[k4 + 3] = (preset.alpha[0] + (preset.alpha[1] - preset.alpha[0]) * t) * fadeIn * flicker;
+      target2.extra[k4] = preset.size[0] + (preset.size[1] - preset.size[0]) * t;
+      target2.extra[k4 + 1] = this.angle[i];
+      target2.extra[k4 + 2] = preset.shape === "flake" ? 1 : 0;
+      target2.extra[k4 + 3] = this.seed[i];
+    }
+    return { additive: a, normal: n, flakes: f };
+  }
+  /**
+   * How many embers popped in the air since the last call, and reset — one
+   * `FireSound.pop()` each keeps the sound on the frame the flash is on.
+   */
+  takePops() {
+    const n = this.pops;
+    this.pops = 0;
+    return n;
+  }
+  /** Empty the air — a fresh sheet. */
+  clear() {
+    this.live = 0;
+    this.perKind.fill(0);
+  }
+  /** Swap the last live particle into slot `i`. Order does not matter; density does. */
+  remove(i) {
+    this.perKind[this.kind[i]] = this.perKind[this.kind[i]] - 1;
+    const last = --this.live;
+    if (i === last) return;
+    this.kind[i] = this.kind[last];
+    this.age[i] = this.age[last];
+    this.life[i] = this.life[last];
+    this.angle[i] = this.angle[last];
+    this.spin[i] = this.spin[last];
+    this.seed[i] = this.seed[last];
+    this.position.copyWithin(i * 3, last * 3, last * 3 + 3);
+    this.velocity.copyWithin(i * 3, last * 3, last * 3 + 3);
+  }
+};
+
+// src/fx/fire.ts
+var fireEmitterDefaults = {
+  embers: 0.35,
+  smoke: 0,
+  ash: 0.12,
+  seed: 7,
+  caps: {}
+};
+var PER_UPDATE = 24;
+var FireEmitter = class {
+  field;
+  pool;
+  locate;
+  o;
+  emberDebt = 0;
+  smokeDebt = 0;
+  state;
+  constructor(field, pool, locate, options = {}) {
+    this.field = field;
+    this.pool = pool;
+    this.locate = locate;
+    this.o = { ...fireEmitterDefaults, ...options };
+    this.state = this.o.seed >>> 0 || 1;
+  }
+  /** Call once a frame, after the field has stepped. */
+  update(dt) {
+    const { field, o } = this;
+    const front = field.frontCount;
+    const consumed = field.consumedCount;
+    if (front === 0 && consumed === 0) {
+      this.emberDebt = 0;
+      this.smokeDebt = 0;
+      return;
+    }
+    for (let k = 0; k < consumed; k++) {
+      if (this.next() < o.ash) this.emit("ash", field.consumedCells[k]);
+    }
+    if (front > 0 && dt > 0) {
+      const [wx, wy, wz] = this.pool.wind;
+      const air = Math.hypot(wx, wy, wz);
+      let heat = 0;
+      for (let k = 0; k < front; k++) heat += field.data[field.frontCells[k] * 4 + HEAT];
+      heat /= front;
+      const struggle = 0.35 + 1.6 * Math.max(0, 0.7 - heat) + air * 0.8;
+      const oxygen = 1 + air * 1.5;
+      this.emberDebt = Math.min(this.emberDebt + front * o.embers * oxygen * dt, PER_UPDATE);
+      this.smokeDebt = Math.min(this.smokeDebt + front * o.smoke * struggle * dt, PER_UPDATE);
+      while (this.emberDebt >= 1) {
+        this.emberDebt -= 1;
+        this.emit("ember", field.frontCells[Math.floor(this.next() * front)]);
+      }
+      while (this.smokeDebt >= 1) {
+        this.smokeDebt -= 1;
+        this.emit("smoke", field.frontCells[Math.floor(this.next() * front)]);
+      }
+    }
+  }
+  emit(name, cell) {
+    const cap = this.o.caps[name];
+    if (cap !== void 0 && this.pool.countOf(name) >= cap) return;
+    const size = this.field.size;
+    const last = size - 1;
+    const at = this.locate(cell % size / last, (cell / size | 0) / last);
+    if (!at) return;
+    if (name === "ember") {
+      const lift = this.next() * this.next() * 0.09;
+      this.pool.spawn(name, at.x + (this.next() - 0.5) * 0.012, at.y + lift, at.z);
+    } else {
+      this.pool.spawn(name, at.x, at.y, at.z);
+    }
+  }
+  /** xorshift32 — its own stream, so the pool's randomness cannot shift which cells are picked. */
+  next() {
+    let s = this.state;
+    s ^= s << 13;
+    s ^= s >>> 17;
+    s ^= s << 5;
+    this.state = s >>> 0;
+    return this.state / 4294967296;
+  }
+};
+
+// src/fx/FxParticles.tsx
+import * as THREE from "three";
+import { useFrame, useThree } from "@react-three/fiber";
+import { useEffect, useMemo } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var STREAK = 0.045;
+var QUAD_STREAK = new Float32Array([-1, 0, 0, 1, 0, 0, 1, 1, 0, -1, 1, 0]);
+var QUAD_FLAKE = new Float32Array([-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0]);
+var QUAD_INDEX = [0, 1, 2, 0, 2, 3];
+function makeTarget(capacity) {
+  return {
+    position: new Float32Array(capacity * 3),
+    color: new Float32Array(capacity * 4),
+    extra: new Float32Array(capacity * 4),
+    velocity: new Float32Array(capacity * 3)
+  };
+}
+function useInstanced(capacity, quad) {
+  const layer = useMemo(() => {
+    const target2 = makeTarget(capacity);
+    const geometry = new THREE.InstancedBufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(quad, 3));
+    geometry.setIndex(QUAD_INDEX);
+    geometry.setAttribute("aPos", new THREE.InstancedBufferAttribute(target2.position, 3));
+    geometry.setAttribute("aVel", new THREE.InstancedBufferAttribute(target2.velocity, 3));
+    geometry.setAttribute("aColor", new THREE.InstancedBufferAttribute(target2.color, 4));
+    geometry.setAttribute("aExtra", new THREE.InstancedBufferAttribute(target2.extra, 4));
+    geometry.instanceCount = 0;
+    geometry.boundingSphere = new THREE.Sphere(new THREE.Vector3(), Infinity);
+    return { target: target2, geometry };
+  }, [capacity, quad]);
+  useEffect(() => () => layer.geometry.dispose(), [layer]);
+  return layer;
+}
+function usePoints(capacity) {
+  const layer = useMemo(() => {
+    const target2 = makeTarget(capacity);
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(target2.position, 3));
+    geometry.setAttribute("pColor", new THREE.BufferAttribute(target2.color, 4));
+    geometry.setAttribute("pExtra", new THREE.BufferAttribute(target2.extra, 4));
+    geometry.setDrawRange(0, 0);
+    geometry.boundingSphere = new THREE.Sphere(new THREE.Vector3(), Infinity);
+    return { target: target2, geometry };
+  }, [capacity]);
+  useEffect(() => () => layer.geometry.dispose(), [layer]);
+  return layer;
+}
+var OUTPUT = (
+  /* glsl */
+  `
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+`
+);
+var EMBER_VERTEX = (
+  /* glsl */
+  `
+attribute vec3 aPos;
+attribute vec3 aVel;
+attribute vec4 aColor;
+attribute vec4 aExtra; // size, angle, shape, seed
+uniform vec2 uResolution;
+uniform float uStreak;
+varying vec4 vColor;
+varying vec2 vQuad;
+void main() {
+  vec4 head = projectionMatrix * viewMatrix * vec4(aPos, 1.0);
+  vec4 tail = projectionMatrix * viewMatrix * vec4(aPos - aVel * uStreak, 1.0);
+  vec2 half_ = 0.5 * uResolution;
+  vec2 d = head.xy / head.w * half_ - tail.xy / tail.w * half_;
+  float len = length(d);
+  vec2 dir = len > 1e-3 ? d / len : vec2(0.0, 1.0);
+  vec2 across = vec2(-dir.y, dir.x);
+  // Diameter in pixels from a size in world units: the projection's own scale.
+  float px = max(1.5, aExtra.x * projectionMatrix[1][1] * half_.y / head.w);
+  float along = len + px;
+  vec2 offset = across * position.x * px * 0.5 + dir * (px * 0.5 - position.y * along);
+  gl_Position = head + vec4(offset / half_ * head.w, 0.0, 0.0);
+  vColor = aColor;
+  vQuad = position.xy;
+}
+`
+);
+var EMBER_FRAGMENT = (
+  /* glsl */
+  `
+varying vec4 vColor;
+varying vec2 vQuad;
+void main() {
+  // A thin hot core with a soft edge, fading to NOTHING behind the head.
+  //
+  // It used to be flat-topped across (smoothstep from 0.35, so the middle
+  // seventy per cent of the width was all at full brightness) and to keep a
+  // quarter of that brightness all the way to the end of the quad. Both
+  // together drew a wide bar with a squared-off end, which is what the review
+  // saw up close. A spark is a point of light smeared by its own motion: it
+  // is brightest on its centre line and it runs out.
+  float across = abs(vQuad.x);
+  float body = exp(-across * across * 7.0);
+  float tail = clamp(1.0 - vQuad.y, 0.0, 1.0);
+  float m = body * tail * tail;
+  if (m <= 0.003) discard;
+  gl_FragColor = vec4(vColor.rgb * vColor.a * m, 1.0);
+${OUTPUT}
+}
+`
+);
+var SMOKE_VERTEX = (
+  /* glsl */
+  `
+attribute vec4 pColor;
+attribute vec4 pExtra; // size, angle, shape, seed
+uniform float uScale;
+varying vec4 vColor;
+varying vec2 vSpin;
+varying float vSeed;
+void main() {
+  vColor = pColor;
+  vSpin = vec2(cos(pExtra.y), sin(pExtra.y));
+  vSeed = pExtra.w;
+  vec4 view = modelViewMatrix * vec4(position, 1.0);
+  bool perspective = projectionMatrix[2][3] == -1.0;
+  float depth = perspective ? max(0.0001, -view.z) : 1.0;
+  gl_PointSize = max(1.0, pExtra.x * uScale / depth);
+  gl_Position = projectionMatrix * view;
+}
+`
+);
+var SMOKE_FRAGMENT = (
+  /* glsl */
+  `
+varying vec4 vColor;
+varying vec2 vSpin;
+varying float vSeed;
+float smHash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123); }
+float smNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(smHash(i), smHash(i + vec2(1.0, 0.0)), u.x), mix(smHash(i + vec2(0.0, 1.0)), smHash(i + vec2(1.0, 1.0)), u.x), u.y);
+}
+void main() {
+  vec2 p = gl_PointCoord * 2.0 - 1.0;
+  p = vec2(p.x * vSpin.x - p.y * vSpin.y, p.x * vSpin.y + p.y * vSpin.x);
+  float r = length(p);
+  // Not a disc: a soft body torn by two octaves of noise, different for
+  // every puff, so a cloud of them is a texture rather than a pile of dots.
+  float n = smNoise(p * 2.2 + vSeed * 19.0) * 0.65 + smNoise(p * 5.1 + vSeed * 7.0) * 0.35;
+  float body = (1.0 - smoothstep(0.2, 1.0, r)) * smoothstep(0.25, 0.75, n + 0.25 * (1.0 - r));
+  if (body <= 0.0) discard;
+  gl_FragColor = vec4(vColor.rgb, vColor.a * body);
+${OUTPUT}
+}
+`
+);
+var FLAKE_VERTEX = (
+  /* glsl */
+  `
+attribute vec3 aPos;
+attribute vec4 aColor;
+attribute vec4 aExtra; // size, angle, shape, seed
+varying vec2 vQuad;
+varying vec4 vColor;
+varying float vLight;
+varying float vSeed;
+mat3 rotation(vec3 axis, float a) {
+  float c = cos(a);
+  float s = sin(a);
+  float t = 1.0 - c;
+  return mat3(
+    t * axis.x * axis.x + c, t * axis.x * axis.y + s * axis.z, t * axis.x * axis.z - s * axis.y,
+    t * axis.x * axis.y - s * axis.z, t * axis.y * axis.y + c, t * axis.y * axis.z + s * axis.x,
+    t * axis.x * axis.z + s * axis.y, t * axis.y * axis.z - s * axis.x, t * axis.z * axis.z + c
+  );
+}
+void main() {
+  float seed = aExtra.w;
+  // Its own tumbling axis, from its seed: flakes do not spin in step.
+  vec3 axis = normalize(vec3(sin(seed * 40.0), cos(seed * 23.0), 0.4 + sin(seed * 71.0) * 0.5));
+  mat3 r = rotation(axis, aExtra.y);
+  // A little curl: burnt paper does not lie flat.
+  vec3 local = vec3(position.x, position.y, position.x * position.x * 0.45 - 0.2) * aExtra.x * 0.5;
+  vec3 world = aPos + r * local;
+  vec3 n = r * vec3(0.0, 0.0, 1.0);
+  // Lit by which way it faces \u2014 double-sided, so either face catches light.
+  vLight = 0.25 + 0.75 * abs(dot(n, normalize(vec3(-0.35, 0.8, 0.5))));
+  vQuad = position.xy;
+  vColor = aColor;
+  vSeed = seed;
+  gl_Position = projectionMatrix * viewMatrix * vec4(world, 1.0);
+}
+`
+);
+var FLAKE_FRAGMENT = (
+  /* glsl */
+  `
+varying vec2 vQuad;
+varying vec4 vColor;
+varying float vLight;
+varying float vSeed;
+float flHash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123); }
+float flNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(flHash(i), flHash(i + vec2(1.0, 0.0)), u.x), mix(flHash(i + vec2(0.0, 1.0)), flHash(i + vec2(1.0, 1.0)), u.x), u.y);
+}
+void main() {
+  float r = length(vQuad);
+  float a = atan(vQuad.y, vQuad.x);
+  // A torn scrap: an outline that wanders, different for every flake.
+  float edge = 0.62 + 0.3 * flNoise(vec2(a * 1.6 + vSeed * 31.0, vSeed * 7.0));
+  float mask = 1.0 - smoothstep(edge - 0.06, edge, r);
+  if (mask <= 0.0) discard;
+  // Char in the middle, pale brittle ash at the edge (\xA78.3) \u2014 in patches
+  // along it, not all the way round: a flake is a few pixels across, and a
+  // continuous pale rim round a dark middle drew it as a hollow ring.
+  float rim = smoothstep(edge - 0.32, edge - 0.04, r);
+  float patches = smoothstep(0.45, 0.75, flNoise(vec2(a * 2.2 + vSeed * 17.0, vSeed * 13.0)));
+  float grain = flNoise(vQuad * 3.0 + vSeed * 23.0);
+  vec3 charC = vec3(0.05, 0.043, 0.038) * (0.7 + 0.6 * grain);
+  // #A49E9D, the spec's own sample of ash (\xA78.3), in linear.
+  vec3 ashC = vec3(0.372, 0.344, 0.340);
+  // Pale ash with char under it, not char with a pale rim.
+  //
+  // It was the other way round, and the flakes came out near black: at 0.07
+  // linear they fell through the hole onto a black stage and read as dust in
+  // the void. Burnt paper ash is a LIGHT grey \u2014 what makes a flake flash dark
+  // and light as it tumbles is vLight, the face it is showing, not its own
+  // colour being nearly black to begin with.
+  vec3 c = mix(ashC, charC, (1.0 - rim * patches) * 0.45) * vLight;
+  // A few carry a hot edge that fades over their first second or so, on ONE
+  // arc of it \u2014 the side that was burning when it tore off. All the way round
+  // drew it as an orange ring.
+  float young = clamp((vColor.a - 0.55) / 0.4, 0.0, 1.0);
+  float arc = smoothstep(0.25, 0.8, cos(a - vSeed * 40.0));
+  float hotEdge = step(vSeed, 0.3) * rim * arc * young;
+  c += vec3(2.4, 0.6, 0.08) * hotEdge;
+  gl_FragColor = vec4(c, smoothstep(0.0, 0.2, vColor.a) * mask);
+${OUTPUT}
+}
+`
+);
+function FxParticles({ pool }) {
+  const embers = useInstanced(pool.capacity, QUAD_STREAK);
+  const flakes = useInstanced(pool.capacity, QUAD_FLAKE);
+  const smoke = usePoints(pool.capacity);
+  const materials = useMemo(
+    () => ({
+      ember: new THREE.ShaderMaterial({
+        vertexShader: EMBER_VERTEX,
+        fragmentShader: EMBER_FRAGMENT,
+        uniforms: { uResolution: { value: new THREE.Vector2(1, 1) }, uStreak: { value: STREAK } },
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending
+      }),
+      smoke: new THREE.ShaderMaterial({
+        vertexShader: SMOKE_VERTEX,
+        fragmentShader: SMOKE_FRAGMENT,
+        uniforms: { uScale: { value: 100 } },
+        transparent: true,
+        depthWrite: false
+      }),
+      flake: new THREE.ShaderMaterial({
+        vertexShader: FLAKE_VERTEX,
+        fragmentShader: FLAKE_FRAGMENT,
+        transparent: true,
+        depthWrite: false,
+        side: THREE.DoubleSide
+      })
+    }),
+    []
+  );
+  useEffect(
+    () => () => {
+      materials.ember.dispose();
+      materials.smoke.dispose();
+      materials.flake.dispose();
+    },
+    [materials]
+  );
+  const size = useThree((s) => s.size);
+  useFrame(({ gl, camera }) => {
+    const counts = pool.write(embers.target, smoke.target, flakes.target);
+    embers.geometry.instanceCount = counts.additive;
+    flakes.geometry.instanceCount = counts.flakes;
+    smoke.geometry.setDrawRange(0, counts.normal);
+    for (const name of ["aPos", "aVel", "aColor", "aExtra"]) {
+      ;
+      embers.geometry.attributes[name].needsUpdate = counts.additive > 0;
+      flakes.geometry.attributes[name].needsUpdate = counts.flakes > 0;
+    }
+    if (counts.normal > 0) {
+      for (const name of ["position", "pColor", "pExtra"]) {
+        ;
+        smoke.geometry.attributes[name].needsUpdate = true;
+      }
+    }
+    const ratio = gl.getPixelRatio();
+    materials.ember.uniforms.uResolution.value.set(
+      size.width * ratio,
+      size.height * ratio
+    );
+    const projection = camera.projectionMatrix.elements[5] ?? 1;
+    materials.smoke.uniforms.uScale.value = size.height * ratio * 0.5 * projection;
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("mesh", { geometry: embers.geometry, material: materials.ember, frustumCulled: false }),
+    /* @__PURE__ */ jsx("points", { geometry: smoke.geometry, material: materials.smoke, frustumCulled: false }),
+    /* @__PURE__ */ jsx("mesh", { geometry: flakes.geometry, material: materials.flake, frustumCulled: false })
+  ] });
+}
+
+// src/fx/FxPost.tsx
+import { Suspense, lazy } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var Pass = lazy(
+  () => import("./FxPostPass-M66QMVVC.js").then((m) => ({ default: m.FxPostPass })).catch((error) => {
+    warnOnce(error);
+    return { default: (() => null) };
+  })
+);
+var warned = false;
+function warnOnce(cause) {
+  if (warned) return;
+  warned = true;
+  console.warn(
+    "[paperlab/fx] Rendering without FxPost \u2014 fire will not bloom.\nIt needs two optional peers:\n  npm i @react-three/postprocessing postprocessing\nLeave <FxPost> out to go without it deliberately and silence this.",
+    ...cause === void 0 ? [] : [cause]
+  );
+}
+function FxPost(props) {
+  return /* @__PURE__ */ jsx2(Suspense, { fallback: null, children: /* @__PURE__ */ jsx2(Pass, { ...props }) });
+}
+
+// src/fx/afterglow.ts
+var SMOULDER = 0.3;
+var OUT = 4e-3;
+var Afterglow = class {
+  size = FIELD_SIZE;
+  pixels = new Uint8Array(FIELD_SIZE * FIELD_SIZE * 4);
+  field;
+  glow = new Float32Array(FIELD_SIZE * FIELD_SIZE);
+  rate = new Float32Array(FIELD_SIZE * FIELD_SIZE);
+  revision = 0;
+  clock = 0;
+  flare = 0;
+  lastField = -1;
+  lit = false;
+  constructor(field, options = {}) {
+    this.field = field;
+    const [shortest, longest] = options.hold ?? [0.6, 2.2];
+    const seed = (options.seed ?? 5) >>> 0;
+    for (let i = 0; i < this.rate.length; i++) {
+      let h = Math.imul(i ^ seed, 2654435761) >>> 0;
+      h ^= h >>> 15;
+      h = Math.imul(h, 2246822519) >>> 0;
+      const life = shortest + (longest - shortest) * ((h >>> 0) / 4294967296);
+      this.rate[i] = 1 / life;
+    }
+    this.pixels.set(field.pixels);
+  }
+  get version() {
+    return this.revision;
+  }
+  get detail() {
+    return this.field.detail;
+  }
+  /** Its own clock: the beads keep flickering after the field has gone to sleep. */
+  get time() {
+    return this.clock;
+  }
+  /** Whether anything is still glowing that the field no longer is. */
+  get smouldering() {
+    return this.lit;
+  }
+  /**
+   * Advance by `dt`, after the field has stepped. `blow` is the breath on the
+   * sheet, 0..1: it flares what is left (§10.6, "on smoulder: beads flare,
+   * then fade").
+   */
+  step(dt, blow = 0) {
+    if (!(dt > 0)) return;
+    this.clock += dt;
+    this.flare = blow > 0.05 ? Math.min(1, this.flare + dt * 4) : Math.max(0, this.flare - dt * 1.5);
+    const data = this.field.data;
+    const glow = this.glow;
+    let lit = false;
+    for (let i = 0; i < glow.length; i++) {
+      const heat = data[i * 4 + HEAT];
+      const was = glow[i];
+      let next;
+      if (heat >= was) {
+        next = heat;
+      } else {
+        next = Math.max(heat, Math.min(was, SMOULDER) * Math.exp(-dt * this.rate[i]));
+      }
+      if (next < OUT) next = 0;
+      glow[i] = next;
+      if (next > heat + OUT) lit = true;
+    }
+    this.lit = lit;
+    this.sync();
+  }
+  /** Copy the field in, and lay the remembered heat over its heat channel. */
+  sync() {
+    const fieldVersion = this.field.version;
+    if (!this.lit && fieldVersion === this.lastField && this.flare === 0) return;
+    this.lastField = fieldVersion;
+    const src = this.field.pixels;
+    const dst = this.pixels;
+    dst.set(src);
+    const boost = 1 + 0.9 * this.flare;
+    for (let i = 0; i < this.glow.length; i++) {
+      const g = Math.round(Math.min(1, this.glow[i] * boost) * 255);
+      const k = i * 4 + HEAT;
+      if (g > dst[k]) dst[k] = g;
+    }
+    this.revision++;
+  }
+};
+
+// src/fx/FxFlames.tsx
+import { useFrame as useFrame2 } from "@react-three/fiber";
+import { useEffect as useEffect2, useMemo as useMemo2, useRef } from "react";
+
+// src/fx/flameShader.ts
+import * as THREE2 from "three";
+var NOISE = (
+  /* glsl */
+  `
+float flHash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123); }
+float flNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(flHash(i), flHash(i + vec2(1.0, 0.0)), u.x), mix(flHash(i + vec2(0.0, 1.0)), flHash(i + vec2(1.0, 1.0)), u.x), u.y);
+}
+float flFbm(vec2 p) {
+  float v = 0.0;
+  float a = 0.5;
+  for (int i = 0; i < 4; i++) {
+    v += a * flNoise(p);
+    p = p * 2.03 + 17.0;
+    a *= 0.5;
+  }
+  return v;
+}
+float flHash1(float n) { return fract(sin(n) * 43758.5453); }
+float flNoise1(float x) {
+  float i = floor(x);
+  float f = fract(x);
+  f = f * f * (3.0 - 2.0 * f);
+  return mix(flHash1(i), flHash1(i + 1.0), f);
+}
+`
+);
+var VERTEX = (
+  /* glsl */
+  `
+attribute vec3 aBase;
+attribute vec4 aShape; // height, width, seed, heat
+uniform float uTime;
+uniform vec3 uLean;
+varying vec2 vUv;
+varying float vSeed;
+varying float vHeat;
+${NOISE}
+void main() {
+  vUv = position.xy;
+  vSeed = aShape.z;
+  vHeat = aShape.w;
+  // The same puff as \`flamePuff\` in flames.ts \u2014 the fire light reads it too.
+  float puff = 0.72 + 0.28 * flNoise1(uTime * 12.5 + aShape.z * 37.0) + 0.12 * (flNoise1(uTime * 23.0 + aShape.z * 11.0) - 0.5);
+  float h = aShape.x * puff;
+  vec3 up = normalize(vec3(0.0, 1.0, 0.0) + uLean);
+  vec3 toCamera = normalize(cameraPosition - aBase);
+  vec3 right = normalize(cross(up, toCamera));
+  // A curve, not a tilt: the root holds and the tip is carried.
+  vec3 p = aBase + toCamera * 0.004 + right * position.x * aShape.y + up * position.y * h
+    + uLean * position.y * position.y * h * 0.8;
+  gl_Position = projectionMatrix * viewMatrix * vec4(p, 1.0);
+}
+`
+);
+var FRAGMENT = (
+  /* glsl */
+  `
+uniform float uTime;
+uniform float uBlue;
+uniform float uGain;
+varying vec2 vUv;
+varying float vSeed;
+varying float vHeat;
+${NOISE}
+void main() {
+  // The quad is 1.8\xD7 the flame's width, so the turbulence can carry the
+  // flame sideways without the quad's own edge cutting it into a bar.
+  float x = vUv.x * 1.8;
+  float y = vUv.y;
+  // Climbing at a speed that itself wanders \u2014 per flame, and over time \u2014 so
+  // the motion never settles into a loop. An offset, not a rate \xD7 time: a
+  // rate that changes would make the pattern jump.
+  float climb = uTime * (2.7 + 0.9 * vSeed) + 1.8 * flNoise1(uTime * 0.37 + vSeed * 9.1);
+  // Three layers of turbulence: a slow sway of the whole tongue, a flutter
+  // near the tip, and a fine shiver \u2014 each warping the next.
+  vec2 q = vec2(x * 1.2 + vSeed * 13.0, y * 1.9 - climb);
+  float sway = flFbm(q);
+  float flutter = flFbm(vec2(x * 2.7 + vSeed * 5.0 + sway * 1.3, y * 4.3 - climb * 1.55));
+  float shiver = flNoise(vec2(x * 7.0 + vSeed * 3.0, y * 11.0 - climb * 2.4));
+  // Every tongue leans its own way \u2014 nothing here is symmetrical.
+  float lean = (fract(vSeed * 91.7) - 0.5) * 0.45;
+  float xw = x + (sway - 0.5) * 1.35 * y + (flutter - 0.5) * 0.5 * y * y + (shiver - 0.5) * 0.12 * y + lean * y;
+  // The teardrop: dense and wide at the source, a point at the top.
+  float half_ = 1.0 * pow(max(y, 0.0), 0.3) * pow(max(1.0 - y, 0.0), 1.3);
+  // Crisp and dense low down, soft and translucent higher up.
+  float body = 1.0 - smoothstep(half_ * mix(0.82, 0.4, y), half_, abs(xw));
+  // Tips that split: a hard threshold high up tears the flame into separate
+  // tongues and wisps that come loose ...
+  float tear = flFbm(vec2(x * 2.4 + vSeed * 7.0, y * 4.2 - climb * 1.7));
+  body *= smoothstep(0.0, 0.14, tear + 0.82 - y * 1.1);
+  // ... and small gaps open inside the upper body, where the gas is thin.
+  float gaps = smoothstep(0.58, 0.72, flFbm(vec2(x * 3.3 - vSeed * 4.0, y * 6.5 - climb * 2.0)));
+  body *= 1.0 - gaps * smoothstep(0.3, 0.8, y) * 0.95;
+  body *= smoothstep(0.0, 0.04, y);
+  // The source is hot and dense: orange-white at the root, yellow above it,
+  // orange at the edges and tips, and translucent as it thins.
+  vec3 white = vec3(1.0, 0.86, 0.62);   // orange-white
+  vec3 yellow = vec3(0.98, 0.62, 0.09); // #FDCE54
+  vec3 orange = vec3(0.77, 0.2, 0.0);   // #E37B04
+  // The orange-white is only the very root; above it the flame is saturated
+  // yellow, then orange. Mixed broadly it washed the whole tongue pale.
+  float base = 1.0 - smoothstep(0.0, 0.26, y);
+  float inner = 1.0 - smoothstep(0.0, half_ * 0.5, abs(xw));
+  vec3 c = mix(orange, yellow, smoothstep(0.35, 0.85, body * (1.0 - y * 0.85)));
+  c = mix(c, white, clamp(base * inner, 0.0, 1.0));
+  // Dense at the source, and bright enough there to bloom; thinning above.
+  c *= mix(1.0, 4.4, base * (0.45 + 0.55 * inner)) * (0.55 + 0.45 * vHeat) * uGain;
+  // Only a match starved of air by moving fast burns blue.
+  c = mix(c, vec3(0.027, 0.025, 0.099) * 2.5, uBlue * 0.75);
+  float fade = 1.0 - smoothstep(0.55, 1.0, y);
+  gl_FragColor = vec4(c * body * fade, 1.0);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}
+`
+);
+function flameGeometry(max) {
+  const g = new THREE2.InstancedBufferGeometry();
+  g.setAttribute(
+    "position",
+    new THREE2.BufferAttribute(new Float32Array([-1, 0, 0, 1, 0, 0, 1, 1, 0, -1, 1, 0]), 3)
+  );
+  g.setIndex([0, 1, 2, 0, 2, 3]);
+  g.setAttribute("aBase", new THREE2.InstancedBufferAttribute(new Float32Array(Math.max(1, max) * 3), 3));
+  g.setAttribute("aShape", new THREE2.InstancedBufferAttribute(new Float32Array(Math.max(1, max) * 4), 4));
+  g.instanceCount = 0;
+  g.boundingSphere = new THREE2.Sphere(new THREE2.Vector3(), Infinity);
+  return g;
+}
+function flameMaterial() {
+  return new THREE2.ShaderMaterial({
+    vertexShader: VERTEX,
+    fragmentShader: FRAGMENT,
+    uniforms: {
+      uTime: { value: 0 },
+      uLean: { value: new THREE2.Vector3() },
+      uBlue: { value: 0 },
+      uGain: { value: 1 }
+    },
+    transparent: true,
+    depthWrite: false,
+    blending: THREE2.AdditiveBlending,
+    side: THREE2.DoubleSide
+  });
+}
+
+// src/fx/FxFlames.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function FxFlames({ field, locate, quality = "medium", wind }) {
+  const max = fxQualityFor(quality).flames;
+  const anchors = useRef([]);
+  const geometry = useMemo2(() => flameGeometry(max), [max]);
+  useEffect2(() => () => geometry.dispose(), [geometry]);
+  const material = useMemo2(() => flameMaterial(), []);
+  useEffect2(() => () => material.dispose(), [material]);
+  useFrame2(() => {
+    const n = flameAnchors(field, locate, max, anchors.current);
+    const base = geometry.getAttribute("aBase");
+    const shape = geometry.getAttribute("aShape");
+    const [wx, wy, wz] = wind ?? [0, 0, 0];
+    const gust = Math.hypot(wx, wy, wz);
+    const shorten = 1 / (1 + gust * 0.6);
+    for (let i = 0; i < n; i++) {
+      const a = anchors.current[i];
+      base.array[i * 3] = a.x;
+      base.array[i * 3 + 1] = a.y;
+      base.array[i * 3 + 2] = a.z;
+      shape.array[i * 4] = a.height * shorten;
+      shape.array[i * 4 + 1] = a.width;
+      shape.array[i * 4 + 2] = a.seed;
+      shape.array[i * 4 + 3] = a.heat;
+    }
+    base.needsUpdate = true;
+    shape.needsUpdate = true;
+    geometry.instanceCount = n;
+    material.uniforms.uTime.value = field.time;
+    material.uniforms.uLean.value.set(wx * 0.5, 0, wz * 0.5);
+  });
+  return /* @__PURE__ */ jsx3("mesh", { geometry, material, frustumCulled: false, renderOrder: 2 });
+}
+
+// src/fx/FxWisps.tsx
+import * as THREE3 from "three";
+import { useFrame as useFrame3 } from "@react-three/fiber";
+import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef2 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function wispAlpha(age) {
+  if (!(age >= 0 && age < LIFE)) return 0;
+  return Math.min(1, age / 0.25) * (1 - age / LIFE) ** 1.6 * 0.42;
+}
+var WISPS = 2;
+var POINTS = 64;
+var LIFE = 3.4;
+var RISE = 0.075;
+var APART = 9;
+function FxWisps({ glow, field, locate, wind }) {
+  const state = useRef2(
+    Array.from({ length: WISPS }, (_, w) => ({
+      cell: -1,
+      phase: w * 3.1 + 0.7,
+      // Ring buffer of births: root position and birth time.
+      root: new Float32Array(POINTS * 3),
+      born: new Float32Array(POINTS).fill(-1e9),
+      next: 0,
+      owed: 0
+    }))
+  );
+  const last = useRef2(-1);
+  const geometry = useMemo3(() => {
+    const g = new THREE3.BufferGeometry();
+    const vertices = WISPS * POINTS * 2;
+    g.setAttribute("position", new THREE3.BufferAttribute(new Float32Array(vertices * 3), 3));
+    g.setAttribute("aAlpha", new THREE3.BufferAttribute(new Float32Array(vertices), 1));
+    const index = [];
+    for (let w = 0; w < WISPS; w++) {
+      for (let i = 0; i < POINTS - 1; i++) {
+        const a = (w * POINTS + i) * 2;
+        index.push(a, a + 1, a + 2, a + 1, a + 3, a + 2);
+      }
+    }
+    g.setIndex(index);
+    g.boundingSphere = new THREE3.Sphere(new THREE3.Vector3(), Infinity);
+    return g;
+  }, []);
+  useEffect3(() => () => geometry.dispose(), [geometry]);
+  const material = useMemo3(
+    () => new THREE3.ShaderMaterial({
+      vertexShader: (
+        /* glsl */
+        `
+          attribute float aAlpha;
+          varying float vAlpha;
+          void main() {
+            vAlpha = aAlpha;
+            gl_Position = projectionMatrix * viewMatrix * vec4(position, 1.0);
+          }
+        `
+      ),
+      fragmentShader: (
+        /* glsl */
+        `
+          varying float vAlpha;
+          void main() {
+            // Pale grey smoke, thin enough that only its accumulation reads.
+            gl_FragColor = vec4(vec3(0.62, 0.61, 0.6), vAlpha);
+            #include <tonemapping_fragment>
+            #include <colorspace_fragment>
+          }
+        `
+      ),
+      transparent: true,
+      depthWrite: false,
+      side: THREE3.DoubleSide
+    }),
+    []
+  );
+  useEffect3(() => () => material.dispose(), [material]);
+  useFrame3(({ camera }) => {
+    const now = glow.time;
+    const dt = last.current < 0 ? 0 : Math.min(0.1, Math.max(0, now - last.current));
+    last.current = now;
+    const beads = smoulderingBeads(glow, field, WISPS);
+    const [wx, , wz] = wind ?? [0, 0, 0];
+    const positions = geometry.getAttribute("position");
+    const alphas = geometry.getAttribute("aAlpha");
+    const p = new THREE3.Vector3();
+    const q = new THREE3.Vector3();
+    const toCamera = new THREE3.Vector3();
+    const side = new THREE3.Vector3();
+    const path = new Float32Array(POINTS * 3);
+    const age = new Float32Array(POINTS);
+    for (let w = 0; w < WISPS; w++) {
+      const s = state.current[w];
+      if (!beads.includes(s.cell)) {
+        const taken = beads.find((c) => !state.current.some((o) => o !== s && o.cell === c)) ?? -1;
+        if (taken !== s.cell) {
+          s.born.fill(-1e9);
+          s.next = 0;
+          s.owed = 0;
+        }
+        s.cell = taken;
+      }
+      if (s.cell >= 0 && dt > 0) {
+        s.owed += dt;
+        const every = LIFE / POINTS;
+        while (s.owed >= every) {
+          s.owed -= every;
+          const at = locate(
+            s.cell % FIELD_SIZE / (FIELD_SIZE - 1),
+            (s.cell / FIELD_SIZE | 0) / (FIELD_SIZE - 1)
+          );
+          if (!at) break;
+          const k = s.next;
+          s.root[k * 3] = at.x;
+          s.root[k * 3 + 1] = at.y;
+          s.root[k * 3 + 2] = at.z + 4e-3;
+          s.born[k] = now;
+          s.next = (k + 1) % POINTS;
+        }
+      }
+      for (let i = 0; i < POINTS; i++) {
+        const k = (s.next - 1 - i + POINTS * 2) % POINTS;
+        const a = now - s.born[k];
+        age[i] = a;
+        const bx = s.root[k * 3];
+        const by = s.root[k * 3 + 1];
+        const bz = s.root[k * 3 + 2];
+        const sway = (noise1(a * 0.8 + s.born[k] * 0.3 + s.phase) - 0.5) * 0.07 * a;
+        const lean = (noise1(a * 0.5 + s.phase * 2.3) - 0.5) * 0.02 * a;
+        path[i * 3] = bx + sway + wx * a * a * 0.25;
+        path[i * 3 + 1] = by + RISE * a * (1 + 0.18 * a);
+        path[i * 3 + 2] = bz + lean + wz * a * a * 0.25;
+      }
+      let anchor = -1;
+      for (let i = 0; i < POINTS; i++) {
+        if (age[i] >= 0 && age[i] < LIFE) {
+          anchor = i;
+          break;
+        }
+      }
+      for (let i = 0; i < POINTS; i++) {
+        const a = age[i];
+        if (!(a >= 0 && a < LIFE)) {
+          if (anchor >= 0) {
+            path[i * 3] = path[anchor * 3];
+            path[i * 3 + 1] = path[anchor * 3 + 1];
+            path[i * 3 + 2] = path[anchor * 3 + 2];
+          } else {
+            const r = (s.next - 1 + POINTS) % POINTS * 3;
+            path[i * 3] = s.root[r];
+            path[i * 3 + 1] = s.root[r + 1];
+            path[i * 3 + 2] = s.root[r + 2];
+          }
+        } else {
+          anchor = i;
+        }
+      }
+      for (let i = 0; i < POINTS; i++) {
+        const a = age[i];
+        p.set(path[i * 3], path[i * 3 + 1], path[i * 3 + 2]);
+        const j = Math.min(POINTS - 1, i + 1);
+        const h = Math.max(0, i - 1);
+        q.set(
+          path[j * 3] - path[h * 3],
+          path[j * 3 + 1] - path[h * 3 + 1],
+          path[j * 3 + 2] - path[h * 3 + 2]
+        );
+        toCamera.copy(camera.position).sub(p);
+        const alive = a >= 0 && a < LIFE;
+        if (alive || i === 0) {
+          side.crossVectors(q, toCamera);
+          if (side.lengthSq() < 1e-20) side.set(1, 0, 0);
+          side.normalize();
+        }
+        const half = 11e-4 + 22e-4 * Math.min(1, Math.max(0, a) / LIFE);
+        const v = (w * POINTS + i) * 2;
+        positions.setXYZ(v, p.x - side.x * half, p.y - side.y * half, p.z - side.z * half);
+        positions.setXYZ(v + 1, p.x + side.x * half, p.y + side.y * half, p.z + side.z * half);
+        const alpha = wispAlpha(a);
+        alphas.setX(v, alpha);
+        alphas.setX(v + 1, alpha);
+      }
+    }
+    positions.needsUpdate = true;
+    alphas.needsUpdate = true;
+  });
+  return /* @__PURE__ */ jsx4("mesh", { geometry, material, frustumCulled: false, renderOrder: 1 });
+}
+function smoulderingBeads(glow, field, max) {
+  const size = FIELD_SIZE;
+  const shown = glow.pixels;
+  const heat = field.pixels;
+  const found = [];
+  for (let y = 1; y < size - 1; y++) {
+    for (let x = 1; x < size - 1; x++) {
+      const c = y * size + x;
+      const g = shown[c * 4 + HEAT];
+      if (g < 10 || heat[c * 4 + HEAT] > 4 || shown[c * 4 + PRESENCE] < 128) continue;
+      const rim = shown[(c - 1) * 4 + PRESENCE] < 128 || shown[(c + 1) * 4 + PRESENCE] < 128 || shown[(c - size) * 4 + PRESENCE] < 128 || shown[(c + size) * 4 + PRESENCE] < 128;
+      if (rim) found.push({ cell: c, g });
+    }
+  }
+  found.sort((a, b) => b.g - a.g || a.cell - b.cell);
+  const picked = [];
+  for (const f of found) {
+    if (picked.length >= max) break;
+    const fx = f.cell % size;
+    const fy = f.cell / size | 0;
+    if (picked.every((p) => Math.hypot(p % size - fx, (p / size | 0) - fy) >= APART)) picked.push(f.cell);
+  }
+  return picked;
+}
+function hash1(n) {
+  const s = Math.sin(n) * 43758.5453;
+  return s - Math.floor(s);
+}
+function noise1(x) {
+  const i = Math.floor(x);
+  let f = x - i;
+  f = f * f * (3 - 2 * f);
+  return hash1(i) + (hash1(i + 1) - hash1(i)) * f;
+}
+
+// src/fx/FxFireFluid.tsx
+import * as THREE5 from "three";
+import { useFrame as useFrame4, useThree as useThree2 } from "@react-three/fiber";
+import { useEffect as useEffect4, useMemo as useMemo4, useRef as useRef3 } from "react";
+
+// src/fx/fluid/FireFluid.ts
+import * as THREE4 from "three";
+
+// src/fx/fluid/passes.ts
+var MAX_SOURCES = 64;
+var PASS_VERTEX = (
+  /* glsl */
+  `
+varying vec2 vUv;
+void main() {
+  vUv = position.xy * 0.5 + 0.5;
+  gl_Position = vec4(position.xy, 0.0, 1.0);
+}
+`
+);
+var NOISE2 = (
+  /* glsl */
+  `
+float fxHash(vec2 p) {
+  vec3 p3 = fract(vec3(p.xyx) * 0.1031);
+  p3 += dot(p3, p3.yzx + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+float fxNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(fxHash(i), fxHash(i + vec2(1.0, 0.0)), u.x), mix(fxHash(i + vec2(0.0, 1.0)), fxHash(i + vec2(1.0, 1.0)), u.x), u.y);
+}
+float fxFbm(vec2 p) {
+  float v = 0.0;
+  float a = 0.5;
+  for (int i = 0; i < 3; i++) {
+    v += a * fxNoise(p);
+    p = p * 2.07 + 13.0;
+    a *= 0.5;
+  }
+  return v;
+}
+float fxHash3(vec3 p) {
+  vec3 p3 = fract(p * 0.1031);
+  p3 += dot(p3, p3.zyx + 31.32);
+  return fract((p3.x + p3.y) * p3.z);
+}
+float fxNoise3(vec3 p) {
+  vec3 i = floor(p);
+  vec3 f = fract(p);
+  vec3 u = f * f * (3.0 - 2.0 * f);
+  float a = mix(mix(fxHash3(i), fxHash3(i + vec3(1.0, 0.0, 0.0)), u.x), mix(fxHash3(i + vec3(0.0, 1.0, 0.0)), fxHash3(i + vec3(1.0, 1.0, 0.0)), u.x), u.y);
+  float b = mix(mix(fxHash3(i + vec3(0.0, 0.0, 1.0)), fxHash3(i + vec3(1.0, 0.0, 1.0)), u.x), mix(fxHash3(i + vec3(0.0, 1.0, 1.0)), fxHash3(i + vec3(1.0, 1.0, 1.0)), u.x), u.y);
+  return mix(a, b, u.z);
+}
+float fxFbm3(vec3 p) {
+  float v = 0.0;
+  float a = 0.5;
+  for (int i = 0; i < 3; i++) {
+    v += a * fxNoise3(p);
+    p = p * 2.07 + 13.0;
+    a *= 0.5;
+  }
+  return v;
+}
+`
+);
+var SOURCES = (
+  /* glsl */
+  `
+uniform vec4 uSources[${MAX_SOURCES}];
+uniform vec4 uAcross[${MAX_SOURCES}];
+uniform int uCount;
+uniform float uAspect;
+float fxEmission(vec2 uv, out vec2 outward, out float smoulder) {
+  float e = 0.0;
+  outward = vec2(0.0);
+  smoulder = 0.0;
+  for (int i = 0; i < ${MAX_SOURCES}; i++) {
+    if (i >= uCount) break;
+    vec4 s = uSources[i];
+    vec4 k = uAcross[i];
+    vec2 d = (uv - s.xy) * vec2(uAspect, 1.0);
+    vec2 n = k.xy;
+    float across = dot(d, n) - k.w;
+    float along = dot(d, vec2(-n.y, n.x));
+    float g = abs(s.w) * exp(-along * along / (s.z * s.z) - across * across / (k.z * k.z));
+    if (s.w < 0.0) {
+      smoulder += g;
+      continue;
+    }
+    e += g;
+    // Off the edge, away from the paper it came from.
+    outward -= g * n;
+  }
+  return e;
+}
+`
+);
+var EMIT = (
+  /* glsl */
+  `
+varying vec2 vUv;
+${SOURCES}
+void main() {
+  vec2 outward;
+  float smoulder;
+  float e = fxEmission(vUv, outward, smoulder);
+  gl_FragColor = vec4(e, outward, smoulder);
+}
+`
+);
+var ADVECT = (
+  /* glsl */
+  `
+uniform sampler2D uVelocity;
+uniform sampler2D uSource;
+uniform vec2 uDomain;
+uniform float uDt;
+uniform vec4 uKeep;
+varying vec2 vUv;
+void main() {
+  vec2 v = texture2D(uVelocity, vUv).xy;
+  vec2 back = vUv - v * uDt / uDomain;
+  gl_FragColor = texture2D(uSource, back) * uKeep;
+}
+`
+);
+var MACCORMACK = (
+  /* glsl */
+  `
+uniform sampler2D uVelocity;
+uniform sampler2D uSource;
+uniform sampler2D uForward;
+uniform sampler2D uBackward;
+uniform vec2 uDomain;
+uniform vec2 uTexel;
+uniform float uDt;
+varying vec2 vUv;
+void main() {
+  vec4 forward = texture2D(uForward, vUv);
+  vec4 phi = forward + 0.5 * (texture2D(uSource, vUv) - texture2D(uBackward, vUv));
+  vec2 v = texture2D(uVelocity, vUv).xy;
+  vec2 back = vUv - v * uDt / uDomain;
+  vec2 corner = (floor(back / uTexel - 0.5) + 0.5) * uTexel;
+  vec4 a = texture2D(uSource, corner);
+  vec4 b = texture2D(uSource, corner + vec2(uTexel.x, 0.0));
+  vec4 c = texture2D(uSource, corner + vec2(0.0, uTexel.y));
+  vec4 d = texture2D(uSource, corner + uTexel);
+  gl_FragColor = clamp(phi, min(min(a, b), min(c, d)), max(max(a, b), max(c, d)));
+}
+`
+);
+var REACT = (
+  /* glsl */
+  `
+uniform sampler2D uA;
+uniform sampler2D uB;
+uniform sampler2D uEmit;
+uniform sampler2D uVelocity;
+uniform vec2 uDomain;
+uniform vec2 uTexel;
+uniform int uOut;
+uniform float uDt;
+uniform float uFuel;
+uniform float uHeat;
+uniform float uSmoke;
+uniform float uPremixed;
+uniform float uAmbient;
+uniform float uBurnRate;
+uniform float uHeatRelease;
+uniform float uCooling;
+uniform float uSmokeProduction;
+uniform float uSmokeFade;
+uniform float uPersistence;
+uniform float uMixing;
+uniform float uEntrain;
+uniform float uFuelBlock;
+uniform float uSootYield;
+uniform float uSootHeat;
+uniform float uStoich;
+uniform float uSmoulderSmoke;
+uniform float uSmoulderHeat;
+varying vec2 vUv;
+void main() {
+  vec4 a = texture2D(uA, vUv);
+  vec4 b = texture2D(uB, vUv);
+  // What a parcel picked up crossing the rim during the step \u2014 sampled back
+  // along its path, not at the one point it ended at. The band gas comes off
+  // is ~2 mm across and the gas crosses it at ~5 mm a step at 60 Hz, so a
+  // point sample drew one line of fuel per step: horizontal stripes up every
+  // tongue.
+  vec2 path = texture2D(uVelocity, vUv).xy * uDt / uDomain;
+  vec4 em = 0.25 * (texture2D(uEmit, vUv) + texture2D(uEmit, vUv - path * 0.25) +
+    texture2D(uEmit, vUv - path * 0.5) + texture2D(uEmit, vUv - path * 0.75));
+  float e = em.r;
+  // What the rim releases this step \u2014 and, where a flame has gone out, the
+  // warm smoke the spot goes on giving off for a while.
+  float fuel = a.r + e * uFuel * uDt;
+  float heat = a.g + (e * uHeat + em.a * uSmoulderHeat) * uDt;
+  float smoke = a.b + (e * uSmoke + em.a * uSmoulderSmoke) * uDt;
+  float premixed = b.r + e * uFuel * uPremixed * uDt;
+  // Air, mixed in from beside and entrained from in front and behind.
+  float around = 0.25 * (
+    texture2D(uB, vUv + vec2(uTexel.x, 0.0)).g + texture2D(uB, vUv - vec2(uTexel.x, 0.0)).g +
+    texture2D(uB, vUv + vec2(0.0, uTexel.y)).g + texture2D(uB, vUv - vec2(0.0, uTexel.y)).g);
+  float oxygen = mix(b.g, around, uMixing);
+  float reach = exp(-fuel / max(uFuelBlock, 1e-4));
+  oxygen += (uAmbient - oxygen) * (1.0 - exp(-uEntrain * reach * uDt));
+  // Fuel burns only as far as there is oxygen for it \u2014 premixed first \u2014 and a
+  // unit of fuel takes uStoich of air. At one to one (as it once was) fuel was
+  // never denser than the air around it, so nothing ever ran out of air and
+  // every scrap of fuel burnt where it stood: no core, no tip.
+  float burn = min(fuel, premixed + oxygen / uStoich) * (1.0 - exp(-uBurnRate * uDt));
+  fuel = max(0.0, fuel - burn) * exp(-uDt * 0.6);
+  float fromPremixed = min(premixed, burn);
+  premixed = max(0.0, premixed - fromPremixed) * exp(-uDt * 0.6);
+  oxygen = max(0.0, oxygen - (burn - fromPremixed) * uStoich);
+  heat = (heat + burn * uHeatRelease) * exp(-uCooling * uDt);
+  float flameHeat = (b.a + burn * uHeatRelease) * exp(-uCooling * uDt);
+  smoke = (smoke + burn * uSmokeProduction) * exp(-uDt / uSmokeFade);
+  float rate = burn / max(uDt, 1e-4);
+  // Soot: forms from hot fuel, burns where there is air, and is gone once the
+  // gas is too cool to glow.
+  float hot = heat / max(uSootHeat, 1e-3);
+  float soot = a.a + uSootYield * (fuel + burn) * smoothstep(0.3, 0.8, hot) * uDt;
+  float air = oxygen / max(uAmbient, 0.05);
+  // Soot that cools stops glowing within a few frames \u2014 it is smoke now, and
+  // the smoke channel already carries that. Held to glowing only below a
+  // twentieth of uSootHeat, it outlived the flame by a hand's breadth and
+  // drew ribbons and hooks of flame colour high over the sheet.
+  float cold = 1.0 - smoothstep(0.2, 0.6, hot);
+  soot *= exp(-uDt * (air / max(uPersistence, 1e-3) + cold * 25.0));
+  // An open top: whatever reaches it leaves.
+  float open = 1.0 - smoothstep(0.9, 1.0, vUv.y);
+  if (uOut == 0) gl_FragColor = vec4(fuel, heat, smoke * open, soot) * vec4(open, open, 1.0, open);
+  else gl_FragColor = vec4(premixed * open, oxygen, rate, flameHeat * open);
+}
+`
+);
+var FORCES = (
+  /* glsl */
+  `
+uniform sampler2D uVelocity;
+uniform sampler2D uA;
+uniform sampler2D uEmit;
+uniform vec2 uTexel;
+uniform vec2 uDomain;
+uniform float uDt;
+uniform float uTime;
+uniform float uBuoyancy;
+uniform float uWind;
+uniform float uTurbulence;
+uniform float uTurbScale;
+uniform float uTurbEvolve;
+uniform float uRadial;
+uniform vec2 uInitVel;
+varying vec2 vUv;
+${NOISE2}
+void main() {
+  vec2 v = texture2D(uVelocity, vUv).xy;
+  vec4 a = texture2D(uA, vUv);
+  // Hot gas rises.
+  v.y += uBuoyancy * a.g * uDt;
+  v.x += uWind * uDt;
+  // Curl noise: divergence-free eddies, in world units, carried up with the
+  // gas AND changing as they go. The third coordinate is time: a 2D pattern
+  // that only scrolled was a wave travelling up a still flame, never a flame
+  // that flickers.
+  float drift = uTime * 0.8 + 1.7 * fxNoise(vec2(uTime * 0.23, 3.1));
+  vec3 p = vec3(vUv * uDomain * uTurbScale + vec2(0.37 * fxNoise(vec2(uTime * 0.17, 9.0)), -drift), uTime * uTurbEvolve);
+  float h = 0.04;
+  float n = fxFbm3(p);
+  vec2 curl = vec2(fxFbm3(p + vec3(0.0, h, 0.0)) - n, -(fxFbm3(p + vec3(h, 0.0, 0.0)) - n)) / h;
+  v += curl * uTurbulence * uDt * (0.2 + clamp(a.g, 0.0, 2.0));
+  // The gas leaves the paper at its own speed, pushed off the edge if asked.
+  vec4 em = texture2D(uEmit, vUv);
+  float e = em.r;
+  vec2 launch = uInitVel + uRadial * em.gb / max(e, 1e-4);
+  v = mix(v, launch, clamp(e * uDt * 6.0, 0.0, 1.0));
+  // Walls on three sides; the top is open.
+  if (vUv.x < uTexel.x || vUv.x > 1.0 - uTexel.x || vUv.y < uTexel.y) v = vec2(0.0);
+  gl_FragColor = vec4(v, 0.0, 1.0);
+}
+`
+);
+var CURL = (
+  /* glsl */
+  `
+uniform sampler2D uVelocity;
+uniform vec2 uTexel;
+uniform float uCell;
+varying vec2 vUv;
+void main() {
+  float l = texture2D(uVelocity, vUv - vec2(uTexel.x, 0.0)).y;
+  float r = texture2D(uVelocity, vUv + vec2(uTexel.x, 0.0)).y;
+  float b = texture2D(uVelocity, vUv - vec2(0.0, uTexel.y)).x;
+  float t = texture2D(uVelocity, vUv + vec2(0.0, uTexel.y)).x;
+  gl_FragColor = vec4((r - l - t + b) * 0.5 / uCell, 0.0, 0.0, 1.0);
+}
+`
+);
+var VORTICITY = (
+  /* glsl */
+  `
+uniform sampler2D uVelocity;
+uniform sampler2D uCurl;
+uniform vec2 uTexel;
+uniform float uCell;
+uniform float uDt;
+uniform float uVorticity;
+varying vec2 vUv;
+void main() {
+  float l = abs(texture2D(uCurl, vUv - vec2(uTexel.x, 0.0)).x);
+  float r = abs(texture2D(uCurl, vUv + vec2(uTexel.x, 0.0)).x);
+  float b = abs(texture2D(uCurl, vUv - vec2(0.0, uTexel.y)).x);
+  float t = abs(texture2D(uCurl, vUv + vec2(0.0, uTexel.y)).x);
+  float w = texture2D(uCurl, vUv).x;
+  vec2 n = vec2(r - l, t - b);
+  n /= length(n) + 1e-5;
+  vec2 v = texture2D(uVelocity, vUv).xy + uVorticity * uCell * vec2(n.y, -n.x) * w * uDt;
+  gl_FragColor = vec4(v, 0.0, 1.0);
+}
+`
+);
+var DIVERGENCE = (
+  /* glsl */
+  `
+uniform sampler2D uVelocity;
+uniform sampler2D uB;
+uniform vec2 uTexel;
+uniform float uCell;
+uniform float uExpansion;
+varying vec2 vUv;
+void main() {
+  float l = texture2D(uVelocity, vUv - vec2(uTexel.x, 0.0)).x;
+  float r = texture2D(uVelocity, vUv + vec2(uTexel.x, 0.0)).x;
+  float b = texture2D(uVelocity, vUv - vec2(0.0, uTexel.y)).y;
+  float t = texture2D(uVelocity, vUv + vec2(0.0, uTexel.y)).y;
+  float div = (r - l + t - b) * 0.5 / uCell - uExpansion * texture2D(uB, vUv).b;
+  gl_FragColor = vec4(div, 0.0, 0.0, 1.0);
+}
+`
+);
+var PRESSURE = (
+  /* glsl */
+  `
+uniform sampler2D uPressure;
+uniform sampler2D uDivergence;
+uniform vec2 uTexel;
+uniform float uCell;
+varying vec2 vUv;
+void main() {
+  float l = texture2D(uPressure, vUv - vec2(uTexel.x, 0.0)).x;
+  float r = texture2D(uPressure, vUv + vec2(uTexel.x, 0.0)).x;
+  float b = texture2D(uPressure, vUv - vec2(0.0, uTexel.y)).x;
+  float t = texture2D(uPressure, vUv + vec2(0.0, uTexel.y)).x;
+  float div = texture2D(uDivergence, vUv).x;
+  gl_FragColor = vec4((l + r + b + t - div * uCell * uCell) * 0.25, 0.0, 0.0, 1.0);
+}
+`
+);
+var GRADIENT = (
+  /* glsl */
+  `
+uniform sampler2D uVelocity;
+uniform sampler2D uPressure;
+uniform vec2 uTexel;
+uniform float uCell;
+varying vec2 vUv;
+void main() {
+  float l = texture2D(uPressure, vUv - vec2(uTexel.x, 0.0)).x;
+  float r = texture2D(uPressure, vUv + vec2(uTexel.x, 0.0)).x;
+  float b = texture2D(uPressure, vUv - vec2(0.0, uTexel.y)).x;
+  float t = texture2D(uPressure, vUv + vec2(0.0, uTexel.y)).x;
+  vec2 v = texture2D(uVelocity, vUv).xy - vec2(r - l, t - b) * 0.5 / uCell;
+  gl_FragColor = vec4(v, 0.0, 1.0);
+}
+`
+);
+var FILL = (
+  /* glsl */
+  `
+uniform vec4 uValue;
+void main() {
+  gl_FragColor = uValue;
+}
+`
+);
+var RENDER_VERTEX = (
+  /* glsl */
+  `
+varying vec2 vUv;
+void main() {
+  vUv = uv;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}
+`
+);
+var RENDER_FRAGMENT = (
+  /* glsl */
+  `
+uniform sampler2D uA;
+uniform sampler2D uB;
+uniform float uTime;
+uniform float uGlow;
+uniform float uSmokeDensity;
+uniform float uPaperWhite;
+uniform float uHeatScale;
+uniform float uSootScale;
+uniform float uContrast;
+uniform float uOpacity;
+uniform float uThin;
+uniform vec3 uTipColor;
+uniform vec3 uBodyColor;
+uniform vec3 uCoreColor;
+uniform vec3 uRootColor;
+uniform float uTipGlow;
+uniform float uBodyGlow;
+uniform float uCoreGlow;
+uniform float uTipFrom;
+uniform float uTipTo;
+uniform float uCoreFrom;
+uniform float uSoftness;
+uniform float uTearing;
+uniform float uRootAmount;
+uniform float uRootReach;
+varying vec2 vUv;
+${NOISE2}
+void main() {
+  // Detail finer than the grid, none of it touching the solve: a small domain
+  // warp so a tongue's outline is never the grid's.
+  vec2 w = vUv * vec2(26.0, 18.0) + vec2(0.0, -uTime * 1.6);
+  vec2 warp = vec2(fxFbm(w), fxFbm(w + 31.7)) - 0.5;
+  vec4 a = texture2D(uA, vUv + warp * 0.004);
+  float fuel = a.r;
+  float heat = texture2D(uB, vUv + warp * 0.004).a;
+  float smoke = a.b;
+  // How dense the glowing soot is, against a full flame's (FIRE_SOOT_SCALE).
+  float rho = a.a / max(uSootScale, 1e-4);
+  // The tip's tearing: carved into the soot where it is thin, so tongues come
+  // apart at their edges and keep their bodies.
+  vec2 n1 = vUv * vec2(34.0, 24.0) + vec2(0.0, -uTime * 2.4);
+  vec2 n2 = vUv * vec2(92.0, 64.0) + vec2(0.0, -uTime * 5.5);
+  float grain = (fxFbm(n1) - 0.5) * 0.72 + (fxNoise(n2) - 0.5) * 0.28;
+  rho = max(0.0, rho * (1.0 + grain * uTearing * (1.0 - smoothstep(0.1, 0.8, rho))));
+  // Temperature against the hottest gas a flame has (FIRE_HEAT_SCALE).
+  float t = pow(clamp(heat / max(uHeatScale, 1e-3), 0.0, 2.0), uContrast);
+
+  // WHERE: the outline, from the soot.
+  float shape = smoothstep(uTipFrom, uTipFrom + uSoftness, rho);
+  // WHAT COLOUR: the zones, as bands of temperature.
+  float toBody = smoothstep(uTipTo - 0.12, uTipTo + 0.12, t);
+  float toCore = smoothstep(uCoreFrom, uCoreFrom + 0.35, t);
+  vec3 color = mix(mix(uTipColor, uBodyColor, toBody), uCoreColor, toCore);
+  float glow = mix(mix(uTipGlow, uBodyGlow, toBody), uCoreGlow, toCore);
+  // Soot emits and absorbs together: thin soot glows as much as it covers, and
+  // a dense flame covers what is behind it only as far as uOpacity says.
+  float cover = 1.0 - exp(-rho * 3.0);
+  float fireAlpha = shape * cover * clamp(uOpacity / 5.0, 0.0, 1.0);
+  vec3 fire = color * glow * shape * uPaperWhite * uGlow * smoothstep(0.0, uThin, cover);
+  // The root: added as LIGHT, where fresh fuel is still near the paper and the
+  // gas has not heated through. Mixed in instead of added, blue makes grey.
+  float rootMask = smoothstep(mix(0.4, 0.02, uRootReach), mix(0.6, 0.12, uRootReach), fuel) * (1.0 - smoothstep(0.25, 0.6, t));
+  fire += uRootColor * rootMask * uRootAmount * uPaperWhite * uGlow * 0.6;
+
+  // Smoke: warm grey-brown (a cool grey over cream reads lavender), lit by
+  // the fire under it.
+  float smokeAlpha = 1.0 - exp(-smoke * uSmokeDensity);
+  vec3 smokeColor = vec3(0.16, 0.13, 0.10) + vec3(0.22, 0.09, 0.02) * smoothstep(0.15, 0.9, t);
+  float alpha = smokeAlpha + fireAlpha - smokeAlpha * fireAlpha;
+  // No square edge: the domain fades out before its borders.
+  float edge = smoothstep(0.0, 0.06, vUv.x) * smoothstep(1.0, 0.94, vUv.x) * smoothstep(0.0, 0.03, vUv.y) * smoothstep(1.0, 0.9, vUv.y);
+  gl_FragColor = vec4((fire + smokeColor * smokeAlpha) * edge, alpha * edge);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}
+`
+);
+
+// src/fx/fluid/FireFluid.ts
+var Pair = class {
+  read;
+  write;
+  constructor(w, h) {
+    this.read = target(w, h);
+    this.write = target(w, h);
+  }
+  swap() {
+    const t = this.read;
+    this.read = this.write;
+    this.write = t;
+  }
+  dispose() {
+    this.read.dispose();
+    this.write.dispose();
+  }
+};
+function target(w, h) {
+  return new THREE4.WebGLRenderTarget(w, h, {
+    type: THREE4.HalfFloatType,
+    format: THREE4.RGBAFormat,
+    minFilter: THREE4.LinearFilter,
+    magFilter: THREE4.LinearFilter,
+    wrapS: THREE4.ClampToEdgeWrapping,
+    wrapT: THREE4.ClampToEdgeWrapping,
+    depthBuffer: false,
+    stencilBuffer: false,
+    generateMipmaps: false
+  });
+}
+function pass(fragmentShader, uniforms) {
+  return new THREE4.ShaderMaterial({
+    vertexShader: PASS_VERTEX,
+    fragmentShader,
+    uniforms,
+    depthTest: false,
+    depthWrite: false,
+    blending: THREE4.NoBlending
+  });
+}
+var FireFluid = class {
+  constructor(renderer, grid, domain) {
+    this.renderer = renderer;
+    this.grid = grid;
+    this.domain = domain;
+    const [vw, vh] = grid.velocity;
+    const [dw, dh] = grid.dye;
+    this.scalars = new Pair(dw, dh);
+    this.air = new Pair(dw, dh);
+    this.velocity = new Pair(vw, vh);
+    this.pressure = new Pair(vw, vh);
+    this.emit = target(dw, dh);
+    this.divergence = target(vw, vh);
+    this.curl = target(vw, vh);
+    this.forward = target(dw, dh);
+    this.backward = target(dw, dh);
+    const aspect = domain.width / domain.height;
+    const vTexel = new THREE4.Vector2(1 / vw, 1 / vh);
+    const dTexel = new THREE4.Vector2(1 / dw, 1 / dh);
+    const cell = domain.width / vw;
+    this.m = {
+      emit: pass(EMIT, {
+        uSources: { value: this.sources },
+        uAcross: { value: this.across },
+        uCount: { value: 0 },
+        uAspect: { value: aspect }
+      }),
+      advect: pass(ADVECT, {
+        uVelocity: { value: null },
+        uSource: { value: null },
+        uDomain: { value: new THREE4.Vector2(domain.width, domain.height) },
+        uDt: { value: 0 },
+        uKeep: { value: new THREE4.Vector4(1, 1, 1, 1) }
+      }),
+      react: pass(REACT, {
+        uA: { value: null },
+        uB: { value: null },
+        uEmit: { value: this.emit.texture },
+        uVelocity: { value: null },
+        uDomain: { value: new THREE4.Vector2(domain.width, domain.height) },
+        uTexel: { value: dTexel },
+        uOut: { value: 0 },
+        uDt: { value: 0 },
+        uFuel: { value: 0 },
+        uHeat: { value: 0 },
+        uSmoke: { value: 0 },
+        uPremixed: { value: 0 },
+        uAmbient: { value: 0 },
+        uBurnRate: { value: 0 },
+        uHeatRelease: { value: 0 },
+        uCooling: { value: 0 },
+        uSmokeProduction: { value: 0 },
+        uSmokeFade: { value: 1 },
+        uPersistence: { value: 0.1 },
+        uMixing: { value: 0 },
+        uEntrain: { value: 0 },
+        uFuelBlock: { value: 1 },
+        uSootYield: { value: 0 },
+        uSootHeat: { value: 1 },
+        uStoich: { value: 1 },
+        uSmoulderSmoke: { value: 0 },
+        uSmoulderHeat: { value: 0 }
+      }),
+      forces: pass(FORCES, {
+        uVelocity: { value: null },
+        uA: { value: null },
+        uEmit: { value: this.emit.texture },
+        uTexel: { value: vTexel },
+        uDomain: { value: new THREE4.Vector2(domain.width, domain.height) },
+        uDt: { value: 0 },
+        uTime: { value: 0 },
+        uBuoyancy: { value: 0 },
+        uWind: { value: 0 },
+        uTurbulence: { value: 0 },
+        uTurbScale: { value: 1 },
+        uTurbEvolve: { value: 0 },
+        uRadial: { value: 0 },
+        uInitVel: { value: new THREE4.Vector2() }
+      }),
+      curl: pass(CURL, { uVelocity: { value: null }, uTexel: { value: vTexel }, uCell: { value: cell } }),
+      vorticity: pass(VORTICITY, {
+        uVelocity: { value: null },
+        uCurl: { value: null },
+        uTexel: { value: vTexel },
+        uCell: { value: cell },
+        uDt: { value: 0 },
+        uVorticity: { value: 0 }
+      }),
+      divergence: pass(DIVERGENCE, {
+        uVelocity: { value: null },
+        uB: { value: null },
+        uTexel: { value: vTexel },
+        uCell: { value: cell },
+        uExpansion: { value: 0 }
+      }),
+      pressure: pass(PRESSURE, {
+        uPressure: { value: null },
+        uDivergence: { value: null },
+        uTexel: { value: vTexel },
+        uCell: { value: cell }
+      }),
+      gradient: pass(GRADIENT, {
+        uVelocity: { value: null },
+        uPressure: { value: null },
+        uTexel: { value: vTexel },
+        uCell: { value: cell }
+      }),
+      fill: pass(FILL, { uValue: { value: new THREE4.Vector4() } }),
+      maccormack: pass(MACCORMACK, {
+        uVelocity: { value: null },
+        uSource: { value: null },
+        uForward: { value: null },
+        uBackward: { value: null },
+        uDomain: { value: new THREE4.Vector2(domain.width, domain.height) },
+        uTexel: { value: new THREE4.Vector2(1 / dw, 1 / dh) },
+        uDt: { value: 0 }
+      })
+    };
+    const triangle = new THREE4.BufferGeometry();
+    triangle.setAttribute(
+      "position",
+      new THREE4.BufferAttribute(new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]), 3)
+    );
+    this.mesh = new THREE4.Mesh(triangle, this.m.fill);
+    this.mesh.frustumCulled = false;
+    this.scene.add(this.mesh);
+  }
+  renderer;
+  grid;
+  domain;
+  /** (fuel, heat, smoke, soot) on the fine grid — what is drawn. */
+  scalars;
+  /** (premixed oxygen, ambient oxygen, burn rate, flame heat) on the fine grid. */
+  air;
+  velocity;
+  pressure;
+  /** The rim's emission this step, on the fine grid — see EMIT. */
+  emit;
+  divergence;
+  curl;
+  /** The two intermediate advections the MacCormack step compares. */
+  forward;
+  backward;
+  /**
+   * Error-compensated advection for the drawn fields. On by default; off is
+   * a single semi-Lagrangian step, which is two passes a step cheaper and
+   * visibly softer — a knob for the lowest tier, and for an A/B.
+   */
+  sharp = true;
+  scene = new THREE4.Scene();
+  camera = new THREE4.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+  mesh;
+  m;
+  sources = Array.from({ length: MAX_SOURCES }, () => new THREE4.Vector4());
+  across = Array.from({ length: MAX_SOURCES }, () => new THREE4.Vector4());
+  /** Whether this renderer can draw into half-float targets at all. */
+  static supported(renderer) {
+    return renderer.capabilities.isWebGL2 && (renderer.extensions.has("EXT_color_buffer_float") || renderer.extensions.has("EXT_color_buffer_half_float"));
+  }
+  /** Empty air, at the given ambient oxygen. */
+  reset(ambient) {
+    this.withRenderer(() => {
+      const fill = this.m.fill;
+      const value = fill.uniforms.uValue.value;
+      value.set(0, 0, 0, 0);
+      for (const t of [this.scalars, this.velocity, this.pressure]) {
+        this.run(fill, t.read);
+        this.run(fill, t.write);
+      }
+      this.run(fill, this.divergence);
+      this.run(fill, this.curl);
+      this.run(fill, this.emit);
+      value.set(0, ambient, 0, 0);
+      this.run(fill, this.air.read);
+      this.run(fill, this.air.write);
+    });
+  }
+  /**
+   * One step of `dt` seconds. `sources` is (u, v, half-length, strength) per
+   * rim segment and `across` is (toward-paper x, y, half-width, offset onto
+   * the paper) — see EMIT — `count` of each; `time` drives the turbulence.
+   */
+  step(dt, u, sources, across, count, time) {
+    const n = Math.min(MAX_SOURCES, count);
+    for (let i = 0; i < n; i++) {
+      this.sources[i].fromArray(sources, i * 4);
+      this.across[i].fromArray(across, i * 4);
+    }
+    const m = this.m;
+    m.emit.uniforms.uCount.value = n;
+    this.withRenderer(() => {
+      this.run(m.emit, this.emit);
+      const advect = m.advect;
+      advect.uniforms.uDt.value = dt;
+      advect.uniforms.uVelocity.value = this.velocity.read.texture;
+      advect.uniforms.uKeep.value.set(0.998, 0.998, 1, 1);
+      advect.uniforms.uSource.value = this.velocity.read.texture;
+      this.run(advect, this.velocity.write);
+      this.velocity.swap();
+      advect.uniforms.uVelocity.value = this.velocity.read.texture;
+      advect.uniforms.uKeep.value.set(1, 1, 1, 1);
+      if (this.sharp) {
+        advect.uniforms.uSource.value = this.scalars.read.texture;
+        this.run(advect, this.forward);
+        advect.uniforms.uDt.value = -dt;
+        advect.uniforms.uSource.value = this.forward.texture;
+        this.run(advect, this.backward);
+        advect.uniforms.uDt.value = dt;
+        const mc = m.maccormack;
+        mc.uniforms.uDt.value = dt;
+        mc.uniforms.uVelocity.value = this.velocity.read.texture;
+        mc.uniforms.uSource.value = this.scalars.read.texture;
+        mc.uniforms.uForward.value = this.forward.texture;
+        mc.uniforms.uBackward.value = this.backward.texture;
+        this.run(mc, this.scalars.write);
+      } else {
+        advect.uniforms.uSource.value = this.scalars.read.texture;
+        this.run(advect, this.scalars.write);
+      }
+      this.scalars.swap();
+      advect.uniforms.uSource.value = this.air.read.texture;
+      this.run(advect, this.air.write);
+      this.air.swap();
+      const react = m.react;
+      const r = react.uniforms;
+      r.uDt.value = dt;
+      r.uFuel.value = u.fuel;
+      r.uHeat.value = u.heat;
+      r.uSmoke.value = u.smoke;
+      r.uPremixed.value = u.premixed;
+      r.uAmbient.value = u.ambient;
+      r.uBurnRate.value = u.burnRate;
+      r.uHeatRelease.value = u.heatRelease;
+      r.uCooling.value = u.cooling;
+      r.uSmokeProduction.value = u.smokeProduction;
+      r.uSmokeFade.value = u.smokeFade;
+      r.uPersistence.value = u.persistence;
+      r.uMixing.value = u.mixing;
+      r.uEntrain.value = u.entrain;
+      r.uFuelBlock.value = u.fuelBlock;
+      r.uSootYield.value = u.sootYield;
+      r.uSootHeat.value = u.sootHeat;
+      r.uStoich.value = u.stoich;
+      r.uSmoulderSmoke.value = u.smoulderSmoke;
+      r.uSmoulderHeat.value = u.smoulderHeat;
+      r.uVelocity.value = this.velocity.read.texture;
+      r.uA.value = this.scalars.read.texture;
+      r.uB.value = this.air.read.texture;
+      r.uOut.value = 0;
+      this.run(react, this.scalars.write);
+      r.uOut.value = 1;
+      this.run(react, this.air.write);
+      this.scalars.swap();
+      this.air.swap();
+      const forces = m.forces;
+      const f = forces.uniforms;
+      f.uVelocity.value = this.velocity.read.texture;
+      f.uA.value = this.scalars.read.texture;
+      f.uDt.value = dt;
+      f.uTime.value = time;
+      f.uBuoyancy.value = u.buoyancy;
+      f.uWind.value = u.wind;
+      f.uTurbulence.value = u.turbulence;
+      f.uTurbScale.value = u.turbulenceScale;
+      f.uTurbEvolve.value = u.turbulenceEvolve;
+      f.uRadial.value = u.radial;
+      f.uInitVel.value.set(u.initialVelocity[0], u.initialVelocity[1]);
+      this.run(forces, this.velocity.write);
+      this.velocity.swap();
+      m.curl.uniforms.uVelocity.value = this.velocity.read.texture;
+      this.run(m.curl, this.curl);
+      const vort = m.vorticity;
+      vort.uniforms.uVelocity.value = this.velocity.read.texture;
+      vort.uniforms.uCurl.value = this.curl.texture;
+      vort.uniforms.uDt.value = dt;
+      vort.uniforms.uVorticity.value = u.vorticity;
+      this.run(vort, this.velocity.write);
+      this.velocity.swap();
+      const div = m.divergence;
+      div.uniforms.uVelocity.value = this.velocity.read.texture;
+      div.uniforms.uB.value = this.air.read.texture;
+      div.uniforms.uExpansion.value = u.expansion;
+      this.run(div, this.divergence);
+      const pressure = m.pressure;
+      pressure.uniforms.uDivergence.value = this.divergence.texture;
+      for (let k = 0; k < this.grid.iterations; k++) {
+        pressure.uniforms.uPressure.value = this.pressure.read.texture;
+        this.run(pressure, this.pressure.write);
+        this.pressure.swap();
+      }
+      const gradient = m.gradient;
+      gradient.uniforms.uVelocity.value = this.velocity.read.texture;
+      gradient.uniforms.uPressure.value = this.pressure.read.texture;
+      this.run(gradient, this.velocity.write);
+      this.velocity.swap();
+    });
+  }
+  dispose() {
+    for (const p of [this.scalars, this.air, this.velocity, this.pressure]) p.dispose();
+    this.emit.dispose();
+    this.divergence.dispose();
+    this.curl.dispose();
+    this.forward.dispose();
+    this.backward.dispose();
+    for (const m of Object.values(this.m)) m.dispose();
+    this.mesh.geometry.dispose();
+  }
+  run(material, out) {
+    this.mesh.material = material;
+    this.renderer.setRenderTarget(out);
+    this.renderer.render(this.scene, this.camera);
+  }
+  /** Passes change the renderer's target and clearing; put both back. */
+  withRenderer(body) {
+    const previous = this.renderer.getRenderTarget();
+    const autoClear = this.renderer.autoClear;
+    this.renderer.autoClear = false;
+    try {
+      body();
+    } finally {
+      this.renderer.setRenderTarget(previous);
+      this.renderer.autoClear = autoClear;
+    }
+  }
+};
+
+// src/fx/fluid/params.ts
+var fireFluidDefaults = {
+  fuel: 33.5,
+  premixedOxygen: 0.28,
+  heat: 3.2,
+  smoke: 0.7,
+  // Was 5 — a full unit a second, 210 mm/s, of gas pushed sideways out of the
+  // rim. Against a buoyancy of 1.7 units/s² that is what rolled the flames
+  // into mushroom caps: the grey spirals over the text that the review called
+  // the most synthetic thing in the frame. A flame leaves paper going UP.
+  radialImpulse: 0.8,
+  // In world units a second now (see `solverUniforms`): 1.4 is ~0.3 m/s, the
+  // speed gas leaves burning paper with. It was 0.5 at a quarter scale —
+  // 26 mm/s — and gas held that slow pooled into a bulb at the rim before
+  // buoyancy stretched it into a neck: every flame was a droplet.
+  initialVelocity: [0, 1.4, 0],
+  burnRate: 6.1,
+  // Was 0.65. Expansion is divergence where the gas burns, and it pushes the
+  // gas SIDEWAYS as much as up: at 0.65 each tongue swelled into a puff and
+  // the smoke billowed out over the paper. Your web reference is thin licking
+  // tongues, and swept at 0.2 / 0.65 / 1.3 the low end is the one that looks
+  // like it.
+  gasExpansion: 0.3,
+  // Was 3, when the flame body was authored below paper white and a tongue
+  // needed carrying further to register. Now the gas leaves the rim at its
+  // real speed and glows above paper white, and 3 threw tongues past the
+  // text; 2 holds them lower. (1.5 was no shorter — height is set by how
+  // soon the gas cools, below — only broader and slower.)
+  buoyancy: 2,
+  // Was 0.92. Gas that stays hot all the way up pools into ONE column: the
+  // rim's forty-odd emission points merge a few centimetres above the paper
+  // and the fire reads as a single plume with a couple of licks beside it.
+  // Hero.png is many separate tongues around the whole rim — tall above,
+  // short below — and cooling them faster is what keeps them apart, because
+  // each one runs out of glow before it can merge with its neighbour.
+  //
+  // 1.8 since a flame's light comes from soot that only lives in hot gas:
+  // cooling is now what sets a tongue's HEIGHT. Swept in live play: 1.15
+  // reached the text (~150 mm), 1.6 ~100 mm, 2.1 short licks (~60 mm);
+  // Hero.png's tallest is ~70 mm.
+  cooling: 1.8,
+  // Was 1.4, which made a thick grey column, then 0.5. Noor's direction is
+  // light smoke, and with MacCormack advection keeping the smoke's fine
+  // structure it needs less of it to read: at 0.5 it veiled the upper sheet.
+  smokeProduction: 0.25,
+  ambientOxygen: 0.47,
+  // Was 0.005 — the slider's own floor, which is to say switched off. The
+  // flame channel decayed with a 5 ms time constant, so it was an
+  // instantaneous quantity with no history and therefore no shape.
+  flamePersistence: 0.06,
+  airMixing: 0.5,
+  // Was 0, also switched off, with all the motion coming from vorticity and
+  // the radial impulse — a few big eddies instead of many small ones, which
+  // is the difference between a fire that tears and one that curls. Swept
+  // against the peak frame: at 2 the flames are still a single plume, at 9
+  // they break into separate tongues around the rim.
+  turbulence: 9,
+  // Finer eddies with it: 6.8 was ~24 mm, 12 is ~14 mm, and the smoke stops
+  // reading as a few big hooks.
+  turbulenceScale: 12,
+  // Was 6.1. Vorticity confinement gives back the swirls the grid smooths
+  // away; at 6 it was manufacturing swirls the flow never had.
+  vorticity: 3,
+  wind: 0.8,
+  // Was 4.2 s. Smoke that lingers that long is stretched by the flow into
+  // long grey veins, and sharper advection keeps every one of them — so the
+  // whole upper sheet and the black stage behind it came out MARBLED. Real
+  // paper smoke thins out within a second or two. Swept in live play against
+  // the default: 1.5 s is thin threads and a clean sheet.
+  smokeFade: 1.5,
+  smokeAfter: 4
+};
+var fireFluidControls = [
+  { group: "Emission", key: "fuel", label: "Fuel", min: 0, max: 50, step: 0.1 },
+  { group: "Emission", key: "premixedOxygen", label: "Premixed oxygen", min: 0, max: 1, step: 0.01 },
+  { group: "Emission", key: "heat", label: "Heat", min: 0, max: 5, step: 0.1 },
+  { group: "Emission", key: "smoke", label: "Smoke", min: 0, max: 2, step: 0.05 },
+  { group: "Emission", key: "radialImpulse", label: "Radial impulse", min: 0, max: 5, step: 0.1 },
+  { group: "Combustion", key: "burnRate", label: "Burn rate", min: 0, max: 10, step: 0.1 },
+  { group: "Combustion", key: "gasExpansion", label: "Gas expansion", min: 0, max: 3, step: 0.05 },
+  { group: "Combustion", key: "buoyancy", label: "Buoyancy", min: 0, max: 6, step: 0.1 },
+  { group: "Combustion", key: "cooling", label: "Cooling", min: 0, max: 3, step: 0.01 },
+  { group: "Combustion", key: "smokeProduction", label: "Smoke production", min: 0, max: 4, step: 0.05 },
+  { group: "Fuel & air", key: "ambientOxygen", label: "Ambient oxygen", min: 0, max: 1, step: 0.01 },
+  {
+    group: "Fuel & air",
+    key: "flamePersistence",
+    label: "Flame persistence",
+    min: 5e-3,
+    max: 1,
+    step: 5e-3
+  },
+  { group: "Fuel & air", key: "airMixing", label: "Air mixing", min: 0, max: 1, step: 0.01 },
+  // 0–10 while the default was 0. Now that turbulence is what breaks the
+  // flames into tongues, the tuned value has to sit somewhere a slider can
+  // move in BOTH directions — see the test.
+  { group: "Motion & turbulence", key: "turbulence", label: "Turbulence", min: 0, max: 20, step: 0.1 },
+  {
+    group: "Motion & turbulence",
+    key: "turbulenceScale",
+    label: "Turbulence scale",
+    min: 0.5,
+    max: 24,
+    step: 0.1
+  },
+  { group: "Motion & turbulence", key: "vorticity", label: "Vorticity", min: 0, max: 8, step: 0.1 },
+  { group: "Motion & turbulence", key: "wind", label: "Wind", min: -3, max: 3, step: 0.05 },
+  { group: "Look", key: "smokeFade", label: "Smoke lingers (s)", min: 0.2, max: 10, step: 0.1 },
+  { group: "Look", key: "smokeAfter", label: "Smoke after the flames (s)", min: 0, max: 12, step: 0.1 }
+];
+function solverUniforms(p) {
+  const finite = (x, fallback) => Number.isFinite(x) ? x : fallback;
+  return {
+    // Gas per second per unit of source strength.
+    fuel: Math.max(0, finite(p.fuel, 0)) * 0.12,
+    premixed: Math.min(1, Math.max(0, finite(p.premixedOxygen, 0))),
+    // Temperature released with the gas, per second. At 1.8 the gas at the
+    // source settled near a third of glowing — cooling took the heat faster
+    // than the rim gave it — and the fire was a faint blush, not a flame.
+    heat: Math.max(0, finite(p.heat, 0)) * 7,
+    smoke: Math.max(0, finite(p.smoke, 0)) * 0.45,
+    // World units a second: A4 flames climb a few tens of centimetres a second.
+    radial: Math.max(0, finite(p.radialImpulse, 0)) * 0.2,
+    // World units a second, one to one — a unit is 210 mm.
+    initialVelocity: [finite(p.initialVelocity[0], 0), finite(p.initialVelocity[1], 0)],
+    // Per second.
+    burnRate: Math.max(0, finite(p.burnRate, 0)) * 2,
+    // Temperature a unit of burnt fuel adds.
+    heatRelease: 3,
+    // Divergence per unit of burning a second — the gas expanding as it burns.
+    expansion: Math.max(0, finite(p.gasExpansion, 0)) * 1.5,
+    // World units a second squared per unit of temperature.
+    buoyancy: Math.max(0, finite(p.buoyancy, 0)) * 0.9,
+    // Per second: a flame at A4 scale has cooled out of sight 10–40 mm up.
+    cooling: Math.max(0, finite(p.cooling, 0)) * 6,
+    smokeProduction: Math.max(0, finite(p.smokeProduction, 0)) * 0.3,
+    smokeFade: Math.max(0.05, finite(p.smokeFade, 2.5)),
+    ambient: Math.min(1, Math.max(0, finite(p.ambientOxygen, 0))),
+    persistence: Math.max(5e-3, finite(p.flamePersistence, 0.085)),
+    mixing: Math.min(1, Math.max(0, finite(p.airMixing, 0.5))) * 0.5,
+    entrain: Math.min(1, Math.max(0, finite(p.airMixing, 0.5))) * 40,
+    fuelBlock: 0.05,
+    sootYield: 30,
+    sootHeat: 2,
+    // Paper's gas takes several times its own mass of air to burn; what
+    // matters here is only that it is well above one, so fuel near the rim is
+    // denser than the air that can reach it and burns from the outside in.
+    stoich: 4,
+    // Several times the rim's own smoke per unit strength: a smouldering spot
+    // has no flame to lift its smoke fast, so it pools and rises slowly, and
+    // at 1.5× it read 0.03 at the 99th percentile — about 3% opacity, gone —
+    // at 8× 0.07, and at 30× thin wisps you had to look for.
+    smoulderSmoke: Math.max(0, finite(p.smoke, 0)) * 0.45 * 80,
+    smoulderHeat: 1.2,
+    turbulence: Math.max(0, finite(p.turbulence, 0)) * 0.35,
+    // Noise frequency per WORLD unit — the pass multiplies by the domain's
+    // size, which it did not before (it read UV, and the domain is two units
+    // tall, so every eddy was half the size this said). 12 → ~14 mm eddies.
+    turbulenceScale: Math.max(0.1, finite(p.turbulenceScale, 4.6)) * 1.25,
+    turbulenceEvolve: 3,
+    vorticity: Math.max(0, finite(p.vorticity, 0)),
+    wind: finite(p.wind, 0) * 0.3
+  };
+}
+
+// src/fx/FxFireFluid.tsx
+import { Fragment as Fragment2, jsx as jsx5 } from "react/jsx-runtime";
+var DOMAIN = { width: 1.5, height: 2 };
+var BELOW = 0.8;
+var STEP = 1 / 120;
+var WARM_STEP = 1 / 60;
+var MAX_STEPS = 6;
+var BAND = 1.2 / 210;
+var SMOULDER_SLOTS = 16;
+var SMOULDER_AFTER = 1;
+var WARM = 3;
+var up = new THREE5.Vector3(0, 1, 0);
+function FxFireFluid({
+  field,
+  locate,
+  quality = "medium",
+  params,
+  running = true,
+  resetKey,
+  glow = 1,
+  zones,
+  heatScale = FIRE_HEAT_SCALE,
+  sootScale = FIRE_SOOT_SCALE,
+  contrast = FIRE_CONTRAST,
+  opacity = FIRE_OPACITY,
+  thin = FIRE_THIN,
+  warm = WARM,
+  sharp,
+  fallback
+}) {
+  const gl = useThree2((s) => s.gl);
+  const camera = useThree2((s) => s.camera);
+  const grid = fxQualityFor(quality).fluid;
+  const fluid = useMemo4(() => FireFluid.supported(gl) ? new FireFluid(gl, grid, DOMAIN) : null, [gl, grid]);
+  useEffect4(() => () => fluid?.dispose(), [fluid]);
+  const merged = useMemo4(() => ({ ...fireFluidDefaults, ...params }), [params]);
+  const material = useMemo4(
+    () => new THREE5.ShaderMaterial({
+      vertexShader: RENDER_VERTEX,
+      fragmentShader: RENDER_FRAGMENT,
+      uniforms: {
+        uA: { value: null },
+        uB: { value: null },
+        uTime: { value: 0 },
+        uGlow: { value: 1 },
+        // Thin: smoke over a clear background, not a veil across it.
+        uSmokeDensity: { value: 0.9 },
+        // How bright the fire is, in the one unit `emission.ts` defines.
+        uPaperWhite: { value: PAPER_WHITE },
+        uHeatScale: { value: FIRE_HEAT_SCALE },
+        uSootScale: { value: FIRE_SOOT_SCALE },
+        uContrast: { value: FIRE_CONTRAST },
+        uOpacity: { value: FIRE_OPACITY },
+        uThin: { value: FIRE_THIN },
+        // The four zones (FireZones). Colours linear, glows in multiples of
+        // paper white, boundaries in fractions of the hottest gas.
+        uTipColor: { value: new THREE5.Vector3() },
+        uBodyColor: { value: new THREE5.Vector3() },
+        uCoreColor: { value: new THREE5.Vector3() },
+        uRootColor: { value: new THREE5.Vector3() },
+        uTipGlow: { value: 0 },
+        uBodyGlow: { value: 0 },
+        uCoreGlow: { value: 0 },
+        uTipFrom: { value: 0 },
+        uTipTo: { value: 0 },
+        uCoreFrom: { value: 0 },
+        uSoftness: { value: 0 },
+        uTearing: { value: 0 },
+        uRootAmount: { value: 0 },
+        uRootReach: { value: 0 }
+      },
+      transparent: true,
+      depthWrite: false,
+      // The fire is always in front of the paper it rises from. A sheet that
+      // drapes or curls crosses the plane in places, and a depth test cut
+      // the fire off there in a hard vertical seam.
+      depthTest: false,
+      // Premultiplied: fire adds light, smoke covers what is behind it.
+      blending: THREE5.CustomBlending,
+      blendSrc: THREE5.OneFactor,
+      blendDst: THREE5.OneMinusSrcAlphaFactor,
+      side: THREE5.DoubleSide
+    }),
+    []
+  );
+  useEffect4(() => () => material.dispose(), [material]);
+  const plane = useMemo4(() => new THREE5.PlaneGeometry(DOMAIN.width, DOMAIN.height), []);
+  useEffect4(() => () => plane.dispose(), [plane]);
+  const mesh = useRef3(null);
+  const state = useRef3({
+    key: /* @__PURE__ */ Symbol("unset"),
+    time: 0,
+    owed: 0,
+    /** The fire's clock when the rim last released anything — flame or smoulder. */
+    lastGas: Number.NEGATIVE_INFINITY,
+    origin: new THREE5.Vector3(),
+    right: new THREE5.Vector3(1, 0, 0),
+    normal: new THREE5.Vector3(0, 0, 1)
+  });
+  const anchors = useRef3([]);
+  const sources = useMemo4(() => new Float32Array(MAX_SOURCES * 4), []);
+  const across = useMemo4(() => new Float32Array(MAX_SOURCES * 4), []);
+  const smoulder = useMemo4(
+    () => Array.from({ length: SMOULDER_SLOTS }, () => ({
+      seen: Number.NEGATIVE_INFINITY,
+      source: new Float32Array(4),
+      across: new Float32Array(4)
+    })),
+    []
+  );
+  const scratch = useMemo4(() => new THREE5.Vector3(), []);
+  const place = () => {
+    const s = state.current;
+    const centre = locate(0.5, 0.5);
+    const c = new THREE5.Vector3(centre?.x ?? 0, centre?.y ?? 0, centre?.z ?? 0);
+    s.normal.set(camera.position.x - c.x, 0, camera.position.z - c.z);
+    if (s.normal.lengthSq() < 1e-8) s.normal.set(0, 0, 1);
+    s.normal.normalize();
+    s.right.crossVectors(up, s.normal).normalize();
+    s.origin.copy(c).addScaledVector(s.right, -DOMAIN.width / 2).addScaledVector(up, -BELOW);
+    const m = mesh.current;
+    if (m) {
+      m.position.copy(s.origin).addScaledVector(s.right, DOMAIN.width / 2).addScaledVector(up, DOMAIN.height / 2);
+      m.position.addScaledVector(s.normal, 0.03);
+      m.quaternion.setFromRotationMatrix(new THREE5.Matrix4().makeBasis(s.right, up, s.normal));
+    }
+  };
+  const gather = (time) => {
+    const s = state.current;
+    const room = MAX_SOURCES - SMOULDER_SLOTS;
+    const n = Math.min(room, flameAnchors(field, locate, room, anchors.current, time));
+    const band = BAND / DOMAIN.height;
+    for (let i = 0; i < n; i++) {
+      const a = anchors.current[i];
+      scratch.set(a.x, a.y, a.z).sub(s.origin);
+      const k = i * 4;
+      sources[k] = scratch.dot(s.right) / DOMAIN.width;
+      sources[k + 1] = scratch.dot(up) / DOMAIN.height;
+      const nu = a.nx * s.right.x + a.ny * s.right.y + a.nz * s.right.z;
+      const nv = a.ny;
+      const nl = Math.hypot(nu, nv);
+      let area;
+      if (nl > 0.25) {
+        const half = Math.max(1.5 / 210, a.width * 0.5) / DOMAIN.height;
+        sources[k + 2] = half;
+        across[k] = nu / nl;
+        across[k + 1] = nv / nl;
+        across[k + 2] = band;
+        across[k + 3] = band;
+        area = half * band;
+      } else {
+        sources[k + 2] = band * 2;
+        across[k] = 0;
+        across[k + 1] = 1;
+        across[k + 2] = band * 2;
+        across[k + 3] = 0;
+        area = band * band * 4;
+      }
+      const disc = Math.max(25e-4, a.width * 0.6 / DOMAIN.height);
+      const tallest = FLAME_HEIGHT[1] * 0.47 * 0.6 / DOMAIN.height;
+      sources[k + 3] = a.height / FLAME_HEIGHT[1] * (0.5 + 0.5 * a.heat) * Math.min(30, disc * tallest / area);
+      const slot = smoulder[Math.floor(a.seed * SMOULDER_SLOTS) % SMOULDER_SLOTS];
+      slot.seen = time;
+      slot.source.set(sources.subarray(k, k + 4));
+      slot.across.set(across.subarray(k, k + 4));
+    }
+    const after = Math.max(0, merged.smokeAfter ?? 0);
+    let count = n;
+    for (const slot of smoulder) {
+      const since = time - slot.seen;
+      if (!(since > SMOULDER_AFTER) || after <= 0 || since > after * 3) continue;
+      const k = count * 4;
+      sources.set(slot.source, k);
+      across.set(slot.across, k);
+      const onset = Math.min(1, (since - SMOULDER_AFTER) / 0.6);
+      sources[k + 3] = -slot.source[3] * onset * Math.exp(-since / after);
+      count++;
+    }
+    return count;
+  };
+  useFrame4((_, delta) => {
+    if (!fluid) return;
+    const s = state.current;
+    const u = solverUniforms(merged);
+    fluid.sharp = sharp ?? quality !== "low";
+    if (s.key !== resetKey) {
+      s.key = resetKey;
+      place();
+      fluid.reset(u.ambient);
+      for (const slot of smoulder) slot.seen = Number.NEGATIVE_INFINITY;
+      const end = field.time;
+      if (field.frontCount > 0) {
+        const steps = Math.round(warm / WARM_STEP);
+        for (let k = 0; k < steps; k++) {
+          const t = end - warm + k * WARM_STEP;
+          fluid.step(WARM_STEP, u, sources, across, gather(t), t);
+        }
+        s.lastGas = end;
+      } else {
+        s.lastGas = Number.NEGATIVE_INFINITY;
+      }
+      s.time = end;
+      s.owed = 0;
+    }
+    const idle = field.frontCount === 0 && s.time - s.lastGas > Math.max(2, merged.smokeFade * 5);
+    const m = mesh.current;
+    if (m) m.visible = !idle;
+    if (running && idle) {
+      s.owed = 0;
+      s.time += Math.min(0.1, Math.max(0, delta));
+    } else if (running) {
+      s.owed += Math.min(0.1, Math.max(0, delta));
+      let taken = 0;
+      while (s.owed >= STEP && taken < MAX_STEPS) {
+        s.owed -= STEP;
+        s.time += STEP;
+        const count = gather(field.time);
+        fluid.step(STEP, u, sources, across, count, s.time);
+        if (count > 0) s.lastGas = s.time;
+        taken++;
+      }
+    }
+    material.uniforms.uA.value = fluid.scalars.read.texture;
+    material.uniforms.uB.value = fluid.air.read.texture;
+    material.uniforms.uTime.value = s.time;
+    material.uniforms.uGlow.value = glow;
+    material.uniforms.uHeatScale.value = heatScale;
+    material.uniforms.uSootScale.value = sootScale;
+    material.uniforms.uContrast.value = contrast;
+    material.uniforms.uOpacity.value = opacity;
+    material.uniforms.uThin.value = thin;
+    const z = fireZones(zones);
+    const mu = material.uniforms;
+    mu.uTipColor.value.fromArray(hexToLinear(z.tip.color));
+    mu.uBodyColor.value.fromArray(hexToLinear(z.body.color));
+    mu.uCoreColor.value.fromArray(hexToLinear(z.core.color));
+    mu.uRootColor.value.fromArray(hexToLinear(z.root.color));
+    mu.uTipGlow.value = z.tip.glow;
+    mu.uBodyGlow.value = z.body.glow;
+    mu.uCoreGlow.value = z.core.glow;
+    mu.uTipFrom.value = z.tip.from;
+    mu.uTipTo.value = z.tip.to;
+    mu.uCoreFrom.value = z.core.from;
+    mu.uSoftness.value = z.tip.softness;
+    mu.uTearing.value = z.tip.tearing;
+    mu.uRootAmount.value = z.root.amount;
+    mu.uRootReach.value = z.root.reach;
+  });
+  if (!fluid) return /* @__PURE__ */ jsx5(Fragment2, { children: fallback ?? null });
+  return /* @__PURE__ */ jsx5("mesh", { ref: mesh, geometry: plane, material, frustumCulled: false, renderOrder: 2 });
+}
+
+// src/fx/FxFireLight.tsx
+import * as THREE6 from "three";
+import { useFrame as useFrame5 } from "@react-three/fiber";
+import { useRef as useRef4 } from "react";
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+function FxFireLight({ field, locate, gain = FIRE_LIGHT_GAIN }) {
+  const front = useRef4(null);
+  const through = useRef4(null);
+  const anchors = useRef4([]);
+  useFrame5(({ camera }) => {
+    const a = front.current;
+    const b = through.current;
+    if (!a || !b) return;
+    const n = flameAnchors(field, locate, 32, anchors.current);
+    if (n === 0) {
+      a.intensity = 0;
+      b.intensity = 0;
+      return;
+    }
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    let h = 0;
+    let flicker = 0;
+    for (let i = 0; i < n; i++) {
+      const f = anchors.current[i];
+      x += f.x;
+      y += f.y;
+      z += f.z;
+      h += f.height;
+      flicker += flamePuff(f.seed, field.time);
+    }
+    x /= n;
+    y /= n;
+    z /= n;
+    h /= n;
+    flicker /= n;
+    const toCamera = new THREE6.Vector3(camera.position.x - x, 0, camera.position.z - z);
+    toCamera.normalize().multiplyScalar(0.035);
+    const lift = h * 0.5;
+    a.position.set(x + toCamera.x, y + lift, z + toCamera.z);
+    b.position.set(x - toCamera.x, y + lift, z - toCamera.z);
+    const level = field.lastStats.front * gain * flicker;
+    a.intensity = level;
+    b.intensity = level * 0.35;
+  });
+  return /* @__PURE__ */ jsxs2(Fragment3, { children: [
+    /* @__PURE__ */ jsx6("pointLight", { ref: front, color: FIRE_COLOR, intensity: 0, decay: 0.9, distance: 0 }),
+    /* @__PURE__ */ jsx6("pointLight", { ref: through, color: FIRE_COLOR, intensity: 0, decay: 0.9, distance: 0 })
+  ] });
+}
+var FIRE_COLOR = new THREE6.Color("#ffa24c");
+var FIRE_LIGHT_GAIN = 42;
+
+// src/fx/FxMatchFlame.tsx
+import * as THREE7 from "three";
+import { useFrame as useFrame6 } from "@react-three/fiber";
+import { useEffect as useEffect5, useMemo as useMemo5, useRef as useRef5 } from "react";
+import { Fragment as Fragment4, jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+var HEIGHT = 20 / 210;
+var FLARE = 0.42;
+var FLARE_GAIN = 1;
+var ARM = 0.32;
+function FxMatchFlame({ match }) {
+  const geometry = useMemo5(() => flameGeometry(1), []);
+  const material = useMemo5(() => flameMaterial(), []);
+  const pool = useMemo5(() => new ParticlePool(160, 3), []);
+  useEffect5(
+    () => () => {
+      geometry.dispose();
+      material.dispose();
+    },
+    [geometry, material]
+  );
+  const light = useRef5(null);
+  const memory = useRef5({
+    time: 0,
+    last: "none",
+    armedAt: 0,
+    flare: 0,
+    flash: 0,
+    spark: 0,
+    was: new THREE7.Vector3(),
+    velocity: new THREE7.Vector3(),
+    lean: new THREE7.Vector3(),
+    at: new THREE7.Vector3(),
+    hasAt: false
+  });
+  useFrame6((_, delta) => {
+    const now = match.current;
+    const m = memory.current;
+    const scripted = now.time !== void 0;
+    const dt = scripted ? Math.max(0, now.time - m.time) : Math.min(0.1, Math.max(0, delta));
+    m.time = scripted ? now.time : m.time + dt;
+    if (now.position) {
+      m.at.set(now.position.x, now.position.y, now.position.z);
+      if (!m.hasAt) m.was.copy(m.at);
+      m.hasAt = true;
+    }
+    if (!scripted && now.state === "lit" && m.last !== "lit") {
+      m.flare = FLARE;
+      m.flash = 0.06;
+      for (let i = 0; i < 16; i++) pool.spawn("ember", m.at.x, m.at.y + HEIGHT * 0.2, m.at.z);
+      for (let i = 0; i < 3; i++) pool.spawn("smoke", m.at.x, m.at.y + HEIGHT * 0.5, m.at.z);
+    }
+    if (!scripted && now.state !== "lit" && m.last === "lit" && m.hasAt) {
+      for (let i = 0; i < 5; i++) pool.spawn("smoke", m.at.x, m.at.y + HEIGHT * 0.6, m.at.z);
+    }
+    if (now.state === "arming" && m.last !== "arming") m.armedAt = m.time;
+    m.last = now.state;
+    if (dt > 0 && m.hasAt) {
+      const v = m.at.clone().sub(m.was).divideScalar(dt);
+      m.velocity.lerp(v, Math.min(1, dt / 0.08));
+      m.was.copy(m.at);
+    }
+    const speed = m.velocity.length();
+    const target2 = m.velocity.clone().multiplyScalar(-0.35);
+    target2.z -= now.blow * 1.2;
+    m.lean.lerp(target2, Math.min(1, dt / 0.15));
+    m.flare = scripted ? Math.max(0, FLARE - (m.time - (now.litAt ?? -FLARE))) : Math.max(0, m.flare - dt);
+    m.flash = scripted ? 0 : Math.max(0, m.flash - dt);
+    const base = geometry.getAttribute("aBase");
+    const shape = geometry.getAttribute("aShape");
+    let height = 0;
+    let width = 0;
+    let gain = 1;
+    let lightLevel = 0;
+    if (now.state === "arming" && m.hasAt) {
+      const p = Math.min(1, (m.time - m.armedAt) / ARM);
+      height = HEIGHT * 0.18 * p;
+      width = height * 0.5;
+      gain = 0.5 + p;
+      lightLevel = 0.012 * p;
+      m.spark -= dt;
+      if (!scripted && m.spark <= 0) {
+        m.spark = 0.07;
+        pool.spawn("ember", m.at.x, m.at.y, m.at.z);
+      }
+    } else if (now.state === "lit" && m.hasAt) {
+      const flare = 1 + FLARE_GAIN * (m.flare / FLARE) ** 2;
+      const stretch = 1 + Math.min(1.2, speed * 0.9);
+      height = HEIGHT * flare * stretch * (now.touching ? 0.6 : 1);
+      width = HEIGHT * 0.32 * (now.touching ? 1.6 : 1) / Math.sqrt(stretch);
+      gain = 1 - now.blow * 0.45 * (0.5 + 0.5 * Math.sin(m.time * 61));
+      lightLevel = 0.035 * flare + (m.flash > 0 ? 0.25 : 0);
+    }
+    material.uniforms.uBlue.value = Math.min(1, Math.max(0, speed * 0.7 - 0.35));
+    material.uniforms.uGain.value = gain;
+    material.uniforms.uTime.value = m.time;
+    material.uniforms.uLean.value.copy(m.lean);
+    base.array[0] = m.at.x;
+    base.array[1] = m.at.y;
+    base.array[2] = m.at.z;
+    shape.array[0] = height;
+    shape.array[1] = width;
+    shape.array[2] = 0.37;
+    shape.array[3] = 1;
+    base.needsUpdate = true;
+    shape.needsUpdate = true;
+    geometry.instanceCount = height > 0 ? 1 : 0;
+    if (light.current) {
+      light.current.position.set(m.at.x, m.at.y + height * 0.5, m.at.z + 0.06);
+      light.current.intensity = lightLevel;
+    }
+    pool.step(dt);
+  });
+  return /* @__PURE__ */ jsxs3(Fragment4, { children: [
+    /* @__PURE__ */ jsx7("mesh", { geometry, material, frustumCulled: false, renderOrder: 3 }),
+    /* @__PURE__ */ jsx7("pointLight", { ref: light, color: "#ffb066", intensity: 0, decay: 1.6, distance: 0 }),
+    /* @__PURE__ */ jsx7(FxParticles, { pool })
+  ] });
+}
+
+// src/fx/sfx/graph.ts
+var STEAL_FADE = 0.012;
+var FxAudio = class {
+  quality;
+  ctx;
+  master;
+  live = [];
+  /**
+   * What each voice owns, until the last of it has actually stopped.
+   *
+   * Outlives the voice's place in `live` on purpose: a stolen voice leaves the
+   * pool at once, so the new sound can have its slot, but its sources are
+   * still fading for a few milliseconds and its gain is still connected. The
+   * nodes are freed when the last source reports `ended`, not before — cut
+   * sooner and the fade that stops stealing from clicking is cut with it.
+   */
+  slots = /* @__PURE__ */ new Map();
+  nextId = 1;
+  unlocked = false;
+  noise = null;
+  constructor(options) {
+    const { quality = "auto", context, volume = 0.8 } = options;
+    this.quality = typeof quality === "string" ? fxQualityFor(quality) : quality;
+    if (!context) throw new Error("FxAudio needs a context \u2014 see createAudioContext()");
+    this.ctx = context;
+    this.master = this.ctx.createGain();
+    this.master.gain.value = volume;
+    this.master.connect(this.ctx.destination);
+  }
+  get context() {
+    return this.ctx;
+  }
+  /** Live voices right now. Never more than the tier's ceiling. */
+  get voices() {
+    return this.live;
+  }
+  get isUnlocked() {
+    return this.unlocked;
+  }
+  get volume() {
+    return this.master.gain.value;
+  }
+  set volume(value) {
+    this.master.gain.value = Math.min(1, Math.max(0, value));
+  }
+  /**
+   * Let sound happen, from inside a user gesture.
+   *
+   * Every browser starts an `AudioContext` suspended until a real interaction
+   * resumes it, and a page that calls this from anywhere else is a page whose
+   * audio silently never starts. Here the cost is zero: `/hands` already has
+   * a button that turns the camera on, and nothing can be heard before the
+   * camera is on anyway.
+   *
+   * Safe to call more than once — it is a latch, not a toggle.
+   */
+  async unlock() {
+    if (this.unlocked) return;
+    if (this.ctx.state === "suspended") await this.ctx.resume();
+    this.unlocked = this.ctx.state === "running";
+  }
+  /**
+   * One second of white noise, made once and shared.
+   *
+   * Nearly every paper sound is filtered noise — a crumple is a cloud of
+   * short bursts of it, a fire is a bed of it, a tear is a fast train of it —
+   * so this is the single most reused object in the graph. Generating it per
+   * voice would allocate a second of audio per crackle.
+   */
+  noiseBuffer() {
+    if (this.noise) return this.noise;
+    const length = Math.floor(this.ctx.sampleRate);
+    const buffer = this.ctx.createBuffer(1, length, this.ctx.sampleRate);
+    const data = buffer.getChannelData(0);
+    let seed = 2654435769;
+    for (let i = 0; i < length; i++) {
+      seed = Math.imul(seed, 1664525) + 1013904223 | 0;
+      data[i] = (seed >>> 0) / 2147483648 - 1;
+    }
+    this.noise = buffer;
+    return buffer;
+  }
+  /**
+   * Take a voice, stealing the least deserving one if the pool is full.
+   *
+   * Returns null only when the ceiling is zero or the caller's priority is
+   * below everything already playing — the one case where refusing is right,
+   * because the alternative is cutting off something more important to play
+   * something less.
+   */
+  take(kind, priority = 0.5) {
+    if (this.quality.voices <= 0) return null;
+    if (this.live.length >= this.quality.voices) {
+      let weakest = 0;
+      for (let i = 1; i < this.live.length; i++) {
+        const a = this.live[i];
+        const b = this.live[weakest];
+        if (a.priority < b.priority || a.priority === b.priority && a.startedAt < b.startedAt) {
+          weakest = i;
+        }
+      }
+      const victim = this.live[weakest];
+      if (victim.priority > priority) return null;
+      victim.stop();
+    }
+    const gain = this.ctx.createGain();
+    gain.connect(this.master);
+    const id = this.nextId++;
+    this.slots.set(id, { gain, sources: [], nodes: [] });
+    const voice = {
+      id,
+      kind,
+      priority,
+      gain,
+      startedAt: this.ctx.currentTime,
+      own: (source) => this.own(id, source),
+      use: (node) => this.useNode(id, node),
+      stop: () => this.release(id)
+    };
+    this.live.push(voice);
+    return voice;
+  }
+  own(id, source) {
+    const slot = this.slots.get(id);
+    const alive = this.live.some((v) => v.id === id);
+    if (!slot || !alive) {
+      stopNow(source);
+      source.disconnect();
+      return;
+    }
+    slot.sources.push(source);
+    source.onended = () => this.ended(id, source);
+  }
+  useNode(id, node) {
+    const slot = this.slots.get(id);
+    const alive = this.live.some((v) => v.id === id);
+    if (!slot || !alive) {
+      node.disconnect();
+      return;
+    }
+    slot.nodes.push(node);
+  }
+  ended(id, source) {
+    source.disconnect();
+    const slot = this.slots.get(id);
+    if (!slot) return;
+    const at = slot.sources.indexOf(source);
+    if (at >= 0) slot.sources.splice(at, 1);
+    if (slot.sources.length > 0) return;
+    if (this.live.some((v) => v.id === id)) this.release(id);
+    else this.free(id);
+  }
+  /** Disconnect a voice's gain. Only once nothing that feeds it is still running. */
+  free(id) {
+    const slot = this.slots.get(id);
+    if (!slot) return;
+    for (const node of slot.nodes) node.disconnect();
+    slot.gain.disconnect();
+    this.slots.delete(id);
+  }
+  /**
+   * Return a voice to the pool, fading it out first.
+   *
+   * The fade is the whole reason this is not just a splice. Cutting a
+   * waveform mid-cycle produces a step, and a step is a click — audible,
+   * cheap-sounding, and most likely to happen exactly when the most is going
+   * on, since that is when voices get stolen.
+   */
+  release(id) {
+    const index = this.live.findIndex((v) => v.id === id);
+    if (index < 0) return;
+    const [voice] = this.live.splice(index, 1);
+    if (!voice) return;
+    const slot = this.slots.get(id);
+    if (!slot || slot.sources.length === 0) {
+      this.free(id);
+      return;
+    }
+    const now = this.ctx.currentTime;
+    voice.gain.gain.cancelScheduledValues(now);
+    voice.gain.gain.setValueAtTime(voice.gain.gain.value, now);
+    voice.gain.gain.linearRampToValueAtTime(0, now + STEAL_FADE);
+    for (const source of [...slot.sources]) {
+      try {
+        source.stop(now + STEAL_FADE);
+      } catch {
+        this.ended(id, source);
+      }
+    }
+  }
+  /** Stop everything. The panic button, and what unmounting calls. */
+  stopAll() {
+    for (const voice of [...this.live]) voice.stop();
+  }
+  /**
+   * A short tone, to prove the chain end to end.
+   *
+   * Deliberately part of the shipped surface rather than a test fixture:
+   * "is the audio graph actually connected" is a question that comes up on
+   * every device, and the honest answer is a sound you can hear. It uses the
+   * same path everything else does — a voice from the pool, the noise buffer,
+   * the master gain — so if this is audible the path works.
+   */
+  test(duration = 0.15) {
+    const voice = this.take("test", 1);
+    if (!voice) return null;
+    const source = this.ctx.createBufferSource();
+    source.buffer = this.noiseBuffer();
+    source.connect(voice.gain);
+    const now = this.ctx.currentTime;
+    voice.gain.gain.setValueAtTime(0, now);
+    voice.gain.gain.linearRampToValueAtTime(0.4, now + 0.01);
+    voice.gain.gain.linearRampToValueAtTime(0, now + duration);
+    source.start(now);
+    source.stop(now + duration);
+    voice.own(source);
+    return voice;
+  }
+  /** Release the context. Nothing survives this. */
+  async dispose() {
+    this.stopAll();
+    for (const id of [...this.slots.keys()]) this.free(id);
+    this.master.disconnect();
+    await this.ctx.close();
+  }
+};
+function stopNow(source) {
+  try {
+    source.stop();
+  } catch {
+  }
+}
+function createAudioContext() {
+  const Ctor = globalThis.AudioContext;
+  if (!Ctor) throw new Error("no Web Audio support in this environment");
+  return new Ctor();
+}
+
+// src/fx/sfx/fire.ts
+var DEFAULTS = { volume: 0.55, fullFront: 0.04, crackle: 0.3, seed: 5 };
+var BED_SMOOTHING = 0.12;
+var CRACKLES_PER_FRAME = 4;
+var FireSound = class {
+  audio;
+  o;
+  bed = null;
+  level = 0;
+  debt = 0;
+  state;
+  constructor(audio, options = {}) {
+    this.audio = audio;
+    this.o = { ...DEFAULTS, ...options };
+    this.state = this.o.seed >>> 0 || 1;
+  }
+  /** True while the bed is playing. */
+  get burning() {
+    return this.bed !== null;
+  }
+  /**
+   * Call once a frame with what the field just did, and where the sheet is.
+   *
+   * `at` is optional: without it the fire is not placed in the room, which is
+   * right for a sheet filling the frame and wrong for one held at arm's
+   * length.
+   */
+  update(dt, stats, at) {
+    const target2 = stats.front > 0 ? Math.min(1, Math.sqrt(stats.front / this.o.fullFront)) : 0;
+    const follow = dt > 0 ? Math.min(1, dt / BED_SMOOTHING) : 1;
+    this.level += (target2 - this.level) * follow;
+    if (target2 > 0 || this.level > 0.02) this.startBed(at);
+    else this.stopBed();
+    if (this.bed) this.driveBed(at);
+    this.debt += stats.charred * this.o.crackle;
+    let budget = CRACKLES_PER_FRAME;
+    while (this.debt >= 1 && budget > 0) {
+      this.debt -= 1;
+      budget--;
+      this.crackle();
+    }
+    if (budget === 0) this.debt %= 1;
+  }
+  /**
+   * A match struck: the scratch of the head across the box, then the hiss of
+   * it flaring as the head burns off (spec §10.2). Two bursts of the shared
+   * noise, one bright and short, one breathier and longer.
+   */
+  strike() {
+    this.burst("fire-strike", 0.9, { type: "bandpass", frequency: 3200, q: 1.1 }, 4e-3, 0.07, 0.8);
+    this.burst("fire-flare", 0.8, { type: "highpass", frequency: 1800, q: 0.7 }, 0.03, 0.45, 0.45, 0.05);
+  }
+  /** Blown out: a soft, low breath of noise (spec §10.6). */
+  puff() {
+    this.burst("fire-puff", 0.6, { type: "lowpass", frequency: 520, q: 0.6 }, 0.02, 0.28, 0.55);
+  }
+  /** One ember popping in the air — a tiny click on the frame it flashes (spec §8.1). */
+  pop() {
+    const f = 3e3 + this.next() * 3e3;
+    this.burst(
+      "fire-pop",
+      0.2,
+      { type: "bandpass", frequency: f, q: 3 },
+      1e-3,
+      0.012 + this.next() * 0.01,
+      0.35
+    );
+  }
+  /** Silence, now — the flame blown out, or the page going away. */
+  stop() {
+    this.stopBed();
+    this.level = 0;
+    this.debt = 0;
+  }
+  startBed(at) {
+    if (this.bed) return;
+    const ctx = this.audio.context;
+    const voice = this.audio.take("fire-bed", 0.7);
+    if (!voice) return;
+    const source = ctx.createBufferSource();
+    source.buffer = this.audio.noiseBuffer();
+    source.loop = true;
+    const filter = ctx.createBiquadFilter();
+    filter.type = "bandpass";
+    filter.frequency.value = 380;
+    filter.Q.value = 0.7;
+    const panner = at ? ctx.createPanner() : null;
+    source.connect(filter);
+    if (panner) {
+      panner.panningModel = "equalpower";
+      panner.distanceModel = "inverse";
+      panner.refDistance = 1;
+      filter.connect(panner);
+      panner.connect(voice.gain);
+    } else {
+      filter.connect(voice.gain);
+    }
+    voice.gain.gain.setValueAtTime(0, ctx.currentTime);
+    source.start(ctx.currentTime);
+    voice.own(source);
+    voice.use(filter);
+    if (panner) voice.use(panner);
+    this.bed = { voice, filter, panner };
+  }
+  driveBed(at) {
+    const bed = this.bed;
+    if (!bed) return;
+    const ctx = this.audio.context;
+    const now = ctx.currentTime;
+    const gain = bed.voice.gain.gain;
+    gain.cancelScheduledValues(now);
+    gain.setValueAtTime(gain.value, now);
+    gain.linearRampToValueAtTime(this.level * this.o.volume, now + BED_SMOOTHING / 2);
+    bed.filter.frequency.setValueAtTime(380 + 900 * this.level, now);
+    if (at && bed.panner) {
+      bed.panner.positionX.setValueAtTime(at.x, now);
+      bed.panner.positionY.setValueAtTime(at.y, now);
+      bed.panner.positionZ.setValueAtTime(at.z, now);
+    }
+  }
+  stopBed() {
+    if (!this.bed) return;
+    this.bed.voice.stop();
+    this.bed = null;
+  }
+  crackle() {
+    const voice = this.audio.take("fire-crackle", 0.25);
+    if (!voice) return;
+    const ctx = this.audio.context;
+    const now = ctx.currentTime;
+    const buffer = this.audio.noiseBuffer();
+    const seconds = buffer.length / ctx.sampleRate;
+    const duration = 0.018 + this.next() * 0.05;
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    const filter = ctx.createBiquadFilter();
+    filter.type = "bandpass";
+    filter.frequency.value = 1400 + this.next() * 2800;
+    filter.Q.value = 1.6 + this.next() * 3;
+    source.connect(filter);
+    filter.connect(voice.gain);
+    const peak = (0.25 + this.next() * 0.5) * this.o.volume * Math.max(0.25, this.level);
+    const gain = voice.gain.gain;
+    gain.setValueAtTime(0, now);
+    gain.linearRampToValueAtTime(peak, now + 4e-3);
+    gain.linearRampToValueAtTime(0, now + duration);
+    source.start(now, this.next() * Math.max(0, seconds - duration), duration);
+    voice.own(source);
+    voice.use(filter);
+  }
+  /**
+   * One shaped burst of the shared noise through one filter — what strike,
+   * puff and pop are made of. `delay` starts it a moment late, which is how
+   * the flare follows the scratch.
+   */
+  burst(name, priority, filterSpec, attack, duration, level, delay = 0) {
+    const voice = this.audio.take(name, priority);
+    if (!voice) return;
+    const ctx = this.audio.context;
+    const now = ctx.currentTime + delay;
+    const buffer = this.audio.noiseBuffer();
+    const seconds = buffer.length / ctx.sampleRate;
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    const filter = ctx.createBiquadFilter();
+    filter.type = filterSpec.type;
+    filter.frequency.value = filterSpec.frequency;
+    filter.Q.value = filterSpec.q;
+    source.connect(filter);
+    filter.connect(voice.gain);
+    const gain = voice.gain.gain;
+    gain.setValueAtTime(0, now);
+    gain.linearRampToValueAtTime(level * this.o.volume, now + attack);
+    gain.linearRampToValueAtTime(0, now + attack + duration);
+    source.start(now, this.next() * Math.max(0, seconds - attack - duration), attack + duration);
+    voice.own(source);
+    voice.use(filter);
+  }
+  /** xorshift32 — its own stream, so nothing else can shift the crackle. */
+  next() {
+    let s = this.state;
+    s ^= s << 13;
+    s ^= s >>> 17;
+    s ^= s << 5;
+    this.state = s >>> 0;
+    return this.state / 4294967296;
+  }
+};
+export {
+  Afterglow,
+  CHAR,
+  DAMAGE_CHANNELS,
+  DAMAGE_LOOK_DEFAULTS,
+  DamageField,
+  FIELD_SIZE,
+  FIRE_GLOW,
+  FIRE_HEAT_SCALE,
+  FIRE_SOOT_SCALE,
+  FIRE_ZONES,
+  FIXED_DT,
+  FLAME_HEIGHT,
+  FX_BLOOM,
+  FX_BLOOM_THRESHOLD,
+  FX_INITIAL_TIER,
+  FX_TIER_ORDER,
+  FireEmitter,
+  FireFluid,
+  FireSound,
+  FxAudio,
+  FxFireFluid,
+  FxFireLight,
+  FxFlames,
+  FxMatchFlame,
+  FxParticles,
+  FxPost,
+  FxWisps,
+  HEAT,
+  PAPER_WHITE,
+  PRESENCE,
+  ParticlePool,
+  SATURATION,
+  createAudioContext,
+  emit,
+  emitHex,
+  fireEmitterDefaults,
+  fireFluidControls,
+  fireFluidDefaults,
+  fireZones,
+  flameAnchors,
+  flamePuff,
+  fxQualityFor,
+  fxQualityNames,
+  fxQualityTiers,
+  hexToLinear,
+  luminance,
+  particlePresets,
+  solverUniforms,
+  srgbToLinear,
+  timesPaperWhite
+};
+//# sourceMappingURL=fx.js.map