@woosh/meep-engine 3.57.0 → 3.59.0

package/src/shade/renderer/particles/DESIGN.md

@@ -36,12 +36,13 @@ authoring:   NodeGraph (nodes+ports)      ──compile──▶  Program (bytec
              standard node library                       │
                                                          ▼
 runtime CPU: ParticleEmitter (at an entity) ── Scene ──▶ GPUSceneContext (transforms table)
-             EmitterRegistry ── GPUDatabase(emitters + emitter_state) ─┤  ProgramHeap ([header][constants][code])
+             EmitterRegistry ── GPUDatabase(emitters + emitter_state + field_bindings) ─┤  ProgramHeap ([header][constants][code][fields])
              GPUParticleSystem (owns every buffer, records the frame)
                                                          ▼
 runtime GPU: particle pool (array<u32>, uniform stride) + alive/dead lists + counters
              emitter state table (GPU-owned: generation, accumulator, age, sleep, pending)
-             ┌─ spawn commands (CPU bursts → pending)
+             ┌─ field bind (per binding row: a bound transform → its field; only while rows exist)
+             ├─ spawn commands (CPU bursts → pending)
              ├─ emitter tick  (per row: cull on the published box, integrate rate, take budget → count)
              ├─ scan (csdldf) → emit dispatch
              ├─ emit  (VM INIT program)   ── per newborn: find emitter in scan, pop dead → init → append alive_new
@@ -56,13 +57,113 @@ runtime GPU: particle pool (array<u32>, uniform stride) + alive/dead lists + cou
              └─ draw      (instanced billboard quads → the four accumulators)
 ```
 
+### Vocabulary: fields
+
+State is a set of **fields**, named and laid out by a `ParticleLayout`, one kind per scope:
+`particle_field`s live in a particle's pool record, `emitter_field`s in its emitter's block and
+`global_field`s in the system's shared section. Particle fields were once called attributes, and
+saves under that name still load: graph node types `attribute` and `setAttribute`
+(`PARTICLE_NODE_TYPE_RENAMES`), a document's `attributes` key, and the assembly mnemonics `LOAD_ATTR`
+and `STORE_ATTR`. The binary effect format never wrote the word.
+
+### Emitter fields
+
+The program is a class and an emitter an instance of it. An effect declares **emitter fields** — an
+`emitter_layout`, a `ParticleLayout.emitter` packed from word zero with no fixed size — and every
+emitter of it carries its own values for them (`emitter_fields`, f32 bit patterns). Two emitters of
+one effect that differ only there share one program, one heap placement and one simulation bucket.
+
+- **Storage.** The packed program buffer's fourth section, after the code:
+  `[header][constants][code][fields]`, header word `PARTICLE_PROGRAM_FIELD_BASE_WORD` saying where it
+  starts. The section opens with `PARTICLE_GLOBAL_FIELD_WORDS` reserved for global fields; each
+  emitter's block is an allocation of the same `OffsetAllocator` kind the other sections use, held
+  by its context as a `FieldBlock` and moved in place by a repack, which moves `placement_version`
+  because the record carries the block's offset (`field_offset`). The fields share the program
+  buffer's binding.
+- **Reading.** The engine's builtins are the emitter's members as the engine declares them, and an
+  effect's emitter fields are the members it declares, so they are read through the same
+  instruction: a `LOAD_BUILTIN` id from `VM_BUILTIN_EMITTER_FIELD_BASE` up reads the
+  instruction's width in words from the emitter's block, as `LOAD_CONST` reads the pool.
+  `vm_ctx.emitter_field_offset` is set beside `emitter_position` by `particle_setup_context`,
+  so emit, simulate and the warm-up all have it. The offset is per lane, as the emitter's position
+  is: a simulate wave is one program, not one emitter, so the read is a vector load where
+  `LOAD_CONST`'s is scalar. The plan's Outcome has what that costs.
+- **Writing.** The CPU's: gameplay writes the component's values in place, `apply_particle_effect`
+  finds the change by comparison and copies it to the emitter, and the registry writes the block
+  when it restages the row. The heap tracks the changed span, and `GPUParticleSystem` writes that
+  span into the existing buffer rather than rebuilding it.
+- **Authoring.** `ParticleEffectDocument.emitter_fields` declares them with the value an emitter
+  starts from; the `emitterField` node reads one. `ParticleEffect` serializes them at version 3.
+
+### Global fields
+
+The system's static members, read by every effect by name — `TIME` and `DELTA_TIME` are the
+engine's, a gust strength or the player's position a game's.
+
+- **Layout.** `ParticleGlobalFields`, owned by the heap: the union of what is loaded, append-only,
+  in the `PARTICLE_GLOBAL_FIELD_WORDS` reserved at the start of the field section, so a global field
+  is addressed from zero and never moves. A program placing a name the system does not have
+  declares it, zero-filled; a game may declare names first. A name is one field: a later reader may
+  not want more components than it was declared with.
+- **Refusal.** A program whose imports the layout cannot take is refused before anything is claimed
+  for it (`ParticleGlobalFields.check`): no id, range or declaration is left behind. The registry's
+  flush keeps the emitter on the program it had, with that program's emitter layout — its block,
+  values and bindings, even when the emitter's layout changed along with the refused program — and
+  does not offer the refused one again until it changes; `GPUParticleEmitterSystem` does the same for an effect it cannot register, and for a
+  global value set at a width the layout refuses, so one bad effect never stops the others.
+- **Linking.** A compiled program cannot know a scene's offsets, so it carries `global_imports`
+  (name and width, in the order it first reads them) and its global `LOAD_BUILTIN` ids are import
+  indices. `ProgramHeap` rewrites them to offsets as it copies the code into place
+  (`particle_link_global_fields`); the program it is keyed by stays unlinked, so deduplication
+  holds. Assembly carries imports as `.global name n`; the optimizers carry them through.
+- **Values.** The CPU's: `GPUParticleSystem.global_fields.set(name, values)` writes words and marks
+  the span, which goes out as one `writeBuffer`; nothing is restaged and no program changes. For a
+  game, `GPUParticleEmitterSystem.set_global_field(name, values)` holds the value until a particle
+  system exists and hands it over again to a replacement one. A global nobody has set reads 0.
+- **Authoring.** `ParticleEffectDocument.global_fields` declares the imports with the value the
+  preview gives them; the `globalField` node reads one; the preview links its own copy of the
+  program to its own layout.
+
+### Transform bindings
+
+A field — an emitter's or a global one — can be bound to a row of the scene's `transforms` table,
+and the GPU writes that row's composed `global` into it every frame: a beam's far end, a homing
+target, a joint the CPU never sees.
+
+- **Table.** `field_bindings`, the particle database's third table (CPU-staged): `source` (a
+  non-owning link to `transforms`, as the emitter's `node` is), `word` (from the field section's
+  base) and `channel` — `POSITION`, `DIRECTION`, `UP` (three words, computed as the emitter's
+  builtins of the same names are) or `ORIENTATION` (a quaternion, scale divided out). A field is
+  bound only to a channel exactly as wide as it.
+- **Pass.** `shader_particle_field_bind`: one thread per binding row, a page group per workgroup,
+  after the counter reset and before the emitter tick, so every VM pass reads this frame's
+  transforms. The program buffer is bound read-write in this pass only. Recorded only while the
+  table has rows.
+- **Authority.** A bound word is rewritten from scratch every frame, so a span upload or a buffer
+  rebuild landing on it is overwritten before anything reads it. Unbinding hands the word
+  back to its own value — the emitter's, or the global's last set value or zero — which goes out
+  with the next upload.
+- **Mirrors.** A mirrored transform is a reflection, which no quaternion is: `ORIENTATION` takes the
+  mirror out of the x axis and writes the rotation that is left.
+- **Bookkeeping.** `EmitterRegistry.bind_emitter_field` / `bind_global_field` and their unbinds. An
+  emitter's bindings are restaged with it, because the word they write is its block's offset plus
+  the field's, and the block moves; one whose field the layout no longer has is dropped, and they
+  go with the emitter.
+- **ECS.** `ParticleEffect.bindings` (`{field, entity, channel}`) and
+  `GPUParticleEmitterSystem.bind_global_field`: entity references, resolved with `row_of_entity`,
+  the row held through the scene's rows while bound. Runtime data and not saved: nothing in the
+  engine's saves carries an entity reference across a load. A target is let go on its own
+  `EntityRemoved`, before the entity is gone; a request the registry refuses — or that names an
+  entity with no `Transform64` — is remembered and not retried until it, or the emitter's layout,
+  changes; one field asked for twice is bound to the first request.
+
 ### Particle storage — single shared pool, uniform stride
 
 All particles live in one `array<u32>` pool with a fixed `RECORD_WORDS` stride (config, default 32
 words = 128 B). Word 0 is a reserved header holding the owning **emitter row** and that row's
-**generation** (`data/particle_header.js`); user attributes occupy words `1..RECORD_WORDS`. A single
-pool + single alive/dead lists means **one** emit dispatch and **one** simulate dispatch cover every
-emitter — the Destiny single-shader property.
+**generation** (`data/particle_header.js`); particle fields occupy words `1..RECORD_WORDS`. A
+single pool + single alive/dead lists means **one** emit dispatch and **one** simulate dispatch
+cover every emitter — the Destiny single-shader property.
 
 Lifecycle uses the canonical GPU dead-list / alive-list pair:
 - `dead_list`: stack of free slot indices (+ atomic count). Filled `dead[i] = i` at construction by
@@ -148,10 +249,10 @@ writes, as it runs an emitter's clock forward (see **Pre-warm**).
 ### Eight storage buffers
 
 A compute stage gets eight storage buffers by default, and the design does not ask for more. Two
-things keep every pass under it: the emitter record and the GPU-owned state are two tables of one
-database buffer, read through one binding; and the VM's constants and code are one packed buffer —
-`[header][constants][code]`, the header's first word saying where the code starts
-(`ParticleConstants.PARTICLE_PROGRAM_HEADER_WORDS`). Emit and simulate bind exactly eight; their
+things keep every pass under it: the emitter record, the GPU-owned state and the transform bindings
+are three tables of one database buffer, read through one binding; and the VM's constants, code and
+fields are one packed buffer — `[header][constants][code][fields]`, the header's first two words
+saying where the code and the fields start (`ParticleConstants.PARTICLE_PROGRAM_HEADER_WORDS`). Emit and simulate bind exactly eight; their
 wide-register variants bind nine, which is the one place the system spends past the default and is
 still inside the ten the engine demands of an adapter. `particle_shaders_wgsl_validity.spec` pins
 the count for every pass.
@@ -180,7 +281,7 @@ recursion, no data-dependent jumps — conditionals are predicated via CMP/SELEC
   Word 0 packs the opcode (bits 0..7), the lane count (8..10), each source's `VM_KIND` (two bits per
   slot at 16..21) and the destination slot (24..31). A source word means what its kind says: `REG`
   is a base slot plus a swizzle, `IMM` is an `f32` bit pattern read in every lane, and `NONE` is a
-  raw field the opcode reads for itself (attribute word-offset+comp / builtin id /
+  raw field the opcode reads for itself (particle field word-offset+comp / builtin id /
   pool index).
 - Constant pool: `array<vec4f>` per program, referenced by `LOAD_CONST`.
 - Two entry sections per program: **INIT** and **UPDATE** (offsets in the emitter record). INIT
@@ -237,14 +338,14 @@ A core `NodeGraph` holds particle nodes (ports + parameters) for INIT and UPDATE
 2. lowers each node to VM ops (nodes emit via a small builder that allocates result registers),
 3. linear-scan register allocation with liveness,
 4. interns constants into the pool,
-5. resolves attribute references,
-6. emits `Program { init, update, constants, reg_count, attributes }`.
+5. resolves particle, emitter and global field references,
+6. emits `ParticleProgram { init, update, constants, register_count, global_imports }`.
 
-Standard node library: constants, attribute get/set, arithmetic/vector/math, random (uniform/sphere/
-disk/cone), authored curves and RGB/RGBA gradients, noise (curl), integrate, gravity, emit-shapes,
-compare/select, kill-if, and `wind` (a world position in, the scene's wind there out: `SAMPLE_WIND`).
-Curves and gradients expand into graph nodes that emit ordinary VM arithmetic; no animation-table
-binding or sampling opcode is needed.
+Standard node library: constants, particle field get/set, emitter and global field get,
+arithmetic/vector/math, random (uniform/sphere/disk/cone), authored curves and RGB/RGBA gradients,
+noise (curl), integrate, gravity, emit-shapes, compare/select, kill-if, and `wind` (a world position
+in, the scene's wind there out: `SAMPLE_WIND`). Curves and gradients expand into graph nodes that
+emit ordinary VM arithmetic; no animation-table binding or sampling opcode is needed.
 
 ### Emitters run at entities' rows
 
@@ -258,8 +359,9 @@ matrix could not do, since the CPU never sees the matrix of a row the GPU owns.
 scene: an emitter is where its owner says it is, and per-frame upkeep is proportional to what
 changed rather than to how many emitters there are.
 
-**The emitter knows nothing about the GPU, and nothing about where.** A `ParticleEmitter` is an
-attribute `layout`, a compiled `program`, a `texture` URL, and the emission parameters — all of
+**The emitter knows nothing about the GPU, and nothing about where.** A `ParticleEmitter` is a
+particle field `layout`, a compiled `program`, an `emitter_layout` with this emitter's
+`emitter_fields`, a `texture` URL, and the emission parameters — all of
 it the author's, all of it meaning the same thing with no device present, all of it what a saved
 effect is made of. Everything the system assigns is a `GPUParticleEmitterContext`, held by the
 `EmitterRegistry` against the emitter and reached through `registry.context(emitter)`: the table
@@ -541,11 +643,11 @@ premultiplied inputs; straight-alpha and additive inputs have alpha scaled befor
 
     offset = F(mode, camera, velocity) · Q · (corner.x · size, corner.y · size · stretch, 0)
 
-- **`Q` is the `orientation` render channel**, a 4-word attribute holding a quaternion (x, y, z, w)
-  — the only rotation a particle has. It is normalised at the draw, because a program integrating a
-  spin drifts off unit length and an unnormalised quaternion scales what it turns by its squared
-  length. The zero quaternion, which is what an attribute nobody wrote holds, reads as no turn with
-  no branch, and so does an unbound channel.
+- **`Q` is the `orientation` render channel**, a 4-word particle field holding a quaternion (x, y,
+  z, w) — the only rotation a particle has. It is normalised at the draw, because a program
+  integrating a spin drifts off unit length and an unnormalised quaternion scales what it turns by
+  its squared length. The zero quaternion, which is what a particle field nobody wrote holds, reads
+  as no turn with no branch, and so does an unbound channel.
 - **`F` is the mode's frame**, a proper rotation whose x and y are the sprite's right and up and whose
   z is the side the mode shows: BILLBOARD the camera's axes; STRETCHED the screen velocity as its up
   and the camera's axes at rest; VERTICAL world +Y as up and a horizontal face toward the eye;
@@ -566,14 +668,14 @@ written into it could face all of them.
 cannot disagree about which way a mode faces. **Bounds do not change**: the basis is a rotation, so no
 corner reaches past `sqrt(2) · size · stretch`, which is what `particle_billboard_radius` already
 states; the bounds pass never reads the channel. **The VM does not change** either: a program writes
-a vec4 attribute like any other, and the node library has what it takes to build one —
+a vec4 particle field like any other, and the node library has what it takes to build one —
 `quatFromAxisAngle`, `quatLookRotation`, `quatRotate`, `quatMultiply`, `quatIntegrate` (exact for a
 constant angular velocity at any step, which the warm-up's stretched ticks need), `sampleRotation`
 (uniform) and `emitterRotation` (the node's own rotation; `EMITTER_DIRECTION` is its -Z).
 
-There was a scalar `rotation` channel, a roll; it is gone rather than kept beside this, and
-`ParticleEffect` serializes at version 2 — a version-1 save loads with its orientation unbound, since
-its bytecode writes an angle. `ORIENTATION_PLAN_2026_10_15.md` has the alternatives and why each lost.
+There is no scalar roll channel beside it. A version-1 `ParticleEffect`, whose bytecode wrote a roll
+angle there, loads with its orientation unbound. `ORIENTATION_PLAN_2026_10_15.md` has the
+alternatives and why each lost.
 
 Additive vs. alpha is never a pipeline switch: the shader emits premultiplied RGB with alpha 0
 (additive) or alpha a (normal), so one setup covers both and the choice stays per particle and
@@ -645,21 +747,23 @@ new Entity()
 ```
 
 `engine/graphics/ecs/particles/ParticleEffect.js` carries everything a `ParticleEmitter` node carries
-except the placement: the layout and compiled program, the texture URL, the rate, `emitting`, the
-pre-warm, the flags, the render bindings and the flipbook grid. Nothing on it depends on a device,
-which is what makes it the unit an editor inspects and a prefab holds.
+except the placement: the layout and compiled program, the emitter layout and this entity's emitter
+field values, the texture URL, the rate, `emitting`, the pre-warm, the flags, the render bindings,
+the flipbook grid and the transform `bindings`. Nothing on it depends on a device, which is what
+makes it the unit an editor inspects and a prefab holds.
 
-**All of it serializes, the compiled program included** — `ParticleEffectSerializationAdapter`,
-registered in `populateEngineSerializationRegistry`. The instruction set was designed to be a durable
+**All of it serializes, the compiled program included; the transform bindings do not** —
+`ParticleEffectSerializationAdapter`, version 3, registered in `populateEngineSerializationRegistry`. The instruction set was designed to be a durable
 format, so a level carries bytecode the way it carries a mesh's indices and a shipped build needs no
 compiler: authoring is an editor's job and it is not in the runtime. Two things are consequently wire
 format and cannot be renumbered without a version bump and an upgrader — the **opcode numbers** in
-`isa/ParticleVMISA.js`, and the **order of the attributes** in a layout, because a layout assigns its
-word offsets from that order and the record's render bindings are those offsets. The constant pool
-goes out as `Uint32` bit patterns rather than floats, because that is the form the pool is already
-compared and hashed in (`ParticleProgram#constant_words`): `-0` and `+0` are the same number and
-different constants, and whether a NaN's payload survives a round trip through a JS `number` is
-implementation-defined even though V8 happens to preserve it.
+`isa/ParticleVMISA.js`, and the **order of the fields** in a layout, because a layout assigns its
+word offsets from that order: the record's render bindings are particle field offsets, and saved
+emitter field values are words in emitter layout order. The
+constant pool goes out as `Uint32` bit patterns rather than floats, because that is the form the
+pool is already compared and hashed in (`ParticleProgram#constant_words`): `-0` and `+0` are the
+same number and different constants, and whether a NaN's payload survives a round trip through a JS
+`number` is implementation-defined even though V8 happens to preserve it.
 
 The system builds one `ParticleEmitter` per linked entity and owns it — registered with the
 scene's particle system at the entity's row (`row_of_entity`, held through the scene context's
@@ -672,7 +776,8 @@ the old one. `emitter_of(entity)` hands the emitter out for what an entity refer
 queued and drained inside the frame so it works before the first frame has run.
 
 Component changes are found by **comparison** rather than announced: once a frame each entity's
-fields are compared against what was last written to its emitter, and the emitter is marked dirty
+component values, emitter field values included, are compared against what was last written to its
+emitter, and the emitter is marked dirty
 only where they differ, so a component nobody touched costs a run of integer comparisons and no
 upload. That is what lets gameplay write `effect.spawn_rate = 0` from code that has never heard of
 this system.
@@ -739,6 +844,7 @@ src/shade/renderer/particles/
   isa/ParticleVMISA.js               opcode table (single source of truth)
   isa/ParticleProgram.js             Program value type + (de)serialization to u32
   isa/ParticleAssembler.js           tiny assembler (build programs in tests/library)
+  isa/particle_link_global_fields.js global field import indices → section offsets, at placement
   vm/ParticleVMReference.js          JS reference executor
   vm/chunk_particle_vm.js            WGSL interpreter CodeChunk (parity target)
   vm/chunk_particle_vm_registers_fast.js  register file in var<private> — the interpreter that runs
@@ -750,17 +856,19 @@ src/shade/renderer/particles/
   graph/ParticleNodeRegistry.js      standard node library (a NodeRegistry)
   graph/particle_graph_authoring.js  authoring sugar over core/model/node-graph
   graph/compile_particle_graph.js    graph → Program (register alloc, const intern)
-  layout/ParticleLayout.js           attribute schema ↔ record word offsets
+  layout/ParticleLayout.js           particle field schema ↔ record word offsets
   data/PARTICLE_EMITTER_STRUCT.js    the emitter row + flag/blend/projection encoding
   data/particle_emitter_record.js    emitter + context -> one row of that struct
   data/PARTICLE_EMITTER_STATE.js     the GPU-owned per-emitter state row (second table of the database)
   data/PARTICLE_DATABASE_SPEC.js     the GPUDatabase schema, and the emitter table's descriptor
+  data/PARTICLE_FIELD_BINDING.js     a transform binding row (third table of the database) + channels
   data/PARTICLE_COUNTERS.js          counter slot indices
   data/particle_header.js            record header encoding (row + generation), JS + WGSL
   coherence/particle_program_buckets.js  CPU reference for the simulation-order bucketing
   coherence/shader_particle_bucket.js    reset / histogram / pad / scatter / fill
   coherence/graph_particle_bucket.js     frame-graph wiring, around graph_prefix_scan_csdldf
-  runtime/ProgramHeap.js             the one packed [header][constants][code] buffer, allocator-backed
+  runtime/ProgramHeap.js             the one packed [header][constants][code][fields] buffer, allocator-backed
+  runtime/ParticleGlobalFields.js    the global field layout: append-only, addressed from zero
   runtime/ProgramPlacement.js        where one program sits in it — what an emitter record carries
   runtime/ParticleEmitter.js         one emitter — authoring data for an effect, with no GPU in it
   runtime/GPUParticleEmitterContext.js  what a registry assigns one: row, generation, placement, patch
@@ -771,6 +879,7 @@ src/shade/renderer/particles/
   shaders/shader_particle_emit.js            per-newborn INIT, sized by the scan
   shaders/shader_particle_simulate.js        per-particle UPDATE + compaction + orphan kill
   shaders/shader_particle_finalize.js        reset counters (+ budget) / build indirect args
+  shaders/shader_particle_field_bind.js      bound transforms → their fields, before the tick
   shaders/chunk_particle_setup_context.js    VM builtins from the emitter's node, + the RNG seed
   shaders/chunk_particle_emitter_age.js      the tick pass's running age, off the emitter_state table
   shaders/chunk_particle_spawn_budget.js     take from the frame's spawn budget; both ticks spend it

package/src/shade/renderer/particles/EMITTER_GLOBAL_STATE_PLAN_2026_10_29.md

@@ -0,0 +1,283 @@
+# Particle, emitter and global fields — scope (2026-10-29, revision 4)
+
+**Status: landed.** `DESIGN.md` (*Vocabulary: fields*, *Emitter fields*, *Global fields*, *Transform
+bindings*) describes what was built. This is the scope as proposed. The **Outcome** section at the
+end lists where the build departs from it, and the measurements.
+
+**The model.** The program is the class and the emitter is an instance.
+- The class declares the fields every instance carries, and the global fields it reads.
+- The instance holds the values.
+- The class's own data — code, the constant pool, its bucket — is never touched by an instance.
+
+**Rejected alternatives:**
+- fixed 32-word emitter rows, in favour of general allocation;
+- GPU-integrated emitter state: values are static or set by gameplay, which the GPU cannot see;
+- a copy of the class for every set of instance values.
+
+## Vocabulary
+
+| scope | term | engine's own members | read by |
+|---|---|---|---|
+| particle | `particle_field` (was "attribute") | none (by design) | `LOAD_PARTICLE_FIELD` / `STORE_PARTICLE_FIELD` |
+| emitter | `emitter_field` | `EMITTER_POSITION`, `_DIRECTION`, `_UP`, `EMITTER_AGE` | `LOAD_BUILTIN` |
+| system | `global_field` | `TIME`, `DELTA_TIME` | `LOAD_BUILTIN` |
+
+**What the rename covers.**
+- **Renamed:** `ParticleLayout`'s entries, the `ParticleEffect` / `ParticleEmitter` API, the editor,
+  the graph node types (`particleField` / `setParticleField`), and the documentation.
+- **What keeps loading:** the graph JSON keys node types by name, and those names are wire format,
+  so `attribute` and `setAttribute` still load as aliases.
+- **Unchanged:** the binary effect format writes a layout's field names, widths and tags, and no
+  vocabulary words, so it does not change.
+- **The mnemonics** become `LOAD_PARTICLE_FIELD` / `STORE_PARTICLE_FIELD`, on the opcode numbers they
+  already have. `LOAD_ATTR` / `STORE_ATTR` text still parses, the precedent being legacy `SWIZZLE`
+  text.
+
+## Format
+
+- **The class declares its `emitter_field`s as a `ParticleLayout`**: name, width, an optional `type`
+  tag, and a default each. It sits on `ParticleProgram` beside the particle layout.
+  - Declaration order is wire format, the same rule as for particle fields.
+- **The class declares the `global_field`s it imports**: a name and a width each.
+- **The system's global layout is the union of what it holds.**
+  - It is append-only, and capacity only rises.
+  - Game code may declare names up front.
+  - A global field nobody has set reads 0.
+
+## Storage: a third region of `ProgramHeap`'s buffer
+
+**`ProgramHeap` already is this.**
+- Its sections are `ProgramRegion`s over flat word arrays, each managed by an `OffsetAllocator`.
+- It packs them into one buffer, `[header][constants][code]`, which every pass running the VM already
+  binds.
+- It repacks when a section has no run long enough, and capacities only rise.
+- A repack moves `placement_version`, and that restages every emitter row.
+
+The fields are a third region:
+
+```
+[header][fields: global (reserved) | emitter blocks][constants][code]
+```
+
+- **Global fields are always addressed from 0.** They take the region's top, reserved at 16 KiB
+  (4,096 words), so they never move.
+- **Each instance's `emitter_field` block is one allocation**, sized to its class's layout.
+  - The emitter record carries `field_offset`, the block's start within the region. The record writer
+    fills it from the instance's context, beside the program placement.
+  - An instance whose class declares no emitter fields allocates nothing.
+- **The header gains a word for the field base**, beside the code base it already holds.
+- **No storage binding is added.**
+  - Emit and simulate stay at eight, and their wide twins at nine, inside the device floor of ten.
+  - A buffer of its own would put the wide twins at ten, the floor itself.
+  - This was the deciding cost.
+- **Upload goes by span.**
+  - Today a placement re-uploads the whole buffer, which is right for code, because code changes
+    rarely.
+  - Field values change with gameplay, so the fields region uploads its changed spans through the
+    engine's existing small-write upload path (small writes batched in blocks, mapped from 32 KiB up).
+  - A repack or growth still rebuilds the whole buffer, as today.
+- **Authority.** The VM reads the buffer and never writes it. The CPU writes values. The binding pass
+  (below) writes the words that are bound.
+
+## Reading
+
+- **`LOAD_BUILTIN` gets two convention ranges above the engine's ids:**
+  - `VM_BUILTIN_EMITTER_FIELD_BASE + word offset`;
+  - `VM_BUILTIN_GLOBAL_FIELD_BASE + import index`.
+  The component count rides in `s1`, as `LOAD_PARTICLE_FIELD` carries it, and lanes past it read 0.
+- **`vm_load_builtin`'s default case calls two host functions.** They follow the external-symbol
+  pattern `particle_vm_sample_wind` already uses: `particle_vm_load_emitter_field` and
+  `particle_vm_load_global_field`. Every host defines them: emit, simulate, their wide twins, and the
+  warm-up advance.
+- **An `emitter_field` is read per lane.**
+  - The emitter row comes from the record header, then `field_offset` from the row, then the words.
+  - Nothing new is held across the interpreter loop, so `vm_ctx` does not grow.
+  - A field read is two dependent reads. Whether to hold `field_offset` in `vm_ctx` instead is decided
+    by the measurement below, not by argument.
+- **A `global_field`'s address is the same in every lane**, so it is a scalar read.
+- **Buckets, the constant pool and wave-uniform decode are untouched.**
+
+### Linking global fields
+
+- Programs are durable content, compiled with no scene present, so a global field's offset cannot be
+  baked in.
+- The operand is an index into the program's import table.
+- `ProgramHeap` rewrites it to the global field's offset when it copies the code into place, which
+  it already does.
+- The heap stays keyed on the unpatched bytecode.
+- Appending a global field moves nothing.
+
+## Transform bindings
+
+- **What they are.** A binding names a `transforms` row, a field and a channel. The GPU writes that
+  row's composed `global` into the field every frame.
+- **What that gives.** A beam's far end, a homing target, a second bone: any transform can drive a
+  field with nothing copied through the CPU. That is what the emitter's own `node` already does for
+  `EMITTER_POSITION`, and it works for a row only the GPU composes, such as an animated joint.
+
+**Storage: a `field_bindings` table** in the particle database. It is CPU-staged and low-churn, which
+is what `GPUDatabase` is for.
+- `source` is a link to the scene's `transforms` table, non-owning, exactly like the emitter record's
+  `node` (`PARTICLE_DATABASE_SPEC.add_link`).
+- `target` is a word address in the fields region. It may be a global field or a word of an emitter
+  block, which is one rule for both scopes.
+- `channel` says what is written:
+
+  | channel | width | from `global` |
+  |---|---|---|
+  | `POSITION` | 3 | the origin, as `EMITTER_POSITION` |
+  | `DIRECTION` | 3 | normalised −Z, as `EMITTER_DIRECTION` |
+  | `UP` | 3 | normalised +Y, as `EMITTER_UP` |
+  | `ORIENTATION` | 4 | a quaternion, as the `orientation` channel takes it |
+
+  The channel width must equal the field's width, and the system refuses the binding otherwise.
+- Targets are restaged when `placement_version` moves, the rule every row already follows.
+
+**The pass: `shader_particle_field_bind`.**
+- One thread per binding row, walked with the table's page iterator, as the tick walks emitters.
+- It reads `scene_read_node(source).global`, the same read `chunk_particle_setup_context` makes, and
+  writes the channel's words into the fields region. The program buffer is bound read-write here and
+  only here.
+- It runs once a frame, after the hierarchy pass has composed the rows and before the tick.
+- The host skips the dispatch while the table is empty.
+
+**Authority.** A bound word is recomputed from scratch every frame.
+- That is the argument that lets the scene's `transforms` table mix CPU fields with a GPU-written
+  `global` (DESIGN.md, *The emitter state*), and it holds here.
+- The CPU's value for a bound field is its default until the first bind.
+- A span upload or a buffer rebuild that lands on a bound word is overwritten before any VM pass
+  reads it.
+
+**ECS.**
+- `ParticleEffect.bindings`: `[{ field, entity, channel }]`, an entity reference, never a row. The
+  system resolves it with `row_of_entity` and holds the row through the scene context's rows, as it
+  does for the emitter's own placement.
+- `GPUParticleSystem.global_fields.bind(name, entity, channel)` does the same for global fields.
+
+## Everything else it touches
+
+- **Optimizers.** `LOAD_BUILTIN` is already a pure read. Width inference has to take a field's width
+  from `s1` rather than from `VM_BUILTIN_COMPONENTS`, and the fuzzer must generate both ranges.
+- **Reference VM.** The host passes `emitter_field` and `global_field` words as it passes the builtins
+  today.
+- **Graph.** New node types, appended at the end of `ParticleNodeRegistry.js`:
+  - `emitterField` (name, type, default);
+  - `globalField` (name, type).
+  Widths are validated per name.
+- **ECS values.**
+  - `ParticleEffect.emitter_fields`: values by name, as `Uint32` bit patterns. Compare-to-last covers
+    them, and a change marks the span dirty. It is not a restage, since a block does not move.
+  - `GPUParticleSystem.global_fields.set(name, value)` does the same for global fields.
+- **Serialization.** The emitter-field layout and the imports ride in the program; values and bindings
+  ride on the effect. `ParticleEffect` goes to v3, with an upgrader that gives old saves none.
+
+## Cost
+
+- **A static value:** written once, when the block is allocated. Nothing per frame.
+- **A changed value:** one span upload. No restage, no rebucket, no program change.
+- **A binding:** one thread a frame, plus one dispatch (a tiny pass measures 5–8 µs here)
+  while any binding exists.
+- **On the GPU:**
+  - an `emitter_field` read is a header reload, a row read and up to four loads;
+  - a `global_field` read is one scalar read;
+  - an effect that reads neither pays nothing that executes.
+
+## What gets measured
+
+- **The interpreter's register footprint.** Simulate and emit compiled through Dawn, before and after,
+  on RDNA2 offline. The default case grows the static code. The gate is no VGPR change.
+- **The cost of an `emitter_field` read.** At 200k alive, on the 4090 and the iGPU, paired in one
+  page:
+  - the effect reading one field per particle, against the same effect reading a constant;
+  - the same pair with `field_offset` held in `vm_ctx`.
+  The cheaper of the two read paths is kept.
+- **The bind pass**, at 1 and 1,000 bindings.
+
+## Stages
+
+Each stage lands red-then-green.
+
+| stage | what lands | pinned by |
+|---|---|---|
+| V0 | the vocabulary rename; old graph node names and mnemonics load as aliases | every existing graph and assembly spec green, plus a saved graph using `attribute` loading |
+| E1 | fields region, `field_offset`, emitter-field layout, `LOAD_BUILTIN` emitter range in both executors, graph node, `ParticleEffect.emitter_fields`, span upload, v3 | two bonfires differing only in flame tint: one program, one bucket, two blocks; a value change uploads one span and moves no program id |
+| G1 | global reservation, imports, link at placement, global range, `global_fields.set` | a global field changes a running effect without restaging an emitter row |
+| B1 | `field_bindings`, the bind pass, the ECS and global bind API | a beam whose far end follows an animated joint the CPU never sees |
+
+## Outcome (2026-10-29)
+
+Landed as revision 4 describes, in four commits — V0 `b8d14148e`, E1 `66031919d`, G1 `f93d1d2e0` and
+B1 `3dd4b7ce7` — and the adversarial review's fixes, `a14459252`, with these departures:
+
+- **Emitter fields are declared by the effect's document, as particle fields are**, and the
+  `emitterField` node reads one by name; the node does not declare. The same for global imports.
+  The emitter layout sits on the effect and the emitter (`emitter_layout`), not on `ParticleProgram`.
+  Values are `Uint32` words in layout order (`emitter_fields`), not a map by name.
+- **The fields are the buffer's fourth section**, `[header][constants][code][fields]`, not a region
+  between the header and the constants.
+- **The VM reads fields inline** in `LOAD_BUILTIN`'s field branch. There are no host functions
+  `particle_vm_load_emitter_field` / `particle_vm_load_global_field`.
+- **Global bindings go through the registry and the ECS system**: `EmitterRegistry.bind_global_field`
+  and `GPUParticleEmitterSystem.bind_global_field`. There is no `GPUParticleSystem.global_fields.bind`.
+- **The bind pass runs after the counter reset**, before the spawn commands and the tick.
+- **A field read takes the instruction's width in words**, as `LOAD_CONST` does, rather than a
+  component count in `s1`: the compiler emits a field at its own width, and `LOAD_BUILTIN`'s operand
+  list — and so every saved assembly text — stays as it was.
+- **`field_offset` is held in `vm_ctx`**, beside `emitter_position`, rather than re-read from the
+  emitter row inside the opcode. The re-read form was not built: the measured cost below is the
+  address being per-lane, and a row found through the particle's own header is per-lane too.
+- **A value change restages the emitter's row** as well as writing its span — the registry's existing
+  path — rather than the span alone.
+- **v3 of `ParticleEffect` carries the program's global imports**, written in E1 so the format bumped
+  once.
+- **Transform bindings on the component are runtime data and not saved**: nothing in the engine's
+  saves carries an entity reference across a load.
+
+**Measured (2026-10-29, at `a14459252`'s code).** Headless Chrome, one device per run. The two arms are two
+particle systems in one page, frames interleaved and the order alternating. Times are GPU timestamps,
+p10, over 1,200 frames on the 4090 and 300 on the iGPU. The emitter tick is the control and reads the
+same in both arms throughout.
+
+- **An `emitter_field` read at 200k alive.** The effect is `position += drift * dt`: six
+  instructions, where `drift` is a 3-wide emitter field in one arm and a 3-wide constant in the
+  other. Simulate:
+
+  | | constant | field | field / constant |
+  |---|---|---|---|
+  | RTX 4090, 2 runs | 132–134 µs | 135–137 µs | 1.008, 1.039 |
+  | Radeon iGPU (RDNA2), 7 runs | 1,893–1,952 µs | 2,111–2,204 µs | 1.111–1.131 |
+
+  On the iGPU that is about 1.1 ns per particle per read: an eighth of a program this short. **The
+  cause is that the address is per-lane.** Simulate's waves are one program, not one emitter, so
+  `vm_ctx.emitter_field_offset` reaches the read per-lane while the constant pool's base arrives
+  wave-uniform. Two experiments show it:
+  - broadcasting the offset from the first lane, valid only in this one-emitter page, brings the ratio
+    to 0.996 and 0.997;
+  - hoisting the header word out of the loop changes nothing (1.117, 1.096).
+- **A guarded broadcast was measured and not kept.** It reads at the first lane's offset when
+  `subgroupAll` says every lane agrees, and per-lane otherwise. Field-reading programs ran 0.985–0.996
+  of the constant arm. But every program without a field read slowed by 2.6–3.6%: 2,001–2,021 µs
+  against 1,949–1,952 µs, in three HEAD/fix pairs run back to back. The cost is there even though such
+  a program never takes the branch. Most effects read no field, so the common case would pay.
+- **The bind pass**, POSITION bindings:
+
+  | | 1 binding | 1,000 bindings |
+  |---|---|---|
+  | RTX 4090, 2 runs | 2.05 µs | 2.05 µs |
+  | Radeon iGPU, 2 runs | 2.20–2.24 µs | 5.44 µs |
+
+  On the 4090 both arms read the same as the emitter-tick control. On the iGPU, 999 more bindings add
+  3.2 µs.
+
+**Not measured:** the interpreter's register footprint. amdspv and spirv-as are not installed on this
+machine. Every VM pass and the bind pass compile and build pipelines under Tint on both GPUs.
+
+## Sources
+
+- UE 5.4 source on disk: `Plugins/FX/Niagara/Source/Niagara/Public/NiagaraTypes.h`
+  (`FNiagaraEmitterParameters` and `FNiagaraSystemParameters` are the engine's members of each scope,
+  with User values beside them), `Classes/NiagaraGPUSystemTick.h`,
+  `Classes/NiagaraParameterCollection.h` (globals bound by name).
+- [Niagara key concepts (namespace read/write table)](https://dev.epicgames.com/documentation/unreal-engine/key-concepts-in-niagara-effects-for-unreal-engine)
+- [VFX Graph instancing](https://docs.unity3d.com/Packages/com.unity.visualeffectgraph@17.2/manual/Instancing.html)
+  — instances share code and load their properties per instance.

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

@@ -22,8 +22,9 @@
  * Persistent GPU state, and only that: a buffer is reserved here if and only if its contents have
  * to survive to the next frame. That is the particle pool, the alive list, the dead
  * free-list, the counters, the simulation-order (coherence) list, simulate's indirect dispatch args
- * (written at the end of one frame, read by the next), the emitter database (the emitter table and
- * the GPU-owned state table, one buffer), the packed program buffer, and the two CPU-uploaded
+ * (written at the end of one frame, read by the next), the emitter database (the emitter table, the
+ * GPU-owned state table and the transform binding table, one buffer), the packed program buffer
+ * (code, constants and field values), and the two CPU-uploaded
  * queues — the spawn-command ring and the warm-up queue. Buffers that depend on the emitter set —
  * the coherence list on the number of distinct programs, the program buffer on the heap, the
  * database on its own pages, the counters on the emitter table's element capacity (they carry the
@@ -184,6 +185,13 @@ export class GPUParticleSystem {
      * @returns {import("./runtime/ParticleEmitter.js").ParticleEmitter[]}
      */
     get emitters(): import("./runtime/ParticleEmitter.js").ParticleEmitter[];
+    /**
+     * The system's global fields — the static members every effect may read by name. Setting one is
+     * a word write and a span upload on the next frame; nothing is restaged and no program changes.
+     *
+     * @returns {import("./runtime/ParticleGlobalFields.js").ParticleGlobalFields}
+     */
+    get global_fields(): import("./runtime/ParticleGlobalFields.js").ParticleGlobalFields;
     /**
      * Number of simulation-order buckets — one per program id the registry can hand out, which is
      * its peak number of distinct compiled programs rather than its current one.

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

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