@woosh/meep-engine 3.19.0 → 3.21.0

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

@@ -156,8 +156,7 @@ export function vm_repack_instruction(words: ArrayLike<number>): number[];
  * @property {number} slot source slot, `0..2`
  * @property {number} kind a {@link VM_KIND}, never `NONE`
  * @property {number} word the source word as encoded
- * @property {number} lanes how many lanes the instruction reads of it: the operation's width, or one
- *   for a slot the ISA marks scalar
+ * @property {number} lanes how many lanes the instruction reads of it: the operation's width
  * @property {number} span register slots the operand reaches from its base, for a register; `0` for a
  *   literal
  */
@@ -165,9 +164,8 @@ export function vm_repack_instruction(words: ArrayLike<number>): number[];
  * Visit every source operand of an instruction — every slot whose kind is not `NONE` — with how
  * many lanes the opcode reads of it and how far into the file it reaches.
  *
- * The rules for the reach are not uniform and live here rather than in each caller: a source is
- * read as wide as the operation runs unless the ISA marks that slot scalar, and a register operand
- * reaches as far as its widest selector among the lanes read.
+ * A source is read as wide as the operation runs, and a register operand reaches as far as its
+ * widest selector among the lanes read.
  *
  * @param {ArrayLike<number>} words an instruction stream
  * @param {number} base index of the instruction's first word
@@ -229,7 +227,7 @@ export function vm_register_kinds(op: number): number;
  * A source word means what its kind says — see {@link VM_KIND}:
  *
  * - `NONE`: not an operand the VM resolves — an unused slot, or a raw field the opcode reads for
- *   itself: an attribute offset, a component count, a builtin id, a curve handle, a pool index.
+ *   itself: an attribute offset, a component count, a builtin id, a pool index.
  * - `REG`: a register operand. Bits 0..7 are the first slot, bits 8..15 a swizzle — see below.
  * - `IMM`: the word IS the `f32` bit pattern of a literal, read in every lane. A scalar or a
  *   lane-uniform vector costs no register and no load; only a vector whose lanes differ still goes
@@ -278,7 +276,6 @@ export namespace VM_OPERAND {
     let ATTR_OFFSET: string;
     let COMP: string;
     let BUILTIN: string;
-    let CURVE: string;
 }
 /**
  * Builtin inputs the host shader assembles per-invocation and the VM reads via `LOAD_BUILTIN`.
@@ -306,58 +303,57 @@ export const VM_BUILTIN_COMPONENTS: {
 };
 /**
  * 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 and the numbers stay unused.
+ * `SWIZZLE`; both are spelled by an operand swizzle now. 61 was the animation-table sampler.
+ * These numbers stay unused.
  */
 export type VM_OP = number;
 export namespace VM_OP {
-    export let HALT: number;
-    export let NOP: number;
-    export let MOV: number;
-    export let LOAD_CONST: number;
-    export let LOAD_ATTR: number;
-    export let STORE_ATTR: number;
-    export let LOAD_BUILTIN: number;
-    export let KILL: number;
-    export let ADD: number;
-    export let SUB: number;
-    export let MUL: number;
-    export let DIV: number;
-    export let MAD: number;
-    export let MIN: number;
-    export let MAX: number;
-    export let MIX: number;
-    export let CLAMP: number;
-    export let NEG: number;
-    export let ABS: number;
-    export let FLOOR: number;
-    export let FRACT: number;
-    export let SQRT: number;
-    export let SIN: number;
-    export let COS: number;
-    export let EXP: number;
-    export let LOG: number;
-    export let POW: number;
-    export let STEP: number;
-    export let SMOOTHSTEP: number;
-    export let RSQRT: number;
-    export let TAN: number;
-    export let ASIN: number;
-    export let ACOS: number;
-    export let ATAN2: number;
-    export let DOT: number;
-    export let CROSS: number;
-    export let LENGTH: number;
-    export let NORMALIZE: number;
-    export let DISTANCE: number;
-    export let CMP_LT: number;
-    export let CMP_LE: number;
-    export let CMP_GT: number;
-    export let CMP_GE: number;
-    export let CMP_EQ: number;
-    export let SELECT: number;
-    export let RANDOM: number;
-    let CURVE_1: number;
-    export { CURVE_1 as CURVE };
+    let HALT: number;
+    let NOP: number;
+    let MOV: number;
+    let LOAD_CONST: number;
+    let LOAD_ATTR: number;
+    let STORE_ATTR: number;
+    let LOAD_BUILTIN: number;
+    let KILL: number;
+    let ADD: number;
+    let SUB: number;
+    let MUL: number;
+    let DIV: number;
+    let MAD: number;
+    let MIN: number;
+    let MAX: number;
+    let MIX: number;
+    let CLAMP: number;
+    let NEG: number;
+    let ABS: number;
+    let FLOOR: number;
+    let FRACT: number;
+    let SQRT: number;
+    let SIN: number;
+    let COS: number;
+    let EXP: number;
+    let LOG: number;
+    let POW: number;
+    let STEP: number;
+    let SMOOTHSTEP: number;
+    let RSQRT: number;
+    let TAN: number;
+    let ASIN: number;
+    let ACOS: number;
+    let ATAN2: number;
+    let DOT: number;
+    let CROSS: number;
+    let LENGTH: number;
+    let NORMALIZE: number;
+    let DISTANCE: number;
+    let CMP_LT: number;
+    let CMP_LE: number;
+    let CMP_GT: number;
+    let CMP_GE: number;
+    let CMP_EQ: number;
+    let SELECT: number;
+    let RANDOM: number;
 }
 /**
  * How an opcode reads the instruction's width field — the lane count it operates on.
@@ -431,7 +427,7 @@ export const VM_OPERAND_SWIZZLE_SHIFT: number;
  *
  * Keyed by opcode number. Used by the assembler for validation/disassembly and by the parity
  * meta-test to enforce that every opcode is handled by both executors.
- * @type {Map<number, {name: string, dst: boolean, operands: [string, string, string], width: string, dest: string, default_width: number, min_width: number, scalar_operands: number[]}>}
+ * @type {Map<number, {name: string, dst: boolean, operands: [string, string, string], width: string, dest: string, default_width: number, min_width: number}>}
  */
 export const VM_ISA: Map<number, {
     name: string;
@@ -441,7 +437,6 @@ export const VM_ISA: Map<number, {
     dest: string;
     default_width: number;
     min_width: number;
-    scalar_operands: number[];
 }>;
 export type ParticleVMOperand = {
     /**
@@ -457,8 +452,7 @@ export type ParticleVMOperand = {
      */
     word: number;
     /**
-     * how many lanes the instruction reads of it: the operation's width, or one
-     * for a slot the ISA marks scalar
+     * how many lanes the instruction reads of it: the operation's width
      */
     lanes: number;
     /**

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":"AA+QA;;;;;;;;GAQG;AACH,oCANW,MAAM,SACN,MAAM,OACN,MAAM,SACN,MAAM,GACJ,MAAM,CASlB;AAED;;;;;;;GAOG;AACH,kCALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAQlB;AAED,qDAAqD;AACrD,oCADY,MAAM,GAAkB,MAAM,CAGzC;AAED,yDAAyD;AACzD,uCADY,MAAM,GAAkB,MAAM,CAGzC;AAED,mEAAmE;AACnE,qCADY,MAAM,GAAkB,MAAM,CAGzC;AAED,kFAAkF;AAClF,uCADY,MAAM,GAAkB,MAAM,CAGzC;AAED;;;;GAIG;AACH,sCAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;AAED,uDAAuD;AACvD,uDADc,MAAM,CAGnB;AAED,6DAA6D;AAC7D,mDADc,MAAM,CAGnB;AAED,+DAA+D;AAC/D,gEADc,MAAM,CAKnB;AAID;;;;;;;;;GASG;AACH,gCANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,0CAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;AAcD;;;;;;;;;;GAUG;AACH,kCAJW,MAAM,YACN,MAAM,GACJ,MAAM,CAIlB;AAED,8EAA8E;AAC9E,sCADY,MAAM,GAAoC,MAAM,CAG3D;AAED,+GAA+G;AAC/G,yCADY,MAAM,GAAoC,MAAM,CAG3D;AAED;;;;GAIG;AACH,sCAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;AAED,+EAA+E;AAC/E,4DADc,MAAM,CAGnB;AAED;;;;;;;GAOG;AACH,sCAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;GASG;AACH,4CAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAoBlB;AAUD,wFAAwF;AACxF,mCADY,MAAM,GAAkB,MAAM,CAKzC;AAED,sEAAsE;AACtE,mCADY,MAAM,GAAiB,MAAM,CAKxC;AAED;;;;;GAKG;AACH,oCAHW,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAIxC;AAID;;;;;;GAMG;AACH,uCAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAelB;AAED;;;;;GAKG;AACH,kCAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAclB;AA6HD;;;;;;;;;;;;;;;GAeG;AACH,wCAPW,MAAM,SACN,MAAM,OACN,MAAM,SACN,MAAM,EAAE,WACR,MAAM,EAAE,GACN,MAAM,EAAE,CAgBpB;AAED;;;;;GAKG;AACH,6CAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAYpB;AAID;;;;;;;;;GASG;AAEH;;;;;;;;;;;;GAYG;AACH,yCALW,UAAU,MAAM,CAAC,QACjB,MAAM,gBACG,iBAAiB,KAAE,IAAI,QAgC1C;AAED;;;;;;;;;GASG;AACH,8CAJW,UAAU,MAAM,CAAC,QACjB,MAAM,gBACG,MAAM,QAAE,MAAM,KAAE,IAAI,QAgBvC;AAED;;;;;;;;GAQG;AACH,wCAJW,UAAU,MAAM,CAAC,QACjB,MAAM,GACJ,MAAM,GAAC,IAAI,CA4BvB;AAED;;;;;;GAMG;AACH,sCAHW,MAAM,GACJ,MAAM,CAclB;AAj2BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH,8FAA8F;AAC9F,4CADoF,MAAM,CAC3C;;;;;yBAKrC,MAAM;;;;;;;;;;;;;yBAqBN,MAAM;;;;;;;;;;;AAwBhB;;;;;;GAMG;AACH;QAFiB,MAAM,GAAE,MAAM;EAW5B;;;;;oBAKO,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA2DN,MAAM;;;;;;;;;;;sBAeN,MAAM;;;;;;;;AAWhB;;;;GAIG;AACH,2BAFU,MAAM,CAEc;AAI9B,8DAA8D;AAC9D,yBADoD,MAAM,CAC3B;AAE/B,gEAAgE;AAChE,6BADsD,MAAM,CAC5B;AAEhC,gFAAgF;AAChF,4BADsE,MAAM,CAC3C;;;;sBAIvB,MAAM;;;;;;;;AAWhB;;;;GAIG;AACH,4BAFU,MAAM,CAEgB;AAEhC,0CAA0C;AAC1C,2BADgC,MAAM,CACR;AAE9B,uEAAuE;AACvE,2BAD6D,MAAM,CACnC;AAKhC,yEAAyE;AACzE,2BAD+D,MAAM,CACtC;AAE/B,+FAA+F;AAC/F,0BADqF,MAAM,CAC3D;AA2GhC,uEAAuE;AACvE,kCAD6D,MAAM,CACP;AAE5D,2EAA2E;AAC3E,mCADiE,MAAM,CACV;AAE7D,kFAAkF;AAClF,mCADwE,MAAM,CACrC;AAEzC,kFAAkF;AAClF,uCADwE,MAAM,CACpC;AA0K1C;;;;;;GAMG;AACH,qBAFU,IAAI,MAAM,EAAE;IAAC,MAAM,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,EAAE,CAAA;CAAC,CAAC,CAEzJ;;;;;UAuKlB,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;;WACN,MAAM;;;;;UAEN,MAAM"}
+{"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

@@ -23,7 +23,7 @@
  * A source word means what its kind says — see {@link VM_KIND}:
  *
  * - `NONE`: not an operand the VM resolves — an unused slot, or a raw field the opcode reads for
- *   itself: an attribute offset, a component count, a builtin id, a curve handle, a pool index.
+ *   itself: an attribute offset, a component count, a builtin id, a pool index.
  * - `REG`: a register operand. Bits 0..7 are the first slot, bits 8..15 a swizzle — see below.
  * - `IMM`: the word IS the `f32` bit pattern of a literal, read in every lane. A scalar or a
  *   lane-uniform vector costs no register and no load; only a vector whose lanes differ still goes
@@ -80,8 +80,6 @@ export const VM_OPERAND = {
     COMP: "comp",
     /** builtin id (see {@link VM_BUILTIN}) */
     BUILTIN: "builtin",
-    /** curve handle (row index into the animation-curve table) */
-    CURVE: "curve",
 };
 
 /**
@@ -130,7 +128,8 @@ export const VM_BUILTIN_COMPONENTS = Object.freeze({
 
 /**
  * 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 and the numbers stay unused.
+ * `SWIZZLE`; both are spelled by an operand swizzle now. 61 was the animation-table sampler.
+ * These numbers stay unused.
  * @enum {number}
  */
 export const VM_OP = {
@@ -185,7 +184,6 @@ export const VM_OP = {
     SELECT: 55,
 
     RANDOM: 60,
-    CURVE: 61,
 };
 
 /**
@@ -559,7 +557,7 @@ const _ = VM_OPERAND.NONE;
  *
  * Keyed by opcode number. Used by the assembler for validation/disassembly and by the parity
  * meta-test to enforce that every opcode is handled by both executors.
- * @type {Map<number, {name: string, dst: boolean, operands: [string, string, string], width: string, dest: string, default_width: number, min_width: number, scalar_operands: number[]}>}
+ * @type {Map<number, {name: string, dst: boolean, operands: [string, string, string], width: string, dest: string, default_width: number, min_width: number}>}
  */
 export const VM_ISA = new Map();
 
@@ -575,7 +573,6 @@ export const VM_ISA = new Map();
  * @param {string} [options.dest] see {@link VM_DEST}; as wide as the operation unless it reduces
  * @param {number} [options.default_width] width the assembler uses when the text does not say
  * @param {number} [options.min_width] narrowest the opcode is meaningful at
- * @param {number[]} [options.scalar_operands] source slots read as a single lane whatever the width
  */
 function def(op, name, dst, s0 = _, s1 = _, s2 = _, options = {}) {
     if (VM_ISA.has(op)) {
@@ -603,7 +600,6 @@ function def(op, name, dst, s0 = _, s1 = _, s2 = _, options = {}) {
         dest,
         default_width,
         min_width: options.min_width ?? 1,
-        scalar_operands: options.scalar_operands ?? [],
     });
 }
 
@@ -669,8 +665,6 @@ def(VM_OP.SELECT, "SELECT", true, R, R, R);
 // One independent uniform draw in `[0, 1)` per lane, and nothing else: a shaped distribution is
 // arithmetic a program writes over this draw — see ../graph/particle_graph_distributions.js.
 def(VM_OP.RANDOM, "RANDOM", true);
-// `t` is one lane; the sampled value fills the destination's width.
-def(VM_OP.CURVE, "CURVE", true, VM_OPERAND.CURVE, R, _, { scalar_operands: [1] });
 
 // --- packing an instruction ---------------------------------------------------------------------
 
@@ -699,7 +693,7 @@ export function vm_pack_instruction(op, width, dst, kinds, sources) {
         const word = sources[slot] >>> 0;
 
         words[1 + slot] = kinds[slot] === VM_KIND.REG && meta !== undefined
-            ? vm_canonical_register(word, meta.scalar_operands.includes(slot) ? 1 : operation_width)
+            ? vm_canonical_register(word, operation_width)
             : word;
     }
 
@@ -731,8 +725,7 @@ export function vm_repack_instruction(words) {
  * @property {number} slot source slot, `0..2`
  * @property {number} kind a {@link VM_KIND}, never `NONE`
  * @property {number} word the source word as encoded
- * @property {number} lanes how many lanes the instruction reads of it: the operation's width, or one
- *   for a slot the ISA marks scalar
+ * @property {number} lanes how many lanes the instruction reads of it: the operation's width
  * @property {number} span register slots the operand reaches from its base, for a register; `0` for a
  *   literal
  */
@@ -741,9 +734,8 @@ export function vm_repack_instruction(words) {
  * Visit every source operand of an instruction — every slot whose kind is not `NONE` — with how
  * many lanes the opcode reads of it and how far into the file it reaches.
  *
- * The rules for the reach are not uniform and live here rather than in each caller: a source is
- * read as wide as the operation runs unless the ISA marks that slot scalar, and a register operand
- * reaches as far as its widest selector among the lanes read.
+ * A source is read as wide as the operation runs, and a register operand reaches as far as its
+ * widest selector among the lanes read.
  *
  * @param {ArrayLike<number>} words an instruction stream
  * @param {number} base index of the instruction's first word
@@ -770,7 +762,7 @@ export function vm_visit_operands(words, base, visit) {
         }
 
         const word = words[base + 1 + slot];
-        const lanes = meta.scalar_operands.includes(slot) ? 1 : operation_width;
+        const lanes = operation_width;
 
         operand.slot = slot;
         operand.kind = kind;

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

@@ -99,7 +99,6 @@ export function assemble_particle_program(text: string): ParticleProgram;
  * | attribute word offset | `@<word>` | `@7` |
  * | attribute component count | a bare integer `1..4` | `3` |
  * | builtin | a {@link VM_BUILTIN} name | `EMITTER_POSITION` |
- * | curve handle | `k<handle>` | `k2` |
  *
  * A register source's selectors say which lane of the value each lane of the instruction reads, one
  * letter of `xyzw` per lane the instruction spans; left off, lane `c` reads lane `c`. A literal is

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

@@ -1 +1 @@
-{"version":3,"file":"particle_assembly.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/particle_assembly.js"],"names":[],"mappings":"AA0KA;;;;;;;;GAQG;AAMH;;;;;;;;;;;GAWG;AACH,sDALW,eAAe;IAEE,MAAM,GAAvB,MAAM;IACJ,MAAM,CAmClB;AA0JD;;;;;;;;;;;GAWG;AACH,8CAHW,MAAM;aACM,eAAe,GAAC,IAAI;iBAAe,0BAA0B,EAAE;EA8IrF;AAED;;;;;;;;GAQG;AACH,gDAJW,MAAM,GACJ,eAAe,CAkB3B;AAjhBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH,oEAAoE;AACpE,6CAD0D,MAAM,CACV;AAEtD,sEAAsE;AACtE,+CAD4D,MAAM,CACR;AAE1D,+DAA+D;AAC/D,oDADqD,MAAM,CACO;AAElE,kEAAkE;AAClE,gDADwD,MAAM,CACJ;AAE1D,iEAAiE;AACjE,iDADuD,MAAM,CACP;AAEtD;;;;;GAKG;AACH,gDAFU,MAAM,CAEqC;AAErD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEoC;;;;;;;;;;UA+CtC,MAAM;aACN,MAAM;;;;;;UA+hBN,MAAM;;;;UACN,MAAM;;;;gBACN,MAAM;;;;YACN,MAAM;;gCA7sBY,sBAAsB"}
+{"version":3,"file":"particle_assembly.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/particle_assembly.js"],"names":[],"mappings":"AAyKA;;;;;;;;GAQG;AAMH;;;;;;;;;;;GAWG;AACH,sDALW,eAAe;IAEE,MAAM,GAAvB,MAAM;IACJ,MAAM,CAmClB;AAwJD;;;;;;;;;;;GAWG;AACH,8CAHW,MAAM,GACJ;IAAC,OAAO,EAAE,eAAe,GAAC,IAAI,CAAC;IAAC,WAAW,EAAE,0BAA0B,EAAE,CAAA;CAAC,CA8ItF;AAED;;;;;;;;GAQG;AACH,gDAJW,MAAM,GACJ,eAAe,CAkB3B;AA9gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,oEAAoE;AACpE,6CAD0D,MAAM,CACV;AAEtD,sEAAsE;AACtE,+CAD4D,MAAM,CACR;AAE1D,+DAA+D;AAC/D,oDADqD,MAAM,CACO;AAElE,kEAAkE;AAClE,gDADwD,MAAM,CACJ;AAE1D,iEAAiE;AACjE,iDADuD,MAAM,CACP;AAEtD;;;;;GAKG;AACH,gDAFU,MAAM,CAEqC;AAErD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEoC;;;;;;;;;;UA+CtC,MAAM;aACN,MAAM;;;;;;UA6hBN,MAAM;;;;UACN,MAAM;;;;gBACN,MAAM;;;;YACN,MAAM;;gCA1sBY,sBAAsB"}

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

@@ -81,7 +81,6 @@ import {
  * | attribute word offset | `@<word>` | `@7` |
  * | attribute component count | a bare integer `1..4` | `3` |
  * | builtin | a {@link VM_BUILTIN} name | `EMITTER_POSITION` |
- * | curve handle | `k<handle>` | `k2` |
  *
  * A register source's selectors say which lane of the value each lane of the instruction reads, one
  * letter of `xyzw` per lane the instruction spans; left off, lane `c` reads lane `c`. A literal is
@@ -268,7 +267,7 @@ function disassemble_instruction(words, base) {
         } else if (vm_decode_kind(word0, slot) === VM_KIND.IMM) {
             operands.push(`${PARTICLE_ASSEMBLY_IMMEDIATE_PREFIX}${format_float(vm_f32_value(word))}`);
         } else {
-            operands.push(format_register(word, meta.scalar_operands.includes(slot) ? 1 : operation_width));
+            operands.push(format_register(word, operation_width));
         }
     }
 
@@ -337,8 +336,6 @@ function format_operand(role, value) {
             return String(value);
         case VM_OPERAND.BUILTIN:
             return BUILTIN_NAME_BY_ID.get(value) ?? String(value);
-        case VM_OPERAND.CURVE:
-            return `k${value}`;
         default:
             return String(value);
     }
@@ -809,7 +806,7 @@ function parse_instruction(line, line_number, report) {
 
     for (let slot = 0; slot < sources.length; slot++) {
         const source = sources[slot];
-        const lanes = meta.scalar_operands.includes(slot) ? 1 : operation_width;
+        const lanes = operation_width;
 
         if (source.kind === VM_KIND.REG && source.selectors !== undefined && source.selectors > 0 && source.selectors !== lanes) {
             report(
@@ -1090,17 +1087,6 @@ function parse_plain_operand(role, token, line_number, report) {
             return id === null ? null : { kind: VM_KIND.NONE, word: id };
         }
 
-        case VM_OPERAND.CURVE: {
-            const handle = parse_prefixed(token, "k");
-
-            if (handle === null) {
-                report(line_number, `Expected a curve handle like 'k0', got '${token}'`);
-                return null;
-            }
-
-            return { kind: VM_KIND.NONE, word: handle };
-        }
-
         default:
             report(line_number, `Unsupported operand role '${role}'`);
             return null;

package/src/shade/renderer/particles/layout/ParticleLayout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/layout/ParticleLayout.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAcI;;;;OAIG;IACH,wBAJW,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,EAyClE;IAtDD;;;OAGG;IACH,YAFU,IAAI,MAAM,EAAE;QAAC,MAAM,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,SAAS,CAAA;KAAC,CAAC,CAE1E;IAEvB;;;OAGG;IACH,aAFU,MAAM,CAE8B;IA8C9C;;;OAGG;IACH,UAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ;QAAC,MAAM,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAQ9D;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,cAHW,cAAc,GACZ,OAAO,CA8BnB;IAED;;;;;;;;;OASG;IACH,QAFa,MAAM,CAclB;CACJ"}
+{"version":3,"file":"ParticleLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/layout/ParticleLayout.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAcI;;;;OAIG;IACH,wBAJW,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,EAyClE;IAtDD;;;OAGG;IACH,YAFU,IAAI,MAAM,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,SAAS,CAAA;KAAC,CAAC,CAE1E;IAEvB;;;OAGG;IACH,aAFU,MAAM,CAE8B;IA8C9C;;;OAGG;IACH,UAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAQ9D;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,cAHW,cAAc,GACZ,OAAO,CA8BnB;IAED;;;;;;;;;OASG;IACH,QAFa,MAAM,CAclB;CACJ"}

package/src/shade/renderer/particles/optimizer/dag/particle_vector_graph.d.ts

@@ -124,7 +124,7 @@ export type ParticleVectorNode = {
      */
     patterns: number[];
     /**
-     * static fields: literal bits, a record word, a builtin id, a curve handle,
+     * static fields: literal bits, a record word, a builtin id,
      * the first draw of a `RANDOM`
      */
     imm: number[];

package/src/shade/renderer/particles/optimizer/dag/particle_vector_graph.js

@@ -66,7 +66,7 @@ export const PV = {
  * @property {number[]} children the values its sources read, one per source
  * @property {number[]} patterns per source, the swizzle it reads that value through — or, for
  *   `BUILD`, the single lane it takes
- * @property {number[]} imm static fields: literal bits, a record word, a builtin id, a curve handle,
+ * @property {number[]} imm static fields: literal bits, a record word, a builtin id,
  *   the first draw of a `RANDOM`
  */
 

package/src/shade/renderer/particles/optimizer/dag/particle_vector_lift.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_vector_lift.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_lift.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,oDARW,OAAO,4BAA4B,EAAE,mBAAmB,gBACxD,UAAU,UAAU,MAAM,CAAC,CAAC;IAEF,SAAS,EAAnC,UAAU,MAAM,CAAC;IACF,cAAc,EAA7B,MAAM;IACJ,2BAA2B,GAAC,IAAI,CAgK5C;AAED;;;;;;;;;;GAUG;AACH,4BAJW,OAAO,4BAA4B,EAAE,mBAAmB,UACxD,mBAAmB,EAAE,GACnB;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAmB5C;;;;;WAlNa,MAAM;;;;UACN,MAAM;;;;;;;YAKN,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,mBAAmB,CAAC;QAAC,QAAQ,MAAM,CAAA;KAAC,CAAC;;;;WAEjE,mBAAmB,EAAE;;;;gBACrB,MAAM;;;;WACN,MAAM,EAAE;;;;gBACR,MAAM,EAAE"}
+{"version":3,"file":"particle_vector_lift.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_lift.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,oDARW,OAAO,4BAA4B,EAAE,mBAAmB,gBACxD,UAAU,UAAU,MAAM,CAAC,CAAC;IAEF,SAAS,EAAnC,UAAU,MAAM,CAAC;IACF,cAAc,EAA7B,MAAM;IACJ,2BAA2B,GAAC,IAAI,CAgK5C;AAED;;;;;;;;;;GAUG;AACH,4BAJW,OAAO,4BAA4B,EAAE,mBAAmB,UACxD,mBAAmB,EAAE,GACnB;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAmB5C;;;;;WAlNa,MAAM;;;;UACN,MAAM;;;;;;;YAKN,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,mBAAmB,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC;;;;WAEjE,mBAAmB,EAAE;;;;gBACrB,MAAM;;;;WACN,MAAM,EAAE;;;;gBACR,MAAM,EAAE"}

package/src/shade/renderer/particles/optimizer/dag/particle_vector_lift.js

@@ -383,20 +383,6 @@ function evaluate(graph, instruction, operands, state) {
             return lanes_of(graph, value, dest);
         }
 
-        // Every lane is the same sample, so one lane holds it and a consumer reading it wide reads a
-        // broadcast.
-        case VM_OP.CURVE: {
-            const value = graph.make({
-                op,
-                width: 1,
-                children: [source(1).value],
-                patterns: [source(1).pattern],
-                imm: [words[1]],
-            });
-
-            return Array.from({ length: dest }, () => ({ value, lane: 0 }));
-        }
-
         default: {
             if (semantics.side_effects) {
                 return null;

package/src/shade/renderer/particles/optimizer/dag/particle_vector_pack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_vector_pack.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_pack.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,6CALW,OAAO,4BAA4B,EAAE,mBAAmB,WACxD,OAAO,2BAA2B,EAAE,2BAA2B,cAC/D,OAAO,8BAA8B,EAAE,uBAAuB,GAC5D,OAAO,6BAA6B,EAAE,oBAAoB,CA8OtE;AA4YD;;;;;;;GAOG;AACH,qCAHW,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,QAAQ,MAAM,CAAA;CAAC,CAAC,GACzE,MAAM,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,QAAQ,MAAM,CAAA;CAAC,CAAC,CAAC,CAsB9F;AAtaD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEiC"}
+{"version":3,"file":"particle_vector_pack.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_pack.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,6CALW,OAAO,4BAA4B,EAAE,mBAAmB,WACxD,OAAO,2BAA2B,EAAE,2BAA2B,cAC/D,OAAO,8BAA8B,EAAE,uBAAuB,GAC5D,OAAO,6BAA6B,EAAE,oBAAoB,CA8OtE;AA4YD;;;;;;;GAOG;AACH,qCAHW,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC,GACzE,MAAM,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,CAsB9F;AAtaD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEiC"}

package/src/shade/renderer/particles/optimizer/dag/particle_vector_pack.js

@@ -204,10 +204,10 @@ export function pack_particle_vectors(graph, section, extraction) {
 
         for (let source = 0; source < node.children.length; source++) {
             group.operands.push(operand(
-                slot_of(node, source),
+                source,
                 node.children[source],
                 node.patterns[source],
-                node.op === VM_OP.CURVE ? 1 : group.width,
+                group.width,
                 sequence
             ));
         }
@@ -695,7 +695,6 @@ export function chunk_stores(stores) {
 function raw_fields(node) {
     switch (node.op) {
         case VM_OP.LOAD_BUILTIN:
-        case VM_OP.CURVE:
             return [node.imm[0], -1, -1];
 
         default:
@@ -703,17 +702,6 @@ function raw_fields(node) {
     }
 }
 
-/**
- * @param {import("./particle_vector_graph.js").ParticleVectorNode} node
- * @param {number} source which of the node's sources
- * @returns {number} the instruction source slot it goes in
- */
-function slot_of(node, source) {
-    // `CURVE` takes its handle in slot 0 and the value it samples in slot 1; everything else fills
-    // its slots in order.
-    return node.op === VM_OP.CURVE ? source + 1 : source;
-}
-
 /**
  * How many lanes of each value anything actually reads.
  *
@@ -772,9 +760,7 @@ function measure_demand(graph, section, extraction) {
             continue;
         }
 
-        const reads = node.op === VM_OP.CURVE
-            ? 1
-            : Math.max(narrowable(node) ? width : node.operand_width, VM_ISA.get(node.op)?.min_width ?? 1);
+        const reads = Math.max(narrowable(node) ? width : node.operand_width, VM_ISA.get(node.op)?.min_width ?? 1);
 
         for (let source = 0; source < node.children.length; source++) {
             let highest = 0;

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

@@ -184,7 +184,7 @@ export type ParticleOptimizerContext = {
      * returns its first word index — {@link  ../isa/ParticleAssembler.js}'s `constant`. Without it a
      * pass can read the pool but not add to it, which only costs it the folds that need a new literal.
      */
-    intern_constant: (values: number[]) => number;
+    intern_constant: ((values: number[]) => number) | null;
     /**
      * size of the register file
      */

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

@@ -1 +1 @@
-{"version":3,"file":"optimize_particle_program.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/optimize_particle_program.js"],"names":[],"mappings":"AA+IA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,kDAxBW,iBAAiB;IAEW,SAAS,GAArC,UAAU,MAAM,CAAC;IAEoB,eAAe,UAA3C,MAAM,EAAE,KAAG,MAAM;IACM,MAAM,GAAtC,cAAc,MAAM,CAAC;IAEJ,cAAc,GAA/B,MAAM;IACY,SAAS,GAA3B,OAAO;IAGU,cAAc,GAA/B,MAAM;IACY,qBAAqB,GAAvC,OAAO;IACW,YAAY,GAA9B,OAAO;IACW,mBAAmB,GAArC,OAAO;IAEU,gBAAgB,GAAjC,MAAM;IACY,iBAAiB,GAAnC,OAAO;IACW,uBAAuB,GAAzC,OAAO;IACW,oBAAoB,GAAtC,OAAO;IACW,WAAW,GAA7B,OAAO;IACL,iBAAiB,CAqC7B;AAuFD;;;;;;GAMG;AACH,iDAHc,MAAM,KACP,MAAM,EAAE,CAIpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,mDAJW,eAAe,YACf,MAAM,GACJ,eAAe,CAsC3B;AAsFD;;;GAGG;AACH,yCAHW,WAAW,GACT,iBAAiB,CAU7B;AAnbD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH;;;;;GAKG;AAEH;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,wCAFU,MAAM;IAAC,MAAM,MAAM,CAAC;IAAC,GAAG,EAAE,qBAAqB,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAC,CAAC,CAwBrH;AAEF;;;;;;;;GAQG;AACH,gDAFU,cAAc,MAAM,CAAC,CAI7B;AAEF;;;;;;;;GAQG;AACH,oDAFU,MAAM,CAEuC;mDAnE5C,MAAM,EAAE,EAAE,WACV,wBAAwB,KACtB,MAAM,EAAE,EAAE,GAAC,IAAI;;;;;eAKd,UAAU,MAAM,CAAC;;;;;;8BACP,MAAM,EAAE,KAAK,MAAM;;;;oBAG7B,MAAM;;;;oBACN,MAAM;;kCApFc,6BAA6B;gCAE/B,2BAA2B"}
+{"version":3,"file":"optimize_particle_program.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/optimize_particle_program.js"],"names":[],"mappings":"AA+IA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,kDAxBW,iBAAiB;IAEW,SAAS,GAArC,UAAU,MAAM,CAAC;IAEoB,eAAe,UAA3C,MAAM,EAAE,KAAG,MAAM;IACM,MAAM,GAAtC,cAAc,MAAM,CAAC;IAEJ,cAAc,GAA/B,MAAM;IACY,SAAS,GAA3B,OAAO;IAGU,cAAc,GAA/B,MAAM;IACY,qBAAqB,GAAvC,OAAO;IACW,YAAY,GAA9B,OAAO;IACW,mBAAmB,GAArC,OAAO;IAEU,gBAAgB,GAAjC,MAAM;IACY,iBAAiB,GAAnC,OAAO;IACW,uBAAuB,GAAzC,OAAO;IACW,oBAAoB,GAAtC,OAAO;IACW,WAAW,GAA7B,OAAO;IACL,iBAAiB,CAqC7B;AAuFD;;;;;;GAMG;AACH,iDAHc,MAAM,KACP,MAAM,EAAE,CAIpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,mDAJW,eAAe,YACf,MAAM,GACJ,eAAe,CAsC3B;AAsFD;;;GAGG;AACH,yCAHW,WAAW,GACT,iBAAiB,CAU7B;AAnbD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH;;;;;GAKG;AAEH;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,wCAFU,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,qBAAqB,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAC,CAAC,CAwBrH;AAEF;;;;;;;;GAQG;AACH,gDAFU,cAAc,MAAM,CAAC,CAI7B;AAEF;;;;;;;;GAQG;AACH,oDAFU,MAAM,CAEuC;mDAnE5C,MAAM,EAAE,EAAE,WACV,wBAAwB,KACtB,MAAM,EAAE,EAAE,GAAC,IAAI;;;;;eAKd,UAAU,MAAM,CAAC;;;;;;qBACjB,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC,GAAC,IAAI;;;;oBAGnC,MAAM;;;;oBACN,MAAM;;kCApFc,6BAA6B;gCAE/B,2BAA2B"}

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,QAgD3B;CACJ;;;;;aArsBa,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;;;;;;;;;;;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"}

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

@@ -362,7 +362,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, particle_lanes_read_at(instruction, read, operation_width))) {
+            for (const slot of particle_read_slots(read, operation_width)) {
                 if (slot < register_slots) {
                     live[slot] = 1;
                 }
@@ -420,19 +420,6 @@ export function particle_peak_live_slots(decoded, register_slots = PARTICLE_VM_R
     return peak;
 }
 
-/**
- * How many lanes of a source an instruction reads once it is narrowed to `operation_width`: one for a
- * slot the ISA marks scalar, the width for everything else.
- *
- * @param {ParticleDecodedInstruction} instruction
- * @param {ParticleOperandRun} read
- * @param {number} operation_width
- * @returns {number}
- */
-function particle_lanes_read_at(instruction, read, operation_width) {
-    return instruction.meta.scalar_operands.includes(read.operand) ? 1 : operation_width;
-}
-
 /**
  * @param {number} base_a
  * @param {number} span_a
@@ -728,28 +715,20 @@ export class ParticleValueNumbering {
         /** Gathered before anything is written: a source may alias the destination. */
         const lanes = new Array(span);
 
-        if (instruction.semantics.broadcasts) {
-            // One value in every lane, so lane `i` is a copy of lane 0 and traces back to it — which
-            // is what lets a consumer read the scalar instead of the widened form.
-            const id = this.next_id++;
-
-            lanes.fill({ id, home: base, producer: publish });
-        } else {
-            // 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_program_equivalence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_program_equivalence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_equivalence.js"],"names":[],"mappings":"AA8GA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;;YACM,WAAW;YAAU,OAAO;eAAa,MAAM;EAgBrE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW;YACA,UAAU;YAAU,OAAO;EAkEhD;AAqCD;;;;;;;;;;;;;;GAcG;AACH,qDAVW;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,SACzD;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;IAErC,SAAS,GAA7B,MAAM;IACkD,KAAK,GAA7D;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI;IAIxC,MAAM,GAAC,IAAI,CAuCvB;AAED;;;;;;;;;;;;;;GAcG;AACH;IARkG,MAAM,EAA7F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACS,KAAK,EAA5F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACvD,YAAY,GAAnC,MAAM,MAAM,CAAC;IACG,UAAU,GAA1B,MAAM;IAGJ,MAAM,GAAC,IAAI,CAqBvB;AAED;;;;;;;GAOG;AACH,qGAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB;AAtRD;;;;;GAKG;AACH,oCAFU,MAAM;IAAC,MAAM,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAA;CAAC,CAAC,CAOjG"}
+{"version":3,"file":"particle_program_equivalence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_equivalence.js"],"names":[],"mappings":"AA2GA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;IACJ;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAevE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW,GACT;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,CAkEjD;AAqCD;;;;;;;;;;;;;;GAcG;AACH,qDAVW;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,SACzD;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;IAErC,SAAS,GAA7B,MAAM;IACkD,KAAK,GAA7D;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI;IAIxC,MAAM,GAAC,IAAI,CAuCvB;AAED;;;;;;;;;;;;;;GAcG;AACH;IARkG,MAAM,EAA7F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACS,KAAK,EAA5F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACvD,YAAY,GAAnC,MAAM,MAAM,CAAC;IACG,UAAU,GAA1B,MAAM;IAGJ,MAAM,GAAC,IAAI,CAqBvB;AAED;;;;;;;GAOG;AACH,qGAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB;AArRD;;;;;GAKG;AACH,oCAFU,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAA;CAAC,CAAC,CAOjG"}

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

@@ -56,7 +56,7 @@ import { PARTICLE_ZERO_ABSORBING_OPS } from "./pass_fold_constants.js";
  *
  * ## Environments
  *
- * A program reads more than its constants — record words, builtins, the RNG, curve samples — and a
+ * A program reads more than its constants — record words, builtins, the RNG — and a
  * pass that mishandled any of those could still agree on a single run. {@link PARTICLE_ENVIRONMENTS}
  * varies all of them, including a record pre-filled with values a `LOAD_ATTR` can pick up.
  */
@@ -92,9 +92,6 @@ function seeded_record() {
     return record;
 }
 
-/** @param {number} handle @param {number} t @returns {number} */
-const sample_curve = (handle, t) => Math.sin(handle + t * 3) * 0.5 + handle * 0.125;
-
 /**
  * The contexts a program is compared in. Seeds differ so a pass that dropped or added a draw shows
  * up as a diverging RNG state rather than only as a diverging record.
@@ -128,7 +125,6 @@ export function run_particle_section({ words, constants, register_count, environ
         record,
         builtins: environment.builtins,
         rng_state: environment.rng_state,
-        sampleCurve: sample_curve,
     });
 
     return { record, killed: result.killed, rng_state: result.rng_state };

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

@@ -1 +1 @@
-{"version":3,"file":"particle_program_fuzz.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_fuzz.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;GAaG;AACH,oDAXuB,MAAM;IAED,WAAW,GAA5B,MAAM;IACY,IAAI,GAAtB,OAAO;IACW,MAAM,GAAxB,OAAO;IACU,cAAc,GAA/B,MAAM;oBAqHhB;AA8ED;;;;;;;;;;;;;;;;;;GAkBG;AACH,yDALuB,MAAM;IAED,MAAM,GAAvB,MAAM;oBAmEhB"}
+{"version":3,"file":"particle_program_fuzz.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_fuzz.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;GAaG;AACH,oDAXuB,MAAM;IAED,WAAW,GAA5B,MAAM;IACY,IAAI,GAAtB,OAAO;IACW,MAAM,GAAxB,OAAO;IACU,cAAc,GAA/B,MAAM;oBAqHhB;AAuED;;;;;;;;;;;;;;;;;;GAkBG;AACH,yDALuB,MAAM;IAED,MAAM,GAAvB,MAAM;oBAmEhB"}