@3driseai/3drise-viewer 0.1.30 → 0.1.31

package/dist/components/particles/FireworksParticles.js

@@ -0,0 +1,1649 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame, useThree } from '@react-three/fiber';
+import { DEFAULT_GENERATIVE_PARTICLES, GENERATIVE_PARTICLES_ANIMATABLE } from '@3driseai/3drise-core';
+import { applyConfigKeyframeAnimations, applyConfigMouseMove, withConfigDefaults } from '../../utils/configAnimations.js';
+import { createPointerUniforms, stepPointerField, usePointerField } from '../../utils/pointerField.js';
+import { createTrailUniforms, applyTrailConfig, createCpuTrail } from '../../utils/particleTrails.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useConfigLiveHandle } from '../../hooks/useConfigLive.js';
+/**
+ * Fireworks — An aerial fireworks show: 20 real shell types, shaped shells, formations and text written in the sky, with drag-limited stars, cooling sparks and lit smoke; fires on its own or where you click. Use for celebrations, New Year and night-sky scenes.
+ */
+// Fireworks — an aerial-shell display: shells rise from a mortar rack, burst at their apex and throw
+// stars whose composition decides what the burst does.
+// Movement: every shell, star, spark and microstar is a ballistic body under gravity and quadratic air
+//           drag a = -k |v - w| (v - w) relative to the air w (wind + the cursor's flow). The drag
+//           coefficient k = 3 rho_air C_d / (4 rho_star d) is per composition: heavy comets (palm,
+//           crossette) carry far, light charcoal stars (willow) stop quickly and hang at their low
+//           terminal speed sqrt(g / k), drooping into the willow shape. A shell is drag-free and its
+//           time fuse fires at the apex (launch speed sqrt(2 g h) sets the burst height). Stars are
+//           packed on a Fibonacci sphere (even, like stars pasted in a shell's hemispheres) or on a
+//           great circle (ring), and inherit the shell's velocity.
+// Shell types (what real shells do):
+//   peony         — coloured stars, no tails; half of them change colour as the star burns through
+//                   its layers (colour from burn fraction).
+//   chrysanthemum — coloured stars that shed charcoal sparks: a burst of drawn lines.
+//   willow        — long-burning charcoal stars with high drag: golden fronds that hang and droop.
+//   palm          — a thick rising trunk and a few heavy comets that arc out like palm fronds.
+//   ring          — stars on one tilted great circle.
+//   crossette     — a few comets that each split into a cross of four at mid-flight.
+//   crackle       — gold glitter stars that fragment into popping microstars (dragon eggs).
+//   strobe        — magnesium stars that blink on and off at their own rates.
+//   mix           — a show: the types in a seeded sequence.
+// Light: stars emit their metal-salt colour (three config colours = strontium red, barium green,
+//        copper blue); charcoal sparks and gold stars glow on the Planck locus — temperature cools
+//        exponentially and visible radiance ~ exp(-c2 / (lambda T)) fades them out around 1100 K.
+//        Brightness follows the burning fragment (~ surface, so it fades as the star shrinks);
+//        film response saturates the brightest cores toward white. Each burst's flash and its
+//        stars light the smoke it leaves, which drifts with the wind and is lit again by later bursts.
+// Mouse (pointerMode) — nothing is drawn at the cursor:
+//   aim      — the rack moves under the cursor and shells burst where it points; a faster stroke
+//              fires more often and leans the shells; strength is the lift charge (burst size).
+//   wind     — the cursor's motion is a gust: a moving-body potential flow plus a wake pushes stars,
+//              sparks and smoke, and sparks in the wake get fresh air and flare.
+//   reignite — sweeping through the falling stars feeds them oxygen: they flare, burn longer and
+//              take the pointer colour.
+// Trails (trailMode): streak = long-exposure photograph, comet = burning tails, echo = afterglow.
+/** mulberry32 — seeded PRNG, returns a function giving floats in [0,1). */
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return function () {
+        a = (a + 0x6d2b79f5) >>> 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;
+    };
+}
+/** Standard normal from a uniform PRNG (Box–Muller, one value per call). */
+function gauss(rng) {
+    const u = Math.max(rng(), 1e-9);
+    const v = rng();
+    return Math.sqrt(-2 * Math.log(u)) * Math.cos(6.283185307 * v);
+}
+/** Viewport-height hook so point sizes are pixel-correct at any canvas size. */
+function attachViewH(obj, u) {
+    const scratch = new THREE.Vector2();
+    obj.onBeforeRender = (renderer) => {
+        renderer.getDrawingBufferSize(scratch);
+        u.uViewH.value = scratch.y;
+    };
+}
+function colorUniform(hex) {
+    return { value: new THREE.Color(hex) };
+}
+/** Quality levels scale counts and trail caps. Structural. */
+const QUALITY_SCALE = { low: 0.5, medium: 1, high: 1.6 };
+function qualityScale(q) { return QUALITY_SCALE[q] || 1; }
+/** Mix the object's own base seed with the `seed` knob into a mulberry32 seed. */
+function seedMix(base, seed) {
+    let h = (base ^ Math.imul((Math.round(seed) | 0) + 0x9e37, 0x85ebca6b)) >>> 0;
+    h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
+    return (h ^ (h >>> 16)) >>> 0;
+}
+/** Fixed-step clock: the same motion at 30, 60 or 144 Hz. */
+function createFixedStep(H, maxSteps) {
+    let acc = 0;
+    return {
+        H,
+        run(d, step) {
+            acc += Math.max(d, 0);
+            let k = 0;
+            while (acc >= H && k < maxSteps) {
+                step(H);
+                acc -= H;
+                k++;
+            }
+            if (k === maxSteps)
+                acc = Math.min(acc, H);
+            return acc / H;
+        },
+        reset() { acc = 0; },
+    };
+}
+/** Selection bounds: an invisible sphere the editor can pick and frame (never rendered). */
+function createPickProxy(center, radius) {
+    const geo = new THREE.SphereGeometry(1, 16, 10);
+    const mat = new THREE.MeshBasicMaterial({ visible: false });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.name = 'pickProxy';
+    mesh.position.set(center[0], center[1], center[2]);
+    mesh.scale.setScalar(radius);
+    return { mesh, dispose() { geo.dispose(); mat.dispose(); } };
+}
+const _frustum = new THREE.Frustum();
+const _pm = new THREE.Matrix4();
+const _sphere = new THREE.Sphere();
+/** Off-screen test: false when the object's bounding sphere is outside the camera frustum. */
+function inView(object, camera, center, radius, size) {
+    if (!camera || !camera.projectionMatrix)
+        return true;
+    object.updateWorldMatrix(true, false);
+    _sphere.center.set(center[0], center[1], center[2]).multiplyScalar(size).applyMatrix4(object.matrixWorld);
+    _sphere.radius = radius * size * object.matrixWorld.getMaxScaleOnAxis();
+    _pm.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+    _frustum.setFromProjectionMatrix(_pm);
+    return _frustum.intersectsSphere(_sphere);
+}
+/** Tanner Helland blackbody fit, kelvin -> linear RGB normalised to its largest channel. */
+function blackbodyRGB(tK, out) {
+    const t = Math.min(Math.max(tK, 1000), 40000) / 100;
+    const r = t <= 66 ? 1 : Math.min(Math.max(1.29293618606 * Math.pow(t - 60, -0.1332047592), 0), 1);
+    const g = t <= 66 ? Math.min(Math.max(0.39008157876 * Math.log(t) - 0.63184144378, 0), 1)
+        : Math.min(Math.max(1.12989086089 * Math.pow(t - 60, -0.0755148492), 0), 1);
+    const b = t >= 66 ? 1 : t <= 19 ? 0 : Math.min(Math.max(0.54320678911 * Math.log(t - 10) - 1.19625408914, 0), 1);
+    out[0] = Math.pow(r, 2.2);
+    out[1] = Math.pow(g, 2.2);
+    out[2] = Math.pow(b, 2.2);
+    const m = Math.max(out[0], out[1], out[2], 1e-3);
+    out[0] /= m;
+    out[1] /= m;
+    out[2] /= m;
+    return out;
+}
+/** Blackbody lookup, 900..2700 K in 10 K steps (the sparks' range): the per-frame colour pass reads it instead of
+ *  evaluating pow / log for every spark. */
+const BB_LUT = (() => { const t = new Float32Array(181 * 3), o = [0, 0, 0]; for (let k = 0; k < 181; k++) {
+    blackbodyRGB(900 + k * 10, o);
+    t[k * 3] = o[0];
+    t[k * 3 + 1] = o[1];
+    t[k * 3 + 2] = o[2];
+} return t; })();
+function bbLut(T, out) {
+    const f = Math.min(Math.max((T - 900) / 10, 0), 179.999), k = Math.floor(f), w = f - k, a = k * 3;
+    out[0] = BB_LUT[a] + (BB_LUT[a + 3] - BB_LUT[a]) * w;
+    out[1] = BB_LUT[a + 1] + (BB_LUT[a + 4] - BB_LUT[a + 1]) * w;
+    out[2] = BB_LUT[a + 2] + (BB_LUT[a + 5] - BB_LUT[a + 2]) * w;
+    return out;
+}
+const POINTER_MODES = ['aim', 'wind', 'reignite'];
+const CLICK_FUSE = 0.9; // seconds from a click to the break
+/** Clicks for fireOnClick: a press and release within 6 px and 350 ms (an orbit drag is not a click).
+ *  Read-only listeners on the same element as the pointer field; the queue lives on the pointer state. */
+function bindClickFire(el, state) {
+    state.clicks = state.clicks || [];
+    let x0 = 0, y0 = 0, t0 = -1;
+    const down = (e) => { if (e.button !== 0)
+        return; x0 = e.clientX; y0 = e.clientY; t0 = performance.now(); };
+    const up = (e) => {
+        if (e.button !== 0 || t0 < 0)
+            return;
+        const dt = performance.now() - t0;
+        t0 = -1;
+        if (dt > 350 || Math.hypot(e.clientX - x0, e.clientY - y0) > 6)
+            return;
+        const r = el.getBoundingClientRect();
+        state.clicks.push([((e.clientX - r.left) / r.width) * 2 - 1, -((e.clientY - r.top) / r.height) * 2 + 1]);
+        if (state.clicks.length > 8)
+            state.clicks.shift();
+    };
+    el.addEventListener('pointerdown', down, { passive: true });
+    el.addEventListener('pointerup', up, { passive: true });
+    return () => { el.removeEventListener('pointerdown', down); el.removeEventListener('pointerup', up); };
+}
+const _cray = new THREE.Raycaster();
+const _cplane = new THREE.Plane();
+const _cn = new THREE.Vector3();
+const _cc = new THREE.Vector3();
+const _chit = new THREE.Vector3();
+const _cv = new THREE.Vector2();
+/** Where a click lands, in the object's sim units: the nearest scene surface it hits (an object, the ground)
+ *  — skipping this object, sprites and lines, inside-out domes (sky) and anything implausibly far — or else the
+ *  camera-facing plane through the show. */
+function clickTarget(ndc, camera, object, size, anchor, own) {
+    _cv.set(ndc[0], ndc[1]);
+    _cray.setFromCamera(_cv, camera);
+    let root = object;
+    while (root.parent)
+        root = root.parent;
+    object.updateWorldMatrix(true, false);
+    const scale = size * object.matrixWorld.getMaxScaleOnAxis();
+    const far = 40 * scale + camera.position.distanceTo(object.getWorldPosition(_cc));
+    const hits = _cray.intersectObject(root, true);
+    for (const h of hits) {
+        const o = h.object, mat = o['material'];
+        if (!('isMesh' in o) || h.distance > far || own.has(o))
+            continue;
+        const m = Array.isArray(mat) ? mat[0] : mat;
+        if (!m || m.visible === false || m.side === THREE.BackSide)
+            continue;
+        let shown = true;
+        for (let a = h.object; a; a = a.parent)
+            if (!a.visible) {
+                shown = false;
+                break;
+            }
+        if (!shown)
+            continue;
+        _chit.copy(h.point);
+        object.worldToLocal(_chit).divideScalar(Math.max(size, 1e-4));
+        return [_chit.x, _chit.y, _chit.z];
+    }
+    object.localToWorld(_cc.copy(anchor).multiplyScalar(size));
+    camera.getWorldDirection(_cn);
+    _cplane.setFromNormalAndCoplanarPoint(_cn, _cc);
+    if (!_cray.ray.intersectPlane(_cplane, _chit))
+        return null;
+    object.worldToLocal(_chit).divideScalar(Math.max(size, 1e-4));
+    return [_chit.x, _chit.y, _chit.z];
+}
+const SHELL_TYPES = ['peony', 'chrysanthemum', 'willow', 'palm', 'ring', 'crossette', 'crackle', 'strobe',
+    'brocade', 'timeRain', 'fish', 'fallingLeaves', 'heart', 'shapedStar', 'kamuro', 'horsetail', 'multiBreak', 'saturn', 'pistil'];
+const TEXT_MODES = ['word', 'letters'];
+const FORMATIONS = ['none', 'line', 'arc', 'v', 'circle', 'triangle', 'square', 'star', 'heart'];
+const FORM_FUSE = 1.8;
+/** Points sampled from text drawn on a hidden canvas: the stars of a text shell. `perGlyph` false — the whole
+ *  string, scaled so it spans x in [-1, 1]; true — one set per character, scaled by the cap height (y in ~[-1, 1]).
+ *  Returns null where there is no canvas (server render, a worker without OffscreenCanvas). */
+function textPoints(str, n, rng, perGlyph) {
+    const make = (w, h) => {
+        let c = null;
+        if (typeof document !== 'undefined') {
+            c = document.createElement('canvas');
+            c.width = w;
+            c.height = h;
+        }
+        else if (typeof OffscreenCanvas !== 'undefined')
+            c = new OffscreenCanvas(w, h);
+        return c;
+    };
+    const FS = 72, font = '900 ' + FS + 'px "Arial Black", "Helvetica Neue", Arial, sans-serif';
+    const probe = make(4, 4);
+    if (!probe)
+        return null;
+    const pctx = probe.getContext('2d');
+    pctx.font = font;
+    const sample = (txt) => {
+        const w = Math.max(8, Math.ceil(pctx.measureText(txt).width) + 12), h = Math.round(FS * 1.3);
+        const cv = make(w, h), ctx = cv.getContext('2d');
+        ctx.font = font;
+        ctx.textBaseline = 'alphabetic';
+        ctx.fillStyle = '#fff';
+        ctx.fillText(txt, 6, Math.round(FS * 1.02));
+        const d = ctx.getImageData(0, 0, w, h).data, px = [];
+        for (let yy = 0; yy < h; yy += 2)
+            for (let xx = 0; xx < w; xx += 2)
+                if (d[(yy * w + xx) * 4 + 3] > 140)
+                    px.push(xx, yy);
+        return { px, w, h };
+    };
+    const pick = (px, m) => {
+        const cnt = px.length / 2, out = [];
+        const idx = Array.from({ length: cnt }, (_, k) => k);
+        for (let k = 0; k < Math.min(m, cnt); k++) {
+            const r = k + Math.floor(rng() * (cnt - k));
+            const t = idx[k];
+            idx[k] = idx[r];
+            idx[r] = t;
+            out.push([px[idx[k] * 2], px[idx[k] * 2 + 1]]);
+        }
+        return out;
+    };
+    const capH = FS * 0.72, base = Math.round(FS * 1.02);
+    if (!perGlyph) {
+        const { px } = sample(str);
+        if (!px.length)
+            return null;
+        let x0 = 1e9, x1 = -1e9;
+        for (let k = 0; k < px.length; k += 2) {
+            x0 = Math.min(x0, px[k]);
+            x1 = Math.max(x1, px[k]);
+        }
+        const cx = (x0 + x1) / 2, sc = 2 / Math.max(x1 - x0, 1);
+        return pick(px, n).map(([a, b]) => [(a - cx) * sc, (base - capH / 2 - b) * sc]);
+    }
+    return Array.from(str).map((ch) => {
+        if (ch === ' ')
+            return null;
+        const { px } = sample(ch);
+        if (!px.length)
+            return null;
+        let x0 = 1e9, x1 = -1e9;
+        for (let k = 0; k < px.length; k += 2) {
+            x0 = Math.min(x0, px[k]);
+            x1 = Math.max(x1, px[k]);
+        }
+        const cx = (x0 + x1) / 2, sc = 2 / capH;
+        return pick(px, n).map(([a, b]) => [(a - cx) * sc, (base - capH / 2 - b) * sc]);
+    });
+} // a formation's shells share one fuse time, so they break together
+/** `n` points spread evenly (by arc length) along a unit outline — a formation of bursts, or the stars of a
+ *  shaped shell. Open shapes (line, arc, v) include both ends; closed ones wrap. Max radius ~1. */
+function outline(shape, n) {
+    let poly, closed = true;
+    if (shape === 'line') {
+        poly = [[-1, 0], [1, 0]];
+        closed = false;
+    }
+    else if (shape === 'arc') {
+        poly = [];
+        for (let k = 0; k <= 24; k++) {
+            const a = Math.PI * (1 - k / 24);
+            poly.push([Math.cos(a), 0.6 * Math.sin(a) - 0.25]);
+        }
+        closed = false;
+    }
+    else if (shape === 'v') {
+        poly = [[-1, 0.55], [0, -0.55], [1, 0.55]];
+        closed = false;
+    }
+    else if (shape === 'triangle') {
+        poly = [[0, 0.9], [-0.95, -0.65], [0.95, -0.65]];
+    }
+    else if (shape === 'square') {
+        poly = [[-0.75, 0.75], [0.75, 0.75], [0.75, -0.75], [-0.75, -0.75]];
+    }
+    else if (shape === 'star' || shape === 'shapedStar') {
+        poly = [];
+        for (let k = 0; k < 10; k++) {
+            const a = Math.PI / 2 + k * Math.PI / 5, r = k % 2 ? 0.42 : 1;
+            poly.push([r * Math.cos(a), r * Math.sin(a)]);
+        }
+    }
+    else if (shape === 'heart') {
+        poly = [];
+        for (let k = 0; k < 48; k++) {
+            const t = (k / 48) * Math.PI * 2, st = Math.sin(t);
+            poly.push([st * st * st, (13 * Math.cos(t) - 5 * Math.cos(2 * t) - 2 * Math.cos(3 * t) - Math.cos(4 * t)) / 17 + 0.1]);
+        }
+    }
+    else {
+        poly = [];
+        for (let k = 0; k < 48; k++) {
+            const a = (k / 48) * Math.PI * 2;
+            poly.push([Math.cos(a), Math.sin(a)]);
+        }
+    }
+    const segs = closed ? poly.length : poly.length - 1;
+    const len = [], tot = [0];
+    for (let k = 0; k < segs; k++) {
+        const a = poly[k], b = poly[(k + 1) % poly.length];
+        len.push(Math.hypot(b[0] - a[0], b[1] - a[1]));
+        tot.push(tot[k] + len[k]);
+    }
+    const L = tot[segs], out = [];
+    for (let q = 0; q < n; q++) {
+        let d = closed ? (q / n) * L : (n > 1 ? (q / (n - 1)) * L : 0.5 * L);
+        let k = 0;
+        while (k < segs - 1 && tot[k + 1] < d)
+            k++;
+        const f = len[k] > 0 ? (d - tot[k]) / len[k] : 0, a = poly[k], b = poly[(k + 1) % poly.length];
+        out.push([a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f]);
+    }
+    return out;
+}
+const SHELL_SELECT = ['mix', ...SHELL_TYPES, 'text'];
+const TEXT_SEL = SHELL_SELECT.length - 1; // shellType 'text': every launch writes the text
+const G = 0.2; // gravity, sim units / s^2 (one sim unit ~ 50 m)
+const Y0 = -1.2; // the mortar rack (ground)
+const H_STEP = 1 / 90; // fixed physics step (s)
+const TR_MODE = { streak: 0.22, comet: 0.2, echo: 0.45 }; // seconds of history per trail unit
+const TRAIL_GAIN = { streak: 1.4, comet: 1.6, echo: 2.6 }; // per-type look-back gain so every mode reads at defaults
+const SPARK_K = 9; // drag of a charcoal spark (tiny, light)
+const GOLD_T = 1850; // charcoal / gold star temperature (K)
+const NB = 24; // burst lights (flash + smoke lighting)
+const NS = 40; // smoke puffs
+/** Selection / pick volume in sim units (× size): the culling sphere and the click proxy. */
+export const BOUNDS = { center: [0, 0, 0], radius: 1.3 };
+// Per composition: stars per shell, ejection speed, drag, burn time (s), sparks / s shed by each star,
+// rising-tail sparks / s, star sprite size, colour slots (0..2 config colours, 3 gold, 4 magnesium white).
+const PROFILE = {
+    peony: { stars: 150, v: 1.49, k: 2.6, burn: 1.7, tail: 0, rise: 30, sz: 1.0 },
+    chrysanthemum: { stars: 120, v: 1.49, k: 2.6, burn: 1.9, tail: 30, rise: 55, sz: 0.9 },
+    willow: { stars: 95, v: 1.28, k: 5.5, burn: 4.2, tail: 34, rise: 70, sz: 0.85 },
+    palm: { stars: 8, v: 1.25, k: 1.7, burn: 2.6, tail: 150, rise: 240, sz: 1.5 },
+    ring: { stars: 72, v: 1.49, k: 2.4, burn: 1.6, tail: 0, rise: 30, sz: 1.05 },
+    crossette: { stars: 7, v: 1.55, k: 1.6, burn: 0.8, tail: 90, rise: 60, sz: 1.3 },
+    crackle: { stars: 90, v: 1.35, k: 3.2, burn: 1.05, tail: 12, rise: 40, sz: 0.8 },
+    strobe: { stars: 85, v: 1.28, k: 3.4, burn: 2.8, tail: 0, rise: 30, sz: 0.95 },
+    brocade: { stars: 170, v: 1.45, k: 3.6, burn: 2.4, tail: 48, rise: 70, sz: 0.85 },
+    timeRain: { stars: 110, v: 1.35, k: 3.0, burn: 0.9, tail: 0, rise: 40, sz: 0.9 },
+    fish: { stars: 60, v: 1.35, k: 2.8, burn: 0.8, tail: 0, rise: 40, sz: 0.85 },
+    fallingLeaves: { stars: 70, v: 1.7, k: 6.5, burn: 4.5, tail: 0, rise: 40, sz: 1.35 },
+    heart: { stars: 84, v: 0.95, k: 2.4, burn: 1.7, tail: 0, rise: 30, sz: 1.05 },
+    shapedStar: { stars: 80, v: 0.95, k: 2.4, burn: 1.7, tail: 0, rise: 30, sz: 1.05 },
+    kamuro: { stars: 110, v: 1.3, k: 7.5, burn: 5.5, tail: 40, rise: 80, sz: 0.85 },
+    horsetail: { stars: 60, v: 0.9, k: 1.6, burn: 3.6, tail: 45, rise: 60, sz: 0.9 },
+    multiBreak: { stars: 5, v: 0.9, k: 1.5, burn: 0.6, tail: 60, rise: 50, sz: 1.1 },
+    saturn: { stars: 110, v: 1.35, k: 2.6, burn: 1.8, tail: 0, rise: 30, sz: 1.0 },
+    pistil: { stars: 130, v: 1.45, k: 2.6, burn: 1.8, tail: 0, rise: 30, sz: 1.0 },
+    text: { stars: 320, v: 0.95, k: 2.4, burn: 1.9, tail: 0, rise: 30, sz: 1.0 },
+};
+// The show order for 'mix' (a seeded walk through it, so neighbours differ).
+const MIX = ['peony', 'chrysanthemum', 'willow', 'ring', 'palm', 'crossette', 'brocade', 'peony', 'crackle', 'timeRain', 'strobe',
+    'chrysanthemum', 'fish', 'willow', 'heart', 'fallingLeaves', 'peony', 'shapedStar', 'kamuro', 'saturn', 'horsetail',
+    'pistil', 'multiBreak', 'chrysanthemum'];
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSize: { value: 1 },
+        uViewH: { value: 800 },
+        uIntensity: { value: 1 },
+        uSpeed: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: colorUniform('#ffffff'),
+        uSecondColor: colorUniform('#ffffff'),
+        uAccentColor: colorUniform('#ffffff'),
+        uSparkColor: colorUniform('#ffffff'),
+        uShellType: { value: 0 },
+        uLaunchRate: { value: 0.6 },
+        uBurstSize: { value: 1 },
+        uBurstHeight: { value: 1 },
+        uBurnTime: { value: 1 },
+        uSpread: { value: 1 },
+        uWind: { value: 0 },
+        uSmoke: { value: 0.5 },
+        uFireOnClick: { value: 0 },
+        uRandomFire: { value: 1 },
+        uFormation: { value: 0 },
+        uFormationCount: { value: 9 },
+        uFormationSize: { value: 1 },
+        uTextMode: { value: 0 },
+        uTextSize: { value: 1 },
+        uText: { value: '' },
+        uPointerMode: { value: 0 },
+        uPointerStrength: { value: 1 },
+        uPointerRadius: { value: 1 },
+        uPointerColor: colorUniform('#ffffff'),
+        ...createPointerUniforms(),
+        ...createTrailUniforms(),
+    };
+}
+function applyConfig(u, c, size) {
+    u.uSize.value = size;
+    u.uIntensity.value = c.intensity;
+    u.uSpeed.value = c.speed;
+    u.uOpacity.value = c.opacity;
+    u.uColor.value.set(c.color);
+    u.uSecondColor.value.set(c.secondColor);
+    u.uAccentColor.value.set(c.accentColor);
+    u.uSparkColor.value.set(c.sparkColor);
+    u.uShellType.value = Math.max(0, SHELL_SELECT.indexOf(c.shellType));
+    u.uLaunchRate.value = c.launchRate;
+    u.uBurstSize.value = c.burstSize;
+    u.uBurstHeight.value = c.burstHeight;
+    u.uBurnTime.value = c.burnTime;
+    u.uSpread.value = c.spread;
+    u.uWind.value = c.wind;
+    u.uSmoke.value = c.smoke;
+    u.uFireOnClick.value = c.fireOnClick ? 1 : 0;
+    u.uRandomFire.value = c.randomFire === false ? 0 : 1;
+    u.uFormation.value = Math.max(0, FORMATIONS.indexOf(c.formation));
+    u.uFormationCount.value = c.formationCount;
+    u.uFormationSize.value = c.formationSize;
+    u.uTextMode.value = Math.max(0, TEXT_MODES.indexOf(c.textMode));
+    u.uTextSize.value = c.textSize;
+    u.uText.value = typeof c.text === 'string' ? c.text : '';
+    u.uPointerMode.value = POINTER_MODES.indexOf(c.pointerMode); // -1 = 'none' (off)
+    u.uPointerStrength.value = c.pointerStrength;
+    u.uPointerRadius.value = c.pointerRadius;
+    u.uPointerColor.value.set(c.pointerColor);
+    applyTrailConfig(u, c);
+}
+// Stars, sparks and microstars: one sprite each, light computed on the CPU from the body's state.
+const starVertex = /* glsl */ `
+uniform float uSize, uViewH, uIntensity, uOpacity;
+attribute vec3 aCol;
+attribute float aS;
+varying vec3 vCol;
+varying float vA;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(position * uSize, 1.0);
+  vCol = aCol * uIntensity;
+  vA = uOpacity;
+  float px = uSize * uViewH * aS / -mv.z;
+  gl_PointSize = clamp(px, 0.0, 48.0) * step(0.0001, aS);
+  gl_Position = projectionMatrix * mv;
+}
+`;
+const starFragment = /* glsl */ `
+varying vec3 vCol;
+varying float vA;
+void main() {
+  vec2 d = gl_PointCoord * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  if (r2 > 1.0) discard;
+  // a hot core with a soft halo (the star's glare)
+  float a = (exp(-r2 * 9.0) + 0.22 * exp(-r2 * 2.4)) * (1.0 - r2) * vA;
+  if (a < 0.002) discard;
+  gl_FragColor = vec4(vCol * a, 1.0);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}
+`;
+// Burst flashes: the flash powder's white blink and the short-lived glow of a fresh burst.
+const flashVertex = /* glsl */ `
+uniform float uSize, uViewH, uIntensity, uOpacity;
+attribute vec4 aF; // r, g, b, strength
+varying vec3 vCol;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(position * uSize, 1.0);
+  vCol = aF.rgb * aF.a * uIntensity * uOpacity;
+  float px = uSize * uViewH * (0.014 + 0.025 * min(aF.a, 1.5)) / -mv.z;
+  gl_PointSize = clamp(px, 0.0, 220.0) * step(0.002, aF.a);
+  gl_Position = projectionMatrix * mv;
+}
+`;
+const flashFragment = /* glsl */ `
+varying vec3 vCol;
+void main() {
+  vec2 d = gl_PointCoord * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  if (r2 > 1.0) discard;
+  float a = (0.35 * exp(-r2 * 40.0) + 0.05 * exp(-r2 * 6.0)) * (1.0 - r2);
+  if (a < 0.002) discard;
+  gl_FragColor = vec4(vCol * a, 1.0);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}
+`;
+// Smoke: camera-facing billowy puffs, premultiplied, lit on the CPU by the bursts around them.
+const smokeVertex = /* glsl */ `
+uniform float uSize;
+attribute vec3 aP;
+attribute vec4 aC; // lit colour rgb, alpha
+attribute vec2 aR; // radius, seed
+varying vec3 vCol;
+varying float vA;
+varying vec2 vUv;
+varying float vSeed;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(aP * uSize, 1.0);
+  mv.xy += position.xy * aR.x * uSize;
+  vCol = aC.rgb; vA = aC.a; vUv = position.xy * 2.0; vSeed = aR.y;
+  gl_Position = projectionMatrix * mv;
+}
+`;
+const smokeFragment = /* glsl */ `
+uniform float uOpacity, uTime;
+varying vec3 vCol;
+varying float vA;
+varying vec2 vUv;
+varying float vSeed;
+float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+float vnoise(vec2 p) {
+  vec2 i = floor(p), f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  return mix(mix(hash(i), hash(i + vec2(1.0, 0.0)), f.x), mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), f.x), f.y);
+}
+void main() {
+  float r = length(vUv);
+  if (r > 1.0) discard;
+  vec2 q = vUv * 1.6 + vSeed * 17.0 + vec2(0.0, uTime * 0.03);
+  float n = 0.55 * vnoise(q) + 0.3 * vnoise(q * 2.1 + 3.1) + 0.15 * vnoise(q * 4.3 + 7.7);
+  float body = smoothstep(1.0, 0.25, r + 0.35 * (n - 0.5));
+  float a = body * (0.55 + 0.6 * n) * vA * uOpacity;
+  if (a < 0.003) discard;
+  gl_FragColor = vec4(vCol * a, a);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}
+`;
+function build(u, c, size) {
+    applyConfig(u, c, size); // the warm-up runs on this config
+    const q = qualityScale(c.quality);
+    const nStar = Math.max(300, Math.round(2400 * q)); // shells, stars, microstars
+    const nSpark = Math.max(500, Math.round(c.particleCount * q)); // charcoal sparks
+    const n = nStar + nSpark;
+    const rng = mulberry32(seedMix(0xf1e7, c.seed));
+    const pos = new Float32Array(n * 3), vel = new Float32Array(n * 3);
+    const kind = new Uint8Array(n); // 0 free, 1 shell, 2 star, 3 spark, 4 microstar
+    const age = new Float32Array(n);
+    const life = new Float32Array(n); // burn time (stars), fuse delay (microstars), tau (sparks)
+    const drag = new Float32Array(n);
+    const slotA = new Uint8Array(n), slotB = new Uint8Array(n);
+    const change = new Float32Array(n); // burn fraction where the colour changes (2 = never)
+    const tailRate = new Float32Array(n), tailAcc = new Float32Array(n);
+    const split = new Uint8Array(n); // crossette: split into a cross at burn-out
+    const crackle = new Uint8Array(n); // microstars spawned at burn-out
+    const strobe = new Float32Array(n); // blink rate (Hz), 0 = steady
+    const rain = new Uint8Array(n); // time rain: slow embers dropped at burn-out
+    const fishN = new Uint8Array(n); // fish: wriggling stars released at burn-out
+    const wiggle = new Float32Array(n); // fish: lateral swimming acceleration
+    const flutter = new Float32Array(n); // falling leaves: rocking rate (rad / s)
+    const sTau = new Float32Array(n), sT0 = new Float32Array(n); // sparks this star sheds: cooling time, temperature
+    const forceA = new Uint8Array(n).fill(255), forceB = new Uint8Array(n); // shells of a formation share colours
+    const chargeMul = new Float32Array(n); // shells: share of the lift charge (smaller in a formation)
+    const sub = new Uint8Array(n); // multi-break: the star breaks again into a small peony
+    const pattern = new Array(nStar).fill(null); // shaped / text shells: the 2D points their stars are laid on
+    const phase = new Float32Array(n);
+    const tint = new Float32Array(n); // share of the pointer colour (aimed shells)
+    const oxy = new Float32Array(n); // extra oxygen (cursor wake / reignite)
+    const T0 = new Float32Array(n); // spark launch temperature
+    const sz = new Float32Array(n);
+    const shellType = new Uint8Array(n); // shells: which composition they carry
+    const targetY = new Float32Array(n);
+    const kTrail = new Float32Array(n); // trails: slot * 10 + brightness
+    const aCol = new Float32Array(n * 3), aS = new Float32Array(n);
+    const freeStar = new Int32Array(nStar), freeSpark = new Int32Array(nSpark);
+    let nfStar = nStar, nfSpark = nSpark;
+    for (let i = 0; i < nStar; i++)
+        freeStar[i] = nStar - 1 - i;
+    for (let i = 0; i < nSpark; i++)
+        freeSpark[i] = n - 1 - i;
+    let trail = null, trailKey = '', trailTR = TR_MODE.comet;
+    // burst lights and smoke
+    const bPos = new Float32Array(NB * 3), bCol = new Float32Array(NB * 3), bAge = new Float32Array(NB).fill(1e9);
+    let bHead = 0;
+    const sPos = new Float32Array(NS * 3), sVel = new Float32Array(NS * 3), sAge = new Float32Array(NS).fill(1e9);
+    const sSeed = new Float32Array(NS), sScale = new Float32Array(NS), sCol = new Float32Array(NS * 3);
+    let sHead = 0;
+    for (let s = 0; s < NS; s++)
+        sSeed[s] = rng();
+    let launchAcc = 0.85, mixIdx = Math.floor(rng() * MIX.length), clock = 0, strokeRate = 0;
+    const hp = new THREE.Vector3(), hv = new THREE.Vector3();
+    const tmp = [0, 0, 0];
+    function takeStar() { return nfStar > 0 ? freeStar[--nfStar] : -1; }
+    function takeSpark() { return nfSpark > 0 ? freeSpark[--nfSpark] : -1; }
+    function release(i) {
+        kind[i] = 0;
+        aS[i] = 0;
+        kTrail[i] = 0;
+        if (i < nStar)
+            freeStar[nfStar++] = i;
+        else
+            freeSpark[nfSpark++] = i;
+    }
+    function place(i, x, y, z, vx, vy, vz) {
+        const j = i * 3;
+        pos[j] = x;
+        pos[j + 1] = y;
+        pos[j + 2] = z;
+        vel[j] = vx;
+        vel[j + 1] = vy;
+        vel[j + 2] = vz;
+        age[i] = 0;
+        oxy[i] = 0;
+        tint[i] = 0;
+        tailAcc[i] = 0;
+        if (trail && i < nStar)
+            trail.reset(i);
+    }
+    function spark(x, y, z, vx, vy, vz, t0, tau, k = 0) {
+        const i = takeSpark();
+        if (i < 0)
+            return;
+        kind[i] = 3;
+        place(i, x, y, z, vx, vy, vz);
+        T0[i] = t0;
+        life[i] = tau;
+        drag[i] = (k || SPARK_K) * (0.8 + 0.4 * rng());
+    }
+    /** A fresh star: every composition flag cleared (slots are pooled). */
+    function star(i) {
+        kind[i] = 2;
+        split[i] = 0;
+        crackle[i] = 0;
+        strobe[i] = 0;
+        rain[i] = 0;
+        fishN[i] = 0;
+        wiggle[i] = 0;
+        flutter[i] = 0;
+        sub[i] = 0;
+        change[i] = 2;
+        tailRate[i] = 0;
+        sTau[i] = 0.45;
+        sT0[i] = 1900;
+        phase[i] = rng() * 6.283;
+    }
+    // ---- launch: a shell leaves the mortar with sqrt(2 g h) and bursts at its apex ----
+    // `at` (a clicked point, sim units): the mortar below it fires a quick-fuse shell that breaks there
+    // after CLICK_FUSE seconds, still climbing (v0 = h / t + g t / 2).
+    function nextType() {
+        const sel = u.uShellType.value;
+        const type = sel === TEXT_SEL ? 'peony' : sel > 0 ? SHELL_TYPES[sel - 1] : MIX[mixIdx];
+        if (sel === 0)
+            mixIdx = (mixIdx + 1 + (rng() < 0.3 ? 1 : 0)) % MIX.length;
+        return type;
+    }
+    // a formation: one salvo of shells whose bursts sit on a shape (line, arc, circle, heart...), all the
+    // same composition and colours, fired on one fuse time so they break together
+    function salvo(at = null) {
+        const shape = FORMATIONS[u.uFormation.value];
+        const cnt = Math.max(2, Math.min(24, Math.round(u.uFormationCount.value)));
+        const span = 0.7 * u.uFormationSize.value;
+        const type = nextType();
+        const A = type === 'willow' || type === 'palm' || type === 'crackle' || type === 'brocade' ? 3 : type === 'strobe' ? 4 : pickSlot();
+        const B = rng() < 0.4 ? (A < 3 ? (A + 1) % 3 : A) : A;
+        const cx = at ? at[0] : u.uSpread.value * (rng() * 2 - 1) * 0.25;
+        const cy = at ? at[1] : -0.1 + 0.5 * u.uBurstHeight.value;
+        const cz = at ? at[2] : 0;
+        const pts = outline(shape, cnt);
+        const cm = Math.min(1, 1.9 / Math.sqrt(cnt)) * Math.min(1.2, u.uFormationSize.value + 0.2);
+        for (const p of pts)
+            launch(false, [cx + p[0] * span, cy + p[1] * span, cz], { type, A, B, fuse: FORM_FUSE, charge: cm });
+    }
+    // text: the word as one shell, or one shell per letter in rows (words wrap to lines of <= 8 letters), all on
+    // one fuse so the text appears at once
+    let textKey = '', textSets = null;
+    function textFire(at = null) {
+        const str = u.uText.value.trim().slice(0, 32), mode = u.uTextMode.value;
+        if (!str)
+            return false;
+        const key = mode + '|' + str;
+        if (key !== textKey) {
+            textKey = key;
+            textSets = mode === 0 ? textPoints(str.toUpperCase(), PROFILE.text.stars, rng, false) : textPoints(str.toUpperCase(), 64, rng, true);
+        }
+        if (!textSets)
+            return false;
+        const A = pickSlot(), B = rng() < 0.4 ? (A + 1) % 3 : A;
+        const cx = at ? at[0] : 0, cy = at ? at[1] : -0.05 + 0.5 * u.uBurstHeight.value, cz = at ? at[2] : 0;
+        const size = u.uTextSize.value;
+        if (mode === 0) {
+            launch(false, [cx, cy, cz], { type: 'text', A, B, fuse: FORM_FUSE, charge: 2.0 * size, pattern: textSets });
+            return true;
+        }
+        // lay the letters out in lines
+        const chars = Array.from(str.toUpperCase()), lines = [[]];
+        let word = [];
+        const flush = () => { const L = lines[lines.length - 1]; if (L.length && L.length + 1 + word.length > 8)
+            lines.push([]); const T = lines[lines.length - 1]; if (T.length)
+            T.push(-1); T.push(...word); word = []; };
+        chars.forEach((ch, k) => { if (ch === ' ')
+            flush();
+        else
+            word.push(k); });
+        flush();
+        const longest = Math.max(...lines.map((l) => l.length));
+        const pitch = Math.min(0.34 * size, 2.3 / Math.max(longest, 1));
+        lines.forEach((L, r) => {
+            const ly = cy + ((lines.length - 1) / 2 - r) * pitch * 1.5;
+            L.forEach((k, q) => {
+                if (k < 0 || !textSets[k])
+                    return;
+                launch(false, [cx + (q - (L.length - 1) / 2) * pitch, ly, cz], { type: 'text', A, B, fuse: FORM_FUSE, charge: pitch * 0.8, pattern: textSets[k] });
+            });
+        });
+        return true;
+    }
+    function fire(aimed, at = null) {
+        if (u.uShellType.value === TEXT_SEL) {
+            if (!textFire(at))
+                launch(aimed, at);
+            return;
+        } // no text (or no canvas): a plain peony
+        if (u.uFormation.value > 0)
+            salvo(at);
+        else
+            launch(aimed, at);
+    }
+    function launch(aimed, at = null, opt = null) {
+        const type = opt ? opt.type : nextType();
+        const spread = u.uSpread.value;
+        let x = spread * (rng() * 2 - 1) * 0.7, z = spread * (rng() - 0.5) * 0.5;
+        let yb = -0.1 + 0.5 * u.uBurstHeight.value * (0.8 + 0.4 * rng());
+        let vx = 0.02 * gauss(rng), vz = 0.02 * gauss(rng);
+        if (aimed) {
+            const R = u.uPointerRadius.value;
+            x = hp.x + 0.18 * R * gauss(rng);
+            z = hp.z + 0.1 * R * gauss(rng);
+            yb = Math.min(Math.max(hp.y, -0.6), 1.1) + 0.05 * gauss(rng);
+            vx += hv.x * 0.25;
+            vz += hv.z * 0.25; // a stroke leans the shells
+        }
+        if (at) {
+            x = at[0];
+            z = at[2];
+            yb = at[1];
+            vx = 0;
+            vz = 0;
+        }
+        yb = Math.max(yb, Y0 + (at ? 0.15 : 0.4));
+        const i = takeStar();
+        if (i < 0)
+            return;
+        const fz = opt ? opt.fuse : CLICK_FUSE;
+        const v0 = at ? (yb - Y0) / fz + 0.5 * G * fz : Math.sqrt(2 * G * (yb - Y0));
+        kind[i] = 1;
+        place(i, x, Y0, z, vx, v0, vz);
+        shellType[i] = type === 'text' ? 255 : SHELL_TYPES.indexOf(type);
+        targetY[i] = yb;
+        pattern[i] = opt && opt.pattern ? opt.pattern : null;
+        tint[i] = aimed ? 0.45 : 0;
+        life[i] = 0;
+        drag[i] = 0;
+        slotA[i] = 3;
+        sz[i] = type === 'palm' ? 1.4 : 0.9;
+        tailRate[i] = PROFILE[type].rise;
+        forceA[i] = opt ? opt.A : 255;
+        forceB[i] = opt ? opt.B : 0;
+        chargeMul[i] = opt ? opt.charge : 1;
+    }
+    function pickSlot() { return Math.floor(rng() * 3); }
+    // ---- burst: stars packed on a Fibonacci sphere (or a great circle), plus flash and smoke ----
+    function burst(s) {
+        const type = shellType[s] === 255 ? 'text' : SHELL_TYPES[shellType[s]];
+        const P = PROFILE[type];
+        const j = s * 3;
+        const x = pos[j], y = pos[j + 1], z = pos[j + 2];
+        const svx = vel[j], svy = vel[j + 1], svz = vel[j + 2];
+        const aimed = tint[s];
+        const charge = u.uBurstSize.value * (aimed > 0 ? 0.7 + 0.3 * u.uPointerStrength.value : 1) * chargeMul[s];
+        const burn = u.uBurnTime.value;
+        const gold = type === 'willow' || type === 'palm' || type === 'crackle' || type === 'brocade' || type === 'fish' || type === 'kamuro' || type === 'horsetail';
+        let A = gold ? 3 : type === 'strobe' ? 4 : pickSlot();
+        let B = A;
+        if (type === 'peony' && rng() < 0.5)
+            B = (A + 1 + Math.floor(rng() * 2)) % 3;
+        if (type === 'chrysanthemum' && rng() < 0.3)
+            B = 3;
+        if (type === 'fallingLeaves') {
+            A = rng() < 0.6 ? 3 : pickSlot();
+            B = A;
+        }
+        if (type === 'saturn' || type === 'multiBreak')
+            B = (A + 1 + Math.floor(rng() * 2)) % 3;
+        if (type === 'pistil')
+            B = rng() < 0.5 ? 4 : (A + 1) % 3;
+        if (forceA[s] !== 255) {
+            A = forceA[s];
+            B = forceB[s];
+        }
+        const pat = pattern[s];
+        pattern[s] = null;
+        const shaped = type === 'heart' || type === 'shapedStar' || type === 'text';
+        const m = type === 'text' && pat ? pat.length : Math.max(type === 'multiBreak' ? 4 : 12, Math.round(P.stars * Math.min(1, 0.35 + 0.65 * chargeMul[s])));
+        // the burst's plane: a shaped shell stands upright facing the front; a ring gets a random tilt
+        const th = rng() * Math.PI * 2, tl = shaped ? 0.25 * rng() : (0.3 + 0.7 * rng()) * 1.05;
+        const nx = Math.sin(tl) * Math.cos(th), ny = shaped ? Math.sin(tl) * Math.sin(th) : Math.cos(tl) * 0.6, nz = shaped ? 1 : Math.sin(tl) * Math.sin(th) * 0.5 + 0.8;
+        const nl = Math.hypot(nx, ny, nz);
+        const n0 = [nx / nl, ny / nl, nz / nl];
+        const e1 = shaped ? [0, 1, 0] : Math.abs(n0[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0];
+        // u1 = normalize(e1 x n0), u2 = n0 x u1 (shaped: u1 points right, u2 up, so the shape stands upright)
+        let u1 = [e1[1] * n0[2] - e1[2] * n0[1], e1[2] * n0[0] - e1[0] * n0[2], e1[0] * n0[1] - e1[1] * n0[0]];
+        const ul = Math.hypot(u1[0], u1[1], u1[2]);
+        u1 = [u1[0] / ul, u1[1] / ul, u1[2] / ul];
+        const u2 = [n0[1] * u1[2] - n0[2] * u1[1], n0[2] * u1[0] - n0[0] * u1[2], n0[0] * u1[1] - n0[1] * u1[0]];
+        const rot = shaped ? 0 : rng() * Math.PI * 2;
+        // one layer of stars: 'sphere' (Fibonacci), 'ring' (great circle), 'pattern' (2D points, speed ~ radius,
+        // so the shape grows self-similar under one drag law) or 'cone' (thrown upward: a horsetail)
+        function layer(cnt, mode, spMul, a, b, pts = null, szMul = 1) {
+            for (let k = 0; k < cnt; k++) {
+                const i = takeStar();
+                if (i < 0)
+                    break;
+                let dx, dy, dz, rad = 1;
+                if (mode === 'ring') {
+                    const an = (k / cnt) * Math.PI * 2 + rot + 0.02 * gauss(rng);
+                    const ca = Math.cos(an), sa = Math.sin(an);
+                    dx = u1[0] * ca + u2[0] * sa;
+                    dy = u1[1] * ca + u2[1] * sa;
+                    dz = u1[2] * ca + u2[2] * sa;
+                }
+                else if (mode === 'pattern') {
+                    const p = pts[k % pts.length];
+                    rad = Math.hypot(p[0], p[1]) || 1e-3;
+                    const ex = p[0] / rad, ey = p[1] / rad;
+                    dx = u1[0] * ex + u2[0] * ey;
+                    dy = u1[1] * ex + u2[1] * ey;
+                    dz = u1[2] * ex + u2[2] * ey;
+                }
+                else if (mode === 'cone') {
+                    const an = rng() * Math.PI * 2, c = 1 - rng() * 0.18;
+                    const sn = Math.sqrt(1 - c * c);
+                    dx = sn * Math.cos(an);
+                    dy = c;
+                    dz = sn * Math.sin(an);
+                }
+                else {
+                    const yy = 1 - (2 * (k + 0.5)) / cnt;
+                    const r = Math.sqrt(1 - yy * yy);
+                    const an = k * 2.399963 + rot;
+                    dx = r * Math.cos(an) + 0.06 * gauss(rng);
+                    dy = yy + 0.06 * gauss(rng);
+                    dz = r * Math.sin(an) + 0.06 * gauss(rng);
+                    if (type === 'palm')
+                        dy = dy * 0.6 + 0.35; // fronds open upward, then droop
+                    const dl = Math.hypot(dx, dy, dz) || 1;
+                    dx /= dl;
+                    dy /= dl;
+                    dz /= dl;
+                }
+                const sp = P.v * charge * spMul * rad * (mode === 'pattern' ? 0.99 + 0.02 * rng() : 0.93 + 0.14 * rng());
+                const keep = mode === 'pattern' ? 0.3 : 1; // a pattern sheds the shell's motion so it reads upright
+                star(i);
+                place(i, x, y, z, svx * keep + dx * sp, svy * keep + dy * sp, svz * keep + dz * sp);
+                life[i] = P.burn * burn * (0.85 + 0.3 * rng());
+                // pattern: quadratic drag gives x(t) = ln(1 + k v t) / k, so k ~ 1 / v keeps k v the same for every star and
+                // the reach proportional to v — the pattern grows as an exact scaled copy instead of bunching at its edges
+                drag[i] = mode === 'pattern' ? P.k / Math.max(rad, 0.15) : P.k * (0.88 + 0.24 * rng());
+                slotA[i] = a;
+                slotB[i] = b;
+                change[i] = b !== a ? 0.45 + 0.1 * rng() : 2;
+                tailRate[i] = P.tail * (0.8 + 0.4 * rng());
+                split[i] = type === 'crossette' ? 1 : 0;
+                crackle[i] = type === 'crackle' ? 4 + Math.floor(rng() * 4) : 0;
+                strobe[i] = type === 'strobe' ? 6 + 7 * rng() : 0;
+                rain[i] = type === 'timeRain' ? 4 + Math.floor(rng() * 3) : 0;
+                fishN[i] = type === 'fish' ? 2 : 0;
+                flutter[i] = type === 'fallingLeaves' ? 3 + 3 * rng() : 0;
+                sub[i] = type === 'multiBreak' ? 1 : 0;
+                if (type === 'brocade') {
+                    sTau[i] = 1.0 * Math.sqrt(burn);
+                    sT0[i] = 1950;
+                }
+                if (type === 'willow') {
+                    sTau[i] = 1.5 * Math.sqrt(burn);
+                    sT0[i] = 1800;
+                }
+                if (type === 'kamuro') {
+                    sTau[i] = 2.0 * Math.sqrt(burn);
+                    sT0[i] = 1760;
+                }
+                if (type === 'horsetail') {
+                    sTau[i] = 1.1 * Math.sqrt(burn);
+                    sT0[i] = 1850;
+                }
+                tint[i] = aimed;
+                sz[i] = P.sz * (szMul || 1);
+            }
+        }
+        if (type === 'ring')
+            layer(m, 'ring', 1, A, B);
+        else if (type === 'text' && pat)
+            layer(m, 'pattern', 1, A, B, pat);
+        else if (shaped)
+            layer(m, 'pattern', 1, A, B, outline(type, m));
+        else if (type === 'saturn') {
+            layer(Math.round(m * 0.6), 'sphere', 0.55, A, A);
+            layer(Math.round(m * 0.55), 'ring', 1.25, B, B);
+        }
+        else if (type === 'pistil') {
+            layer(m, 'sphere', 1, A, A);
+            layer(Math.round(m * 0.3), 'sphere', 0.38, B, B, null, 1.25);
+        }
+        else if (type === 'horsetail')
+            layer(m, 'cone', 1, A, B);
+        else if (type === 'multiBreak') {
+            layer(m, 'sphere', 1, A, B);
+            layer(30, 'sphere', 0.45, A, A);
+        }
+        else
+            layer(m, 'sphere', 1, A, B);
+        // flash light
+        const b = bHead;
+        bHead = (bHead + 1) % NB;
+        bPos[b * 3] = x;
+        bPos[b * 3 + 1] = y;
+        bPos[b * 3 + 2] = z;
+        bAge[b] = 0;
+        slotColor(A, 1900, tmp);
+        bCol[b * 3] = 0.45 + 0.55 * tmp[0];
+        bCol[b * 3 + 1] = 0.45 + 0.55 * tmp[1];
+        bCol[b * 3 + 2] = 0.45 + 0.55 * tmp[2];
+        // the shell leaves a puff of smoke where it broke
+        const sm = sHead;
+        sHead = (sHead + 1) % NS;
+        sPos[sm * 3] = x;
+        sPos[sm * 3 + 1] = y;
+        sPos[sm * 3 + 2] = z;
+        sVel[sm * 3] = svx * 0.3;
+        sVel[sm * 3 + 1] = svy * 0.3;
+        sVel[sm * 3 + 2] = svz * 0.3;
+        sAge[sm] = 0;
+        sScale[sm] = (0.7 + 0.5 * rng()) * Math.min(Math.max(charge, 0.4), 1.6) * (type === 'palm' || type === 'crossette' ? 0.75 : 1);
+        release(s);
+    }
+    // linear colour of a slot: 0..2 the config colours, 3 gold (charcoal at temperature T), 4 magnesium white
+    const spk = [0, 0, 0];
+    function slotColor(slot, T, out) {
+        if (slot === 0) {
+            out[0] = u.uColor.value.r;
+            out[1] = u.uColor.value.g;
+            out[2] = u.uColor.value.b;
+        }
+        else if (slot === 1) {
+            out[0] = u.uSecondColor.value.r;
+            out[1] = u.uSecondColor.value.g;
+            out[2] = u.uSecondColor.value.b;
+        }
+        else if (slot === 2) {
+            out[0] = u.uAccentColor.value.r;
+            out[1] = u.uAccentColor.value.g;
+            out[2] = u.uAccentColor.value.b;
+        }
+        else if (slot === 3) {
+            bbLut(T, out);
+            const sc = u.uSparkColor.value, mm = Math.max(sc.r, sc.g, sc.b, 1e-3);
+            // the tint sets the hue (a sodium, titanium or iron mix); temperature still sets how it cools
+            const w = 0.65, lum = 0.4 + 0.6 * out[1]; // green channel falls first as it cools
+            out[0] += (sc.r / mm * lum - out[0]) * w;
+            out[1] += (sc.g / mm * lum - out[1]) * w;
+            out[2] += (sc.b / mm * lum - out[2]) * w;
+        }
+        else {
+            out[0] = 1;
+            out[1] = 0.96;
+            out[2] = 0.9;
+        }
+        return out;
+    }
+    function step(h) {
+        clock += h;
+        const mode = u.uPointerMode.value;
+        const S = u.uPointerStrength.value, act = u.uPointerActive.value, Rr = u.uPointerRadius.value;
+        hp.copy(u.uPointer.value);
+        hv.copy(u.uPointerVel.value);
+        const aimOn = mode === 0 && S > 0.01 && act > 0.05;
+        const windOn = mode === 1 && S > 0.01 && act > 0.01;
+        const reOn = mode === 2 && S > 0.01 && act > 0.01;
+        const stroke = hv.length() * act;
+        strokeRate += (stroke - strokeRate) * Math.min(1, h * 4);
+        // ---- the show clock: shells per second (a faster aiming stroke fires more) ----
+        const rate = u.uLaunchRate.value * (aimOn ? 1 + 1.5 * S * strokeRate / (strokeRate + 0.5) : 1);
+        // randomFire off: the show clock stops (aimed shells too) and only clicks fire
+        // a formation fires whole salvos, one every ~3 shells' worth of time
+        if (u.uRandomFire.value > 0.5)
+            launchAcc += rate * h * (u.uFormation.value > 0 || u.uShellType.value === TEXT_SEL ? 1 / 3 : 1);
+        while (launchAcc >= 1) {
+            launchAcc -= 1;
+            fire(aimOn);
+        }
+        // ---- air: the wind plus the cursor's flow (moving-body dipole + trailing wake) ----
+        const wx = u.uWind.value * 0.12;
+        const RS = 0.18 * Rr;
+        const AIR = 1.4 * S * act;
+        const bvx = hv.x * AIR, bvy = hv.y * AIR, bvz = hv.z * AIR;
+        const bsp = Math.hypot(bvx, bvy, bvz), bn = bsp > 1e-4 ? 1 / bsp : 0;
+        const gust = windOn && bsp > 0.02;
+        const reach = 0.3 * Rr, reGain = reOn ? S * act * Math.min(1, stroke / (stroke + 0.35)) * 2.2 : 0;
+        for (let i = 0; i < n; i++) {
+            const kd = kind[i];
+            if (kd === 0)
+                continue;
+            const j = i * 3;
+            let x = pos[j], y = pos[j + 1], z = pos[j + 2];
+            let vx = vel[j], vy = vel[j + 1], vz = vel[j + 2];
+            age[i] += h;
+            let ax = wx, ay = 0, az = 0, wake = 0;
+            if (gust) {
+                const qx = x - hp.x, qy = y - hp.y, qz = z - hp.z;
+                const r2 = qx * qx + qy * qy + qz * qz;
+                if (r2 < 64 * RS * RS) {
+                    const r = Math.sqrt(r2) + 1e-6;
+                    if (r > RS) {
+                        const k3 = (RS * RS * RS) / (2 * r2 * r);
+                        const vr = (bvx * qx + bvy * qy + bvz * qz) / r;
+                        ax += k3 * (3 * vr * qx / r - bvx);
+                        ay += k3 * (3 * vr * qy / r - bvy);
+                        az += k3 * (3 * vr * qz / r - bvz);
+                    }
+                    else {
+                        ax += bvx;
+                        ay += bvy;
+                        az += bvz;
+                    }
+                    const behind = -(qx * bvx + qy * bvy + qz * bvz) * bn;
+                    if (behind > 0) {
+                        const wk = Math.exp(-(r2 - behind * behind) / (RS * RS * 1.5) - behind / (8 * RS));
+                        ax += bvx * wk * 0.7;
+                        ay += bvy * wk * 0.7;
+                        az += bvz * wk * 0.7;
+                        wake = wk;
+                    }
+                }
+            }
+            let feed = 0;
+            if (reGain > 0 && kd !== 1) {
+                const qx = x - hp.x, qy = y - hp.y, qz = z - hp.z;
+                const d2 = (qx * qx + qy * qy + qz * qz) / (reach * reach);
+                if (d2 < 4)
+                    feed = reGain * Math.max(0, 1 - d2 * 0.25) * Math.max(0, 1 - d2 * 0.25);
+            }
+            const o = Math.min(2, wake * S * 1.5 + feed);
+            oxy[i] += (o - oxy[i]) * Math.min(1, h * (o > oxy[i] ? 10 : 2.5));
+            if (kd === 1) {
+                // shell: drag-free ballistic flight; the time fuse fires at the apex
+                vy -= G * h;
+                vx += (ax - wx) * h * 0.3;
+                vz += az * h * 0.3;
+                x += vx * h;
+                y += vy * h;
+                z += vz * h;
+                tailAcc[i] += tailRate[i] * h;
+                while (tailAcc[i] >= 1) {
+                    tailAcc[i] -= 1;
+                    spark(x, y, z, vx * 0.1 + 0.03 * gauss(rng), vy * 0.1 + 0.02 * gauss(rng), vz * 0.1 + 0.03 * gauss(rng), 1800, 0.32);
+                }
+                pos[j] = x;
+                pos[j + 1] = y;
+                pos[j + 2] = z;
+                vel[j] = vx;
+                vel[j + 1] = vy;
+                vel[j + 2] = vz;
+                if (vy <= 0 || y >= targetY[i])
+                    burst(i);
+                continue;
+            }
+            if (kd === 2 && wiggle[i] > 0) {
+                // fish: a little rocket that swims — thrust along its heading plus a lateral wriggle
+                const sp = Math.hypot(vx, vy, vz) || 1;
+                const w = wiggle[i] * Math.sin(age[i] * 13 + phase[i]);
+                vx += (vx / sp * 0.35 - vy / sp * w) * h;
+                vy += (vy / sp * 0.35 + vx / sp * w + G * 0.6) * h;
+                vz += vz / sp * 0.35 * h;
+            }
+            else if (kd === 2 && flutter[i] > 0) {
+                // falling leaves: a flat piece rocks side to side as it sinks (lift ~ sin of its swing)
+                ax += 0.22 * Math.sin(age[i] * flutter[i] + phase[i]);
+            }
+            // quadratic drag relative to the air, semi-implicit; then gravity
+            const k = drag[i];
+            const rx = vx - ax, ry = vy - ay, rz = vz - az;
+            const damp = 1 / (1 + k * Math.sqrt(rx * rx + ry * ry + rz * rz) * h);
+            vx = ax + rx * damp;
+            vy = ay + ry * damp - G * h;
+            vz = az + rz * damp;
+            x += vx * h;
+            y += vy * h;
+            z += vz * h;
+            pos[j] = x;
+            pos[j + 1] = y;
+            pos[j + 2] = z;
+            vel[j] = vx;
+            vel[j + 1] = vy;
+            vel[j + 2] = vz;
+            if (kd === 3) {
+                if (oxy[i] > 0.05)
+                    age[i] -= h * Math.min(oxy[i], 1) * 0.8; // fresh air keeps it burning
+                if (age[i] > life[i] * 2 || y < Y0)
+                    release(i);
+                continue;
+            }
+            if (kd === 4) {
+                if (age[i] > life[i] + 0.07)
+                    release(i);
+                continue;
+            }
+            // star
+            if (oxy[i] > 0.05)
+                age[i] -= h * Math.min(oxy[i], 1.2) * 0.6;
+            if (tailRate[i] > 0) {
+                tailAcc[i] += tailRate[i] * h * (1 + oxy[i]);
+                while (tailAcc[i] >= 1) {
+                    tailAcc[i] -= 1;
+                    spark(x, y, z, vx * 0.25 + 0.025 * gauss(rng), vy * 0.25 + 0.025 * gauss(rng), vz * 0.25 + 0.025 * gauss(rng), sT0[i], sTau[i]);
+                }
+            }
+            if (age[i] >= life[i] || y < Y0) {
+                if (split[i] && y > Y0) {
+                    // crossette: the comet splits into a cross perpendicular to its flight
+                    const sp = Math.hypot(vx, vy, vz) || 1;
+                    const fx = vx / sp, fy = vy / sp, fz = vz / sp;
+                    let px = -fy, py = fx, pz = 0;
+                    const pl = Math.hypot(px, py) || 1;
+                    px /= pl;
+                    py /= pl;
+                    const qx2 = fy * pz - fz * py, qy2 = fz * px - fx * pz, qz2 = fx * py - fy * px;
+                    const dirs = [[px, py, pz], [-px, -py, -pz], [qx2, qy2, qz2], [-qx2, -qy2, -qz2]];
+                    for (let d = 0; d < 4; d++) {
+                        const c2 = takeStar();
+                        if (c2 < 0)
+                            break;
+                        const s2 = 0.42 * u.uBurstSize.value;
+                        const pa = slotA[i], pb = slotB[i], pt = tint[i];
+                        star(c2);
+                        place(c2, x, y, z, vx * 0.5 + dirs[d][0] * s2, vy * 0.5 + dirs[d][1] * s2, vz * 0.5 + dirs[d][2] * s2);
+                        life[c2] = 1.1 * u.uBurnTime.value * (0.9 + 0.2 * rng());
+                        drag[c2] = 2.4;
+                        slotA[c2] = pa;
+                        slotB[c2] = pb;
+                        tailRate[c2] = 55;
+                        tint[c2] = pt;
+                        sz[c2] = 1.0;
+                    }
+                }
+                if (sub[i] && y > Y0) {
+                    // multi-break: the comet breaks again into a small peony in the second colour
+                    const sb = slotB[i], pt = tint[i];
+                    for (let d = 0; d < 34; d++) {
+                        const c2 = takeStar();
+                        if (c2 < 0)
+                            break;
+                        const yy = 1 - (2 * (d + 0.5)) / 34, r = Math.sqrt(1 - yy * yy), an = d * 2.399963;
+                        const s2 = 0.62 * u.uBurstSize.value * (0.93 + 0.14 * rng());
+                        star(c2);
+                        place(c2, x, y, z, vx * 0.4 + r * Math.cos(an) * s2, vy * 0.4 + yy * s2, vz * 0.4 + r * Math.sin(an) * s2);
+                        life[c2] = 1.3 * u.uBurnTime.value * (0.85 + 0.3 * rng());
+                        drag[c2] = 2.8;
+                        slotA[c2] = sb;
+                        slotB[c2] = sb;
+                        tint[c2] = pt;
+                        sz[c2] = 0.95;
+                    }
+                    const b2 = bHead;
+                    bHead = (bHead + 1) % NB;
+                    bPos[b2 * 3] = x;
+                    bPos[b2 * 3 + 1] = y;
+                    bPos[b2 * 3 + 2] = z;
+                    bAge[b2] = 0;
+                    slotColor(sb, 1900, tmp);
+                    bCol[b2 * 3] = 0.45 + 0.55 * tmp[0];
+                    bCol[b2 * 3 + 1] = 0.45 + 0.55 * tmp[1];
+                    bCol[b2 * 3 + 2] = 0.45 + 0.55 * tmp[2];
+                }
+                if (rain[i] && y > Y0) {
+                    // time rain: the star burns out into slow embers that sink and glow for seconds
+                    for (let d = 0; d < rain[i]; d++)
+                        spark(x, y, z, vx * 0.3 + 0.04 * gauss(rng), vy * 0.3 + 0.04 * gauss(rng), vz * 0.3 + 0.04 * gauss(rng), 1850, 2.2 * u.uBurnTime.value, 18);
+                }
+                if (fishN[i] && y > Y0) {
+                    // fish: each star releases little swimmers that wriggle off in their own directions
+                    for (let d = 0; d < fishN[i]; d++) {
+                        const c2 = takeStar();
+                        if (c2 < 0)
+                            break;
+                        const pa = slotA[i], pt = tint[i];
+                        let dx = gauss(rng), dy = gauss(rng), dz = gauss(rng);
+                        const dl = Math.hypot(dx, dy, dz) || 1;
+                        star(c2);
+                        place(c2, x, y, z, vx * 0.3 + dx / dl * 0.32, vy * 0.3 + dy / dl * 0.32, vz * 0.3 + dz / dl * 0.32);
+                        life[c2] = 1.2 * u.uBurnTime.value * (0.8 + 0.4 * rng());
+                        drag[c2] = 1.6;
+                        slotA[c2] = pa;
+                        slotB[c2] = pa;
+                        wiggle[c2] = 2.2 + rng();
+                        tailRate[c2] = 28;
+                        sTau[c2] = 0.3;
+                        tint[c2] = pt;
+                        sz[c2] = 0.8;
+                    }
+                }
+                if (crackle[i] && y > Y0) {
+                    // dragon eggs: the glitter star breaks into microstars that pop a moment later
+                    for (let d = 0; d < crackle[i]; d++) {
+                        const c2 = takeStar();
+                        if (c2 < 0)
+                            break;
+                        const pt = tint[i];
+                        kind[c2] = 4;
+                        place(c2, x, y, z, vx * 0.6 + 0.09 * gauss(rng), vy * 0.6 + 0.09 * gauss(rng), vz * 0.6 + 0.09 * gauss(rng));
+                        life[c2] = 0.05 + 0.6 * rng();
+                        drag[c2] = 6;
+                        slotA[c2] = 4;
+                        tint[c2] = pt;
+                        sz[c2] = 1.1;
+                    }
+                }
+                release(i);
+            }
+        }
+        // ---- smoke: drifts with the air, buoyant, spreads ~ sqrt(t) ----
+        for (let s = 0; s < NS; s++) {
+            if (sAge[s] > 30)
+                continue;
+            sAge[s] += h;
+            const j = s * 3;
+            let ax = wx, ay = 0.008, az = 0;
+            if (gust) {
+                const qx = sPos[j] - hp.x, qy = sPos[j + 1] - hp.y, qz = sPos[j + 2] - hp.z;
+                const r2 = qx * qx + qy * qy + qz * qz, R2 = 4 * RS * RS + 0.04;
+                const f = Math.exp(-r2 / R2);
+                ax += bvx * f * 0.6;
+                ay += bvy * f * 0.6;
+                az += bvz * f * 0.6;
+            }
+            const kk = Math.min(1, h * 1.5);
+            sVel[j] += (ax - sVel[j]) * kk;
+            sVel[j + 1] += (ay - sVel[j + 1]) * kk;
+            sVel[j + 2] += (az - sVel[j + 2]) * kk;
+            sPos[j] += sVel[j] * h;
+            sPos[j + 1] += sVel[j + 1] * h;
+            sPos[j + 2] += sVel[j + 2] * h;
+        }
+        for (let b = 0; b < NB; b++)
+            if (bAge[b] < 1e8)
+                bAge[b] += h;
+    }
+    // ---- warm-up: the show is under way when it appears ----
+    const stepper = createFixedStep(H_STEP, 8);
+    for (let s = 0; s < Math.round(4.2 / H_STEP); s++)
+        step(H_STEP);
+    // ---- geometry ----
+    const geo = new THREE.BufferGeometry();
+    const posAttr = new THREE.BufferAttribute(pos, 3).setUsage(THREE.DynamicDrawUsage);
+    const colAttr = new THREE.BufferAttribute(aCol, 3).setUsage(THREE.DynamicDrawUsage);
+    const sAttr = new THREE.BufferAttribute(aS, 1).setUsage(THREE.DynamicDrawUsage);
+    geo.setAttribute('position', posAttr);
+    geo.setAttribute('aCol', colAttr);
+    geo.setAttribute('aS', sAttr);
+    const mat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: starVertex, fragmentShader: starFragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const stars = new THREE.Points(geo, mat);
+    stars.frustumCulled = false;
+    stars.renderOrder = 2;
+    attachViewH(stars, u);
+    const fpos = new Float32Array(NB * 3), fF = new Float32Array(NB * 4);
+    const fgeo = new THREE.BufferGeometry();
+    const fpAttr = new THREE.BufferAttribute(fpos, 3).setUsage(THREE.DynamicDrawUsage);
+    const fFAttr = new THREE.BufferAttribute(fF, 4).setUsage(THREE.DynamicDrawUsage);
+    fgeo.setAttribute('position', fpAttr);
+    fgeo.setAttribute('aF', fFAttr);
+    const fmat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: flashVertex, fragmentShader: flashFragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const flashes = new THREE.Points(fgeo, fmat);
+    flashes.frustumCulled = false;
+    flashes.renderOrder = 2;
+    // smoke quads: the template corners stay within ±0.5 (selection bounds read them)
+    const sgeo = new THREE.InstancedBufferGeometry();
+    sgeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array([-0.5, -0.5, 0, 0.5, -0.5, 0, 0.5, 0.5, 0, -0.5, 0.5, 0]), 3));
+    sgeo.setIndex([0, 1, 2, 0, 2, 3]);
+    const iP = new Float32Array(NS * 3), iC = new Float32Array(NS * 4), iR = new Float32Array(NS * 2);
+    const iPA = new THREE.InstancedBufferAttribute(iP, 3).setUsage(THREE.DynamicDrawUsage);
+    const iCA = new THREE.InstancedBufferAttribute(iC, 4).setUsage(THREE.DynamicDrawUsage);
+    const iRA = new THREE.InstancedBufferAttribute(iR, 2).setUsage(THREE.DynamicDrawUsage);
+    sgeo.setAttribute('aP', iPA);
+    sgeo.setAttribute('aC', iCA);
+    sgeo.setAttribute('aR', iRA);
+    sgeo.instanceCount = NS;
+    const smat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: smokeVertex, fragmentShader: smokeFragment,
+        transparent: true, depthWrite: false, premultipliedAlpha: true, blending: THREE.NormalBlending, side: THREE.DoubleSide,
+    });
+    const smoke = new THREE.Mesh(sgeo, smat);
+    smoke.frustumCulled = false;
+    smoke.renderOrder = 1;
+    const object = new THREE.Group();
+    const proxy = createPickProxy(BOUNDS.center, BOUNDS.radius);
+    object.add(smoke, flashes, stars, proxy.mesh);
+    const anchor = new THREE.Vector3(0, 0.25, 0);
+    // a click on this object's own pick volume is a click in the show's space, not on another object
+    const own = new Set();
+    function ownProxies(obj) {
+        own.clear();
+        obj.traverse((o) => own.add(o));
+        let a = obj.parent;
+        for (let d = 0; a && d < 5; d++, a = a.parent)
+            for (const ch of a.children)
+                if (ch.name === 'pickProxy')
+                    own.add(ch);
+    }
+    // ---- light: computed once per rendered frame from each body's state ----
+    const cA = [0, 0, 0], cB = [0, 0, 0];
+    function upload() {
+        const pc = u.uPointerColor.value;
+        for (let i = 0; i < n; i++) {
+            const kd = kind[i];
+            if (kd === 0) {
+                aS[i] = 0;
+                continue;
+            }
+            let b = 0, r = 0, g = 0, bl = 0, size = 0, slot = 3;
+            if (kd === 3) {
+                // charcoal spark on the Planck locus, cooling exponentially
+                const T = 1000 + (T0[i] - 1000) * Math.exp(-age[i] / life[i]) + 220 * Math.min(oxy[i], 1);
+                b = Math.exp(-5500 * (1 / T - 1 / 1900)) * 1.3;
+                slotColor(3, T, cA);
+                r = cA[0];
+                g = cA[1];
+                bl = cA[2];
+                size = 0.022;
+            }
+            else if (kd === 1) {
+                b = 0.9;
+                slotColor(3, 1950, cA);
+                r = cA[0];
+                g = cA[1];
+                bl = cA[2];
+                size = 0.03 * sz[i];
+            }
+            else if (kd === 4) {
+                // microstar: dark until its fuse pops it
+                const t = age[i] - life[i];
+                b = t < 0 ? 0 : 3.2 * Math.exp(-t / 0.025);
+                slotColor(4, 0, cA);
+                r = cA[0];
+                g = cA[1];
+                bl = cA[2];
+                size = 0.04 * sz[i];
+                slot = 4;
+            }
+            else {
+                const fr = Math.min(age[i] / life[i], 1);
+                // ignition flare, then the fragment burns down (light ~ surface ~ (1 - f)^(2/3))
+                b = Math.min(age[i] / 0.05, 1) * Math.pow(1 - fr, 0.66) * (1 + 0.7 * Math.exp(-age[i] / 0.12));
+                b *= Math.min(1, (1 - fr) / 0.12);
+                if (flutter[i] > 0)
+                    b *= 0.35 + 0.65 * Math.abs(Math.sin(age[i] * flutter[i] * 0.5 + phase[i]));
+                if (strobe[i] > 0) {
+                    const s = 0.5 + 0.5 * Math.sin(age[i] * strobe[i] * 6.2832 + phase[i]);
+                    b *= 0.04 + 1.4 * s * s * s * s * s * s;
+                }
+                const w = change[i] < 1.5 ? Math.min(Math.max((fr - change[i]) / 0.08 + 0.5, 0), 1) : 0;
+                slot = w > 0.5 ? slotB[i] : slotA[i];
+                slotColor(slotA[i], GOLD_T, cA);
+                if (w > 0) {
+                    slotColor(slotB[i], GOLD_T, cB);
+                    cA[0] += (cB[0] - cA[0]) * w;
+                    cA[1] += (cB[1] - cA[1]) * w;
+                    cA[2] += (cB[2] - cA[2]) * w;
+                }
+                r = cA[0];
+                g = cA[1];
+                bl = cA[2];
+                b *= slotA[i] === 3 ? 1.1 : 1.15;
+                size = 0.036 * sz[i];
+            }
+            // the cursor's oxygen: brighter, and toward the pointer colour; aimed shells carry its tint
+            const tt = Math.min(1, tint[i] + 0.35 * oxy[i]);
+            if (tt > 0) {
+                r += (pc.r - r) * tt;
+                g += (pc.g - g) * tt;
+                bl += (pc.b - bl) * tt;
+            }
+            b *= 1 + 1.3 * oxy[i];
+            // film response: bright cores saturate toward white
+            const E = 1.25 * b;
+            const j = i * 3;
+            aCol[j] = 1 - Math.exp(-r * E) + 0.05 * Math.max(E - 2, 0);
+            aCol[j + 1] = 1 - Math.exp(-g * E) + 0.05 * Math.max(E - 2, 0);
+            aCol[j + 2] = 1 - Math.exp(-bl * E) + 0.05 * Math.max(E - 2, 0);
+            aS[i] = b > 0.004 ? size * (0.75 + 0.35 * Math.min(b, 2)) : 0;
+            if (i < nStar)
+                kTrail[i] = slot * 10 + Math.min(b, 9.5) * (kd === 1 ? 0.6 : 1);
+        }
+        posAttr.needsUpdate = true;
+        colAttr.needsUpdate = true;
+        sAttr.needsUpdate = true;
+        // flashes
+        for (let b = 0; b < NB; b++) {
+            const a = bAge[b];
+            const s = a > 3 ? 0 : 0.6 * Math.exp(-a / 0.05) + 0.1 * Math.exp(-a / 0.6);
+            fpos[b * 3] = bPos[b * 3];
+            fpos[b * 3 + 1] = bPos[b * 3 + 1];
+            fpos[b * 3 + 2] = bPos[b * 3 + 2];
+            fF[b * 4] = bCol[b * 3];
+            fF[b * 4 + 1] = bCol[b * 3 + 1];
+            fF[b * 4 + 2] = bCol[b * 3 + 2];
+            fF[b * 4 + 3] = s;
+        }
+        fpAttr.needsUpdate = true;
+        fFAttr.needsUpdate = true;
+        // smoke: ambient night sky + every burst's light (falls off with distance, fades as its stars burn out)
+        const sm = u.uSmoke.value;
+        smoke.visible = sm > 0.001;
+        for (let s = 0; s < NS; s++) {
+            const a = sAge[s];
+            const j = s * 3;
+            iP[j] = sPos[j];
+            iP[j + 1] = sPos[j + 1];
+            iP[j + 2] = sPos[j + 2];
+            if (a > 30) {
+                iC[s * 4 + 3] = 0;
+                iR[s * 2] = 0;
+                continue;
+            }
+            let r = 0.035, g = 0.04, bl = 0.06;
+            for (let b = 0; b < NB; b++) {
+                const ba = bAge[b];
+                if (ba > 4)
+                    continue;
+                const dx = bPos[b * 3] - sPos[j], dy = bPos[b * 3 + 1] - sPos[j + 1], dz = bPos[b * 3 + 2] - sPos[j + 2];
+                const L = (0.6 * Math.exp(-ba / 0.12) + 0.3 * Math.exp(-ba / 1.4)) * 0.035 / (dx * dx + dy * dy + dz * dz + 0.05);
+                r += bCol[b * 3] * L;
+                g += bCol[b * 3 + 1] * L;
+                bl += bCol[b * 3 + 2] * L;
+            }
+            const lm = Math.max(r, g, bl);
+            if (lm > 0.9) {
+                r *= 0.9 / lm;
+                g *= 0.9 / lm;
+                bl *= 0.9 / lm;
+            }
+            iC[s * 4] = r;
+            iC[s * 4 + 1] = g;
+            iC[s * 4 + 2] = bl;
+            iC[s * 4 + 3] = sm * 0.11 * Math.min(a / 0.6, 1) * Math.exp(-a / 9);
+            iR[s * 2] = sScale[s] * (0.25 + 0.9 * Math.sqrt(a / (a + 5)));
+            iR[s * 2 + 1] = sSeed[s];
+        }
+        iPA.needsUpdate = true;
+        iCA.needsUpdate = true;
+        iRA.needsUpdate = true;
+    }
+    // ---- trails: the star's own colour (slot) and brightness, packed in TRAIL_K ----
+    const trailGLSL = /* glsl */ `
+uniform vec3 uColor, uSecondColor, uAccentColor, uSparkColor;
+vec3 trailShade(vec3 p, float f) {
+  float slot = floor(TRAIL_K / 10.0 + 0.001);
+  float b = TRAIL_K - slot * 10.0;
+  vec3 c = slot < 0.5 ? uColor : slot < 1.5 ? uSecondColor : slot < 2.5 ? uAccentColor
+         : slot < 3.5 ? mix(vec3(1.0, 0.55, 0.2), uSparkColor / max(max(uSparkColor.r, uSparkColor.g), max(uSparkColor.b, 1e-3)), 0.65)
+         : vec3(1.0, 0.96, 0.9);
+  // the star's own colour at the head, cooling toward the trail colour along the tail
+  return mix(c, uTrailColor, 0.2 + 0.6 * f) * min(b, 2.5) * 1.1;
+}
+vec3 trailView(vec3 mv, out float mag) { mag = 1.0; return mv; }
+`;
+    const materials = [mat, fmat, smat];
+    function buildTrails(mode, share) {
+        trailTR = TR_MODE[mode] || TR_MODE.comet;
+        const key = mode + ':' + share;
+        if (key === trailKey)
+            return;
+        trailKey = key;
+        if (trail) {
+            object.remove(trail.object);
+            trail.dispose();
+            trail = null;
+        }
+        materials.length = 3;
+        // trails only on the star slots (shells, stars, microstars) — sparks are their own tails
+        trail = createCpuTrail(mode, { u, n: nStar, pos, vel, k: kTrail, glsl: trailGLSL, sizePx: 0.02, spacing: 0.004, sub: 8, alpha: TRAIL_GAIN[mode] || 1 });
+        if (!trail)
+            return;
+        trail.object.renderOrder = 2;
+        trail.object.traverse((o) => { o.renderOrder = 2; });
+        object.add(trail.object);
+        materials.push(...trail.materials);
+    }
+    buildTrails(c.trailMode, c.trailShare);
+    upload();
+    return {
+        object,
+        materials,
+        apply(cfg) { if (cfg)
+            buildTrails(cfg.trailMode, cfg.trailShare); },
+        update(dt, camera, pointer) {
+            const rdt = Math.min(Math.max(dt, 0), 1 / 20);
+            if (camera && !inView(object, camera, BOUNDS.center, BOUNDS.radius, u.uSize.value))
+                return;
+            const d = rdt * u.uSpeed.value;
+            u.uTime.value += d;
+            if (camera && pointer)
+                stepPointerField(u, pointer, camera, object, u.uSize.value, rdt, anchor);
+            if (pointer && pointer.clicks && pointer.clicks.length) {
+                if (camera && u.uFireOnClick.value > 0.5) {
+                    ownProxies(object);
+                    for (const c of pointer.clicks) {
+                        const t = clickTarget(c, camera, object, u.uSize.value, anchor, own);
+                        if (t)
+                            fire(false, t);
+                    }
+                }
+                pointer.clicks.length = 0;
+            }
+            u.uVelScale.value = trailTR;
+            let simD = 0;
+            stepper.run(d, (hh) => { step(hh); simD += hh; });
+            if (simD > 0) {
+                upload();
+                if (trail)
+                    trail.update(simD / trailTR);
+            }
+        },
+        seek(t) { for (let s = 0; s < Math.round(t / H_STEP); s++)
+            step(H_STEP); upload(); },
+        dispose() {
+            geo.dispose();
+            mat.dispose();
+            fgeo.dispose();
+            fmat.dispose();
+            sgeo.dispose();
+            smat.dispose();
+            proxy.dispose();
+            if (trail)
+                trail.dispose();
+        },
+        _state: { pos, vel, kind, slotA, slotB, n, nStar },
+    };
+}
+/** Defaults for every knob live in core (DEFAULT_GENERATIVE_PARTICLES.fireworks). */
+const DEFAULTS = DEFAULT_GENERATIVE_PARTICLES.fireworks;
+/** Knobs that rebuild the simulation: they change on commit, never through the live path. */
+const STRUCTURAL = ['particleCount', 'seed', 'quality'];
+/** Knobs an animation (or mouse move) may drive per frame — generated from applyConfig. */
+const ANIMATABLE = new Set(GENERATIVE_PARTICLES_ANIMATABLE.fireworks.map((p) => p.value));
+const FireworksParticles = ({ id, size, config, animations, mouseMove, onObjectReady, onObjectDispose }) => {
+    const rootRef = useRef(null);
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    const s = size > 0 ? size : 1;
+    // the committed config over the core defaults (a plain record: the lab code reads it by key)
+    const cfg = useMemo(() => withConfigDefaults(DEFAULTS, config), [config]);
+    // uniforms outlive the objects, so keyframe animations survive a rebuild
+    const uniforms = useMemo(() => createUniforms(), []);
+    // rebuilt only when a structural knob changes (trails rebuild inside apply())
+    const instance = useMemo(() => build(uniforms, cfg, s), [uniforms, cfg.particleCount, cfg.seed, cfg.quality]);
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => {
+        applyConfig(uniforms, cfg, s);
+        instance.apply(cfg);
+    }, [instance, uniforms, cfg, s]);
+    // Slider drags and keyframe animations are both overrides on the committed config.
+    // This is the one place they are merged and pushed; keyframes first, pointer on top.
+    const keyframes = animations?.particles?.animations;
+    const animOverride = useRef({});
+    const animFrom = useRef({});
+    const animStart = useRef(0);
+    useEffect(() => { animStart.current = performance.now(); animFrom.current = {}; }, [keyframes]);
+    const push = useCallback((overrides) => {
+        const merged = { ...cfg, ...overrides, ...animOverride.current };
+        const z = merged.size;
+        applyConfig(uniforms, merged, z && z > 0 ? z : s);
+    }, [cfg, uniforms, s]);
+    const live = useConfigLiveHandle(rootRef, id, 'particles', cfg, STRUCTURAL, push);
+    // The pointer field, plus clicks (fireOnClick) read from the same element, never intercepted.
+    const pointer = usePointerField();
+    const gl = useThree((st) => st.gl);
+    const connected = useThree((st) => st.events.connected);
+    useEffect(() => bindClickFire(connected ?? gl.domElement, pointer), [gl, connected, pointer]);
+    useFrame((state, delta) => {
+        instance.update(Math.min(delta, 0.1), state.camera, pointer);
+        const pointerBound = !!mouseMove?.enabled && !!mouseMove.properties?.length;
+        if (keyframes?.length || pointerBound) {
+            applyConfigKeyframeAnimations(keyframes, animFrom.current, cfg, animOverride.current, performance.now() - animStart.current, ANIMATABLE);
+            if (pointerBound)
+                applyConfigMouseMove(mouseMove.properties, cfg, animOverride.current, state.pointer, ANIMATABLE);
+            push(live.current);
+        }
+    });
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default FireworksParticles;