paperlab 0.6.0 → 0.7.0

package/dist/chunk-GB6BMHC3.js

@@ -0,0 +1,811 @@
+import {
+  DAMAGE_CHANNELS
+} from "./chunk-7TLIWPGM.js";
+
+// src/fx/field.ts
+var CHAR = DAMAGE_CHANNELS.char;
+var SATURATION = DAMAGE_CHANNELS.saturation;
+var HEAT = DAMAGE_CHANNELS.heat;
+var PRESENCE = DAMAGE_CHANNELS.presence;
+var FIELD_SIZE = 64;
+var FIXED_DT = 1 / 120;
+var MAX_STEPS_PER_FRAME = 8;
+var REST = 1e-3;
+var IGNITION = 0.35;
+var STABLE = 0.4;
+var 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
+};
+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;
+}
+var EMPTY = () => ({ x0: 1, y0: 1, x1: 0, y1: 0 });
+var 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++;
+  }
+};
+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;
+}
+
+// src/fx/emission.ts
+var LUMA = [0.2126, 0.7152, 0.0722];
+var PAPER_WHITE = 1.6;
+var FX_BLOOM_THRESHOLD = PAPER_WHITE * 2.25;
+var FIRE_GLOW = [4, 8];
+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);
+}
+var FIRE_HEAT_SCALE = 0.65;
+var FIRE_SOOT_SCALE = 3;
+var FX_BLOOM = 0.55;
+var FIRE_CONTRAST = 0.9;
+var FIRE_OPACITY = 5;
+var FIRE_THIN = 0.55;
+var 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 }
+};
+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)
+  ];
+}
+
+// src/fx/flames.ts
+var FLAME_HEIGHT = [10 / 210, 40 / 210];
+var FLAME_HEAT = 0.22;
+var IRREGULAR = 0.4;
+var MM = 63 / 210;
+var scratchA = { x: 0, y: 0, z: 0 };
+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;
+}
+
+// src/fx/quality.ts
+var fxQualityNames = ["auto", "low", "medium", "high"];
+var 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 }
+  }
+};
+var FX_INITIAL_TIER = "medium";
+var FX_TIER_ORDER = ["low", "medium", "high"];
+function fxQualityFor(name) {
+  return fxQualityTiers[name === "auto" ? FX_INITIAL_TIER : name];
+}
+
+export {
+  CHAR,
+  SATURATION,
+  HEAT,
+  PRESENCE,
+  FIELD_SIZE,
+  FIXED_DT,
+  DamageField,
+  PAPER_WHITE,
+  FX_BLOOM_THRESHOLD,
+  FIRE_GLOW,
+  srgbToLinear,
+  luminance,
+  timesPaperWhite,
+  emit,
+  emitHex,
+  FIRE_HEAT_SCALE,
+  FIRE_SOOT_SCALE,
+  FX_BLOOM,
+  FIRE_CONTRAST,
+  FIRE_OPACITY,
+  FIRE_THIN,
+  FIRE_ZONES,
+  fireZones,
+  hexToLinear,
+  FLAME_HEIGHT,
+  flameAnchors,
+  flamePuff,
+  fxQualityNames,
+  fxQualityTiers,
+  FX_INITIAL_TIER,
+  FX_TIER_ORDER,
+  fxQualityFor
+};
+//# sourceMappingURL=chunk-GB6BMHC3.js.map