@woosh/meep-engine 3.15.0 → 3.17.0

package/src/shade/renderer/particles/optimizer/pass_allocate_registers.d.ts

@@ -0,0 +1,99 @@
+export function pass_allocate_registers(instructions: number[][], context: import("./optimize_particle_program.js").ParticleOptimizerContext): number[][];
+/**
+ * @typedef {object} ParticleRegisterSegment
+ * @property {number} slot the slot it occupies in the program as it stands
+ * @property {number} start the instruction that writes it, or `-1` for the reset
+ * @property {number} end the last instruction that reads it; `start` when nothing does
+ * @property {number} parent union-find link
+ * @property {number} placed the slot it is given, once the cluster is placed; `-1` until then
+ */
+/**
+ * @typedef {object} ParticleRegisterShape
+ * @property {number[]} members segment indices
+ * @property {number} origin the lowest slot among the members, which the others keep their distance from
+ * @property {number} extent slots from the origin to one past the highest member
+ * @property {number} start the earliest write among the members
+ */
+/**
+ * @typedef {object} ParticleRegisterSegments
+ * @property {ParticleRegisterSegment[]} segments
+ * @property {ParticleRegisterShape[]} shapes the clusters, in the order they are placed
+ * @property {Int32Array[]} read_segment per instruction, per source slot, the segment the operand's canonical base slot read
+ * @property {Uint32Array[]} read_word per instruction, per source slot, the operand in its canonical spelling
+ * @property {Int32Array} write_segment per instruction, the segment its destination base slot is written into
+ * @property {number} high_water one past the highest slot the program reaches
+ */
+/**
+ * Every stretch of every slot, and which of them have to keep their distance.
+ *
+ * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction[]} decoded
+ * @param {number} slots size of the register file
+ * @returns {ParticleRegisterSegments|null} `null` when an operand reaches outside the file
+ */
+export function analyze_particle_register_segments(decoded: import("./particle_program_analysis.js").ParticleDecodedInstruction[], slots: number): ParticleRegisterSegments | null;
+/** @type {string} */
+export const PARTICLE_PASS_ALLOCATE_REGISTERS: string;
+export type ParticleRegisterSegment = {
+    /**
+     * the slot it occupies in the program as it stands
+     */
+    slot: number;
+    /**
+     * the instruction that writes it, or `-1` for the reset
+     */
+    start: number;
+    /**
+     * the last instruction that reads it; `start` when nothing does
+     */
+    end: number;
+    /**
+     * union-find link
+     */
+    parent: number;
+    /**
+     * the slot it is given, once the cluster is placed; `-1` until then
+     */
+    placed: number;
+};
+export type ParticleRegisterShape = {
+    /**
+     * segment indices
+     */
+    members: number[];
+    /**
+     * the lowest slot among the members, which the others keep their distance from
+     */
+    origin: number;
+    /**
+     * slots from the origin to one past the highest member
+     */
+    extent: number;
+    /**
+     * the earliest write among the members
+     */
+    start: number;
+};
+export type ParticleRegisterSegments = {
+    segments: ParticleRegisterSegment[];
+    /**
+     * the clusters, in the order they are placed
+     */
+    shapes: ParticleRegisterShape[];
+    /**
+     * per instruction, per source slot, the segment the operand's canonical base slot read
+     */
+    read_segment: Int32Array[];
+    /**
+     * per instruction, per source slot, the operand in its canonical spelling
+     */
+    read_word: Uint32Array[];
+    /**
+     * per instruction, the segment its destination base slot is written into
+     */
+    write_segment: Int32Array;
+    /**
+     * one past the highest slot the program reaches
+     */
+    high_water: number;
+};
+//# sourceMappingURL=pass_allocate_registers.d.ts.map

package/src/shade/renderer/particles/optimizer/pass_allocate_registers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pass_allocate_registers.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_allocate_registers.js"],"names":[],"mappings":"AA0FqC,0JAEqB;AAxB1D;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH,4DAJW,OAAO,gCAAgC,EAAE,0BAA0B,EAAE,SACrE,MAAM,GACJ,wBAAwB,GAAC,IAAI,CAsHzC;AAlND,qBAAqB;AACrB,+CADW,MAAM,CACoD;;;;;UA6DvD,MAAM;;;;WACN,MAAM;;;;SACN,MAAM;;;;YACN,MAAM;;;;YACN,MAAM;;;;;;aAKN,MAAM,EAAE;;;;YACR,MAAM;;;;YACN,MAAM;;;;WACN,MAAM;;;cAKN,uBAAuB,EAAE;;;;YACzB,qBAAqB,EAAE;;;;kBACvB,UAAU,EAAE;;;;eACZ,WAAW,EAAE;;;;mBACb,UAAU;;;;gBACV,MAAM"}

package/src/shade/renderer/particles/optimizer/pass_allocate_registers.js

@@ -0,0 +1,313 @@
+import { vm_canonical_register, vm_operand_base, vm_operand_with_base, vm_with_dst } from "../isa/ParticleVMISA.js";
+import { pass_pack_registers } from "./pass_pack_registers.js";
+import {
+    decode_particle_instructions,
+    particle_instruction_is_well_formed,
+    particle_read_slots,
+} from "./particle_program_analysis.js";
+
+/** @type {string} */
+export const PARTICLE_PASS_ALLOCATE_REGISTERS = "allocate_registers";
+
+/**
+ * Give every value a slot for as long as it lives, and no longer.
+ *
+ * The frontend's allocator hands out slots as it lowers, and the passes above this one then delete,
+ * narrow and forward values without ever moving one. What is left is a file where a slot holds a
+ * value that died a hundred instructions ago while a fresh one is put somewhere new — and the file's
+ * high-water mark is what the interpreter pays for, since `vm_reg` is sized by it (see the occupancy
+ * note in `vm/chunk_particle_vm.js`). Packing closes the holes nothing ever touched; this pass is
+ * the other half, reusing the slots that are touched but not at the same time.
+ *
+ * ## Segments and clusters
+ *
+ * Straight-line code has exact lifetimes: a slot's value lives from the instruction that writes it
+ * to the last one that reads it before the next write. Each such stretch is a SEGMENT, and a slot
+ * that is read before anything writes it has a segment from the reset — the zero it holds has to
+ * stay unwritten until that read. Two segments may share a slot when their stretches do not overlap,
+ * and a read at the instruction that overwrites the slot does not overlap it, because every executor
+ * reads its sources before it writes.
+ *
+ * What stops this being interval colouring one slot at a time is that operands name RUNS. A value
+ * three lanes wide is three consecutive slots, and a swizzled read names slots at fixed distances
+ * from its base. So every operand's slots are joined into one CLUSTER whose members keep their
+ * distances; the cluster is placed as a shape, and a member's slot is checked against its own
+ * stretch rather than the cluster's whole extent, so a scalar can sit in the gap of a swizzle that
+ * skips it. All of the constraints come from the layout the program already has, which is why the
+ * shapes are always consistent.
+ *
+ * Clusters are placed in order of when they are first written, each at the lowest origin that fits
+ * — the interval-graph greedy, which is optimal for scalars and a good heuristic for shapes. A
+ * placement that needs more slots than the program had is thrown away, so the pass never makes a
+ * file bigger, and one that needs the same number is thrown away too, so the pass reaches a fixed
+ * point instead of shuffling a program it cannot shrink. Packing runs after every placement, since
+ * a shape may leave a slot between its members that nothing uses, and placement runs again on the
+ * packed file until it has nothing more to give.
+ *
+ * @type {import("./optimize_particle_program.js").ParticleOptimizerPass}
+ */
+export function pass_allocate_registers(instructions, context) {
+    let current = instructions;
+    let changed = false;
+
+    // Every round makes the file strictly smaller, so it cannot take more of them than there are
+    // slots — and it has to run to the end, or the next run of the optimizer would find more to do.
+    for (let round = 0; round < context.register_slots; round++) {
+        const allocated = allocate_once(current, context.register_slots);
+
+        if (allocated === null) {
+            break;
+        }
+
+        current = pass_pack_registers(allocated, context) ?? allocated;
+        changed = true;
+    }
+
+    return changed ? current : null;
+}
+
+/**
+ * @typedef {object} ParticleRegisterSegment
+ * @property {number} slot the slot it occupies in the program as it stands
+ * @property {number} start the instruction that writes it, or `-1` for the reset
+ * @property {number} end the last instruction that reads it; `start` when nothing does
+ * @property {number} parent union-find link
+ * @property {number} placed the slot it is given, once the cluster is placed; `-1` until then
+ */
+
+/**
+ * @typedef {object} ParticleRegisterShape
+ * @property {number[]} members segment indices
+ * @property {number} origin the lowest slot among the members, which the others keep their distance from
+ * @property {number} extent slots from the origin to one past the highest member
+ * @property {number} start the earliest write among the members
+ */
+
+/**
+ * @typedef {object} ParticleRegisterSegments
+ * @property {ParticleRegisterSegment[]} segments
+ * @property {ParticleRegisterShape[]} shapes the clusters, in the order they are placed
+ * @property {Int32Array[]} read_segment per instruction, per source slot, the segment the operand's canonical base slot read
+ * @property {Uint32Array[]} read_word per instruction, per source slot, the operand in its canonical spelling
+ * @property {Int32Array} write_segment per instruction, the segment its destination base slot is written into
+ * @property {number} high_water one past the highest slot the program reaches
+ */
+
+/**
+ * Every stretch of every slot, and which of them have to keep their distance.
+ *
+ * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction[]} decoded
+ * @param {number} slots size of the register file
+ * @returns {ParticleRegisterSegments|null} `null` when an operand reaches outside the file
+ */
+export function analyze_particle_register_segments(decoded, slots) {
+    /** @type {ParticleRegisterSegment[]} */
+    const segments = [];
+    /** @type {Int32Array} per slot, the segment currently in it, or `-1` */
+    const current = new Int32Array(slots).fill(-1);
+    const read_segment = decoded.map(() => new Int32Array(3).fill(-1));
+    const read_word = decoded.map(() => new Uint32Array(3));
+    const write_segment = new Int32Array(decoded.length).fill(-1);
+
+    let high_water = 0;
+
+    const create = (slot, start) => {
+        segments.push({ slot, start, end: start, parent: segments.length, placed: -1 });
+        current[slot] = segments.length - 1;
+
+        return segments.length - 1;
+    };
+
+    const find = (id) => {
+        while (segments[id].parent !== id) {
+            segments[id].parent = segments[segments[id].parent].parent;
+            id = segments[id].parent;
+        }
+
+        return id;
+    };
+
+    const union = (ids) => {
+        const root = find(ids[0]);
+
+        for (let i = 1; i < ids.length; i++) {
+            segments[find(ids[i])].parent = root;
+        }
+    };
+
+    for (let i = 0; i < decoded.length; i++) {
+        const instruction = decoded[i];
+
+        // Reads first: the executors read every source before they write the destination.
+        for (const read of instruction.reads) {
+            const read_slots = particle_read_slots(read);
+
+            if (read_slots.some(slot => slot < 0 || slot >= slots)) {
+                return null;
+            }
+
+            high_water = Math.max(high_water, read.base + read.span);
+
+            const ids = read_slots.map(slot => {
+                const id = current[slot] >= 0 ? current[slot] : create(slot, -1);
+
+                segments[id].end = i;
+
+                return id;
+            });
+
+            union(ids);
+
+            // A pass that narrowed the instruction may have left the operand spelled from a base
+            // slot it no longer reads; the canonical spelling's base is the lowest slot it does.
+            const word = vm_canonical_register(read.word, read.lanes);
+
+            read_word[i][read.operand] = word;
+            read_segment[i][read.operand] = ids[read_slots.indexOf(vm_operand_base(word))];
+        }
+
+        const write = instruction.write;
+
+        if (write !== null) {
+            if (write.base + write.span > slots) {
+                return null;
+            }
+
+            high_water = Math.max(high_water, write.base + write.span);
+
+            const ids = [];
+
+            for (let lane = 0; lane < write.span; lane++) {
+                ids.push(create(write.base + lane, i));
+            }
+
+            union(ids);
+            write_segment[i] = ids[0];
+        }
+    }
+
+    /** @type {Map<number, number[]>} root -> members */
+    const clusters = new Map();
+
+    for (let id = 0; id < segments.length; id++) {
+        const root = find(id);
+
+        if (!clusters.has(root)) {
+            clusters.set(root, []);
+        }
+
+        clusters.get(root).push(id);
+    }
+
+    const shapes = Array.from(clusters.values(), members => {
+        let origin = Infinity;
+        let highest = -Infinity;
+        let start = Infinity;
+
+        for (const id of members) {
+            origin = Math.min(origin, segments[id].slot);
+            highest = Math.max(highest, segments[id].slot);
+            start = Math.min(start, segments[id].start);
+        }
+
+        return { members, origin, extent: highest - origin + 1, start };
+    });
+
+    shapes.sort((a, b) => a.start - b.start || a.origin - b.origin);
+
+    return { segments, shapes, read_segment, read_word, write_segment, high_water };
+}
+
+/**
+ * First fit: each shape at the lowest origin where every member's slot is free for the member's own
+ * stretch. Fills in `placed` on the segments.
+ *
+ * @param {ParticleRegisterSegments} analysis
+ * @param {number} slots
+ * @returns {number} one past the highest slot placed, or `-1` when a shape does not fit
+ */
+function place_shapes({ segments, shapes }, slots) {
+    /** @type {Array<Array<[number, number]>>} per slot, the stretches already placed in it */
+    const occupied = Array.from({ length: slots }, () => []);
+
+    const free = (slot, segment) => occupied[slot].every(
+        ([start, end]) => !(segment.start < end && start < segment.end)
+    );
+
+    let count = 0;
+
+    for (const shape of shapes) {
+        let placed = false;
+
+        for (let origin = 0; origin + shape.extent <= slots && !placed; origin++) {
+            if (shape.members.every(id => free(origin + segments[id].slot - shape.origin, segments[id]))) {
+                for (const id of shape.members) {
+                    const segment = segments[id];
+
+                    segment.placed = origin + segment.slot - shape.origin;
+                    occupied[segment.placed].push([segment.start, segment.end]);
+                }
+
+                count = Math.max(count, origin + shape.extent);
+                placed = true;
+            }
+        }
+
+        if (!placed) {
+            return -1;
+        }
+    }
+
+    return count;
+}
+
+/**
+ * One placement, or `null` when it would not make the file strictly smaller.
+ *
+ * @param {number[][]} instructions
+ * @param {number} slots size of the register file
+ * @returns {number[][]|null}
+ */
+function allocate_once(instructions, slots) {
+    const decoded = decode_particle_instructions(instructions);
+    const analysis = analyze_particle_register_segments(decoded, slots);
+
+    if (analysis === null) {
+        return null;
+    }
+
+    const count = place_shapes(analysis, slots);
+
+    if (count < 0 || count >= analysis.high_water) {
+        return null;
+    }
+
+    const { segments, read_segment, read_word, write_segment } = analysis;
+
+    /** @type {number[][]} */
+    const out = [];
+
+    for (let i = 0; i < decoded.length; i++) {
+        const instruction = decoded[i];
+        const words = instruction.words.slice();
+
+        if (instruction.write !== null) {
+            words[0] = vm_with_dst(words[0], segments[write_segment[i]].placed);
+        }
+
+        for (const read of instruction.reads) {
+            words[1 + read.operand] = vm_operand_with_base(
+                read_word[i][read.operand],
+                segments[read_segment[i][read.operand]].placed
+            );
+        }
+
+        if (!particle_instruction_is_well_formed(words)) {
+            return null;
+        }
+
+        out.push(words);
+    }
+
+    return out;
+}

package/src/shade/renderer/particles/optimizer/pass_dedup_constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Every `(base, span)` a section loads from the pool. A `LOAD_CONST` is the one instruction that
+ * reads it, and its pool index is its first source word.
+ *
+ * @param {ArrayLike<ArrayLike<number>>} instructions four-word tuples
+ * @param {function(number, number, number): void} visit `(index, base, span)`
+ */
+export function visit_particle_constant_reads(instructions: ArrayLike<ArrayLike<number>>, visit: (arg0: number, arg1: number, arg2: number) => void): void;
+export function pass_dedup_constants(instructions: number[][], context: import("./optimize_particle_program.js").ParticleOptimizerContext): number[][];
+/** @type {string} */
+export const PARTICLE_PASS_DEDUP_CONSTANTS: string;
+//# sourceMappingURL=pass_dedup_constants.d.ts.map

package/src/shade/renderer/particles/optimizer/pass_dedup_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pass_dedup_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_dedup_constants.js"],"names":[],"mappings":"AA+GA;;;;;;GAMG;AACH,4DAHW,UAAU,UAAU,MAAM,CAAC,CAAC,gBACnB,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,QAWhD;AAzB+B,uJAUkE;AA9GlG,qBAAqB;AACrB,4CADW,MAAM,CAC8C"}

package/src/shade/renderer/particles/optimizer/pass_dedup_constants.js

@@ -0,0 +1,198 @@
+import { VM_OP, vm_decode_op, vm_decode_width, vm_operation_width } from "../isa/ParticleVMISA.js";
+
+/** @type {string} */
+export const PARTICLE_PASS_DEDUP_CONSTANTS = "dedup_constants";
+
+/**
+ * Point every `LOAD_CONST` at the first copy of the value it loads, and drop the pool words that
+ * nothing reads any more.
+ *
+ * `LOAD_CONST` is the only instruction that reads the constant pool, and it reads a *run* — `base`
+ * from the operand and as many words as the instruction is wide. So two loads of the same value are
+ * the same instruction only when they name the same base, and when they do not, every pass
+ * downstream is looking at two different things:
+ *
+ *     LOAD_CONST.1 r1, c0        LOAD_CONST.1 r1, c0
+ *     MUL.1 r2, r0, r1           MUL.1 r2, r0, r1
+ *     LOAD_CONST.1 r3, c1        LOAD_CONST.1 r3, c0
+ *     MUL.1 r4, r0, r3           MUL.1 r4, r0, r3
+ *     ADD.1 r5, r2, r4           ADD.1 r5, r2, r4
+ *
+ * With `c0` and `c1` holding the same number those two programs compute the same thing, but only the
+ * right-hand one collapses: subexpression sharing folds the second load, copy propagation rewrites
+ * the second `MUL` to read the first load's register, sharing then folds the two identical `MUL`s,
+ * and dead code removes what is left. Seven instructions become five and six registers become four.
+ * The left-hand one does not move at all. Canonicalizing the base is what makes the two the same
+ * program, so this pass buys nothing on its own and everything through the passes after it.
+ *
+ * ## Where the duplicates come from
+ *
+ * Not from the node-graph compiler: {@link ../isa/ParticleAssembler.js}'s `constant` already scans
+ * the whole pool for a matching run before appending, so a graph lowers to a pool with no duplicate
+ * runs and no dead words — measured on the starter effect and on `simplex3`/`curl3`/`curl4` graphs,
+ * every one of which comes out with nothing for this pass to find.
+ *
+ * They come from the other frontends:
+ *
+ * - **hand-written assembly**, where `.const c0 3` / `.const c1 3` is laid out exactly as typed,
+ *   because the indices are the author's to choose and the parser will not renumber them;
+ * - **the optimizer itself**, whose folds intern new literals and whose lane-peeling speculation
+ *   runs the whole pipeline twice against one shared pool — so the literals belonging to the run
+ *   that lost are still sitting in it;
+ * - **`f32` rounding**, since the pool is built as doubles and only becomes a `Float32Array` at the
+ *   end: two values that `constant` saw as distinct can land on the same float.
+ *
+ * ## Two halves, one switch
+ *
+ * The pass proper is the operand rewrite above: per section, and it never touches the pool, which is
+ * what makes it safe when both sections share one. Compacting the pool needs to see every reference
+ * in the program at once, so it is a step of
+ * {@link ./optimize_particle_program.js optimize_particle_program} rather than a pass, and
+ * it runs under this same switch — the rewrite is what makes words dead and the compaction is the
+ * only thing that shows it, so a caller turning one off wants the other off too. A caller using the
+ * per-section entry point gets the rewrite alone; there is no pool for it to compact.
+ *
+ * ## What must not change
+ *
+ * Runs are compared as `f32` **bit patterns**, not as numbers. That keeps `-0` out of `+0` — the two
+ * are a visible difference the moment anything divides by one — and keeps two `NaN`s with different
+ * payloads apart, which costs nothing since neither is a literal any frontend emits. Comparing the
+ * bits the pool will actually hold, rather than the doubles it holds on the way there, is also what
+ * catches the rounding case above.
+ */
+
+/** Scratch for reading a value's `f32` bits. Module-level because this runs per pool word. */
+const F32_SCRATCH = new Float32Array(1);
+
+/** @type {Uint32Array} the same four bytes, as an integer */
+const U32_SCRATCH = new Uint32Array(F32_SCRATCH.buffer);
+
+/**
+ * @param {number} value
+ * @returns {number} the bits `value` has once the pool is a `Float32Array`
+ */
+function f32_bits(value) {
+    F32_SCRATCH[0] = value;
+
+    return U32_SCRATCH[0];
+}
+
+/**
+ * @param {ArrayLike<number>} constants
+ * @param {number} base
+ * @param {number} span
+ * @returns {string} an identity for the run of values at `base`, distinct for every distinct run
+ */
+function run_key(constants, base, span) {
+    let key = `${span}`;
+
+    for (let i = 0; i < span; i++) {
+        key += `:${f32_bits(constants[base + i])}`;
+    }
+
+    return key;
+}
+
+/**
+ * The span of pool words an instruction reads, or 0 when it is not a `LOAD_CONST`.
+ *
+ * @param {ArrayLike<number>} words the five words of one instruction
+ * @returns {number}
+ */
+function constant_span(words) {
+    const op = vm_decode_op(words[0]);
+
+    if (op !== VM_OP.LOAD_CONST) {
+        return 0;
+    }
+
+    return vm_operation_width(op, vm_decode_width(words[0]));
+}
+
+/**
+ * Every `(base, span)` a section loads from the pool. A `LOAD_CONST` is the one instruction that
+ * reads it, and its pool index is its first source word.
+ *
+ * @param {ArrayLike<ArrayLike<number>>} instructions four-word tuples
+ * @param {function(number, number, number): void} visit `(index, base, span)`
+ */
+export function visit_particle_constant_reads(instructions, visit) {
+    for (let index = 0; index < instructions.length; index++) {
+        const words = instructions[index];
+        const span = constant_span(words);
+
+        if (span > 0) {
+            visit(index, words[1], span);
+        }
+    }
+}
+
+/**
+ * @type {import("./optimize_particle_program.js").ParticleOptimizerPass}
+ */
+export function pass_dedup_constants(instructions, context) {
+    const constants = context.constants;
+
+    if (constants === undefined || constants.length === 0) {
+        return null;
+    }
+
+    /** @type {Array<{index: number, base: number, span: number}>} */
+    const reads = [];
+
+    /** @type {Set<number>} only the spans something actually loads are worth indexing */
+    const spans = new Set();
+
+    // One walk rather than one per question: this pass sits in the sweep loop and a `curl3` effect
+    // is four thousand instructions, so decoding them all twice per invocation was most of what it
+    // cost — and on a pool the assembler built there is nothing at the end of it to find.
+    visit_particle_constant_reads(instructions, (index, base, span) => {
+        if (base < 0 || base + span > constants.length) {
+            // Out of the pool: a malformed program, which `validate` reports and this pass leaves
+            // exactly as it found it rather than rewriting into a different kind of wrong.
+            return;
+        }
+
+        reads.push({ index, base, span });
+        spans.add(span);
+    });
+
+    if (reads.length === 0) {
+        return null;
+    }
+
+    /** @type {Map<string, number>} run identity -> the first base holding it */
+    const earliest = new Map();
+
+    for (const span of spans) {
+        for (let base = 0; base + span <= constants.length; base++) {
+            const key = run_key(constants, base, span);
+
+            // ascending, and only the first wins: the canonical base for a run is the earliest one,
+            // which is a fixed point — running this pass again moves nothing — and monotonically
+            // decreasing, so it cannot ping-pong with anything in the sweep it sits in.
+            if (!earliest.has(key)) {
+                earliest.set(key, base);
+            }
+        }
+    }
+
+    /** @type {number[][]|null} */
+    let out = null;
+
+    for (const read of reads) {
+        const canonical = earliest.get(run_key(constants, read.base, read.span));
+
+        if (canonical === undefined || canonical === read.base) {
+            continue;
+        }
+
+        if (out === null) {
+            out = instructions.map(words => Array.from(words));
+        }
+
+        out[read.index][1] = canonical;
+    }
+
+    return out;
+}

package/src/shade/renderer/particles/optimizer/pass_eliminate_dead_code.d.ts

@@ -0,0 +1,4 @@
+export function pass_eliminate_dead_code(instructions: number[][], context: import("./optimize_particle_program.js").ParticleOptimizerContext): number[][];
+/** @type {string} */
+export const PARTICLE_PASS_DEAD_CODE: string;
+//# sourceMappingURL=pass_eliminate_dead_code.d.ts.map

package/src/shade/renderer/particles/optimizer/pass_eliminate_dead_code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pass_eliminate_dead_code.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_eliminate_dead_code.js"],"names":[],"mappings":"AAmD8jF,2JAAqP;AAjDnzF,qBAAqB;AACrB,sCADW,MAAM,CACkC"}