@woosh/meep-engine 3.29.0 → 3.31.0

package/src/shade/renderer/particles/data/PARTICLE_DATABASE_SPEC.js

@@ -1,68 +1,81 @@
-import { KILOBYTE } from "../../../../core/science/units/memory/KILOBYTE.js";
-import { GPUDatabaseDefinition } from "../../buffer/table/GPUDatabaseDefinition.js";
-import { PARTICLE_EMITTER_STATE_STRUCT } from "./PARTICLE_EMITTER_STATE.js";
-import { PARTICLE_EMITTER_STRUCT } from "./PARTICLE_EMITTER_STRUCT.js";
-
-/**
- * Emitters are counted in tens, not thousands, so the engine-wide default page (128 KB) would
- * reserve two orders of magnitude more than a scene ever fills. 16 KB still holds ~140 emitters per
- * page and the table grows a page at a time past that.
- *
- * @type {number}
- */
-export const PARTICLE_EMITTER_PAGE_SIZE = 16 * KILOBYTE;
-
-/**
- * How big an emitter database's buffer starts out. The page address table takes 32 KB (two tables'
- * worth of `GPU_DATABASE_PAGE_LIMIT` u32 slots), so this leaves room for one page of each table —
- * around a hundred and forty emitters — before the database grows itself.
- *
- * @type {number}
- */
-export const PARTICLE_DATABASE_INITIAL_SIZE = 64 * KILOBYTE;
-
-/** Name of the emitter table within {@link PARTICLE_DATABASE_SPEC}. */
-export const PARTICLE_EMITTER_TABLE = "emitters";
-
-/** Name of the GPU-owned emitter state table within {@link PARTICLE_DATABASE_SPEC}. */
-export const PARTICLE_EMITTER_STATE_TABLE = "emitter_state";
-
-/**
- * Schema of the particle system's GPU database. Two tables, one row per emitter in each, at the
- * same row index:
- *
- * - `emitters` — CPU-authored and low-churn, exactly the shape `GPUDatabase` is for. Adding or
- *   removing one emitter queues that one record for upload; the rest of the table is not touched,
- *   and the pass shaders address rows by a stable id that survives its neighbours coming and going.
- * - `emitter_state` — GPU-owned ({@link ./PARTICLE_EMITTER_STATE.js}): claimed with a zero record
- *   when the emitter's row is, then written only by the tick and spawn-command passes.
- *
- * One buffer for both is what keeps every pass that reads an emitter at one binding for the pair.
- *
- * Programs and their constant pools are NOT here: they are variable-length and shared between
- * emitters, so they live in the packed {@link ../runtime/ProgramArena.js} buffer, referenced by the
- * offsets each emitter record carries.
- *
- * @type {GPUDatabaseDefinition}
- */
-export const PARTICLE_DATABASE_SPEC = GPUDatabaseDefinition.from({
-    [PARTICLE_EMITTER_TABLE]: PARTICLE_EMITTER_STRUCT,
-    [PARTICLE_EMITTER_STATE_TABLE]: PARTICLE_EMITTER_STATE_STRUCT,
-}, PARTICLE_EMITTER_PAGE_SIZE);
-
-/**
- * Descriptor for the emitter table — the source of the WGSL reader every emitter-consuming pass
- * pulls in ({@link GPUTypedTableDescriptor#chunk_read}, and
- * {@link GPUTypedTableDescriptor#chunk_read_field} for the passes that want a single field).
- *
- * @type {GPUTypedTableDescriptor}
- */
-export const PARTICLE_EMITTER_DESCRIPTOR = PARTICLE_DATABASE_SPEC.get(PARTICLE_EMITTER_TABLE);
-
-/**
- * Descriptor for the state table — the tick pass reads and writes whole rows through it, the
- * spawn-command pass adds to one, and the emit / simulate passes read the age off it.
- *
- * @type {GPUTypedTableDescriptor}
- */
-export const PARTICLE_EMITTER_STATE_DESCRIPTOR = PARTICLE_DATABASE_SPEC.get(PARTICLE_EMITTER_STATE_TABLE);
+import { KILOBYTE } from "../../../../core/science/units/memory/KILOBYTE.js";
+import { GPUDatabaseDefinition } from "../../buffer/table/GPUDatabaseDefinition.js";
+import { SCENE_DATABASE_SPEC } from "../../scene/SCENE_DATABASE_SPEC.js";
+import { PARTICLE_EMITTER_STATE_STRUCT } from "./PARTICLE_EMITTER_STATE.js";
+import { PARTICLE_EMITTER_STRUCT } from "./PARTICLE_EMITTER_STRUCT.js";
+
+/**
+ * Emitters are counted in tens, not thousands, so the engine-wide default page (128 KB) would
+ * reserve two orders of magnitude more than a scene ever fills. 16 KB still holds ~140 emitters per
+ * page and the table grows a page at a time past that.
+ *
+ * @type {number}
+ */
+export const PARTICLE_EMITTER_PAGE_SIZE = 16 * KILOBYTE;
+
+/**
+ * How big an emitter database's buffer starts out. The page address table takes 32 KB (two tables'
+ * worth of `GPU_DATABASE_PAGE_LIMIT` u32 slots), so this leaves room for one page of each table —
+ * around a hundred and forty emitters — before the database grows itself.
+ *
+ * @type {number}
+ */
+export const PARTICLE_DATABASE_INITIAL_SIZE = 64 * KILOBYTE;
+
+/** Name of the emitter table within {@link PARTICLE_DATABASE_SPEC}. */
+export const PARTICLE_EMITTER_TABLE = "emitters";
+
+/** Name of the GPU-owned emitter state table within {@link PARTICLE_DATABASE_SPEC}. */
+export const PARTICLE_EMITTER_STATE_TABLE = "emitter_state";
+
+/**
+ * Schema of the particle system's GPU database. Two tables, one row per emitter in each, at the
+ * same row index:
+ *
+ * - `emitters` — CPU-authored and low-churn, exactly the shape `GPUDatabase` is for. Adding or
+ *   removing one emitter queues that one record for upload; the rest of the table is not touched,
+ *   and the pass shaders address rows by a stable id that survives its neighbours coming and going.
+ * - `emitter_state` — GPU-owned ({@link ./PARTICLE_EMITTER_STATE.js}): claimed with a zero record
+ *   when the emitter's row is, then written only by the tick and spawn-command passes.
+ *
+ * One buffer for both is what keeps every pass that reads an emitter at one binding for the pair.
+ *
+ * Programs and their constant pools are NOT here: they are variable-length and shared between
+ * emitters, so they live in the packed {@link ../runtime/ProgramArena.js} buffer, referenced by the
+ * offsets each emitter record carries.
+ *
+ * @type {GPUDatabaseDefinition}
+ */
+export const PARTICLE_DATABASE_SPEC = GPUDatabaseDefinition.from({
+    [PARTICLE_EMITTER_TABLE]: PARTICLE_EMITTER_STRUCT,
+    [PARTICLE_EMITTER_STATE_TABLE]: PARTICLE_EMITTER_STATE_STRUCT,
+}, PARTICLE_EMITTER_PAGE_SIZE);
+
+// The transforms row of the emitter's entity, where the passes read its world matrix. Until the
+// registry is told the row, the record names the scene root, row 0 — a real row, not a null. The
+// emitter system holds the row through the scene's rows; it is not this database's to free.
+PARTICLE_DATABASE_SPEC.add_link({
+    table: PARTICLE_EMITTER_TABLE,
+    field: 'node',
+    target_database: SCENE_DATABASE_SPEC,
+    target_table: 'transforms',
+    nullable: false,
+    owning: false,
+});
+
+/**
+ * Descriptor for the emitter table — the source of the WGSL reader every emitter-consuming pass
+ * pulls in ({@link GPUTypedTableDescriptor#chunk_read}, and
+ * {@link GPUTypedTableDescriptor#chunk_read_field} for the passes that want a single field).
+ *
+ * @type {GPUTypedTableDescriptor}
+ */
+export const PARTICLE_EMITTER_DESCRIPTOR = PARTICLE_DATABASE_SPEC.get(PARTICLE_EMITTER_TABLE);
+
+/**
+ * Descriptor for the state table — the tick pass reads and writes whole rows through it, the
+ * spawn-command pass adds to one, and the emit / simulate passes read the age off it.
+ *
+ * @type {GPUTypedTableDescriptor}
+ */
+export const PARTICLE_EMITTER_STATE_DESCRIPTOR = PARTICLE_DATABASE_SPEC.get(PARTICLE_EMITTER_STATE_TABLE);

package/src/shade/renderer/particles/graph/groups/simplex_reference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simplex_reference.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/simplex_reference.js"],"names":[],"mappings":"AAyGA;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,GACN,MAAM,CA2ElB"}
+{"version":3,"file":"simplex_reference.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/simplex_reference.js"],"names":[],"mappings":"AA+GA;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,GACN,MAAM,CA2ElB"}

package/src/shade/renderer/particles/graph/groups/simplex_reference.js

@@ -18,8 +18,14 @@
  * double-precision oracle takes the other branch there and disagrees with the VM about a third of the
  * time, and it would be the one that was wrong: a GPU is `f32` too.
  *
- * So `fr` is applied wherever the VM would have stored a register, and nowhere else. Sums inside a
- * dot product are not rounded per term, because the opcode accumulates and stores once.
+ * So `fr` is applied wherever the VM would have stored a register — and inside `DOT` and
+ * `NORMALIZE` as well, because the shader computes those entirely in f32 and the reference executor
+ * now does the same. This file used to say the sum was accumulated wide and rounded once, which was
+ * a faithful transcription of a reference VM that summed in f64: f32 results without f32 range.
+ *
+ * The one place `fr` is deliberately absent from an intermediate is a product the group spells as a
+ * `MAD` — `row * ns_x + ns_y`, and the two reflections below it. `MAD` models the fused form, so
+ * its product is not rounded on either executor; see the opcode in {@link ../../vm/ParticleVMReference.js}.
  */
 
 /** @type {function(number):number} */
@@ -34,16 +40,16 @@ const G3 = 1 / 6;
 /**
  * @param {number[]} a
  * @param {number[]} b
- * @returns {number} the dot product, accumulated wide and rounded once, as `DOT` does
+ * @returns {number} the dot product, every step of it in f32, as `DOT` does
  */
 function dot(a, b) {
     let sum = 0;
 
     for (let i = 0; i < a.length; i++) {
-        sum += a[i] * b[i];
+        sum = fr(sum + fr(a[i] * b[i]));
     }
 
-    return fr(sum);
+    return sum;
 }
 
 /**
@@ -58,8 +64,8 @@ function step(edge, x) {
 }
 
 /**
- * `NORMALIZE`, as the opcode does it: the length is accumulated and taken wide and only the lanes
- * are rounded, and a zero vector normalises to zero rather than to nothing.
+ * `NORMALIZE`, as the opcode does it: every step of the length in f32, and a zero vector normalises
+ * to zero rather than to nothing.
  *
  * The group used to spell this as Gustavson's `taylorInvSqrt` — a line through the band the gradient
  * table's squared lengths fall in — and now calls the opcode, which is one instruction rather than
@@ -73,12 +79,12 @@ function normalize(v) {
     let sum = 0;
 
     for (const component of v) {
-        sum += component * component;
+        sum = fr(sum + fr(component * component));
     }
 
-    const length = Math.sqrt(sum);
+    const length = fr(Math.sqrt(sum));
 
-    const inverse = length > 0 ? 1 / length : 0;
+    const inverse = length > 0 ? fr(1 / length) : 0;
 
     return v.map(component => fr(component * inverse));
 }

package/src/shade/renderer/particles/graph_particles.d.ts

@@ -59,7 +59,7 @@
  * ## What is imported, and what the graph owns
  *
  * A buffer is imported only if its contents cross the frame boundary: the pool, the free list, the
- * counters, the alive lists, `sim_list` (written here, read by next frame's simulate),
+ * counters, the alive list, `sim_list` (written here, read by next frame's simulate),
  * `dispatch_args` (the same), the program blob and the two CPU-uploaded queues. Everything else is
  * produced and consumed inside one graph, so the pass that first writes it declares it with a
  * {@link BufferResourceDescriptor} in place of a handle and the graph allocates it just in time and
@@ -85,7 +85,9 @@
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
  * @param {number} params.camera graph handle of the view's camera uniform (`CAMERA_UNIFORM_STRUCT`)
  * @param {number} params.scene_database graph handle of the scene database — the emitters' nodes
- * @param {object} params.gpu the persistent buffers, see {@link GPUParticleSystem}
+ * @param {object} params.gpu the persistent buffers, see {@link GPUParticleSystem}. `gpu.alive_read`
+ *   is the exception: it is the previous frame's alive list and is present only when
+ *   `frame.rebucket` says this frame reads one
  * @param {object} params.emitters the emitter table's shape this frame
  * @param {number} params.emitters.capacity the table's element capacity — the length of the count
  *   list the scan consumes

package/src/shade/renderer/particles/graph_particles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA7BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IACS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CA4TrC;;;;;UAlWa,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;;sBACN,MAAM"}
+{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IA/BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IAGS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CAgUrC;;;;;UAxWa,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;;sBACN,MAAM"}

package/src/shade/renderer/particles/graph_particles.js

@@ -98,7 +98,7 @@ import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
  * ## What is imported, and what the graph owns
  *
  * A buffer is imported only if its contents cross the frame boundary: the pool, the free list, the
- * counters, the alive lists, `sim_list` (written here, read by next frame's simulate),
+ * counters, the alive list, `sim_list` (written here, read by next frame's simulate),
  * `dispatch_args` (the same), the program blob and the two CPU-uploaded queues. Everything else is
  * produced and consumed inside one graph, so the pass that first writes it declares it with a
  * {@link BufferResourceDescriptor} in place of a handle and the graph allocates it just in time and
@@ -126,7 +126,9 @@ import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
  * @param {number} params.camera graph handle of the view's camera uniform (`CAMERA_UNIFORM_STRUCT`)
  * @param {number} params.scene_database graph handle of the scene database — the emitters' nodes
- * @param {object} params.gpu the persistent buffers, see {@link GPUParticleSystem}
+ * @param {object} params.gpu the persistent buffers, see {@link GPUParticleSystem}. `gpu.alive_read`
+ *   is the exception: it is the previous frame's alive list and is present only when
+ *   `frame.rebucket` says this frame reads one
  * @param {object} params.emitters the emitter table's shape this frame
  * @param {number} params.emitters.capacity the table's element capacity — the length of the count
  *   list the scan consumes
@@ -197,6 +199,10 @@ export function graph_particles_simulate({
     if (frame.rebucket) {
         // Live program edits can split a previously uniform wave. Rebuild from the previous
         // compact alive list BEFORE reset discards its count and before simulate broadcasts code.
+        //
+        // `gpu.alive_read` exists only here. It is the one reader the previous frame's list ever
+        // has, which is why the feature holds one list rather than a ping-pong pair and keeps the
+        // old one only across a frame that rebuckets — see `GPUParticleSystem#swap_alive_list`.
         const bucketed = graph_particle_bucket({
             graph, emitter_database, pool, counters, capacity, bucket_count,
             alive: graph_import_buffer(graph, gpu.alive_read, "particles/alive_read"),

package/src/shade/renderer/particles/isa/ParticleVMISA.d.ts

@@ -292,15 +292,34 @@ export namespace VM_BUILTIN {
     let TIME: number;
 }
 /**
- * How many lanes each builtin fills. The lanes past that read zero when a load is wider — see
- * `vm_load_builtin` in {@link ../vm/chunk_particle_vm.js} — so this is a builtin's type as far as
- * a program is concerned, and it is what types a `builtin` node in a graph.
+ * How many lanes each builtin fills. The lanes past that read {@link VM_BUILTIN_PADDING} when a
+ * load is wider, so this is a builtin's type as far as a program is concerned, and it is what types
+ * a `builtin` node in a graph.
  *
  * @type {Object<number, number>}
  */
 export const VM_BUILTIN_COMPONENTS: {
     [x: number]: number;
 };
+/**
+ * What a builtin's lanes past {@link VM_BUILTIN_COMPONENTS} read when a load is wider than it.
+ *
+ * Part of the ISA rather than of whatever supplies the values, because the two executors have to
+ * agree and they cannot if each host decides. `vm_load_builtin` in the WGSL always fixed its own —
+ * zero behind a scalar, `vec4(pos, 1.0)` for the position, `vec4(dir, 0.0)` for the directions —
+ * while the CPU reference took whatever four-array its host handed it. The editor's host fills the
+ * scalars in all four lanes and gives the position a `w` of 0, so `LOAD_BUILTIN.3 DELTA_TIME` read
+ * (dt, dt, dt) in the preview and (dt, 0, 0) on the GPU, and `LOAD_BUILTIN.4 EMITTER_POSITION` read
+ * a `w` of 0 against the shader's 1.
+ *
+ * A position closes its window with one because it is a point and a direction with zero because it
+ * is a direction: the padding is what makes the four-vector mean the same thing under a transform.
+ *
+ * @type {Object<number, number>}
+ */
+export const VM_BUILTIN_PADDING: {
+    [x: number]: number;
+};
 /**
  * Opcodes. Numbers are stable wire values — never renumber, only append. 19 was `SCALE` and 45 was
  * `SWIZZLE`; both are spelled by an operand swizzle now. 61 was the animation-table sampler.

package/src/shade/renderer/particles/isa/ParticleVMISA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleVMISA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/ParticleVMISA.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ParticleVMISA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/ParticleVMISA.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/particles/isa/ParticleVMISA.js

@@ -109,9 +109,9 @@ export const VM_BUILTIN = {
 };
 
 /**
- * How many lanes each builtin fills. The lanes past that read zero when a load is wider — see
- * `vm_load_builtin` in {@link ../vm/chunk_particle_vm.js} — so this is a builtin's type as far as
- * a program is concerned, and it is what types a `builtin` node in a graph.
+ * How many lanes each builtin fills. The lanes past that read {@link VM_BUILTIN_PADDING} when a
+ * load is wider, so this is a builtin's type as far as a program is concerned, and it is what types
+ * a `builtin` node in a graph.
  *
  * @type {Object<number, number>}
  */
@@ -126,6 +126,33 @@ export const VM_BUILTIN_COMPONENTS = Object.freeze({
     [VM_BUILTIN.TIME]: 1,
 });
 
+/**
+ * What a builtin's lanes past {@link VM_BUILTIN_COMPONENTS} read when a load is wider than it.
+ *
+ * Part of the ISA rather than of whatever supplies the values, because the two executors have to
+ * agree and they cannot if each host decides. `vm_load_builtin` in the WGSL always fixed its own —
+ * zero behind a scalar, `vec4(pos, 1.0)` for the position, `vec4(dir, 0.0)` for the directions —
+ * while the CPU reference took whatever four-array its host handed it. The editor's host fills the
+ * scalars in all four lanes and gives the position a `w` of 0, so `LOAD_BUILTIN.3 DELTA_TIME` read
+ * (dt, dt, dt) in the preview and (dt, 0, 0) on the GPU, and `LOAD_BUILTIN.4 EMITTER_POSITION` read
+ * a `w` of 0 against the shader's 1.
+ *
+ * A position closes its window with one because it is a point and a direction with zero because it
+ * is a direction: the padding is what makes the four-vector mean the same thing under a transform.
+ *
+ * @type {Object<number, number>}
+ */
+export const VM_BUILTIN_PADDING = Object.freeze({
+    [VM_BUILTIN.DELTA_TIME]: 0,
+    [VM_BUILTIN.EMITTER_AGE]: 0,
+    [VM_BUILTIN.EMITTER_POSITION]: 1,
+    [VM_BUILTIN.EMITTER_DIRECTION]: 0,
+    [VM_BUILTIN.EMITTER_UP]: 0,
+    [VM_BUILTIN.PARTICLE_INDEX]: 0,
+    [VM_BUILTIN.SPAWN_FRACTION]: 0,
+    [VM_BUILTIN.TIME]: 0,
+});
+
 /**
  * Opcodes. Numbers are stable wire values — never renumber, only append. 19 was `SCALE` and 45 was
  * `SWIZZLE`; both are spelled by an operand swizzle now. 61 was the animation-table sampler.

package/src/shade/renderer/particles/isa/particle_assembly.js

@@ -990,9 +990,43 @@ function parse_destination(token, line_number, report) {
         return null;
     }
 
+    if (!register_index_fits(index, token, line_number, report)) {
+        return null;
+    }
+
     return index;
 }
 
+/**
+ * Whether a register index can be said at all, reporting when it cannot.
+ *
+ * Both parsers ended at `parse_unsigned`, which takes any run of digits, and the number went
+ * straight into `vm_register` / `vm_encode_word0`, which mask it to 8 bits — so an index above the
+ * file's ceiling wrapped into a different, perfectly valid slot. Nothing downstream could notice:
+ * `check_stream_references` re-derives its bounds from the ALREADY MASKED words, so the high-water
+ * mark is the wrapped index and the `.registers` check agrees with it. A typed digit turned one
+ * program into another and the round trip printed back the wrong one. The constant-pool index is
+ * bounded for exactly this reason; the register, which is on nearly every line, was not.
+ *
+ * @param {number} index
+ * @param {string} token
+ * @param {number} line_number
+ * @param {function(number, string):void} report
+ * @returns {boolean}
+ */
+function register_index_fits(index, token, line_number, report) {
+    if (index < PARTICLE_VM_REGISTER_SLOTS) {
+        return true;
+    }
+
+    report(
+        line_number,
+        `Register '${token}' is beyond the ${PARTICLE_VM_REGISTER_SLOTS} slots an instruction word can address`
+    );
+
+    return false;
+}
+
 /**
  * An operand in a register slot: a register, optionally read through selectors, or a literal.
  *
@@ -1005,6 +1039,12 @@ function parse_register_operand(token, line_number, report) {
     const register = /^r(\d+)(?:\.([xyzw]{1,4}))?$/i.exec(token);
 
     if (register !== null) {
+        const base = Number.parseInt(register[1], 10);
+
+        if (!register_index_fits(base, token, line_number, report)) {
+            return null;
+        }
+
         const selectors = register[2] ?? "";
         const lanes = [0, 1, 2, 3].map(lane => (lane < selectors.length
             ? SWIZZLE_LANES.indexOf(selectors.charAt(lane).toLowerCase())
@@ -1012,7 +1052,7 @@ function parse_register_operand(token, line_number, report) {
 
         return {
             kind: VM_KIND.REG,
-            word: vm_register(Number.parseInt(register[1], 10), pack_swizzle(lanes[0], lanes[1], lanes[2], lanes[3])),
+            word: vm_register(base, pack_swizzle(lanes[0], lanes[1], lanes[2], lanes[3])),
             selectors: selectors.length,
             token,
         };

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

@@ -83,10 +83,16 @@ export function particle_read_slots(read: ParticleOperandRun, lanes?: number): n
  * instruction — which is also what lets a pass move a base or fold a swizzle without asking how the
  * result sits against the other operands.
  *
+ * The file is the one the CALLER asked for. It used to be the ISA ceiling regardless: every pass
+ * takes `context.register_slots` and every pass validates what it emits through here, so asking
+ * for 48 slots and getting an instruction that names slot 200 passed the one check the passes lean
+ * on, and a reduced register file was not enforced anywhere in the pipeline.
+ *
  * @param {ArrayLike<number>} words the four words of a single instruction
+ * @param {number} [register_slots] size of the file to measure against
  * @returns {boolean}
  */
-export function particle_instruction_is_well_formed(words: ArrayLike<number>): boolean;
+export function particle_instruction_is_well_formed(words: ArrayLike<number>, register_slots?: number): boolean;
 /**
  * Def-use over the instruction stream: an edge `i -> j` says instruction `j` reads a slot
  * instruction `i` last wrote.

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

@@ -1 +1 @@
-{"version":3,"file":"particle_program_analysis.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_analysis.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AACH,mDAJW,UAAU,MAAM,CAAC,UACjB,MAAM,GACJ,0BAA0B,CAiDtC;AAED;;;GAGG;AACH,2DAHW,UAAU,UAAU,MAAM,CAAC,CAAC,GAC1B,0BAA0B,EAAE,CAUxC;AAED;;;;;;;GAOG;AACH,0CAJW,kBAAkB,UAClB,MAAM,GACJ,MAAM,EAAE,CAUpB;AAED;;;;;;;;;;;GAWG;AACH,2DAHW,UAAU,MAAM,CAAC,GACf,OAAO,CAiBnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,sDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,QAAQ,CAyDpB;AAED;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,gDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,oBAAoB,CA6EhC;AAED;;;;;;;;;;;GAWG;AACH,kDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,MAAM,CAmClB;AAED;;;;;;GAMG;AACH,8CANW,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;;;;;;;;GAaG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAmBnB;AAED;;;;;;;;;;GAUG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAanB;AAED;;;;;;;;;;;GAWG;AACH,oDANW,0BAA0B,EAAE,SAC5B,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAiCnB;AAED;;;;;;;;;;;;;GAaG;AACH;IACI;;OAEG;IACH,oBAFW,MAAM,EAsBhB;IAnBG,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,gDAAgD;IAChD,UADW,UAAU,CACgB;IACrC,mEAAmE;IACnE,MADW,UAAU,CACY;IACjC,kGAAkG;IAClG,UADW,UAAU,CACyB;IAC9C,qBAAqB;IACrB,SADW,MAAM,CACG;IACpB,sEAAsE;IACtE,WADW,MAAM,CACC;IAUtB;;;;OAIG;IACH,aAJW,MAAM,QACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CAczB;IAED;;;;;OAKG;IACH,eAHW,kBAAkB,GAChB,MAAM,EAAE,GAAC,IAAI,CAUzB;IAED;;;;OAIG;IACH,YAJW,MAAM,OACN,MAAM,EAAE,GACN,OAAO,CAcnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,qBAJW,kBAAkB,GAChB,MAAM,CAiDlB;IAED;;;;;;;;OAQG;IACH,eAFW,UAAU,MAAM,CAAC,QAwC3B;CACJ;;;;;aAhrBa,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;;aACN,MAAM;;;;;WAEN,MAAM;;;;UAEN,MAAM;;;;;;WAKN,MAAM;;;;WACN,MAAM,EAAE;QACR,MAAM;;;;WACN,MAAM;;;;SACN,MAAM;;;;WACN,MAAM;;;;qBACN,MAAM;;;;UACN,MAAM;eACN,OAAO,4BAA4B,EAAE,mBAAmB;;;;WACxD,kBAAkB,GAAC,IAAI;;;;WACvB,kBAAkB,EAAE;;;;aACpB,kBAAkB,EAAE;;;;;;;UAoMpB,UAAU;;;;;WAEV,UAAU;;;;gBAEV,UAAU;;;;gBACV,MAAM;;yBAvRK,wCAAwC"}
+{"version":3,"file":"particle_program_analysis.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_analysis.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AACH,mDAJW,UAAU,MAAM,CAAC,UACjB,MAAM,GACJ,0BAA0B,CAiDtC;AAED;;;GAGG;AACH,2DAHW,UAAU,UAAU,MAAM,CAAC,CAAC,GAC1B,0BAA0B,EAAE,CAUxC;AAED;;;;;;;GAOG;AACH,0CAJW,kBAAkB,UAClB,MAAM,GACJ,MAAM,EAAE,CAUpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,2DAJW,UAAU,MAAM,CAAC,mBACjB,MAAM,GACJ,OAAO,CAiBnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,sDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,QAAQ,CAyDpB;AAED;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,gDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,oBAAoB,CA6EhC;AAED;;;;;;;;;;;GAWG;AACH,kDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,MAAM,CAmClB;AAED;;;;;;GAMG;AACH,8CANW,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;;;;;;;;GAaG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAmBnB;AAED;;;;;;;;;;GAUG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAanB;AAED;;;;;;;;;;;GAWG;AACH,oDANW,0BAA0B,EAAE,SAC5B,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAiCnB;AAED;;;;;;;;;;;;;GAaG;AACH;IACI;;OAEG;IACH,oBAFW,MAAM,EAsBhB;IAnBG,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,gDAAgD;IAChD,UADW,UAAU,CACgB;IACrC,mEAAmE;IACnE,MADW,UAAU,CACY;IACjC,kGAAkG;IAClG,UADW,UAAU,CACyB;IAC9C,qBAAqB;IACrB,SADW,MAAM,CACG;IACpB,sEAAsE;IACtE,WADW,MAAM,CACC;IAUtB;;;;OAIG;IACH,aAJW,MAAM,QACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CAczB;IAED;;;;;OAKG;IACH,eAHW,kBAAkB,GAChB,MAAM,EAAE,GAAC,IAAI,CAUzB;IAED;;;;OAIG;IACH,YAJW,MAAM,OACN,MAAM,EAAE,GACN,OAAO,CAcnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,qBAJW,kBAAkB,GAChB,MAAM,CAiDlB;IAED;;;;;;;;OAQG;IACH,eAFW,UAAU,MAAM,CAAC,QAwC3B;CACJ;;;;;aAtrBa,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;;aACN,MAAM;;;;;WAEN,MAAM;;;;UAEN,MAAM;;;;;;WAKN,MAAM;;;;WACN,MAAM,EAAE;QACR,MAAM;;;;WACN,MAAM;;;;SACN,MAAM;;;;WACN,MAAM;;;;qBACN,MAAM;;;;UACN,MAAM;eACN,OAAO,4BAA4B,EAAE,mBAAmB;;;;WACxD,kBAAkB,GAAC,IAAI;;;;WACvB,kBAAkB,EAAE;;;;aACpB,kBAAkB,EAAE;;;;;;;UA0MpB,UAAU;;;;;WAEV,UAAU;;;;gBAEV,UAAU;;;;gBACV,MAAM;;yBA7RK,wCAAwC"}

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

@@ -176,10 +176,16 @@ export function particle_read_slots(read, lanes = read.lanes) {
  * instruction — which is also what lets a pass move a base or fold a swizzle without asking how the
  * result sits against the other operands.
  *
+ * The file is the one the CALLER asked for. It used to be the ISA ceiling regardless: every pass
+ * takes `context.register_slots` and every pass validates what it emits through here, so asking
+ * for 48 slots and getting an instruction that names slot 200 passed the one check the passes lean
+ * on, and a reduced register file was not enforced anywhere in the pipeline.
+ *
  * @param {ArrayLike<number>} words the four words of a single instruction
+ * @param {number} [register_slots] size of the file to measure against
  * @returns {boolean}
  */
-export function particle_instruction_is_well_formed(words) {
+export function particle_instruction_is_well_formed(words, register_slots = PARTICLE_VM_REGISTER_SLOTS) {
     if (vm_kinds_problem(words, 0) !== null) {
         return false;
     }
@@ -188,7 +194,7 @@ export function particle_instruction_is_well_formed(words) {
     const runs = decoded.write === null ? decoded.reads : [decoded.write, ...decoded.reads];
 
     for (const run of runs) {
-        if (run.base < 0 || run.base + run.span > PARTICLE_VM_REGISTER_SLOTS) {
+        if (run.base < 0 || run.base + run.span > register_slots) {
             return false;
         }
     }
@@ -362,7 +368,7 @@ export function analyze_particle_lanes(decoded, register_slots = PARTICLE_VM_REG
         }
 
         for (const read of instruction.reads) {
-            for (const slot of particle_read_slots(read, operation_width)) {
+            for (const slot of particle_read_slots(read, operation_width)) {
                 if (slot < register_slots) {
                     live[slot] = 1;
                 }
@@ -715,20 +721,20 @@ export class ParticleValueNumbering {
         /** Gathered before anything is written: a source may alias the destination. */
         const lanes = new Array(span);
 
-        // A copy carries values only from a REGISTER source. A literal is a value the file never
-        // held, so a MOV from one mints — and its word is not the slot it would otherwise be
-        // read as.
-        const source = instruction.op === VM_OP.MOV && instruction.sources[0].kind === VM_KIND.REG
-            ? instruction.sources[0]
-            : null;
-
-        for (let lane = 0; lane < span; lane++) {
-            const from = source === null ? -1 : vm_operand_slot(source.word, lane);
-
-            lanes[lane] = from >= 0 && from < this.slots
-                ? { id: this.value_id[from], home: this.home[from], producer: this.producer[from] }
-                : { id: this.next_id++, home: base + lane, producer: publish };
-        }
+        // A copy carries values only from a REGISTER source. A literal is a value the file never
+        // held, so a MOV from one mints — and its word is not the slot it would otherwise be
+        // read as.
+        const source = instruction.op === VM_OP.MOV && instruction.sources[0].kind === VM_KIND.REG
+            ? instruction.sources[0]
+            : null;
+
+        for (let lane = 0; lane < span; lane++) {
+            const from = source === null ? -1 : vm_operand_slot(source.word, lane);
+
+            lanes[lane] = from >= 0 && from < this.slots
+                ? { id: this.value_id[from], home: this.home[from], producer: this.producer[from] }
+                : { id: this.next_id++, home: base + lane, producer: publish };
+        }
 
         for (let lane = 0; lane < span; lane++) {
             const slot = base + lane;

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

@@ -1 +1 @@
-{"version":3,"file":"particle_vm_semantics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_vm_semantics.js"],"names":[],"mappings":"AA4IA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAW/B;AA1JD;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,+CAA+C;AAC/C,2BADW,IAAI,MAAM,EAAE,mBAAmB,CAAC,CACL;;;;;;;kBA1BxB,OAAO;;;;;cAGP,OAAO;;;;;;gBAEP,OAAO;;;;;;eAGP,OAAO;;;;;;;;cAGP,OAAO;;;;;;;;;;sBAKP,OAAO"}
+{"version":3,"file":"particle_vm_semantics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_vm_semantics.js"],"names":[],"mappings":"AAkJA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAW/B;AAhKD;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,+CAA+C;AAC/C,2BADW,IAAI,MAAM,EAAE,mBAAmB,CAAC,CACL;;;;;;;kBA1BxB,OAAO;;;;;cAGP,OAAO;;;;;;gBAEP,OAAO;;;;;;eAGP,OAAO;;;;;;;;cAGP,OAAO;;;;;;;;;;sBAKP,OAAO"}

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

@@ -89,11 +89,17 @@ semantics(VM_OP.ADD, EXACT);
 semantics(VM_OP.SUB, EXACT);
 semantics(VM_OP.MUL, EXACT);
 semantics(VM_OP.DIV, EXACT);
-// `a * b + c` is one rounding on hardware that contracts it into an FMA and two in the reference.
+// The reference leaves the product unrounded — it models the fused form — and the shader spells
+// `a * b + c`, which a driver may contract into an FMA or may round in between. The two executors
+// agree exactly on the first reading and not on the second, and nothing in WGSL says which one a
+// device takes.
 semantics(VM_OP.MAD, INEXACT);
 semantics(VM_OP.MIN, EXACT);
 semantics(VM_OP.MAX, EXACT);
-// The reference spells it `a + (b - a) * t`; WGSL's `mix` is free to round it differently.
+// The reference now spells it as WGSL defines it, `a * (1 - t) + b * t`, rather than as the lerp
+// `a + (b - a) * t` — those are different numbers, not different roundings, wherever the span
+// `b - a` overflows or swallows an end. What is left is that a driver may contract either product
+// with the sum, which is the same slack `MAD` has.
 semantics(VM_OP.MIX, INEXACT);
 semantics(VM_OP.CLAMP, EXACT);
 

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

@@ -302,7 +302,7 @@ function allocate_once(instructions, slots) {
             );
         }
 
-        if (!particle_instruction_is_well_formed(words)) {
+        if (!particle_instruction_is_well_formed(words, slots)) {
             return null;
         }
 

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

@@ -1 +1 @@
-{"version":3,"file":"pass_fold_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_fold_constants.js"],"names":[],"mappings":"AAyF4B,sJAEwD;AAuJpF;;;;;;;;;;GAUG;AACH,gDANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAmElB;AA9SD,qBAAqB;AACrB,2CADW,MAAM,CAC4C;AAE7D;;;;;GAKG;AACH,0CAFU,IAAI,MAAM,CAAC,CAE2C"}
+{"version":3,"file":"pass_fold_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_fold_constants.js"],"names":[],"mappings":"AAyF4B,sJAEwD;AAuJpF;;;;;;;;;;GAUG;AACH,gDANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAyElB;AApTD,qBAAqB;AACrB,2CADW,MAAM,CAC4C;AAE7D;;;;;GAKG;AACH,0CAFU,IAAI,MAAM,CAAC,CAE2C"}