paperlab 0.6.0 → 0.7.0

package/dist/fx.cjs

@@ -0,0 +1,4276 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target2, all) => {
+  for (var name in all)
+    __defProp(target2, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/surface/damageContract.ts
+var DAMAGE_LOOK_DEFAULTS, DAMAGE_CHANNELS;
+var init_damageContract = __esm({
+  "src/surface/damageContract.ts"() {
+    "use strict";
+    DAMAGE_LOOK_DEFAULTS = {
+      // §5 asks for 0.3–1 mm. 1.8 was outside it, and outside the slider's range
+      // it was tuned in — a control at its limit is a report that something
+      // underneath is wrong, which in this case was a fire nothing could see.
+      emberWidth: 0.9,
+      emberIntensity: 1.45,
+      emberCoverage: 0.6,
+      emberFlicker: 1.65,
+      emberGlow: 1.25,
+      sparkle: 0.5,
+      lipWidth: 1.2,
+      // Was 1.5, its slider's ceiling, which made the ash lip brighter than the
+      // paper it sits on. Ash is pale GREY; the reference's lip is dimmer than
+      // the sheet, not a highlight drawn on it.
+      lipBrightness: 0.85,
+      // Was 1, also a ceiling. At full warmth the char is milk chocolate —
+      // closer to cardboard than to charcoal (§5). Burnt paper keeps a little
+      // warmth in the plates and reads near black in a frame with a fire in it.
+      charWarmth: 0.3,
+      // Was 1, also a ceiling. The cracks are drawn as thin polygon outlines, so
+      // at full strength the char reads as a mosaic rather than as broken plates.
+      charCracks: 0.55,
+      scorchReach: 30,
+      scorchDarkness: 1.17,
+      fingers: 1.25,
+      edgeWave: 8.5,
+      edgeBite: 3.6
+    };
+    DAMAGE_CHANNELS = { char: 0, saturation: 1, heat: 2, presence: 3 };
+  }
+});
+
+// src/fx/field.ts
+function diffusionTensor(rate, anisotropy, fibre) {
+  const along = rate * 2 * anisotropy / (1 + anisotropy);
+  const across = rate * 2 / (1 + anisotropy);
+  const c = Math.cos(fibre);
+  const s = Math.sin(fibre);
+  return {
+    xx: along * c * c + across * s * s,
+    yy: along * s * s + across * c * c,
+    xy: (along - across) * c * s
+  };
+}
+function stencil(rate, anisotropy, fibre, dt = FIXED_DT) {
+  const d = diffusionTensor(rate, anisotropy, fibre);
+  const cross = Math.min(Math.abs(d.xy), d.xx, d.yy);
+  const scale = dt * (FIELD_SIZE - 1) * (FIELD_SIZE - 1);
+  let ax = (d.xx - cross) * scale;
+  let ay = (d.yy - cross) * scale;
+  let ad = cross * scale;
+  const total = ax + ay + ad;
+  const clamped = total > STABLE;
+  if (clamped) {
+    const k = STABLE / total;
+    ax *= k;
+    ay *= k;
+    ad *= k;
+  }
+  return { ax, ay, ad, diagonal: d.xy >= 0 ? 1 : -1, clamped };
+}
+function hash(x, y, seed) {
+  let h = Math.imul(x, 374761393) ^ Math.imul(y, 668265263) ^ Math.imul(seed, 1274126177);
+  h = Math.imul(h ^ h >>> 13, 1274126177);
+  return ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+function grow(into, box) {
+  if (box.x0 > box.x1) return;
+  if (into.x0 > into.x1) {
+    into.x0 = box.x0;
+    into.y0 = box.y0;
+    into.x1 = box.x1;
+    into.y1 = box.y1;
+    return;
+  }
+  if (box.x0 < into.x0) into.x0 = box.x0;
+  if (box.y0 < into.y0) into.y0 = box.y0;
+  if (box.x1 > into.x1) into.x1 = box.x1;
+  if (box.y1 > into.y1) into.y1 = box.y1;
+}
+var CHAR, SATURATION, HEAT, PRESENCE, FIELD_SIZE, FIXED_DT, MAX_STEPS_PER_FRAME, REST, IGNITION, STABLE, DEFAULTS, EMPTY, DamageField;
+var init_field = __esm({
+  "src/fx/field.ts"() {
+    "use strict";
+    init_damageContract();
+    CHAR = DAMAGE_CHANNELS.char;
+    SATURATION = DAMAGE_CHANNELS.saturation;
+    HEAT = DAMAGE_CHANNELS.heat;
+    PRESENCE = DAMAGE_CHANNELS.presence;
+    FIELD_SIZE = 64;
+    FIXED_DT = 1 / 120;
+    MAX_STEPS_PER_FRAME = 8;
+    REST = 1e-3;
+    IGNITION = 0.35;
+    STABLE = 0.4;
+    DEFAULTS = {
+      fibre: 0,
+      anisotropy: 3,
+      heatDiffusion: 58e-5,
+      wicking: 45e-4,
+      charRate: 2.7,
+      consumeRate: 6,
+      combustion: 2.4,
+      cooling: 0.18,
+      wetResistance: 2.6,
+      drying: 0.015,
+      grain: 0.34,
+      seed: 1
+    };
+    EMPTY = () => ({ x0: 1, y0: 1, x1: 0, y1: 0 });
+    DamageField = class {
+      size = FIELD_SIZE;
+      /** RGBA per texel in float, row-major from v = 0. The simulation's own state. */
+      data;
+      /** The same, at 8 bits, for upload. Kept in step with `data` over what changed. */
+      pixels;
+      /**
+       * How ragged the sheet DRAWS this field's edges, 0..1 — see
+       * `DamageSource.detail`. Not a simulation option, because it changes
+       * nothing the field computes: set it from `fxQualityFor(tier).detail`, and
+       * again whenever the tier moves.
+       */
+      detail = 1;
+      revision = 0;
+      next;
+      /** Per-texel ignition threshold, fixed for the life of the sheet. */
+      tinder;
+      o;
+      heat;
+      water;
+      accumulator = 0;
+      /** Fixed steps run since the field was made — its own clock. See {@link time}. */
+      steps = 0;
+      /** Cells that might change on the next step. Everything outside is at rest. */
+      active = EMPTY();
+      /** Cells written since the last pack into `pixels`. */
+      touched = EMPTY();
+      visited = 0;
+      /** Running totals, so the stats never have to walk the whole grid. */
+      present;
+      wetTotal = 0;
+      stats = {
+        front: 0,
+        charred: 0,
+        consumed: 0,
+        wetted: 0,
+        saturation: 0,
+        remaining: 1
+      };
+      /**
+       * Texels whose presence reached zero during the last `step`, in the first
+       * {@link consumedCount} slots — where ash leaves from.
+       *
+       * WHERE, not just how many. The stats were enough for the sound, which
+       * wants a level; an emitter wants a place. Fixed buffers the size of the
+       * grid and written in place: a burning sheet must not allocate a list a
+       * step, and a texel is consumed once, so a step can never fill it twice.
+       */
+      consumedCells = new Int32Array(FIELD_SIZE * FIELD_SIZE);
+      /** The burn front as of the last step that ran, in the first {@link frontCount} slots — where embers and smoke leave from. */
+      frontCells = new Int32Array(FIELD_SIZE * FIELD_SIZE);
+      consumedLength = 0;
+      frontLength = 0;
+      constructor(options = {}) {
+        this.o = { ...DEFAULTS, ...options };
+        const n = FIELD_SIZE * FIELD_SIZE;
+        this.data = new Float32Array(n * 4);
+        this.next = new Float32Array(n * 4);
+        this.pixels = new Uint8Array(n * 4);
+        this.tinder = new Float32Array(n);
+        this.present = n;
+        for (let i = 0; i < n; i++) {
+          this.data[i * 4 + PRESENCE] = 1;
+          this.pixels[i * 4 + PRESENCE] = 255;
+          const x = i % FIELD_SIZE;
+          const y = i / FIELD_SIZE | 0;
+          const coarse = hash(x >> 2, y >> 2, this.o.seed);
+          const fine = hash(x, y, this.o.seed * 7 + 11);
+          this.tinder[i] = 1 + this.o.grain * (coarse * 0.65 + fine * 0.35 - 0.5);
+        }
+        this.next.set(this.data);
+        this.heat = stencil(this.o.heatDiffusion, this.o.anisotropy, this.o.fibre);
+        this.water = stencil(this.o.wicking, this.o.anisotropy, this.o.fibre);
+      }
+      /** Bumped whenever `pixels` changes. */
+      get version() {
+        return this.revision;
+      }
+      /**
+       * Simulated seconds this field has burned for — whole fixed steps, never
+       * wall time.
+       *
+       * What anything DRAWN from the field animates on: the ember line's beads
+       * flicker and crawl, flames puff, and all of it has to be the same at the
+       * same moment of the same burn, or a replay flickers differently from the
+       * original and a capture can never be taken twice. Stops while the field
+       * sleeps, which is right — a sheet at rest has nothing hot left to move.
+       */
+      get time() {
+        return this.steps * FIXED_DT;
+      }
+      /** Nothing is happening to this sheet, and stepping it costs nothing. */
+      get asleep() {
+        return this.active.x0 > this.active.x1;
+      }
+      /**
+       * Cells the last `step` visited.
+       *
+       * The cost of the field, stated in the one unit that means the same thing on
+       * every machine. Milliseconds would make a test of it a test of whoever ran
+       * it — which is how the hands harness spent weeks passing on one laptop.
+       */
+      get cellsVisited() {
+        return this.visited;
+      }
+      /** What the last `step` produced. */
+      get lastStats() {
+        return this.stats;
+      }
+      /** How many of {@link consumedCells} the last `step` wrote. Always `lastStats.consumed`. */
+      get consumedCount() {
+        return this.consumedLength;
+      }
+      /**
+       * How many of {@link frontCells} are current. `lastStats.front` times the
+       * texel count — and held, like it, across a frame too short to step.
+       */
+      get frontCount() {
+        return this.frontLength;
+      }
+      /** Texel index for a UV, clamped to the sheet. */
+      at(u, v) {
+        const x = Math.min(FIELD_SIZE - 1, Math.max(0, Math.round(u * (FIELD_SIZE - 1))));
+        const y = Math.min(FIELD_SIZE - 1, Math.max(0, Math.round(v * (FIELD_SIZE - 1))));
+        return y * FIELD_SIZE + x;
+      }
+      /** The four channels at a UV, for anything that needs to ask a question of a point. */
+      sample(u, v) {
+        const i = this.at(u, v) * 4;
+        return [this.data[i], this.data[i + 1], this.data[i + 2], this.data[i + 3]];
+      }
+      /**
+       * Add to one channel in a soft disc.
+       *
+       * Every paint operation is this with a different channel, which is the
+       * point of having one primitive: `ignite` and `wet` are not two systems
+       * that happen to look alike, they are the same write.
+       *
+       * `plateau` is the fraction of the radius that takes the full amount
+       * before the falloff starts. Zero for anything added, so the deposit has a
+       * soft peak — a flame held near paper does not deposit a stamped disc of
+       * heat, and a too-perfect edge is the first thing that reads as fake.
+       * Raised for anything removed, because a pure smoothstep never quite
+       * reaches zero even at its centre, and "almost all the way through" is not
+       * a hole.
+       */
+      paint(channel, u, v, radius, amount, plateau = 0) {
+        if (radius <= 0 || amount === 0) return;
+        const last = FIELD_SIZE - 1;
+        const cx = u * last;
+        const cy = v * last;
+        const r = radius * last;
+        const box = {
+          x0: Math.max(0, Math.floor(cx - r)),
+          y0: Math.max(0, Math.floor(cy - r)),
+          x1: Math.min(last, Math.ceil(cx + r)),
+          y1: Math.min(last, Math.ceil(cy + r))
+        };
+        if (box.x0 > box.x1 || box.y0 > box.y1) return;
+        const r2 = r * r;
+        const { data, next } = this;
+        for (let y = box.y0; y <= box.y1; y++) {
+          for (let x = box.x0; x <= box.x1; x++) {
+            const dx = x - cx;
+            const dy = y - cy;
+            const d2 = dx * dx + dy * dy;
+            if (d2 > r2) continue;
+            const t = plateau >= 1 ? 1 : Math.min(1, (1 - Math.sqrt(d2) / r) / (1 - plateau));
+            const falloff = t * t * (3 - 2 * t);
+            const i = (y * FIELD_SIZE + x) * 4 + channel;
+            const before = data[i];
+            const after = Math.min(1, Math.max(0, before + amount * falloff));
+            if (after === before) continue;
+            data[i] = after;
+            next[i] = after;
+            if (channel === PRESENCE) this.present += after - before;
+            if (channel === SATURATION) this.wetTotal += after - before;
+          }
+        }
+        grow(this.active, box);
+        grow(this.touched, box);
+        this.pack();
+      }
+      /** Hold a flame near the sheet. Heat, not char — the burning is the field's job. */
+      ignite(u, v, radius = 0.06, amount = 1) {
+        this.paint(HEAT, u, v, radius, amount);
+      }
+      /** Wet the sheet. Saturation wicks along the fibre from wherever it lands. */
+      wet(u, v, radius = 0.08, amount = 0.9) {
+        this.paint(SATURATION, u, v, radius, amount);
+      }
+      /**
+       * Take the paper away along a path: a tear, a cut, a punched hole.
+       *
+       * Presence only ever decreases. A sheet does not grow back, and a paint op
+       * that could raise it would make every burn reversible by accident.
+       */
+      cut(u0, v0, u1, v1, width = 0.02) {
+        const steps = Math.max(1, Math.ceil(Math.hypot(u1 - u0, v1 - v0) * FIELD_SIZE));
+        for (let s = 0; s <= steps; s++) {
+          const t = s / steps;
+          this.paint(PRESENCE, u0 + (u1 - u0) * t, v0 + (v1 - v0) * t, width, -1, 0.5);
+        }
+      }
+      /** Punch a hole. The middle of the sheet, which a fixed-topology mesh cannot do. */
+      punch(u, v, radius = 0.04) {
+        this.paint(PRESENCE, u, v, radius, -1, 0.5);
+      }
+      /**
+       * Advance the field by a frame's worth of real time.
+       *
+       * Fixed steps from an accumulator, so the same simulated second is the same
+       * fire at any frame rate. A sheet nothing is happening to returns at once
+       * and visits no cells at all — which is the condition for keeping this on
+       * the main thread, and the thing the first version could not do: an
+       * untouched sheet cost exactly what a burning one did.
+       */
+      step(delta) {
+        this.visited = 0;
+        this.consumedLength = 0;
+        if (delta <= 0) {
+          this.stats = { ...this.stats, charred: 0, consumed: 0, wetted: 0 };
+          return this.stats;
+        }
+        if (this.asleep) {
+          this.accumulator = 0;
+          this.frontLength = 0;
+          this.stats = { ...this.stats, front: 0, charred: 0, consumed: 0, wetted: 0 };
+          return this.stats;
+        }
+        this.accumulator = Math.min(this.accumulator + delta, FIXED_DT * MAX_STEPS_PER_FRAME);
+        let charred = 0;
+        let consumed = 0;
+        let wetted = 0;
+        let front = 0;
+        let stepped = false;
+        while (this.accumulator >= FIXED_DT && !this.asleep) {
+          this.accumulator -= FIXED_DT;
+          this.steps++;
+          stepped = true;
+          const done = this.substep();
+          charred += done.charred;
+          consumed += done.consumed;
+          wetted += done.wetted;
+          front = done.front;
+        }
+        this.pack();
+        const n = FIELD_SIZE * FIELD_SIZE;
+        this.stats = {
+          // A frame shorter than one fixed step runs none — one frame in six at
+          // 144 Hz — and nothing about the fire changed on it. Reporting 0 there
+          // would drop the burn's sound to silence mid-burn, six times a second.
+          front: stepped ? front / n : this.stats.front,
+          charred,
+          consumed,
+          wetted,
+          saturation: this.wetTotal / n,
+          remaining: this.present / n
+        };
+        return this.stats;
+      }
+      /**
+       * One fixed step of diffusion and reaction, over the active region only.
+       *
+       * The region is the box around every cell that could change, grown by one
+       * cell because diffusion reaches exactly one neighbour per step. Cells
+       * outside it are at rest and read-only here — their neighbours may read
+       * them, and nothing writes them.
+       *
+       * Written into `next` and copied back over the same region, rather than
+       * swapping the two buffers. A swap needs both buffers to agree everywhere
+       * the step did not write, and a region that SHRINKS breaks that: a cell the
+       * last step wrote into one buffer still holds an older value in the other.
+       * Copying the region back keeps them identical outside it, for the cost of
+       * the region itself — which is the cost that matters, since it is zero on
+       * a sheet at rest rather than a whole grid every step.
+       */
+      substep() {
+        const { data, next, tinder, o } = this;
+        const heat = this.heat;
+        const water = this.water;
+        const size = FIELD_SIZE;
+        const last = size - 1;
+        const dt = FIXED_DT;
+        const region = {
+          x0: Math.max(0, this.active.x0 - 1),
+          y0: Math.max(0, this.active.y0 - 1),
+          x1: Math.min(last, this.active.x1 + 1),
+          y1: Math.min(last, this.active.y1 + 1)
+        };
+        const awake = EMPTY();
+        let charred = 0;
+        let consumed = 0;
+        let wetted = 0;
+        let front = 0;
+        const { frontCells, consumedCells } = this;
+        const hd = heat.diagonal;
+        const wd = water.diagonal;
+        for (let y = region.y0; y <= region.y1; y++) {
+          const hasN = y < region.y1;
+          const hasS = y > region.y0;
+          for (let x = region.x0; x <= region.x1; x++) {
+            this.visited++;
+            const i = y * size + x;
+            const b = i * 4;
+            const presence = data[b + PRESENCE];
+            if (presence <= 0) {
+              this.wetTotal -= data[b + SATURATION];
+              next[b + HEAT] = 0;
+              next[b + SATURATION] = 0;
+              next[b + CHAR] = data[b + CHAR];
+              next[b + PRESENCE] = 0;
+              continue;
+            }
+            const hasE = x < region.x1;
+            const hasW = x > region.x0;
+            const e = hasE ? i + 1 : i;
+            const w = hasW ? i - 1 : i;
+            const n = hasN ? i + size : i;
+            const s = hasS ? i - size : i;
+            const hd1 = hd > 0 ? hasN && hasE ? i + size + 1 : i : hasN && hasW ? i + size - 1 : i;
+            const hd2 = hd > 0 ? hasS && hasW ? i - size - 1 : i : hasS && hasE ? i - size + 1 : i;
+            const wd1 = wd > 0 ? hasN && hasE ? i + size + 1 : i : hasN && hasW ? i + size - 1 : i;
+            const wd2 = wd > 0 ? hasS && hasW ? i - size - 1 : i : hasS && hasE ? i - size + 1 : i;
+            const me = e * 4;
+            const mw = w * 4;
+            const mn = n * 4;
+            const ms = s * 4;
+            const pe = Math.min(presence, data[me + PRESENCE]);
+            const pw = Math.min(presence, data[mw + PRESENCE]);
+            const pn = Math.min(presence, data[mn + PRESENCE]);
+            const ps = Math.min(presence, data[ms + PRESENCE]);
+            const h0 = data[b + HEAT];
+            const h1 = hd1 * 4;
+            const h2 = hd2 * 4;
+            let h = h0 + heat.ax * ((data[me + HEAT] - h0) * pe + (data[mw + HEAT] - h0) * pw) + heat.ay * ((data[mn + HEAT] - h0) * pn + (data[ms + HEAT] - h0) * ps) + heat.ad * ((data[h1 + HEAT] - h0) * Math.min(presence, data[h1 + PRESENCE]) + (data[h2 + HEAT] - h0) * Math.min(presence, data[h2 + PRESENCE]));
+            h -= h * o.cooling * dt;
+            const sat = data[b + SATURATION];
+            const w1 = wd1 * 4;
+            const w2 = wd2 * 4;
+            let g = sat + water.ax * ((data[me + SATURATION] - sat) * pe + (data[mw + SATURATION] - sat) * pw) + water.ay * ((data[mn + SATURATION] - sat) * pn + (data[ms + SATURATION] - sat) * ps) + water.ad * ((data[w1 + SATURATION] - sat) * Math.min(presence, data[w1 + PRESENCE]) + (data[w2 + SATURATION] - sat) * Math.min(presence, data[w2 + PRESENCE]));
+            if (g > 0 && h > 0) {
+              const boiled = Math.min(g, h * o.wetResistance * dt);
+              g -= boiled;
+              h -= boiled / o.wetResistance;
+            }
+            g -= g * o.drying * dt;
+            const char = data[b + CHAR];
+            let c = char;
+            const threshold = tinder[i] * IGNITION;
+            if (h > threshold && g < 0.25) {
+              const made = Math.min(1 - c, o.charRate * (h - threshold) * dt);
+              if (made > 0) {
+                c += made;
+                h += made * o.combustion;
+                if (char < 0.5 && c >= 0.5) charred++;
+              }
+            }
+            let p = presence;
+            if (c > 0.85) {
+              p = Math.max(0, p - o.consumeRate * (c - 0.85) * dt);
+              if (p <= 0) {
+                consumed++;
+                consumedCells[this.consumedLength++] = i;
+              }
+            }
+            h = Math.min(1, Math.max(0, h));
+            g = Math.min(1, Math.max(0, g));
+            c = Math.min(1, c);
+            if (g > sat + 1e-6) wetted++;
+            if (p > 0.15 && c > 0.08 && c < 0.92 && h > 0.1) frontCells[front++] = i;
+            next[b + CHAR] = c;
+            next[b + SATURATION] = g;
+            next[b + HEAT] = h;
+            next[b + PRESENCE] = p;
+            this.present += p - presence;
+            this.wetTotal += g - sat;
+            if (h > REST || g > REST || c > 0.85 && p > 0) {
+              if (x < awake.x0) awake.x0 = x;
+              if (x > awake.x1) awake.x1 = x;
+              if (y < awake.y0) awake.y0 = y;
+              if (y > awake.y1) awake.y1 = y;
+            }
+          }
+        }
+        for (let y = region.y0; y <= region.y1; y++) {
+          const from = (y * size + region.x0) * 4;
+          const to = (y * size + region.x1 + 1) * 4;
+          data.set(next.subarray(from, to), from);
+        }
+        grow(this.touched, region);
+        this.active = awake;
+        this.frontLength = front;
+        return { charred, consumed, wetted, front };
+      }
+      /** Quantise everything touched since the last pack, and mark it uploadable. */
+      pack() {
+        const t = this.touched;
+        if (t.x0 > t.x1) return;
+        const { data, pixels } = this;
+        for (let y = t.y0; y <= t.y1; y++) {
+          const from = (y * FIELD_SIZE + t.x0) * 4;
+          const to = (y * FIELD_SIZE + t.x1 + 1) * 4;
+          for (let k = from; k < to; k++) pixels[k] = Math.round(data[k] * 255);
+        }
+        this.touched = EMPTY();
+        this.revision++;
+      }
+    };
+  }
+});
+
+// src/fx/emission.ts
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function luminance(c) {
+  return c[0] * LUMA[0] + c[1] * LUMA[1] + c[2] * LUMA[2];
+}
+function timesPaperWhite(c) {
+  return luminance(c) / PAPER_WHITE;
+}
+function emit(srgb, times) {
+  const linear = [
+    srgbToLinear(srgb[0]),
+    srgbToLinear(srgb[1]),
+    srgbToLinear(srgb[2])
+  ];
+  const lum = luminance(linear);
+  if (lum <= 1e-6) return [0, 0, 0];
+  const gain = times * PAPER_WHITE / lum;
+  return [linear[0] * gain, linear[1] * gain, linear[2] * gain];
+}
+function emitHex(hex, times) {
+  const n = Number.parseInt(hex.replace("#", ""), 16);
+  return emit([(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255], times);
+}
+function fireZones(input) {
+  return {
+    root: { ...FIRE_ZONES.root, ...input?.root },
+    core: { ...FIRE_ZONES.core, ...input?.core },
+    body: { ...FIRE_ZONES.body, ...input?.body },
+    tip: { ...FIRE_ZONES.tip, ...input?.tip }
+  };
+}
+function hexToLinear(hex) {
+  const n = Number.parseInt(hex.replace("#", ""), 16);
+  return [
+    srgbToLinear((n >> 16 & 255) / 255),
+    srgbToLinear((n >> 8 & 255) / 255),
+    srgbToLinear((n & 255) / 255)
+  ];
+}
+var LUMA, PAPER_WHITE, FX_BLOOM_THRESHOLD, FIRE_GLOW, FIRE_HEAT_SCALE, FIRE_SOOT_SCALE, FX_BLOOM, FIRE_CONTRAST, FIRE_OPACITY, FIRE_THIN, FIRE_ZONES;
+var init_emission = __esm({
+  "src/fx/emission.ts"() {
+    "use strict";
+    LUMA = [0.2126, 0.7152, 0.0722];
+    PAPER_WHITE = 1.6;
+    FX_BLOOM_THRESHOLD = PAPER_WHITE * 2.25;
+    FIRE_GLOW = [4, 8];
+    FIRE_HEAT_SCALE = 0.65;
+    FIRE_SOOT_SCALE = 3;
+    FX_BLOOM = 0.55;
+    FIRE_CONTRAST = 0.9;
+    FIRE_OPACITY = 5;
+    FIRE_THIN = 0.55;
+    FIRE_ZONES = {
+      root: { color: "#3b6bff", amount: 0, reach: 0.5 },
+      // glow 6 (was 4.6): once the core became the hottest few percent of a
+      // flame instead of its whole root, 4.6 no longer cleared the bloom
+      // threshold — bloom's share of the peak frame fell to 0.48%, under the
+      // budget. Brighter keeps the same small area: 1.47% bloom, near-white 0.8%.
+      // Starting it lower (from 0.45) bloomed 6.4% but put near-white back at 4.7%.
+      core: { color: "#fff7d4", glow: 6, from: 0.55 },
+      // Saturated, because the tone curve takes saturation away from anything
+      // above paper white: #ffdd7c at this glow came out pale yellow (s ~0.4),
+      // and measured 7.5% yellow against Flame_base.png's 29%.
+      body: { color: "#ffcf3a", glow: 1.3 },
+      // to: 0.4, measured against Flame_base.png with bloom off (bloom's halo
+      // counts as flame in any diff): near-white / pale / yellow / orange came out
+      // 0.7 / 21 / 34 / 44% against the reference's 0.9 / 17 / 29 / 43. At 0.32
+      // the body took half the flame and it was 51% yellow; at 0.45, 64% orange.
+      tip: { color: "#ff9e2c", glow: 0.9, from: 0.08, to: 0.4, softness: 0.15, tearing: 0.35 }
+    };
+  }
+});
+
+// src/fx/flames.ts
+function flameAnchors(field, locate, max, out, time = field.time) {
+  if (max <= 0 || field.frontCount === 0) return 0;
+  const size = field.size;
+  const last = size - 1;
+  const data = field.data;
+  const rim = [];
+  let cx = 0;
+  let cy = 0;
+  for (let y = 1; y < last; y++) {
+    for (let x = 1; x < last; x++) {
+      const cell = y * size + x;
+      if (data[cell * 4 + HEAT] < FLAME_HEAT || data[cell * 4 + PRESENCE] < 0.5) continue;
+      if (data[(cell - 1) * 4 + PRESENCE] >= 0.5 && data[(cell + 1) * 4 + PRESENCE] >= 0.5 && data[(cell - size) * 4 + PRESENCE] >= 0.5 && data[(cell + size) * 4 + PRESENCE] >= 0.5) {
+        continue;
+      }
+      rim.push(cell);
+      cx += x;
+      cy += y;
+    }
+  }
+  if (rim.length === 0) return 0;
+  cx /= rim.length;
+  cy /= rim.length;
+  const angle = (cell) => Math.atan2((cell / size | 0) - cy, cell % size - cx);
+  rim.sort((a, b) => angle(a) - angle(b) || a - b);
+  const picks = [];
+  for (const cell of rim) {
+    const seed = hash2(cell, 1);
+    const a = angle(cell);
+    const cluster = clamp01(
+      0.62 * noise2(Math.cos(a) * 1.6 + time * 0.42, Math.sin(a) * 1.6 - time * 0.17) + 0.38 * noise2(Math.cos(a) * 4.1 - time * 0.73 + 7.3, Math.sin(a) * 4.1 + time * 0.31) - 0.12
+    );
+    const epoch = Math.floor(time * 1.4 + seed * 10);
+    if (hash2(cell, epoch + 7) > 0.38 + 0.55 * cluster) continue;
+    const breath = noise1(time * 0.9 + seed * 31);
+    if (breath < 0.16) continue;
+    const life = 0.3 + 0.7 * smoothstep(0.16, 0.5, breath);
+    picks.push({ cell, seed, cluster, life, along: (hash2(cell, 5) - 0.5) * 3, scale: 1 });
+    if (cluster > 0.5) {
+      const extra = cluster > 0.72 ? 2 : 1;
+      for (let k = 0; k < extra; k++) {
+        const side = hash2(cell, 11 + k);
+        picks.push({
+          cell,
+          seed: hash2(cell, 21 + k),
+          cluster,
+          life: life * (0.6 + 0.4 * side),
+          along: (side < 0.5 ? -1 : 1) * (1.5 + 3 * hash2(cell, 31 + k)),
+          scale: 0.4 + 0.45 * hash2(cell, 41 + k)
+        });
+      }
+    }
+  }
+  picks.sort((p, q) => q.cluster * 0.7 + q.seed * 0.3 - (p.cluster * 0.7 + p.seed * 0.3) || p.cell - q.cell);
+  const count = Math.min(max, picks.length);
+  let n = 0;
+  for (let i = 0; i < count; i++) {
+    const pick = picks[i];
+    const cell = pick.cell;
+    const x = cell % size;
+    const y = cell / size | 0;
+    const gx = data[(cell + 1) * 4 + PRESENCE] - data[(cell - 1) * 4 + PRESENCE];
+    const gy = data[(cell + size) * 4 + PRESENCE] - data[(cell - size) * 4 + PRESENCE];
+    const gl = Math.hypot(gx, gy) || 1;
+    const shift = pick.along * MM / last;
+    const u = x / last + -gy / gl * shift;
+    const v = y / last + gx / gl * shift;
+    const at = locate(u, v);
+    if (!at) continue;
+    const rx = at.x;
+    const ry = at.y;
+    const rz = at.z;
+    const toward = locate(u + gx / gl / last, v + gy / gl / last);
+    let upper = 0;
+    scratchA.x = 0;
+    scratchA.y = 0;
+    scratchA.z = 0;
+    if (toward) {
+      const l = Math.hypot(toward.x - rx, toward.y - ry, toward.z - rz) || 1;
+      scratchA.x = (toward.x - rx) / l;
+      scratchA.y = (toward.y - ry) / l;
+      scratchA.z = (toward.z - rz) / l;
+      upper = scratchA.y;
+    }
+    const heat = data[cell * 4 + HEAT];
+    const hot = Math.sqrt(Math.min(1, (heat - FLAME_HEAT) / 0.35));
+    const rim2 = 0.35 + 0.65 * (0.5 + 0.5 * upper);
+    const base = (FLAME_HEIGHT[0] + (FLAME_HEIGHT[1] - FLAME_HEIGHT[0]) * hot) * rim2;
+    const height = base * (0.2 + 1.3 * pick.cluster ** 1.4) * (0.6 + 0.8 * pick.seed) * pick.life * pick.scale;
+    let anchor = out[n];
+    if (!anchor) {
+      anchor = { x: 0, y: 0, z: 0, height: 0, width: 0, seed: 0, heat: 0, upper: 0, nx: 0, ny: 0, nz: 0 };
+      out[n] = anchor;
+    }
+    anchor.nx = scratchA.x;
+    anchor.ny = scratchA.y;
+    anchor.nz = scratchA.z;
+    anchor.x = rx;
+    anchor.y = ry;
+    anchor.z = rz;
+    anchor.height = Math.min(FLAME_HEIGHT[1], height);
+    anchor.width = anchor.height * (0.32 + 0.3 * hash2(cell, 3));
+    anchor.seed = pick.seed;
+    anchor.heat = hot;
+    anchor.upper = upper;
+    n++;
+  }
+  if (n >= 3 && variation(out, n) < IRREGULAR) {
+    for (let i = 0; i < n; i++) {
+      const a = out[i];
+      a.height = Math.min(FLAME_HEIGHT[1], a.height * (0.3 + 1.4 * hash2(Math.floor(a.seed * 1e6), 9)));
+      a.width = a.height * (0.32 + 0.3 * hash2(Math.floor(a.seed * 1e6), 3));
+    }
+  }
+  return n;
+}
+function variation(anchors, n) {
+  let sum = 0;
+  for (let i = 0; i < n; i++) sum += anchors[i].height;
+  const mean = sum / n;
+  if (!(mean > 0)) return 0;
+  let sq = 0;
+  for (let i = 0; i < n; i++) sq += (anchors[i].height - mean) ** 2;
+  return Math.sqrt(sq / n) / mean;
+}
+function clamp01(x) {
+  return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+function smoothstep(a, b, x) {
+  const t = clamp01((x - a) / (b - a));
+  return t * t * (3 - 2 * t);
+}
+function hash2(a, b) {
+  let h = Math.imul(a ^ Math.imul(b, 668265261), 2654435761) >>> 0;
+  h ^= h >>> 15;
+  h = Math.imul(h, 2246822519) >>> 0;
+  h ^= h >>> 13;
+  return (h >>> 0) / 4294967296;
+}
+function noise2(x, y) {
+  const ix = Math.floor(x);
+  const iy = Math.floor(y);
+  let fx = x - ix;
+  let fy = y - iy;
+  fx = fx * fx * (3 - 2 * fx);
+  fy = fy * fy * (3 - 2 * fy);
+  const h = (i, j) => hash2(i * 73856093, j * 19349663 + 7);
+  const a = h(ix, iy) + (h(ix + 1, iy) - h(ix, iy)) * fx;
+  const b = h(ix, iy + 1) + (h(ix + 1, iy + 1) - h(ix, iy + 1)) * fx;
+  return a + (b - a) * fy;
+}
+function flamePuff(seed, time) {
+  return 0.72 + 0.28 * noise1(time * 12.5 + seed * 37) + 0.12 * (noise1(time * 23 + seed * 11) - 0.5);
+}
+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;
+}
+var FLAME_HEIGHT, FLAME_HEAT, IRREGULAR, MM, scratchA;
+var init_flames = __esm({
+  "src/fx/flames.ts"() {
+    "use strict";
+    init_field();
+    FLAME_HEIGHT = [10 / 210, 40 / 210];
+    FLAME_HEAT = 0.22;
+    IRREGULAR = 0.4;
+    MM = 63 / 210;
+    scratchA = { x: 0, y: 0, z: 0 };
+  }
+});
+
+// src/fx/haze.ts
+var THREE2, import_postprocessing, HAZE_SOURCES, FRAGMENT, HazeGradeEffect;
+var init_haze = __esm({
+  "src/fx/haze.ts"() {
+    "use strict";
+    THREE2 = __toESM(require("three"), 1);
+    import_postprocessing = require("postprocessing");
+    HAZE_SOURCES = 16;
+    FRAGMENT = /* glsl */
+    `
+uniform vec4 uSources[${HAZE_SOURCES}];
+uniform int uCount;
+uniform float uTime;
+uniform float uAmount;
+uniform vec3 uWarm;
+uniform float uGrade;
+
+float hzHash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123); }
+float hzNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(hzHash(i), hzHash(i + vec2(1.0, 0.0)), u.x), mix(hzHash(i + vec2(0.0, 1.0)), hzHash(i + vec2(1.0, 1.0)), u.x), u.y);
+}
+
+// Heat haze: the air above a flame is hotter than the air beside it, and
+// light bends through the difference. A few pixels of upward-scrolling
+// displacement, only in the column above each flame, fading with height.
+void mainUv(inout vec2 uv) {
+  vec2 offset = vec2(0.0);
+  for (int i = 0; i < ${HAZE_SOURCES}; i++) {
+    if (i >= uCount) break;
+    vec4 s = uSources[i];
+    vec2 d = uv - s.xy;
+    float h = max(s.z, 1e-4);
+    float above = d.y / h;
+    if (above < -0.1 || above > 3.2) continue;
+    float across = abs(d.x) / (h * 0.55 + 1e-4);
+    // Around the flame's own boundary as well as above it: gentle inside the
+    // body, strongest in the hot column over it, gone by three flame heights.
+    float column = smoothstep(0.3, 0.9, above) * (1.0 - smoothstep(1.4, 3.2, above));
+    float around = smoothstep(-0.1, 0.15, above) * (1.0 - smoothstep(0.8, 1.2, above)) * 0.45;
+    float m = (1.0 - smoothstep(0.45, 1.15, across)) * max(column, around) * s.w;
+    vec2 q = vec2(uv.x * 140.0, uv.y * 90.0 - uTime * 3.0);
+    offset += (vec2(hzNoise(q), hzNoise(q + 31.7)) - 0.5) * m;
+  }
+  uv += offset * uAmount;
+}
+
+// The grade: the whole frame warms as the fire grows \u2014 a few percent, no
+// more (spec \xA77). A multiply, so black stays black.
+void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+  outputColor = vec4(inputColor.rgb * mix(vec3(1.0), uWarm, uGrade), inputColor.a);
+}
+`;
+    HazeGradeEffect = class extends import_postprocessing.Effect {
+      constructor() {
+        super("HazeGradeEffect", FRAGMENT, {
+          blendFunction: import_postprocessing.BlendFunction.NORMAL,
+          uniforms: /* @__PURE__ */ new Map([
+            ["uSources", new THREE2.Uniform(Array.from({ length: HAZE_SOURCES }, () => new THREE2.Vector4()))],
+            ["uCount", new THREE2.Uniform(0)],
+            ["uTime", new THREE2.Uniform(0)],
+            // 1–3 px at 1080p, as a fraction of the frame.
+            ["uAmount", new THREE2.Uniform(2.2 / 1080)],
+            ["uWarm", new THREE2.Uniform(new THREE2.Vector3(1.04, 1, 0.94))],
+            ["uGrade", new THREE2.Uniform(0)]
+          ])
+        });
+      }
+      get sources() {
+        return this.uniforms.get("uSources").value;
+      }
+      set count(n) {
+        this.uniforms.get("uCount").value = n;
+      }
+      set time(t) {
+        this.uniforms.get("uTime").value = t;
+      }
+      /** 0 turns the shimmer off (the low tier) and keeps the grade. */
+      set amount(px1080) {
+        this.uniforms.get("uAmount").value = px1080 / 1080;
+      }
+      /** 0..1 — how much of the warm grade to apply. */
+      set grade(g) {
+        this.uniforms.get("uGrade").value = g;
+      }
+    };
+  }
+});
+
+// src/fx/quality.ts
+function fxQualityFor(name) {
+  return fxQualityTiers[name === "auto" ? FX_INITIAL_TIER : name];
+}
+var fxQualityNames, fxQualityTiers, FX_INITIAL_TIER, FX_TIER_ORDER;
+var init_quality = __esm({
+  "src/fx/quality.ts"() {
+    "use strict";
+    fxQualityNames = ["auto", "low", "medium", "high"];
+    fxQualityTiers = {
+      /** A desktop GPU, or a phone that has measured its way up here. */
+      high: {
+        particles: 2e3,
+        voices: 16,
+        detail: 1,
+        bloomScale: 1,
+        flames: 64,
+        caps: { ember: 200, smoke: 200, ash: 120 },
+        haze: 2,
+        fluid: { velocity: [192, 256], dye: [384, 512], iterations: 36 }
+      },
+      /** The default worth aiming at: a recent phone, or an integrated laptop GPU. */
+      medium: {
+        particles: 900,
+        voices: 10,
+        detail: 1,
+        bloomScale: 1,
+        flames: 36,
+        caps: { ember: 80, smoke: 80, ash: 60 },
+        haze: 0,
+        fluid: { velocity: [144, 192], dye: [288, 384], iterations: 30 }
+      },
+      /**
+       * A throttled phone with the camera and the tracker already running, which
+       * is the realistic case rather than the pessimistic one. The fire is the
+       * same fire; the shower is thinner, fewer crackles overlap, and its edge is
+       * the grid's own.
+       */
+      low: {
+        particles: 350,
+        voices: 6,
+        detail: 0,
+        bloomScale: 0.5,
+        flames: 16,
+        caps: { ember: 30, smoke: 30, ash: 20 },
+        haze: 0,
+        fluid: { velocity: [96, 128], dye: [192, 256], iterations: 20 }
+      }
+    };
+    FX_INITIAL_TIER = "medium";
+    FX_TIER_ORDER = ["low", "medium", "high"];
+  }
+});
+
+// src/fx/FxPostPass.tsx
+var FxPostPass_exports = {};
+__export(FxPostPass_exports, {
+  FX_BLOOM: () => FX_BLOOM,
+  FX_BLOOM_THRESHOLD: () => FX_BLOOM_THRESHOLD,
+  FxPostPass: () => FxPostPass,
+  PAPER_WHITE: () => PAPER_WHITE
+});
+function FxPostPass({
+  film = "neutral",
+  quality = "medium",
+  bloom = FX_BLOOM,
+  threshold = FX_BLOOM_THRESHOLD,
+  field,
+  locate,
+  haze: hazeOverride
+}) {
+  const { bloomScale, haze: tierHaze } = fxQualityFor(quality);
+  const hazePx = hazeOverride ?? tierHaze;
+  const haze = (0, import_react2.useMemo)(() => new HazeGradeEffect(), []);
+  const anchors = (0, import_react2.useRef)([]);
+  (0, import_fiber2.useFrame)(({ camera }) => {
+    if (!field || !locate) {
+      haze.count = 0;
+      haze.grade = 0;
+      return;
+    }
+    const n = hazePx > 0 ? flameAnchors(field, locate, HAZE_SOURCES, anchors.current) : 0;
+    const sources = haze.sources;
+    for (let i = 0; i < n; i++) {
+      const a = anchors.current[i];
+      root.set(a.x, a.y, a.z).project(camera);
+      top.set(a.x, a.y + a.height, a.z).project(camera);
+      sources[i].set(root.x * 0.5 + 0.5, root.y * 0.5 + 0.5, Math.max(0, (top.y - root.y) * 0.5), a.heat);
+    }
+    haze.count = n;
+    haze.time = field.time;
+    haze.amount = hazePx;
+    haze.grade = Math.min(1, field.lastStats.front / 0.03);
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_postprocessing2.EffectComposer, { children: [
+    bloom > 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_postprocessing2.Bloom,
+      {
+        intensity: bloom,
+        luminanceThreshold: threshold,
+        luminanceSmoothing: 0.02,
+        mipmapBlur: true,
+        resolutionScale: bloomScale
+      }
+    ) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("primitive", { object: haze }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_postprocessing2.ToneMapping, { mode: modes[film] })
+  ] });
+}
+var import_postprocessing2, import_fiber2, import_postprocessing3, import_react2, THREE3, import_jsx_runtime2, modes, root, top;
+var init_FxPostPass = __esm({
+  "src/fx/FxPostPass.tsx"() {
+    "use strict";
+    import_postprocessing2 = require("@react-three/postprocessing");
+    import_fiber2 = require("@react-three/fiber");
+    import_postprocessing3 = require("postprocessing");
+    import_react2 = require("react");
+    THREE3 = __toESM(require("three"), 1);
+    init_emission();
+    init_flames();
+    init_haze();
+    init_quality();
+    import_jsx_runtime2 = require("react/jsx-runtime");
+    modes = {
+      agx: import_postprocessing3.ToneMappingMode.AGX,
+      neutral: import_postprocessing3.ToneMappingMode.NEUTRAL,
+      filmic: import_postprocessing3.ToneMappingMode.ACES_FILMIC
+    };
+    root = new THREE3.Vector3();
+    top = new THREE3.Vector3();
+  }
+});
+
+// src/fx.ts
+var fx_exports = {};
+__export(fx_exports, {
+  Afterglow: () => Afterglow,
+  CHAR: () => CHAR,
+  DAMAGE_CHANNELS: () => DAMAGE_CHANNELS,
+  DAMAGE_LOOK_DEFAULTS: () => DAMAGE_LOOK_DEFAULTS,
+  DamageField: () => DamageField,
+  FIELD_SIZE: () => FIELD_SIZE,
+  FIRE_GLOW: () => FIRE_GLOW,
+  FIRE_HEAT_SCALE: () => FIRE_HEAT_SCALE,
+  FIRE_SOOT_SCALE: () => FIRE_SOOT_SCALE,
+  FIRE_ZONES: () => FIRE_ZONES,
+  FIXED_DT: () => FIXED_DT,
+  FLAME_HEIGHT: () => FLAME_HEIGHT,
+  FX_BLOOM: () => FX_BLOOM,
+  FX_BLOOM_THRESHOLD: () => FX_BLOOM_THRESHOLD,
+  FX_INITIAL_TIER: () => FX_INITIAL_TIER,
+  FX_TIER_ORDER: () => FX_TIER_ORDER,
+  FireEmitter: () => FireEmitter,
+  FireFluid: () => FireFluid,
+  FireSound: () => FireSound,
+  FxAudio: () => FxAudio,
+  FxFireFluid: () => FxFireFluid,
+  FxFireLight: () => FxFireLight,
+  FxFlames: () => FxFlames,
+  FxMatchFlame: () => FxMatchFlame,
+  FxParticles: () => FxParticles,
+  FxPost: () => FxPost,
+  FxWisps: () => FxWisps,
+  HEAT: () => HEAT,
+  PAPER_WHITE: () => PAPER_WHITE,
+  PRESENCE: () => PRESENCE,
+  ParticlePool: () => ParticlePool,
+  SATURATION: () => SATURATION,
+  createAudioContext: () => createAudioContext,
+  emit: () => emit,
+  emitHex: () => emitHex,
+  fireEmitterDefaults: () => fireEmitterDefaults,
+  fireFluidControls: () => fireFluidControls,
+  fireFluidDefaults: () => fireFluidDefaults,
+  fireZones: () => fireZones,
+  flameAnchors: () => flameAnchors,
+  flamePuff: () => flamePuff,
+  fxQualityFor: () => fxQualityFor,
+  fxQualityNames: () => fxQualityNames,
+  fxQualityTiers: () => fxQualityTiers,
+  hexToLinear: () => hexToLinear,
+  luminance: () => luminance,
+  particlePresets: () => particlePresets,
+  solverUniforms: () => solverUniforms,
+  srgbToLinear: () => srgbToLinear,
+  timesPaperWhite: () => timesPaperWhite
+});
+module.exports = __toCommonJS(fx_exports);
+init_field();
+init_damageContract();
+
+// src/fx/particles.ts
+init_emission();
+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
+init_field();
+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
+var THREE = __toESM(require("three"), 1);
+var import_fiber = require("@react-three/fiber");
+var import_react = require("react");
+var import_jsx_runtime = require("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 = (0, import_react.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]);
+  (0, import_react.useEffect)(() => () => layer.geometry.dispose(), [layer]);
+  return layer;
+}
+function usePoints(capacity) {
+  const layer = (0, import_react.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]);
+  (0, import_react.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 = (0, import_react.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
+      })
+    }),
+    []
+  );
+  (0, import_react.useEffect)(
+    () => () => {
+      materials.ember.dispose();
+      materials.smoke.dispose();
+      materials.flake.dispose();
+    },
+    [materials]
+  );
+  const size = (0, import_fiber.useThree)((s) => s.size);
+  (0, import_fiber.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__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("mesh", { geometry: embers.geometry, material: materials.ember, frustumCulled: false }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("points", { geometry: smoke.geometry, material: materials.smoke, frustumCulled: false }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("mesh", { geometry: flakes.geometry, material: materials.flake, frustumCulled: false })
+  ] });
+}
+
+// src/fx/FxPost.tsx
+var import_react3 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var Pass = (0, import_react3.lazy)(
+  () => Promise.resolve().then(() => (init_FxPostPass(), FxPostPass_exports)).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__ */ (0, import_jsx_runtime3.jsx)(import_react3.Suspense, { fallback: null, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Pass, { ...props }) });
+}
+
+// src/fx.ts
+init_emission();
+
+// src/fx/afterglow.ts
+init_field();
+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
+var import_fiber3 = require("@react-three/fiber");
+var import_react4 = require("react");
+init_flames();
+
+// src/fx/flameShader.ts
+var THREE4 = __toESM(require("three"), 1);
+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 FRAGMENT2 = (
+  /* 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 THREE4.InstancedBufferGeometry();
+  g.setAttribute(
+    "position",
+    new THREE4.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 THREE4.InstancedBufferAttribute(new Float32Array(Math.max(1, max) * 3), 3));
+  g.setAttribute("aShape", new THREE4.InstancedBufferAttribute(new Float32Array(Math.max(1, max) * 4), 4));
+  g.instanceCount = 0;
+  g.boundingSphere = new THREE4.Sphere(new THREE4.Vector3(), Infinity);
+  return g;
+}
+function flameMaterial() {
+  return new THREE4.ShaderMaterial({
+    vertexShader: VERTEX,
+    fragmentShader: FRAGMENT2,
+    uniforms: {
+      uTime: { value: 0 },
+      uLean: { value: new THREE4.Vector3() },
+      uBlue: { value: 0 },
+      uGain: { value: 1 }
+    },
+    transparent: true,
+    depthWrite: false,
+    blending: THREE4.AdditiveBlending,
+    side: THREE4.DoubleSide
+  });
+}
+
+// src/fx/FxFlames.tsx
+init_quality();
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function FxFlames({ field, locate, quality = "medium", wind }) {
+  const max = fxQualityFor(quality).flames;
+  const anchors = (0, import_react4.useRef)([]);
+  const geometry = (0, import_react4.useMemo)(() => flameGeometry(max), [max]);
+  (0, import_react4.useEffect)(() => () => geometry.dispose(), [geometry]);
+  const material = (0, import_react4.useMemo)(() => flameMaterial(), []);
+  (0, import_react4.useEffect)(() => () => material.dispose(), [material]);
+  (0, import_fiber3.useFrame)(() => {
+    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__ */ (0, import_jsx_runtime4.jsx)("mesh", { geometry, material, frustumCulled: false, renderOrder: 2 });
+}
+
+// src/fx/FxWisps.tsx
+var THREE5 = __toESM(require("three"), 1);
+var import_fiber4 = require("@react-three/fiber");
+var import_react5 = require("react");
+init_field();
+var import_jsx_runtime5 = require("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 = (0, import_react5.useRef)(
+    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 = (0, import_react5.useRef)(-1);
+  const geometry = (0, import_react5.useMemo)(() => {
+    const g = new THREE5.BufferGeometry();
+    const vertices = WISPS * POINTS * 2;
+    g.setAttribute("position", new THREE5.BufferAttribute(new Float32Array(vertices * 3), 3));
+    g.setAttribute("aAlpha", new THREE5.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 THREE5.Sphere(new THREE5.Vector3(), Infinity);
+    return g;
+  }, []);
+  (0, import_react5.useEffect)(() => () => geometry.dispose(), [geometry]);
+  const material = (0, import_react5.useMemo)(
+    () => new THREE5.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: THREE5.DoubleSide
+    }),
+    []
+  );
+  (0, import_react5.useEffect)(() => () => material.dispose(), [material]);
+  (0, import_fiber4.useFrame)(({ 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 THREE5.Vector3();
+    const q = new THREE5.Vector3();
+    const toCamera = new THREE5.Vector3();
+    const side = new THREE5.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 = (noise12(a * 0.8 + s.born[k] * 0.3 + s.phase) - 0.5) * 0.07 * a;
+        const lean = (noise12(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__ */ (0, import_jsx_runtime5.jsx)("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 hash12(n) {
+  const s = Math.sin(n) * 43758.5453;
+  return s - Math.floor(s);
+}
+function noise12(x) {
+  const i = Math.floor(x);
+  let f = x - i;
+  f = f * f * (3 - 2 * f);
+  return hash12(i) + (hash12(i + 1) - hash12(i)) * f;
+}
+
+// src/fx/FxFireFluid.tsx
+var THREE7 = __toESM(require("three"), 1);
+var import_fiber5 = require("@react-three/fiber");
+var import_react6 = require("react");
+init_emission();
+init_flames();
+
+// src/fx/fluid/FireFluid.ts
+var THREE6 = __toESM(require("three"), 1);
+
+// 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 THREE6.WebGLRenderTarget(w, h, {
+    type: THREE6.HalfFloatType,
+    format: THREE6.RGBAFormat,
+    minFilter: THREE6.LinearFilter,
+    magFilter: THREE6.LinearFilter,
+    wrapS: THREE6.ClampToEdgeWrapping,
+    wrapT: THREE6.ClampToEdgeWrapping,
+    depthBuffer: false,
+    stencilBuffer: false,
+    generateMipmaps: false
+  });
+}
+function pass(fragmentShader, uniforms) {
+  return new THREE6.ShaderMaterial({
+    vertexShader: PASS_VERTEX,
+    fragmentShader,
+    uniforms,
+    depthTest: false,
+    depthWrite: false,
+    blending: THREE6.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 THREE6.Vector2(1 / vw, 1 / vh);
+    const dTexel = new THREE6.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 THREE6.Vector2(domain.width, domain.height) },
+        uDt: { value: 0 },
+        uKeep: { value: new THREE6.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 THREE6.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 THREE6.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 THREE6.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 THREE6.Vector4() } }),
+      maccormack: pass(MACCORMACK, {
+        uVelocity: { value: null },
+        uSource: { value: null },
+        uForward: { value: null },
+        uBackward: { value: null },
+        uDomain: { value: new THREE6.Vector2(domain.width, domain.height) },
+        uTexel: { value: new THREE6.Vector2(1 / dw, 1 / dh) },
+        uDt: { value: 0 }
+      })
+    };
+    const triangle = new THREE6.BufferGeometry();
+    triangle.setAttribute(
+      "position",
+      new THREE6.BufferAttribute(new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]), 3)
+    );
+    this.mesh = new THREE6.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 THREE6.Scene();
+  camera = new THREE6.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+  mesh;
+  m;
+  sources = Array.from({ length: MAX_SOURCES }, () => new THREE6.Vector4());
+  across = Array.from({ length: MAX_SOURCES }, () => new THREE6.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
+init_quality();
+var import_jsx_runtime6 = require("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 THREE7.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 = (0, import_fiber5.useThree)((s) => s.gl);
+  const camera = (0, import_fiber5.useThree)((s) => s.camera);
+  const grid = fxQualityFor(quality).fluid;
+  const fluid = (0, import_react6.useMemo)(() => FireFluid.supported(gl) ? new FireFluid(gl, grid, DOMAIN) : null, [gl, grid]);
+  (0, import_react6.useEffect)(() => () => fluid?.dispose(), [fluid]);
+  const merged = (0, import_react6.useMemo)(() => ({ ...fireFluidDefaults, ...params }), [params]);
+  const material = (0, import_react6.useMemo)(
+    () => new THREE7.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 THREE7.Vector3() },
+        uBodyColor: { value: new THREE7.Vector3() },
+        uCoreColor: { value: new THREE7.Vector3() },
+        uRootColor: { value: new THREE7.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: THREE7.CustomBlending,
+      blendSrc: THREE7.OneFactor,
+      blendDst: THREE7.OneMinusSrcAlphaFactor,
+      side: THREE7.DoubleSide
+    }),
+    []
+  );
+  (0, import_react6.useEffect)(() => () => material.dispose(), [material]);
+  const plane = (0, import_react6.useMemo)(() => new THREE7.PlaneGeometry(DOMAIN.width, DOMAIN.height), []);
+  (0, import_react6.useEffect)(() => () => plane.dispose(), [plane]);
+  const mesh = (0, import_react6.useRef)(null);
+  const state = (0, import_react6.useRef)({
+    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 THREE7.Vector3(),
+    right: new THREE7.Vector3(1, 0, 0),
+    normal: new THREE7.Vector3(0, 0, 1)
+  });
+  const anchors = (0, import_react6.useRef)([]);
+  const sources = (0, import_react6.useMemo)(() => new Float32Array(MAX_SOURCES * 4), []);
+  const across = (0, import_react6.useMemo)(() => new Float32Array(MAX_SOURCES * 4), []);
+  const smoulder = (0, import_react6.useMemo)(
+    () => Array.from({ length: SMOULDER_SLOTS }, () => ({
+      seen: Number.NEGATIVE_INFINITY,
+      source: new Float32Array(4),
+      across: new Float32Array(4)
+    })),
+    []
+  );
+  const scratch = (0, import_react6.useMemo)(() => new THREE7.Vector3(), []);
+  const place = () => {
+    const s = state.current;
+    const centre = locate(0.5, 0.5);
+    const c = new THREE7.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 THREE7.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;
+  };
+  (0, import_fiber5.useFrame)((_, 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__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children: fallback ?? null });
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("mesh", { ref: mesh, geometry: plane, material, frustumCulled: false, renderOrder: 2 });
+}
+
+// src/fx/FxFireLight.tsx
+var THREE8 = __toESM(require("three"), 1);
+var import_fiber6 = require("@react-three/fiber");
+var import_react7 = require("react");
+init_flames();
+var import_jsx_runtime7 = require("react/jsx-runtime");
+function FxFireLight({ field, locate, gain = FIRE_LIGHT_GAIN }) {
+  const front = (0, import_react7.useRef)(null);
+  const through = (0, import_react7.useRef)(null);
+  const anchors = (0, import_react7.useRef)([]);
+  (0, import_fiber6.useFrame)(({ 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 THREE8.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__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("pointLight", { ref: front, color: FIRE_COLOR, intensity: 0, decay: 0.9, distance: 0 }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("pointLight", { ref: through, color: FIRE_COLOR, intensity: 0, decay: 0.9, distance: 0 })
+  ] });
+}
+var FIRE_COLOR = new THREE8.Color("#ffa24c");
+var FIRE_LIGHT_GAIN = 42;
+
+// src/fx/FxMatchFlame.tsx
+var THREE9 = __toESM(require("three"), 1);
+var import_fiber7 = require("@react-three/fiber");
+var import_react8 = require("react");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var HEIGHT = 20 / 210;
+var FLARE = 0.42;
+var FLARE_GAIN = 1;
+var ARM = 0.32;
+function FxMatchFlame({ match }) {
+  const geometry = (0, import_react8.useMemo)(() => flameGeometry(1), []);
+  const material = (0, import_react8.useMemo)(() => flameMaterial(), []);
+  const pool = (0, import_react8.useMemo)(() => new ParticlePool(160, 3), []);
+  (0, import_react8.useEffect)(
+    () => () => {
+      geometry.dispose();
+      material.dispose();
+    },
+    [geometry, material]
+  );
+  const light = (0, import_react8.useRef)(null);
+  const memory = (0, import_react8.useRef)({
+    time: 0,
+    last: "none",
+    armedAt: 0,
+    flare: 0,
+    flash: 0,
+    spark: 0,
+    was: new THREE9.Vector3(),
+    velocity: new THREE9.Vector3(),
+    lean: new THREE9.Vector3(),
+    at: new THREE9.Vector3(),
+    hasAt: false
+  });
+  (0, import_fiber7.useFrame)((_, 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__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("mesh", { geometry, material, frustumCulled: false, renderOrder: 3 }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("pointLight", { ref: light, color: "#ffb066", intensity: 0, decay: 1.6, distance: 0 }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(FxParticles, { pool })
+  ] });
+}
+
+// src/fx.ts
+init_flames();
+
+// src/fx/sfx/graph.ts
+init_quality();
+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 DEFAULTS2 = { 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 = { ...DEFAULTS2, ...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;
+  }
+};
+
+// src/fx.ts
+init_quality();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs.map