@woosh/meep-engine 3.33.0 → 3.34.0

package/src/engine/graphics/{particles/particular/engine/utils/volume → texture/sampler}/lut_to_sampler.js

@@ -1,4 +1,4 @@
-import { Sampler2D } from "../../../../../texture/sampler/Sampler2D.js";
+import { Sampler2D } from "./Sampler2D.js";
 
 /**
  *

package/src/engine/graphics3/GPUParticleEmitterSystem.d.ts

@@ -89,9 +89,6 @@ export function apply_particle_effect(emitter: ParticleEmitter, effect: Particle
  * inside the renderer, driven from the emitter table these rows are in — see
  * `shade/renderer/particles/DESIGN.md`. This system's whole contribution is membership, placement,
  * the fields, and the sprite sheet.
- *
- * It also does not retire the CPU `ParticleEmitterSystem`, which serves the `particular` effects the
- * game still ships. The two coexist and share nothing.
  */
 export class GPUParticleEmitterSystem extends System<any> {
     /**

package/src/engine/graphics3/GPUParticleEmitterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUParticleEmitterSystem.js"],"names":[],"mappings":"AAyzBA;;;;;;;;;;;;;;;;GAgBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CA4BnB;AA10BD;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH;IAoDI;;;;;OAKG;IACH,sBALW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAgB7D;IArED,6DAA6C;IAE7C;;;OAGG;IACH,OAFU,YAAY,CAEO;IAiE7B;;;;;;OAMG;IACH,iEAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,mBAJW,MAAM,GACJ,eAAe,GAAC,IAAI,CAWhC;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,SACN,MAAM,QA4BhB;IA6BD,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CAyB1B;IAED;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QAqChB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,4BAHW,MAAM,GACJ,IAAI,CAgBhB;IAoCD;;;;;;;;;;;;OAYG;IACH,eAHW,OAAO,gDAAgD,EAAE,YAAY,GACnE,IAAI,CAqChB;;CAiWJ;;;;;gBA3xBa,MAAM;;;;WACN,OAAO,yCAAyC,EAAE,UAAU,GAAC,IAAI;;;YAKjE,MAAM;;;;YACN,cAAc;;;;eACd,WAAW;;;;aACX,eAAe,GAAC,IAAI;;;;;aACpB,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI;gCAGjE,IAAI;;;;SACf,MAAM,GAAC,IAAI;;;;aACX,oBAAoB,GAAC,IAAI;;gCAvCP,2DAA2D;+BAS5D,6CAA6C;uBAPrD,kBAAkB;4BAEb,iCAAiC;6BAMhC,2CAA2C"}
+{"version":3,"file":"GPUParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUParticleEmitterSystem.js"],"names":[],"mappings":"AAszBA;;;;;;;;;;;;;;;;GAgBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CA4BnB;AAv0BD;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH;IAoDI;;;;;OAKG;IACH,sBALW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAgB7D;IArED,6DAA6C;IAE7C;;;OAGG;IACH,OAFU,YAAY,CAEO;IAiE7B;;;;;;OAMG;IACH,iEAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,mBAJW,MAAM,GACJ,eAAe,GAAC,IAAI,CAWhC;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,SACN,MAAM,QA4BhB;IA6BD,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CAyB1B;IAED;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QAqChB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,4BAHW,MAAM,GACJ,IAAI,CAgBhB;IAoCD;;;;;;;;;;;;OAYG;IACH,eAHW,OAAO,gDAAgD,EAAE,YAAY,GACnE,IAAI,CAqChB;;CAiWJ;;;;;gBAxxBa,MAAM;;;;WACN,OAAO,yCAAyC,EAAE,UAAU,GAAC,IAAI;;;YAKjE,MAAM;;;;YACN,cAAc;;;;eACd,WAAW;;;;aACX,eAAe,GAAC,IAAI;;;;;aACpB,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI;gCAGjE,IAAI;;;;SACf,MAAM,GAAC,IAAI;;;;aACX,oBAAoB,GAAC,IAAI;;gCAvCP,2DAA2D;+BAS5D,6CAA6C;uBAPrD,kBAAkB;4BAEb,iCAAiC;6BAMhC,2CAA2C"}

package/src/engine/graphics3/GPUParticleEmitterSystem.js

@@ -99,9 +99,6 @@ const BURST_QUEUE_LIMIT = 256;
  * inside the renderer, driven from the emitter table these rows are in — see
  * `shade/renderer/particles/DESIGN.md`. This system's whole contribution is membership, placement,
  * the fields, and the sprite sheet.
- *
- * It also does not retire the CPU `ParticleEmitterSystem`, which serves the `particular` effects the
- * game still ships. The two coexist and share nothing.
  */
 export class GPUParticleEmitterSystem extends System {
     dependencies = [ParticleEffect, Transform64];

package/src/engine/network/NetworkSession.d.ts

@@ -140,7 +140,7 @@ export class NetworkSession {
      *   Default 4. See {@link ServerAuthoritativeServer}.
      * - `tick_rate_hz`: the network tick rate, which is the engine's fixed-step
      *   rate — given, it sets `entity_manager.fixedUpdateStepSize`; omitted, the
-     *   session uses the step the engine already has (60 Hz by default). Every
+     *   session uses the step the engine already has. Every
      *   peer must run the same rate.
      * - `frame_capacity` sizes the action-log ring (rollback depth + back-fill
      *   range + retransmit window — see {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}).

package/src/engine/network/NetworkSession.js

@@ -747,7 +747,7 @@ export class NetworkSession {
      *   Default 4. See {@link ServerAuthoritativeServer}.
      * - `tick_rate_hz`: the network tick rate, which is the engine's fixed-step
      *   rate — given, it sets `entity_manager.fixedUpdateStepSize`; omitted, the
-     *   session uses the step the engine already has (60 Hz by default). Every
+     *   session uses the step the engine already has. Every
      *   peer must run the same rate.
      * - `frame_capacity` sizes the action-log ring (rollback depth + back-fill
      *   range + retransmit window — see {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}).

package/src/engine/physics/cloth/MEASUREMENTS.md

@@ -3869,3 +3869,118 @@ The slack now carries a relative term of two ulps as well as the constant. It
 fails without it, and only for a cloth grazing a face: a query box as wide as
 the collider survives losing one side, which is why the first spec written for
 this passed and pinned nothing.
+
+---
+
+## 60. Every particle paid for a contact, and the loop paying most was not the one named
+
+The 2026-09-18 engine review (CPX-018) said `cloth_contact_warm_start` and
+`cloth_contact_dual_update` sweep every particle's four slots — once a substep
+and once an iteration — to find the few that hold a row, and proposed a compact
+list of occupied slots, emitted by `cloth_contact_find`, for them to walk
+instead. The sweep is real. What it costs is about a per cent, and the loop
+that does cost is a third one the review did not name: `cloth_contact_accumulate`,
+which the vertex solve calls for every particle every iteration, and which set up
+a contact's whole working set before it looked at a slot.
+
+**How it was measured.** Nothing under `__fixtures__` can see it: the library
+bench steps with a null collider table (§58), and §23's harness times a whole
+step once per variant. So both numbers here come from scratch harnesses over
+§23's hanging sheet at three sizes, paired and interleaved in one process with the
+arm order rotated and reversed every round. Each variant runs on its own copy of
+`cloth_step` → `cloth_solve_vertex` → `cloth_contact_row`, beside an unmodified
+copy as a control — a patched copy gets its own compiled code, and without the
+control that difference reads as a result. Every arm computes the same thing,
+and the states agree byte for byte after every run, which is how the harness
+knows it timed the same work.
+
+The two passes the review named, with a timer around each call inside the
+running step:
+
+```
+                                  rows   the passes      compact list    slot-0 test
+                                         (share of step)  saves           saves
+  400 p   2×4, 4 spheres            22     1.8%             1.3%            1.1%
+  1024 p  2×4, 1 sphere              6     1.3%             1.2%            1.0%
+  1024 p  2×4, 20 spheres          137     2.0%             1.1%            0.9%
+  1024 p  2×4, out of reach          0     1.3%             1.3%            1.0%
+  8100 p  4×2, 6 spheres            93     1.4%             1.2%            1.0%
+```
+
+**Flat in the particle count**, because the passes and the step are both linear
+in particles — the review's 8,000-particle garment is the same share as a
+400-particle one. And the whole step, one change at a time, as a ratio to the
+shipping step:
+
+```
+                                  rows   copy      the       the           both   contact path
+                                         control   passes    accumulate           withheld
+  400 p   2×4, out of reach          0   1.009     1.023     0.988         0.980    0.964
+  1024 p  2×4, out of reach          0   1.013     1.006     0.975         0.965    0.946
+  8100 p  4×2, out of reach          0   0.982     0.974     0.989         0.975    0.947
+  400 p   2×4, 4 spheres            22   0.994     0.982     0.905         0.890      —
+  1024 p  2×4, 20 spheres          156   0.984     0.994     0.937         0.907      —
+  8100 p  4×2, 6 spheres           116   1.035     0.990     0.936         0.901      —
+```
+
+The passes alone do not clear the control's ±3.5%, which is the timer's one per
+cent agreeing with it. **The accumulate is the cost: 6% to 9.5% of a colliding
+step**, and 1% to 2.5% of one with no rows. Why an untouched particle costs more
+on a cloth that has contacts somewhere is a reading rather than a measurement:
+only then is the friction path compiled in, and the function loaded three
+positions, six arrays and ten accumulator words — writing the ten straight back —
+for every particle before it looked at a slot.
+
+The last column withholds the collider table from `cloth_step` when there are no
+rows, which is an exact deletion there, and it prices the idle contact path at
+**3.6% to 5.4%**. §23 put the same thing at +1.1%; that figure was a difference of
+two separately run minima inside its own table's ±5%, and should not be read as
+a bound.
+
+### What changed
+
+A particle's rows were already its leading slots: `cloth_contact_find` clears all
+four and fills from the first. The accumulate, the warm start and the dual
+update now read them that way — an empty first slot is a particle with no
+contact and costs the load that says so, and the first empty slot ends a
+particle's rows. The contract is written on `CLOTH_CONTACT_SLOTS` and pinned by a
+spec that walks five colliders in and out of reach of one particle, more than
+there are slots and with the survivors changing places. A `cloth_contact_find`
+that right-aligns its rows fails it, and eleven other contact specs with it.
+
+Before and after, on the code as landed — two "after" arms, so their
+disagreement is the reading's precision:
+
+```
+                                  rows   before      after    after, second copy
+  400 p   2×4, out of reach          0   1.921 ms    0.924    0.918
+  1024 p  2×4, out of reach          0   4.940 ms    0.931    0.945
+  8100 p  4×2, out of reach          0   63.00 ms    0.942    0.951
+  400 p   2×4, 4 spheres            22   2.802 ms    0.897    0.909
+  1024 p  2×4, 20 spheres          156   5.576 ms    0.872    0.902
+  8100 p  4×2, 6 spheres           116   70.46 ms    0.961    0.919
+```
+
+**About a tenth off a colliding step, and a twentieth off an idle one**: across
+this run and an earlier one at three times the background load, the twelve
+colliding readings have a median of 0.90 and the twelve idle ones 0.95.
+
+### Not done, and why
+
+- **The compact list.** It needs a new `ClothState` region — 16 bytes a particle,
+  and the worker's shared layout with it — for the passes' one per cent, and it
+  cannot reach the accumulate at all: that loop is driven one particle at a time
+  by the colour sweep, not by a list of slots.
+- **The self-collision scratch keeps its `fill(0)`.** The review proposed clearing
+  only the particles the pair list touches. At §33's pair counts — 318 to 740 on
+  400 particles — that measured 2.2 to 5.2 µs an iteration against the fill's
+  0.14, which is a 29 KB memset. And clearing from the *current* list goes stale:
+  the list is rebuilt every step, so a particle that has left a pair keeps last
+  step's force.
+- **Withholding the table when `cloth_contact_find` returns nothing.** Exact where
+  it applies, and priced above, but since §59 a collider reaches the table only
+  within reach of the cloth's bounds, so a table with no rows in it is a passing
+  moment, and the slot-0 test already takes most of it.
+
+**No library entry is re-sized.** Its bench cannot see a collider (§58), and a
+garment on a body is the colliding half of the tables above.

package/src/engine/physics/cloth/solver/cloth_contact_find.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_contact_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_contact_find.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DARW,YAAY,GAAC,YAAY,QACzB,UAAU,SACV,MAAM,MACN,MAAM,GAGJ,MAAM,CAmLlB;AA7RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH;;;;;;;;;GASG;AACH,mCAFU,MAAM,CAEsB"}
+{"version":3,"file":"cloth_contact_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_contact_find.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DARW,YAAY,GAAC,YAAY,QACzB,UAAU,SACV,MAAM,MACN,MAAM,GAGJ,MAAM,CAqLlB;AA/RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH;;;;;;;;;GASG;AACH,mCAFU,MAAM,CAEsB"}

package/src/engine/physics/cloth/solver/cloth_contact_find.js

@@ -264,6 +264,8 @@ export function cloth_contact_find(state, table, keys, count, dt) {
             }
         }
 
+        // Into the leading slots and nothing after them: the rows read the first
+        // empty slot as the end of a particle's contacts (CLOTH_CONTACT_SLOTS).
         for (let s = 0; s < found; s++) {
             const slot = base + s;
 

package/src/engine/physics/cloth/solver/constraint/cloth_contact_row.d.ts

@@ -116,6 +116,15 @@ export function cloth_contact_dual_update(state: ClothState, table: Float32Array
  * accumulation is a counted loop over `CLOTH_CONTACT_SLOTS` adjacent entries,
  * and a per-cloth capacity would put a load and a multiply in the inner loop to
  * buy a garment nothing.
+ *
+ * **A particle's rows are its leading slots.** `cloth_contact_find` fills them
+ * from the first and leaves every slot after the last row empty, and every loop
+ * over them reads it that way: an empty first slot is a particle with no
+ * contact, and the first empty slot is the end of a particle's rows. That is
+ * what lets a particle touching nothing cost one load. Most particles of a
+ * colliding cloth touch nothing, the accumulation visits every one of them every
+ * iteration, and setting up a contact's working set for each of them was 6–9% of
+ * the step (`MEASUREMENTS.md` §60).
  * @type {number}
  */
 export const CLOTH_CONTACT_SLOTS: number;

package/src/engine/physics/cloth/solver/constraint/cloth_contact_row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_contact_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_contact_row.js"],"names":[],"mappings":"AA8GA;;;;;;;;GAQG;AACH,sDANW,YAAY,+BAEZ,MAAM,SACN,YAAY,GAAC,YAAY,QAwLnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QA0ChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oEALW,YAAY,GAAC,YAAY,QACzB,MAAM,eACN,MAAM,qBACN,MAAM,QAkGhB;AAjcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;;;;;;;;;;;;GAcG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,qCAFU,MAAM,CAE2B"}
+{"version":3,"file":"cloth_contact_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_contact_row.js"],"names":[],"mappings":"AAuHA;;;;;;;;GAQG;AACH,sDANW,YAAY,+BAEZ,MAAM,SACN,YAAY,GAAC,YAAY,QA8LnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QA8ChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oEALW,YAAY,GAAC,YAAY,QACzB,MAAM,eACN,MAAM,qBACN,MAAM,QAsGhB;AAxdD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,qCAFU,MAAM,CAE2B"}

package/src/engine/physics/cloth/solver/constraint/cloth_contact_row.js

@@ -96,6 +96,15 @@ import {
  * accumulation is a counted loop over `CLOTH_CONTACT_SLOTS` adjacent entries,
  * and a per-cloth capacity would put a load and a multiply in the inner loop to
  * buy a garment nothing.
+ *
+ * **A particle's rows are its leading slots.** `cloth_contact_find` fills them
+ * from the first and leaves every slot after the last row empty, and every loop
+ * over them reads it that way: an empty first slot is a particle with no
+ * contact, and the first empty slot is the end of a particle's rows. That is
+ * what lets a particle touching nothing cost one load. Most particles of a
+ * colliding cloth touch nothing, the accumulation visits every one of them every
+ * iteration, and setting up a contact's working set for each of them was 6–9% of
+ * the step (`MEASUREMENTS.md` §60).
  * @type {number}
  */
 export const CLOTH_CONTACT_SLOTS = 4;
@@ -122,6 +131,12 @@ export function cloth_contact_accumulate(accumulator, state, particle, table) {
 
     const base = particle * CLOTH_CONTACT_SLOTS;
 
+    if (collider[base] < 0) {
+        // No contact, and it leaves before anything below is loaded — see
+        // CLOTH_CONTACT_SLOTS for why that is most particles.
+        return;
+    }
+
     const position = state.position;
 
     const self = particle * 3;
@@ -157,7 +172,7 @@ export function cloth_contact_accumulate(accumulator, state, particle, table) {
         const record = collider[slot];
 
         if (record < 0) {
-            continue;
+            break;
         }
 
         const r = record * CCR_STRIDE;
@@ -330,6 +345,12 @@ export function cloth_contact_warm_start(state, alpha, gamma, k_min_ratio, k_max
     const decay = alpha * gamma;
 
     for (let particle = 0; particle < particle_count; particle++) {
+        const base = particle * CLOTH_CONTACT_SLOTS;
+
+        if (collider[base] < 0) {
+            continue;
+        }
+
         const compliance = mass_inverse[particle];
 
         if (compliance === 0) {
@@ -341,13 +362,11 @@ export function cloth_contact_warm_start(state, alpha, gamma, k_min_ratio, k_max
         const lo = k_min_ratio * scale;
         const hi = k_max_ratio * scale;
 
-        const base = particle * CLOTH_CONTACT_SLOTS;
-
         for (let s = 0; s < CLOTH_CONTACT_SLOTS; s++) {
             const slot = base + s;
 
             if (collider[slot] < 0) {
-                continue;
+                break;
             }
 
             lambda[slot] *= decay;
@@ -390,14 +409,18 @@ export function cloth_contact_dual_update(state, table, beta, k_max_ratio, inver
     const radius = state.contact_radius;
 
     for (let particle = 0; particle < particle_count; particle++) {
+        const base = particle * CLOTH_CONTACT_SLOTS;
+
+        if (collider[base] < 0) {
+            continue;
+        }
+
         const compliance = mass_inverse[particle];
 
         if (compliance === 0) {
             continue;
         }
 
-        const base = particle * CLOTH_CONTACT_SLOTS;
-
         const self = particle * 3;
 
         const x = position[self];
@@ -412,7 +435,7 @@ export function cloth_contact_dual_update(state, table, beta, k_max_ratio, inver
             const record = collider[slot];
 
             if (record < 0) {
-                continue;
+                break;
             }
 
             const r = record * CCR_STRIDE;

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#418@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#413@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#418@#clear_field"(fluid: FluidComponent): void;
+    static "__#413@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#418@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#413@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#418@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#413@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

package/src/engine/sound/ecs/audio/AudioEmitterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AudioEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/AudioEmitterSystem.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAgCI;;;;;OAKG;IACH,0FAHW;QAAC,MAAM,CAAC,EAAC,MAAM,CAAC;QAAC,cAAc,CAAC,EAAC,MAAM,CAAC;QAAC,cAAc,CAAC,EAAC,MAAM,CAAA;KAAC,qBA+C1E;IAjFD,2DAA2C;IAE3C;;;;;OAKG;IACH,iBAFU,kBAAkB,CAEA;IAE5B;;;OAGG;IACH,cAFU,eAAe,CAEP;IAElB;;;;;OAKG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;;OAIG;IACH,aAFU,sBAAoB,IAAI,CAEf;IAWf;;;;;OAKG;IACH,aAFU,oBAAkB,IAAI,CAEF;IAE9B;;OAEG;IACH,yBAA8B;IAE9B;;OAEG;IACH,iBAFU,YAAY,CAEoB;IAE1C;;OAEG;IACH,2BAAgC;IAQhC;;;OAGG;IACH,mBAAkF;IAElF;;;;OAIG;IACH,SAFU,cAAc,CAE4C;IAGxE;;;;OAIG;IACH,cAJW,YAAY,aACZ,WAAW,UACX,MAAM,QAqChB;IAED;;;;OAIG;IACH,gBAJW,YAAY,aACZ,WAAW,UACX,MAAM,QA6BhB;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,GACJ,gBAAc,IAAI,CAe9B;IAqDD,6BAoFC;;CACJ;uBA7WsB,wBAAwB;4BAGnB,uCAAuC;6BAKtC,mBAAmB;+BACjB,qBAAqB"}
+{"version":3,"file":"AudioEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/AudioEmitterSystem.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAgCI;;;;;OAKG;IACH,0FAHW;QAAC,MAAM,CAAC,EAAC,MAAM,CAAC;QAAC,cAAc,CAAC,EAAC,MAAM,CAAC;QAAC,cAAc,CAAC,EAAC,MAAM,CAAA;KAAC,qBA+C1E;IAjFD,2DAA2C;IAE3C;;;;;OAKG;IACH,iBAFU,kBAAkB,CAEA;IAE5B;;;OAGG;IACH,cAFU,eAAe,CAEP;IAElB;;;;;OAKG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;;OAIG;IACH,aAFU,sBAAoB,IAAI,CAEf;IAWf;;;;;OAKG;IACH,aAFU,oBAAkB,IAAI,CAEF;IAE9B;;OAEG;IACH,yBAA8B;IAE9B;;OAEG;IACH,iBAFU,YAAY,CAEoB;IAE1C;;OAEG;IACH,2BAAgC;IAQhC;;;OAGG;IACH,mBAAkF;IAElF;;;;OAIG;IACH,SAFU,cAAc,CAE4C;IAGxE;;;;OAIG;IACH,cAJW,YAAY,aACZ,WAAW,UACX,MAAM,QA4ChB;IAED;;;;OAIG;IACH,gBAJW,YAAY,aACZ,WAAW,UACX,MAAM,QA+BhB;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,GACJ,gBAAc,IAAI,CAe9B;IAqDD,6BAoFC;;CACJ;uBAvXsB,wBAAwB;4BAGnB,uCAAuC;6BAKtC,mBAAmB;+BACjB,qBAAqB"}

package/src/engine/sound/ecs/audio/AudioEmitterSystem.js

@@ -11,6 +11,7 @@ import SoundListener from "../SoundListener.js";
 import { AudioEmitter } from "./AudioEmitter.js";
 import { LiveEmitterSet } from "./LiveEmitterSet.js";
 import { EventType } from "../../../ecs/EventType.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../../../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 
 /**
  * The listener's orientation, read out of its transform once a frame.
@@ -143,12 +144,19 @@ export class AudioEmitterSystem extends System {
         // class doc.
         const managed = emitter.autoplay && emitter.event.is3D && emitter.event.rootClip.loops();
 
-        const record = { emitter, transform, managed, instance: null, onVolume: null, onEnded: null };
+        const record = { emitter, transform, managed, instance: null, onVolume: null, onEnded: null, onMoved: null };
 
         if (managed) {
             const pathing = emitter.acoustic && this.acousticSim !== null && this.acousticSim.pathing;
             this.liveSet.add(entity, emitter.event, transform.translation, volume2dB(emitter.volume.getValue()), emitter.acoustic, pathing, emitter.sourceRadius, transform.rotation, emitter.directivity);
             record.onVolume = () => this.liveSet.setGainDb(entity, volume2dB(emitter.volume.getValue()));
+
+            // The live set reads the translation through a live view, but a Transform64 cannot say it
+            // was written - its writer announces that through the dataset. Refitting on the
+            // announcement is what keeps a dormant emitter free: one that never moves is never visited.
+            record.onMoved = () => this.liveSet.moved(entity);
+
+            this.entityManager.dataset.addEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, record.onMoved);
         } else {
             if (emitter.autoplay) {
                 record.instance = this.#play(emitter, transform, record);
@@ -191,6 +199,8 @@ export class AudioEmitterSystem extends System {
         emitter.volume.onChanged.remove(record.onVolume);
 
         if (record.managed) {
+            this.entityManager.dataset.removeEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, record.onMoved);
+
             this.liveSet.remove(entity); // demotes (hard cut) if live, then unregisters
         } else if (record.instance !== null) {
             this.directInstances.delete(record.instance);
@@ -315,7 +325,7 @@ export class AudioEmitterSystem extends System {
             }
         }
 
-        // Promote/demote the spatial live set (throttled internally). Refresh BEFORE the tick so a
+        // Promote/demote the spatial live set. Refresh BEFORE the tick so a
         // freshly-promoted instance spatializes on the same frame. With no usable listener the live set
         // is not refreshed: never-promoted managed emitters stay dormant, while any already-live ones
         // keep playing against the last known listener pose until a listener returns. The direct (2D)

package/src/engine/sound/ecs/audio/LiveEmitterSet.d.ts

@@ -58,7 +58,7 @@ export class LiveEmitterSet {
      * Register an emitter (dormant until a refresh promotes it).
      * @param {number} entity
      * @param {EventDescription} event
-     * @param {Vector3} position shared position vector (tracked reactively by the spatial index)
+     * @param {Float64Array} position live translation view over the entity's transform; report its moves with {@link moved}
      * @param {number} [gainDb] per-emitter instance gain in dB, applied on every promotion (default 0 = unity)
      * @param {boolean} [acoustic] opt the promoted instances into the acoustic simulation (default false)
      * @param {boolean} [pathing] opt the promoted instances into corner-leakage render (default false)
@@ -66,7 +66,16 @@ export class LiveEmitterSet {
      * @param {Quaternion|null} [orientation] shared source orientation ref (tracks the entity), for directivity
      * @param {AcousticDirectivity|null} [directivity] source radiation directivity (null = omni)
      */
-    add(entity: number, event: EventDescription, position: Vector3, gainDb?: number, acoustic?: boolean, pathing?: boolean, sourceRadius?: number, orientation?: Quaternion | null, directivity?: AcousticDirectivity | null): void;
+    add(entity: number, event: EventDescription, position: Float64Array, gainDb?: number, acoustic?: boolean, pathing?: boolean, sourceRadius?: number, orientation?: Quaternion | null, directivity?: AcousticDirectivity | null): void;
+    /**
+     * Report that a registered emitter moved, so the broadphase refits it. No-op for an unknown entity.
+     *
+     * The position is a live view, so whatever reads it reads the current value - what the set cannot
+     * do is notice that it was written. {@link refresh} considers only what this reported, which is
+     * what keeps a dormant emitter free: nothing visits it until it moves.
+     * @param {number} entity
+     */
+    moved(entity: number): void;
     /**
      * Invoke `callback` for each currently-live instance (bounded by the budget). Used by the
      * `AudioEmitterSystem` to feed live spatial instances to the acoustic simulation.

package/src/engine/sound/ecs/audio/LiveEmitterSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LiveEmitterSet.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/LiveEmitterSet.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IA2EI;;;OAGG;IACH,6EAFW;QAAC,MAAM,CAAC,EAAC,MAAM,CAAC;QAAC,cAAc,CAAC,EAAC,MAAM,CAAC;QAAC,cAAc,CAAC,EAAC,MAAM,CAAA;KAAC,EAO1E;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,gBAAc,SAAS,CAInC;IAED;;;;;;;;;;;OAWG;IACH,YAVW,MAAM,uDAGN,MAAM,aACN,OAAO,YACP,OAAO,iBACP,MAAM,gBACN,aAAW,IAAI,gBACf,sBAAoB,IAAI,QAOlC;IAED;;;;OAIG;IACH,+CAFmC,IAAI,QAMtC;IAED;;;;;;;OAOG;IACH,kBAHW,MAAM,UACN,MAAM,QAehB;IAED;;;OAGG;IACH,eAFW,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,0BAFW,MAAM,EAAE,GAAC,YAAY,QAoE/B;;CAgFJ"}
+{"version":3,"file":"LiveEmitterSet.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/LiveEmitterSet.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IA2EI;;;OAGG;IACH,6EAFW;QAAC,MAAM,CAAC,EAAC,MAAM,CAAC;QAAC,cAAc,CAAC,EAAC,MAAM,CAAC;QAAC,cAAc,CAAC,EAAC,MAAM,CAAA;KAAC,EAO1E;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,gBAAc,SAAS,CAInC;IAED;;;;;;;;;;;OAWG;IACH,YAVW,MAAM,qCAEN,YAAY,WACZ,MAAM,aACN,OAAO,YACP,OAAO,iBACP,MAAM,gBACN,aAAW,IAAI,gBACf,sBAAoB,IAAI,QAOlC;IAED;;;;;;;OAOG;IACH,cAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,+CAFmC,IAAI,QAMtC;IAED;;;;;;;OAOG;IACH,kBAHW,MAAM,UACN,MAAM,QAehB;IAED;;;OAGG;IACH,eAFW,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,0BAFW,MAAM,EAAE,GAAC,YAAY,QA+D/B;;CAgFJ"}

package/src/engine/sound/ecs/audio/LiveEmitterSet.js

@@ -75,7 +75,7 @@ export class LiveEmitterSet {
      * entity -> { event, position, gainDb, playingSince }. `gainDb` is the per-emitter instance gain
      * (e.g. the owning `AudioEmitter.volume` in dB) re-applied on every promotion so it survives a
      * demote→re-promote cycle; `playingSince` carries the continuous-clock phase (see {@link add}).
-     * @type {Map<number, {event: EventDescription, position: Vector3, gainDb: number, playingSince: number, acoustic: boolean, pathing: boolean, sourceRadius: number, orientation: Quaternion|null, directivity: AcousticDirectivity|null}>}
+     * @type {Map<number, {event: EventDescription, position: Float64Array, gainDb: number, playingSince: number, acoustic: boolean, pathing: boolean, sourceRadius: number, orientation: Quaternion|null, directivity: AcousticDirectivity|null}>}
      */
     #emitters = new Map();
 
@@ -160,7 +160,7 @@ export class LiveEmitterSet {
      * Register an emitter (dormant until a refresh promotes it).
      * @param {number} entity
      * @param {EventDescription} event
-     * @param {Vector3} position shared position vector (tracked reactively by the spatial index)
+     * @param {Float64Array} position live translation view over the entity's transform; report its moves with {@link moved}
      * @param {number} [gainDb] per-emitter instance gain in dB, applied on every promotion (default 0 = unity)
      * @param {boolean} [acoustic] opt the promoted instances into the acoustic simulation (default false)
      * @param {boolean} [pathing] opt the promoted instances into corner-leakage render (default false)
@@ -175,6 +175,18 @@ export class LiveEmitterSet {
         this.#emitters.set(entity, { event, position, gainDb, playingSince: this.#sopra.currentTime, acoustic, pathing, sourceRadius, orientation, directivity });
     }
 
+    /**
+     * Report that a registered emitter moved, so the broadphase refits it. No-op for an unknown entity.
+     *
+     * The position is a live view, so whatever reads it reads the current value - what the set cannot
+     * do is notice that it was written. {@link refresh} considers only what this reported, which is
+     * what keeps a dormant emitter free: nothing visits it until it moves.
+     * @param {number} entity
+     */
+    moved(entity) {
+        this.#index.refresh(entity);
+    }
+
     /**
      * Invoke `callback` for each currently-live instance (bounded by the budget). Used by the
      * `AudioEmitterSystem` to feed live spatial instances to the acoustic simulation.
@@ -246,11 +258,6 @@ export class LiveEmitterSet {
      * @param {number[]|Float64Array} listenerPosition reads 3 elements
      */
     refresh(listenerPosition) {
-        // The translations are live views over the entities' transforms, so the positions are
-        // already current - only the BVH leaves are stale, and a transform has no signal to refit
-        // them on. One pass here costs what the per-move refits cost before.
-        this.#index.refresh_all();
-
         const candidates = this.#candidates;
         const candidateCount = this.#index.queryAudible(candidates, 0, listenerPosition);
 

package/src/engine/sound/ecs/audio/SpatialAudioIndex.d.ts

@@ -8,9 +8,10 @@
  * `EventInstance`, no WebAudio nodes, no per-frame work. Promoting in-range emitters to live instances
  * (voice slots, stealing, fades) is layered on top later; this class only answers the cull.
  *
- * Leaf bounds track the emitter REACTIVELY: each leaf subscribes to its position's `onChanged`, so a
- * still emitter costs nothing per frame and a moving one refits only when it actually moves. (meep is
- * fully dynamic — there is no static/dynamic distinction and no per-tick refit loop.)
+ * Leaf bounds track the emitter on demand: a position is a live view with no signal of its own, so the
+ * owner calls {@link refresh} for an entity when the dataset announces its transform changed. A still
+ * emitter costs nothing per frame and a moving one refits only when it actually moves. (meep is fully
+ * dynamic — there is no static/dynamic distinction and no per-tick refit loop.)
  *
  * The cull is conservative: the leaf is a cube of half-extent `distanceMax`, so its corners admit a
  * few emitters whose true (spherical) distance slightly exceeds `distanceMax`. That is correct
@@ -56,7 +57,7 @@ export class SpatialAudioIndex {
      */
     queryAudible(out: number[], out_offset: number, listenerPosition: Vector3): number;
     /**
-     * Re-fit the entity's leaf to its current pose.
+     * Re-fit the entity's leaf to its current pose. No-op for an unknown entity.
      *
      * The translation this index holds is a live view over the transform's buffer, so it is already
      * up to date - what it cannot do is announce itself. The owner calls this when the dataset says
@@ -64,17 +65,7 @@ export class SpatialAudioIndex {
      *
      * @param {number} entity
      */
-    /**
-     * Re-fit every leaf.
-     *
-     * The translations are live views over their transforms, so the data is already current - what
-     * is stale is the leaf AABB in the BVH. One pass per tick costs what the per-move refits cost
-     * before, and it is what the emitters' own "next tick re-attenuates" behaviour expects.
-     *
-     * @returns {void}
-     */
-    refresh_all(): void;
-    refresh(entity: any): void;
+    refresh(entity: number): void;
     #private;
 }
 //# sourceMappingURL=SpatialAudioIndex.d.ts.map

package/src/engine/sound/ecs/audio/SpatialAudioIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpatialAudioIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/SpatialAudioIndex.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAyBI;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,YALW,MAAM,qCAEN,YAAY,QAgBtB;IAED;;;;OAIG;IACH,eAFW,MAAM,QAYhB;IAiBD;;;;;;;;;;;OAWG;IACH,kBALW,MAAM,EAAE,cACR,MAAM,8BAEJ,MAAM,CASlB;IACD;;;;;;;;OAQG;IACH;;;;;;;;OAQG;IACH,eAFa,IAAI,CAMhB;IAED,2BAQC;;CAEJ"}
+{"version":3,"file":"SpatialAudioIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/SpatialAudioIndex.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAyBI;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,YALW,MAAM,qCAEN,YAAY,QAgBtB;IAED;;;;OAIG;IACH,eAFW,MAAM,QAYhB;IAiBD;;;;;;;;;;;OAWG;IACH,kBALW,MAAM,EAAE,cACR,MAAM,8BAEJ,MAAM,CASlB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QAUhB;;CAEJ"}