@woosh/meep-engine 3.30.0 → 3.32.0

package/src/engine/sound/material/concrete/SoundMaterialComposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoundMaterialComposition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/material/concrete/SoundMaterialComposition.js"],"names":[],"mappings":"AAWA;IACI;;;OAGG;IACH,WAFU,+BAA+B,EAAE,CAE5B;IAEf;;;OAGG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;;OAIG;IACH,2BAA0B;IAE1B;;;;;;;MAMC;IAED;;;;aASC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,YACN,+BAA+B,UAC/B,MAAM,QAKhB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAQhB;IAED,8FA+BC;CACJ;;;;gDAzG+C,uCAAuC"}
+{"version":3,"file":"SoundMaterialComposition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/material/concrete/SoundMaterialComposition.js"],"names":[],"mappings":"AA8BA;IACI;;;OAGG;IACH,WAFU,+BAA+B,EAAE,CAE5B;IAEf;;;OAGG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;;OAIG;IACH,2BAA0B;IAE1B;;;;;;;MAMC;IAED;;;;aASC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,YACN,+BAA+B,UAC/B,MAAM,QAKhB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAQhB;IAED,8FAiDC;CACJ;;;;gDA9I+C,uCAAuC"}

package/src/engine/sound/material/concrete/SoundMaterialComposition.js

@@ -4,10 +4,29 @@ import { serializeSoundMaterialToJSON } from "./json/serializeSoundMaterialToJSO
 import { deserializeSoundMaterialFromJSON } from "./json/deserializeSoundMaterialFromJSON.js";
 
 /**
+ * Gather buffers, one per level of nesting.
  *
- * @type {SoundAssetPlaybackSpec[]}
+ * A composition may hold another composition, and the child is handed the
+ * parent's gather buffer as its DESTINATION — so a single shared array is both
+ * the inner composition's output and every grandchild's scratch, and each raw
+ * grandchild write to slot 0 lands on top of the result the inner composition
+ * had just stored there. An outer composition over an inner one holding two
+ * sounds returned the second one twice.
+ *
+ * Indexed by depth rather than allocated per call because a composition's
+ * sounds are computed per interaction — a footstep — and the nesting is a
+ * handful of levels at most, so the stack is allocated once and reused.
+ *
+ * @type {SoundAssetPlaybackSpec[][]}
+ */
+const scratch_by_depth = [];
+
+/**
+ * How many {@link SoundMaterialComposition#computeInteractionSounds} calls are
+ * on the stack. The innermost one owns `scratch_by_depth[depth - 1]`.
+ * @type {number}
  */
-const temp = [];
+let scratch_depth = 0;
 
 export class SoundMaterialComposition extends AbstractSoundMaterialDefinition {
     /**
@@ -75,30 +94,48 @@ export class SoundMaterialComposition extends AbstractSoundMaterialDefinition {
 
         let offset = destination_offset;
 
-        for (let i = 0; i < this.materials.length; i++) {
-            const def = this.materials[i];
-            const weight = this.weights[i];
+        // This level's own gather buffer. A child composition takes the next
+        // one down, so its grandchildren cannot write over what it is storing.
+        const depth = scratch_depth++;
+
+        let temp = scratch_by_depth[depth];
 
-            const additions = def.computeInteractionSounds(temp, 0, interaction);
+        if (temp === undefined) {
+            temp = [];
 
-            // adjust based on weights
-            for (let j = 0; j < additions; j++) {
-                const source = temp[j];
+            scratch_by_depth[depth] = temp;
+        }
 
-                const destination_volume = source.volume * weight;
+        try {
+            for (let i = 0; i < this.materials.length; i++) {
+                const def = this.materials[i];
+                const weight = this.weights[i];
 
-                if (destination_volume < this.__volume_threshold) {
-                    continue;
-                }
+                const additions = def.computeInteractionSounds(temp, 0, interaction);
+
+                // adjust based on weights
+                for (let j = 0; j < additions; j++) {
+                    const source = temp[j];
 
-                const target = source.clone();
+                    const destination_volume = source.volume * weight;
 
-                target.multiplyVolume(weight);
+                    if (destination_volume < this.__volume_threshold) {
+                        continue;
+                    }
 
-                destination[offset] = target;
+                    const target = source.clone();
 
-                offset++;
+                    target.multiplyVolume(weight);
+
+                    destination[offset] = target;
+
+                    offset++;
+                }
             }
+        } finally {
+            // A child that throws must not leave the stack a level deeper for
+            // every interaction after it.
+            scratch_depth = depth;
         }
 
         return offset - destination_offset;

package/src/engine/sound/material/detector/terrain/TerrainSoundMaterialSurfaceDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainSoundMaterialSurfaceDetector.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/material/detector/terrain/TerrainSoundMaterialSurfaceDetector.js"],"names":[],"mappings":"AAWA;IAcI,cAUC;IAvBD;;;OAGG;IACH,WAFU,iCAAiC,CAE5B;IAEf;;;;OAIG;IACH,kBAAiB;IAKb;;;;OAIG;IACH,oBAAiD;IAIrD,uCAUC;IAED;;;OAGG;IACH,mCAuBC;IAED;;;;OAIG;IACH,8BAHW,MAAM,mDAUhB;IAED,wDAyBC;CACJ;6CA/G4C,oCAAoC"}
+{"version":3,"file":"TerrainSoundMaterialSurfaceDetector.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/material/detector/terrain/TerrainSoundMaterialSurfaceDetector.js"],"names":[],"mappings":"AAUA;IAcI,cAUC;IAvBD;;;OAGG;IACH,WAFU,iCAAiC,CAE5B;IAEf;;;;OAIG;IACH,kBAAiB;IAKb;;;;OAIG;IACH,oBAAiD;IAIrD,uCAUC;IAED;;;OAGG;IACH,mCAuBC;IAED;;;;OAIG;IACH,8BAHW,MAAM,mDAUhB;IAED,wDAyDC;CACJ;6CA/I4C,oCAAoC"}

package/src/engine/sound/material/detector/terrain/TerrainSoundMaterialSurfaceDetector.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../../../core/assert.js";
-import { vector_normalize } from "../../../../../core/geom/vec/vector_normalize.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
 import { deserializeSoundMaterialFromJSON } from "../../concrete/json/deserializeSoundMaterialFromJSON.js";
 import { SilentSoundMaterial } from "../../concrete/SilentSoundMaterial.js";
@@ -102,15 +101,47 @@ export class TerrainSoundMaterialSurfaceDetector extends SoundMaterialSurfaceDet
         const result = [];
 
 
+        const weights = this.__composite.weights;
+
+        let total = 0;
+
         for (let i = 0; i < layer_count; i++) {
 
             const weight = this.__terrain.splat.sampleWeight(u, v, i);
 
-            this.__composite.weights[i] = weight;
+            weights[i] = weight;
+
+            total += weight;
 
         }
 
-        vector_normalize(this.__composite.weights, this.__composite.weights, layer_count);
+        // Splat weights are a partition of unity, so the normalisation is
+        // `w / sum(w)`. Normalising to Euclidean MAGNITUDE instead — which is
+        // what `vector_normalize` does — leaves them summing to between 1 and
+        // sqrt(N), and every contributing clip's volume is multiplied by its
+        // weight: a 50/50 layer boundary played two clips at 0.707 instead of
+        // two at 0.5, about 3 dB louder than either pure surface and 6 dB with
+        // four layers, so the footstep level pumped on every crossing.
+        if (total > 0) {
+
+            const inverse_total = 1 / total;
+
+            for (let i = 0; i < layer_count; i++) {
+                weights[i] *= inverse_total;
+            }
+
+        } else {
+
+            // An unpainted splat cell, which no layer claims. Dividing here
+            // gave `0 * Infinity` — a NaN volume per layer, past a threshold
+            // test that NaN does not fail, and past the `assert.notNaN` in
+            // `setVolume`, which is stripped in a shipped build. Silence is
+            // the honest answer for ground made of no material.
+            for (let i = 0; i < layer_count; i++) {
+                weights[i] = 0;
+            }
+
+        }
 
         const additions = this.__composite.computeInteractionSounds(result, 0, interaction);
 

package/src/engine/sound/simulation/core/AcousticSolution.d.ts

@@ -14,6 +14,11 @@ export class AcousticSolution {
     /**
      * Per-band (low/mid/high) fraction of energy that LEAKS through the occluder(s), [0, 1]. Only
      * meaningful when `occlusion > 0`. 1 = transparent.
+     *
+     * Energy, carried straight through from {@link AcousticMaterial.transmission}. The render seam
+     * (`EventInstance.setAcoustic`) takes its square root for the direct send's gain, and
+     * `sqrt(1 - transmission)` for the leak's, so the two paths divide the arriving energy exactly.
+     *
      * @type {Float32Array}
      */
     transmission: Float32Array;

package/src/engine/sound/simulation/core/AcousticSolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcousticSolution.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticSolution.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;IACI;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,cAFU,YAAY,CAEqB;IAE3C;;;;;;OAMG;IACH,SAFU,YAAY,CAEgB;IAEtC;;;;OAIG;IACH,SAFU,OAAO,CAED;IAEhB;;;;OAIG;IACH,MAFU,YAAY,CAEK;IAE3B;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,aAFU,YAAY,CAEoB;IAE1C;;;;;OAKG;IACH,iBAFU,MAAM,CAEI;IAEpB;;OAEG;IACH,cAiBC;CACJ"}
+{"version":3,"file":"AcousticSolution.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticSolution.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;IACI;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;;;;;;;OASG;IACH,cAFU,YAAY,CAEqB;IAE3C;;;;;;OAMG;IACH,SAFU,YAAY,CAEgB;IAEtC;;;;OAIG;IACH,SAFU,OAAO,CAED;IAEhB;;;;OAIG;IACH,MAFU,YAAY,CAEK;IAE3B;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,aAFU,YAAY,CAEoB;IAE1C;;;;;OAKG;IACH,iBAFU,MAAM,CAEI;IAEpB;;OAEG;IACH,cAiBC;CACJ"}

package/src/engine/sound/simulation/core/AcousticSolution.js

@@ -15,6 +15,11 @@ export class AcousticSolution {
     /**
      * Per-band (low/mid/high) fraction of energy that LEAKS through the occluder(s), [0, 1]. Only
      * meaningful when `occlusion > 0`. 1 = transparent.
+     *
+     * Energy, carried straight through from {@link AcousticMaterial.transmission}. The render seam
+     * (`EventInstance.setAcoustic`) takes its square root for the direct send's gain, and
+     * `sqrt(1 - transmission)` for the leak's, so the two paths divide the arriving energy exactly.
+     *
      * @type {Float32Array}
      */
     transmission = new Float32Array([1, 1, 1]);

package/src/engine/sound/simulation/definition/AcousticMaterial.d.ts

@@ -28,6 +28,14 @@ export class AcousticMaterial {
     scattering: number;
     /**
      * Fraction of energy passing THROUGH the surface, per band (low/mid/high). 0 = fully blocking.
+     *
+     * Energy, like everything else on this class — `absorption` is consumed as
+     * `energy *= 1 - absorption` by the reflection trace, and a number authored here has to mean
+     * the same thing to both consumers. The single conversion to the amplitude a `GainNode` wants
+     * is in `EventInstance.setAcoustic`, which is the only seam between the two domains.
+     *
+     * So 0.01 is 20 dB of transmission loss, not 40.
+     *
      * @type {Float32Array}
      */
     transmission: Float32Array;

package/src/engine/sound/simulation/definition/AcousticMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcousticMaterial.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/definition/AcousticMaterial.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH;IAoBI;;;OAGG;IACH,uDAHW;QAAC,UAAU,CAAC,EAAC,MAAM,EAAE,GAAC,YAAY,CAAC;QAAC,UAAU,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC1F,gBAAgB,CAsB5B;IA3CD;;;;OAIG;IACH,YAFU,YAAY,CAEyB;IAE/C;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,YAAY,CAEqB;IA4B3C;;;OAGG;IACH,cAHW,gBAAgB,GACd,OAAO,CAUnB;IAED,eAUC;IAED;;OAEG;IACH,SAFa,gBAAgB,CAc5B;IAED;;;;MAMC;IAED;;OAEG;IACH,mDAFW;QAAC,UAAU,EAAC,MAAM,EAAE,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,EAAE,CAAA;KAAC,QAUzE;CACJ"}
+{"version":3,"file":"AcousticMaterial.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/definition/AcousticMaterial.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH;IA4BI;;;OAGG;IACH,uDAHW;QAAC,UAAU,CAAC,EAAC,MAAM,EAAE,GAAC,YAAY,CAAC;QAAC,UAAU,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC1F,gBAAgB,CAsB5B;IAnDD;;;;OAIG;IACH,YAFU,YAAY,CAEyB;IAE/C;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;OAWG;IACH,cAFU,YAAY,CAEqB;IA4B3C;;;OAGG;IACH,cAHW,gBAAgB,GACd,OAAO,CAUnB;IAED,eAUC;IAED;;OAEG;IACH,SAFa,gBAAgB,CAc5B;IAED;;;;MAMC;IAED;;OAEG;IACH,mDAFW;QAAC,UAAU,EAAC,MAAM,EAAE,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,EAAE,CAAA;KAAC,QAUzE;CACJ"}

package/src/engine/sound/simulation/definition/AcousticMaterial.js

@@ -24,6 +24,14 @@ export class AcousticMaterial {
 
     /**
      * Fraction of energy passing THROUGH the surface, per band (low/mid/high). 0 = fully blocking.
+     *
+     * Energy, like everything else on this class — `absorption` is consumed as
+     * `energy *= 1 - absorption` by the reflection trace, and a number authored here has to mean
+     * the same thing to both consumers. The single conversion to the amplitude a `GainNode` wants
+     * is in `EventInstance.setAcoustic`, which is the only seam between the two domains.
+     *
+     * So 0.01 is 20 dB of transmission loss, not 40.
+     *
      * @type {Float32Array}
      */
     transmission = new Float32Array([0, 0, 0]);

package/src/engine/sound/simulation/probe/probe_visibility_augment.d.ts

@@ -9,21 +9,23 @@
  * For a 2-ring chord the two criteria largely coincide (an acute corner is also a big detour), but the
  * explicit angle gate catches sharp corners the length threshold alone would miss. The length test is local
  * (vs the 2-hop, not a global Dijkstra) — cheap and O(n·degree²); acoustically the bends that matter are
- * local corners. Candidates are added highest-detour-first up to `budgetFraction` of the base edge count.
- * Pure geometry; offline (no WebAudio).
+ * local corners. Candidates are added highest-detour-first up to `budgetMultiple` TIMES the base edge count
+ * — the default is above the whole qualifying candidate pool on a lattice, so it caps nothing; pass a number
+ * below 1 for a cap that binds. Pure geometry; offline (no WebAudio).
  *
  * @param {AcousticProbeField} field
  * @param {AcousticOccluderIndex} index the acoustic scene
  * @param {{a: ArrayLike<number>, b: ArrayLike<number>}} edges the current edges (base + bridges)
  * @param {number} [stretchFactor] add a chord when the straight ‖uv‖ beats the 2-hop ‖uw‖+‖wv‖ by ≥ this
  * @param {number} [kinkThreshold] add a chord when the corner at w is acute: dot(̂(u−w), −̂(v−w)) < this
- * @param {number} [budgetFraction] cap added edges at this fraction of the base edge count
+ * @param {number} [budgetMultiple] cap added edges at this multiple of the base edge count; below 1 it is a
+ * fraction and binds, at the default of 3 it does not
  * @returns {{a: number[], b: number[]}} the shortcut edges to add (possibly empty)
  */
 export function probe_visibility_augment(field: AcousticProbeField, index: AcousticOccluderIndex, edges: {
     a: ArrayLike<number>;
     b: ArrayLike<number>;
-}, stretchFactor?: number, kinkThreshold?: number, budgetFraction?: number): {
+}, stretchFactor?: number, kinkThreshold?: number, budgetMultiple?: number): {
     a: number[];
     b: number[];
 };

package/src/engine/sound/simulation/probe/probe_visibility_augment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_visibility_augment.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_augment.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yGANW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,kBAC5C,MAAM,kBACN,MAAM,mBACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA4GtC"}
+{"version":3,"file":"probe_visibility_augment.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_augment.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,yGAPW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,kBAC5C,MAAM,kBACN,MAAM,mBACN,MAAM,GAEJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA4GtC"}

package/src/engine/sound/simulation/probe/probe_visibility_augment.js

@@ -11,8 +11,18 @@ const DEFAULT_STRETCH = 1.06;
 // ...or when the corner at the shared neighbour is sharp: dot(̂(u−w), −̂(v−w)) < this — i.e. the angle u-w-v
 // is acute (a diffraction corner the sound must wrap around). -0.5 ≈ corners sharper than 60°.
 const DEFAULT_KINK = -0.866;
-// Cap added edges at this fraction of the base edge count — a handful of the highest-benefit shortcuts, so
-// the augmentation composes with the base graph rather than densifying it.
+// Cap added edges at this MULTIPLE of the base edge count. Three is deliberately generous: on a lattice of
+// probes it is above the number of chords that survive the stretch and kink tests at all, so the default is
+// effectively "add every qualifying shortcut" and the graph comes out several times denser than the Delaunay
+// base. Pass a number below 1 for a cap that actually binds.
+//
+// This constant read "cap added edges at this FRACTION of the base edge count — a handful of the
+// highest-benefit shortcuts, so the augmentation composes with the base graph rather than densifying it",
+// which is the opposite of what 3 does, and the parameter was named to match the comment rather than the
+// value. The value is what shipped and what the acoustics were tuned against, so it stands and the words
+// move: measured on a doorway scene at minSpacing 3, the portal-densification stage's routed-length
+// balancing only shows up at this budget — at 1 or below the cross-opening chords it adds change no
+// shortest path. Lowering it is an acoustics decision with a measurable cost, not a typo fix.
 const DEFAULT_BUDGET = 3;
 
 /**
@@ -26,15 +36,17 @@ const DEFAULT_BUDGET = 3;
  * For a 2-ring chord the two criteria largely coincide (an acute corner is also a big detour), but the
  * explicit angle gate catches sharp corners the length threshold alone would miss. The length test is local
  * (vs the 2-hop, not a global Dijkstra) — cheap and O(n·degree²); acoustically the bends that matter are
- * local corners. Candidates are added highest-detour-first up to `budgetFraction` of the base edge count.
- * Pure geometry; offline (no WebAudio).
+ * local corners. Candidates are added highest-detour-first up to `budgetMultiple` TIMES the base edge count
+ * — the default is above the whole qualifying candidate pool on a lattice, so it caps nothing; pass a number
+ * below 1 for a cap that binds. Pure geometry; offline (no WebAudio).
  *
  * @param {AcousticProbeField} field
  * @param {AcousticOccluderIndex} index the acoustic scene
  * @param {{a: ArrayLike<number>, b: ArrayLike<number>}} edges the current edges (base + bridges)
  * @param {number} [stretchFactor] add a chord when the straight ‖uv‖ beats the 2-hop ‖uw‖+‖wv‖ by ≥ this
  * @param {number} [kinkThreshold] add a chord when the corner at w is acute: dot(̂(u−w), −̂(v−w)) < this
- * @param {number} [budgetFraction] cap added edges at this fraction of the base edge count
+ * @param {number} [budgetMultiple] cap added edges at this multiple of the base edge count; below 1 it is a
+ * fraction and binds, at the default of 3 it does not
  * @returns {{a: number[], b: number[]}} the shortcut edges to add (possibly empty)
  */
 export function probe_visibility_augment(
@@ -43,7 +55,7 @@ export function probe_visibility_augment(
     edges,
     stretchFactor = DEFAULT_STRETCH,
     kinkThreshold = DEFAULT_KINK,
-    budgetFraction = DEFAULT_BUDGET
+    budgetMultiple = DEFAULT_BUDGET
 ) {
     const n = field.size;
 
@@ -124,7 +136,7 @@ export function probe_visibility_augment(
     const order = candU.map((_, i) => i);
     order.sort((i, j) => candBenefit[j] - candBenefit[i]);
 
-    const budget = Math.floor(budgetFraction * m);
+    const budget = Math.floor(budgetMultiple * m);
     const added = new Set();
     const outA = [];
     const outB = [];

package/src/engine/sound/simulation/render/FoaProbeReverbRenderer.d.ts

@@ -45,6 +45,45 @@ export class FoaProbeReverbRenderer {
      * @type {number}
      */
     minDecay: number;
+    /**
+     * Minimum change in decay (seconds) that triggers a re-bake + crossfade — avoids churning four
+     * convolvers on tiny listener moves.
+     *
+     * This gated on the nearest *probe index* alone, which in a `bakeProbeField` cover is every few
+     * metres of walking, and each crossing synthesises four mono `AudioBuffer`s on the main thread.
+     * Two adjacent probes in one room measure nearly the same decay, so the index changing says almost
+     * nothing about whether the IR would. Same rule and same default as {@link ProbeReverbRenderer},
+     * where it landed as GAP-032.
+     *
+     * @type {number}
+     */
+    changeThreshold: number;
+    /**
+     * Longest impulse response this will synthesise, in seconds.
+     *
+     * `foaReverbImpulseResponse` sized its buffers straight from the RT60 with no ceiling. An 8 s probe
+     * at 48 kHz is `length = 384,000`: four mono `AudioBuffer`s, about 6.1 MB, synthesised
+     * sample-by-sample **on the main thread** on every probe-cell crossing. That is the hitch the scalar
+     * path already diagnosed and clamped under GAP-032, and the fix had simply not travelled.
+     *
+     * Three seconds is what a `ConvolverNode` is comfortable running. Raise it if you have measured that
+     * you can afford to.
+     *
+     * @type {number}
+     */
+    maxDecaySeconds: number;
+    set sendLevel(value: number);
+    /**
+     * How much of the send actually comes back, 0..1.
+     *
+     * There was no level in this path either: the wet gains crossfade between silence and **unity**, so
+     * connecting a bus output to {@link input} the way this class documents put the whole mix through the
+     * convolvers at full wet. See {@link ProbeReverbRenderer#sendLevel} for the argument; this is the same
+     * default and the same immediate application to a live crossfade.
+     *
+     * @type {number}
+     */
+    get sendLevel(): number;
     /**
      * The node sources / a sopra bus send their post-fader copy into.
      * @returns {AudioNode}

package/src/engine/sound/simulation/render/FoaProbeReverbRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FoaProbeReverbRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/FoaProbeReverbRenderer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAsHI;;;OAGG;IACH,2BAHW,gBAAgB,eAChB,SAAS,EAkEnB;IAzLD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,UAFU,MAAM,CAEA;IA2KhB;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,oDAGC;IAED;;;;;;;;;OASG;IACH,UALW,MAAM,KACN,MAAM,KACN,MAAM,eACN;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAkB/C;;CAkEJ"}
+{"version":3,"file":"FoaProbeReverbRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/FoaProbeReverbRenderer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA0MI;;;OAGG;IACH,2BAHW,gBAAgB,eAChB,SAAS,EAkEnB;IA7QD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,UAFU,MAAM,CAEA;IAEhB;;;;;;;;;;;OAWG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;;;;;;;;OAYG;IACH,iBAFU,MAAM,CAEI;IAgBpB,6BAUC;IAxBD;;;;;;;;;OASG;IACH,wBAEC;IAoND;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,oDAeC;IAED;;;;;;;;;OASG;IACH,UALW,MAAM,KACN,MAAM,KACN,MAAM,eACN;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAsB/C;;CA+FJ"}

package/src/engine/sound/simulation/render/FoaProbeReverbRenderer.js

@@ -66,6 +66,87 @@ export class FoaProbeReverbRenderer {
      */
     minDecay = 0.05;
 
+    /**
+     * Minimum change in decay (seconds) that triggers a re-bake + crossfade — avoids churning four
+     * convolvers on tiny listener moves.
+     *
+     * This gated on the nearest *probe index* alone, which in a `bakeProbeField` cover is every few
+     * metres of walking, and each crossing synthesises four mono `AudioBuffer`s on the main thread.
+     * Two adjacent probes in one room measure nearly the same decay, so the index changing says almost
+     * nothing about whether the IR would. Same rule and same default as {@link ProbeReverbRenderer},
+     * where it landed as GAP-032.
+     *
+     * @type {number}
+     */
+    changeThreshold = 0.1;
+
+    /**
+     * Longest impulse response this will synthesise, in seconds.
+     *
+     * `foaReverbImpulseResponse` sized its buffers straight from the RT60 with no ceiling. An 8 s probe
+     * at 48 kHz is `length = 384,000`: four mono `AudioBuffer`s, about 6.1 MB, synthesised
+     * sample-by-sample **on the main thread** on every probe-cell crossing. That is the hitch the scalar
+     * path already diagnosed and clamped under GAP-032, and the fix had simply not travelled.
+     *
+     * Three seconds is what a `ConvolverNode` is comfortable running. Raise it if you have measured that
+     * you can afford to.
+     *
+     * @type {number}
+     */
+    maxDecaySeconds = 3;
+
+    /**
+     * How much of the send actually comes back, 0..1.
+     *
+     * There was no level in this path either: the wet gains crossfade between silence and **unity**, so
+     * connecting a bus output to {@link input} the way this class documents put the whole mix through the
+     * convolvers at full wet. See {@link ProbeReverbRenderer#sendLevel} for the argument; this is the same
+     * default and the same immediate application to a live crossfade.
+     *
+     * @type {number}
+     */
+    get sendLevel() {
+        return this.#sendLevel;
+    }
+
+    set sendLevel(value) {
+        this.#sendLevel = value;
+
+        if (this.#currentlyAudible) {
+            const level = Math.max(FADE_EPSILON, value);
+
+            for (let ch = 0; ch < CHANNELS; ch++) {
+                rampGain(this.#wets[this.#active][ch].gain, level, 0.02, this.#ctx);
+            }
+        }
+    }
+
+    /** @private @type {number} */
+    #sendLevel = 1;
+
+    /**
+     * Per-band RT60 the currently baked IR was made from, so a re-bake can be skipped when the next
+     * probe's bands are within {@link changeThreshold} of it.
+     *
+     * NaN until the first bake: every comparison against NaN is false, so the threshold cannot suppress
+     * the first crossfade. Zeros would have — a probe measuring below minDecay is within threshold of
+     * zero, and the renderer would have sat at its construction gains with nothing scheduled.
+     *
+     * @private
+     * @type {Float64Array}
+     */
+    #currentBands = new Float64Array([NaN, NaN, NaN]);
+
+    /**
+     * Whether the baked IR is audible, i.e. whether the last crossfade went to the send level or to
+     * silence. Part of the re-bake decision for the same reason it is in the scalar renderer: a
+     * `minDecay` crossing can be smaller than `changeThreshold`, and gating on the bands alone would
+     * leave the reverb stuck on or off across that boundary.
+     * @private
+     * @type {boolean}
+     */
+    #currentlyAudible = false;
+
     /**
      * @type {BaseAudioContext}
      */
@@ -126,6 +207,9 @@ export class FoaProbeReverbRenderer {
      * Set by {@link setProbeField} to force a re-bake on the next {@link update} even when the nearest
      * probe index is unchanged — in particular so swapping in an EMPTY field (whose nearest index is also
      * -1, like the initial state) still mutes the previous field's reverb instead of leaving it playing.
+     *
+     * It cannot cover unbinding, which is what the ECS layer actually does: {@link update} returns on a
+     * null field before it reaches the re-bake, so {@link setProbeField} mutes that case itself.
      * @type {boolean}
      */
     #dirty = false;
@@ -257,6 +341,18 @@ export class FoaProbeReverbRenderer {
     setProbeField(probeField) {
         this.#probeField = probeField;
         this.#dirty = true; // force a re-bake on the next update even if the nearest index is unchanged
+
+        if (probeField === null) {
+            // Unbinding mutes here rather than on the next update, because
+            // `update` returns on a null field before it can reach the
+            // re-bake the flag above was set for — so otherwise the last
+            // room's IR stays at full send level for the rest of the session.
+            // `AcousticProbeFieldSystem` unbinds on unlink, which is every
+            // level transition and teardown.
+            this.#dirty = false;
+            this.#currentProbe = -1;
+            this.#rebake(null, -1);
+        }
     }
 
     /**
@@ -284,6 +380,10 @@ export class FoaProbeReverbRenderer {
             this.#rebake(field, i);
         }
 
+        // NOTE the probe index is the *trigger*; whether anything is actually re-baked is decided inside
+        // #rebake against changeThreshold, so walking across a cover of probes in one room does not
+        // synthesise four buffers per cell crossing.
+
         this.#updateDecode(orientation);
     }
 
@@ -311,9 +411,38 @@ export class FoaProbeReverbRenderer {
             audible = Math.max(bands[0], bands[1], bands[2]) >= this.minDecay;
         }
 
+        const current = this.#currentBands;
+
+        const bandsClose = Math.abs(bands[0] - current[0]) < this.changeThreshold
+            && Math.abs(bands[1] - current[1]) < this.changeThreshold
+            && Math.abs(bands[2] - current[2]) < this.changeThreshold;
+
+        /*
+         Re-bake and crossfade unless BOTH the IR is unchanged (sub-threshold band move) AND the
+         audible/silent state is unchanged. Gating on `bandsClose` alone would swallow a `minDecay`
+         crossing smaller than `changeThreshold` (0.1 > 0.05) and leave the reverb stuck on or off
+         across that boundary — the same reasoning as ProbeReverbRenderer#setBands.
+        */
+        if (bandsClose && audible === this.#currentlyAudible) {
+            return;
+        }
+
+        current[0] = bands[0];
+        current[1] = bands[1];
+        current[2] = bands[2];
+        this.#currentlyAudible = audible;
+
         const inactive = 1 - this.#active;
 
         if (audible) {
+            // clamped here rather than at the bake, so a field that ships a long RT60 still plays at a
+            // length the convolvers can run and the allocation stays bounded
+            const ceiling = this.maxDecaySeconds;
+
+            bands[0] = Math.min(bands[0], ceiling);
+            bands[1] = Math.min(bands[1], ceiling);
+            bands[2] = Math.min(bands[2], ceiling);
+
             const ir = foaReverbImpulseResponse(this.#ctx, bands, dirs, this.decayPower, this.#random);
             this.#convolvers[inactive][W].buffer = ir.w;
             this.#convolvers[inactive][X].buffer = ir.x;
@@ -322,7 +451,7 @@ export class FoaProbeReverbRenderer {
         }
 
         const cf = this.crossfadeSeconds;
-        const target = audible ? 1 : FADE_EPSILON;
+        const target = audible ? Math.max(FADE_EPSILON, this.#sendLevel) : FADE_EPSILON;
 
         for (let ch = 0; ch < CHANNELS; ch++) {
             rampGain(this.#wets[this.#active][ch].gain, FADE_EPSILON, cf, this.#ctx);

package/src/engine/sound/simulation/render/ProbeReverbRenderer.d.ts

@@ -83,9 +83,10 @@ export class ProbeReverbRenderer {
      */
     get output(): AudioNode;
     /**
-     * @param {AcousticProbeField} probeField the baked probe volume the reverb reads from
+     * @param {AcousticProbeField|null} probeField the baked probe volume the
+     *   reverb reads from, or `null` to unbind it
      */
-    setProbeField(probeField: AcousticProbeField): void;
+    setProbeField(probeField: AcousticProbeField | null): void;
     /**
      * Drive the reverb from the listener position via the bound probe field. No-op if no field is set.
      * @param {number} x

package/src/engine/sound/simulation/render/ProbeReverbRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeReverbRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/ProbeReverbRenderer.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH;IAwII;;;OAGG;IACH,0BAHW,gBAAgB,eAChB,SAAS,EA8BnB;IAvKD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,UAFU,MAAM,CAEA;IAsBhB,6BAQC;IA5BD;;;;;;;;;;;;;;;OAeG;IACH,wBAEC;IAeD;;;;;;;;;;;;;;OAcG;IACH,iBAFU,MAAM,CAEI;IAgGpB;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,oDAEC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,KACN,MAAM,QAShB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAOhB;IAED;;;;OAIG;IACH,gBAFW,YAAY,GAAC,MAAM,EAAE,QAiD/B;;CACJ"}
+{"version":3,"file":"ProbeReverbRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/ProbeReverbRenderer.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH;IAwII;;;OAGG;IACH,0BAHW,gBAAgB,eAChB,SAAS,EA8BnB;IAvKD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,UAFU,MAAM,CAEA;IAsBhB,6BAQC;IA5BD;;;;;;;;;;;;;;;OAeG;IACH,wBAEC;IAeD;;;;;;;;;;;;;;OAcG;IACH,iBAFU,MAAM,CAEI;IAgGpB;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,0BAHW,qBAAmB,IAAI,QAkBjC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,KACN,MAAM,QAShB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAOhB;IAED;;;;OAIG;IACH,gBAFW,YAAY,GAAC,MAAM,EAAE,QAiD/B;;CACJ"}

package/src/engine/sound/simulation/render/ProbeReverbRenderer.js

@@ -202,10 +202,24 @@ export class ProbeReverbRenderer {
     }
 
     /**
-     * @param {AcousticProbeField} probeField the baked probe volume the reverb reads from
+     * @param {AcousticProbeField|null} probeField the baked probe volume the
+     *   reverb reads from, or `null` to unbind it
      */
     setProbeField(probeField) {
         this.#probeField = probeField;
+
+        if (probeField === null) {
+            // Unbinding has to mute here, not leave it to `update`: `update` is
+            // the only path to the wet gains and it returns on a null field, so
+            // otherwise the convolver keeps the last room's IR at full send
+            // level for the rest of the session. `AcousticProbeFieldSystem`
+            // unbinds on unlink, which is every level transition and teardown.
+            this.#scratchBands[0] = 0;
+            this.#scratchBands[1] = 0;
+            this.#scratchBands[2] = 0;
+
+            this.setBands(this.#scratchBands);
+        }
     }
 
     /**

package/src/engine/sound/sopra/SopraEngine.d.ts

@@ -78,6 +78,16 @@ export class SopraEngine {
     get masterBusOutput(): AudioNode;
     /**
      * Replace the mixer with a new bus tree (rebuilds the WebAudio graph).
+     *
+     * The graph being replaced is disposed first. Without that it stayed wired into the destination
+     * — two mixers summing at once, the old one audible but unreachable because
+     * {@link setBusVolume}, the ducking and the snapshots all address the new graph's nodes — and
+     * its whole node tree leaked, because the destination still referenced it.
+     *
+     * A live {@link EventInstance} captured its bus input node when its chain was built and goes on
+     * feeding the old graph, so anything already playing is silenced by the swap rather than
+     * re-routed. Swap between scenes, or stop what is playing first.
+     *
      * @param {BusDefinition[]} busDefinitions
      */
     setBuses(busDefinitions: BusDefinition[]): void;

package/src/engine/sound/sopra/SopraEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SopraEngine.d.ts","sourceRoot":"","sources":["../../../../../src/engine/sound/sopra/SopraEngine.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"SopraEngine.d.ts","sourceRoot":"","sources":["../../../../../src/engine/sound/sopra/SopraEngine.js"],"names":[],"mappings":"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"}