@woosh/meep-engine 2.169.1 → 2.169.2

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

@@ -0,0 +1,55 @@
+/**
+ * Longest tail either band-set can produce: the per-band bin counts derived from `decayBands`.
+ *
+ * @param {number} decaySeconds RT60 of one band
+ * @param {number} sampleRate
+ * @returns {number} tail length in samples (at least 1)
+ */
+export function reverb_band_length(decaySeconds: number, sampleRate: number): number;
+/**
+ * Synthesise the THREE decaying-noise band tails a reverb impulse response is made of, writing each band's
+ * enveloped samples into its own output array.
+ *
+ * WHY this exists: the tail model — split one white-noise stream into low/mid/high with a pair of one-pole
+ * filters, then give each band its OWN `(1 − i/len)^power` envelope so a band rings for exactly its own RT60 —
+ * is the acoustic character of the whole reverb path, and it was written out twice: once for the scalar
+ * stereo IR ({@link reverbImpulseResponse}) and once for the B-format directional IR
+ * ({@link foaReverbImpulseResponse}). Only the WRITE-OUT differs (an omni sum vs a per-band
+ * direction-weighted fan into W/X/Y/Z), so retuning the crossover, the filter coefficients or the envelope
+ * shape had to land in both or the two renderers would disagree about what the same room sounds like. The
+ * split is drawn where {@link EventInstance}'s crossover helpers already draw it: shared per-BUFFER
+ * production, per-sample consumption left to the caller (no per-sample callback).
+ *
+ * The bands are energy-preserving: `low + mid + high === noise` before enveloping, so equal RT60s reconstruct
+ * the plain scalar tail exactly.
+ *
+ * Outputs are `Float64Array` rather than `Float32Array` deliberately: the callers sum and re-weight these
+ * values, and rounding each band to float32 first would perturb the sum. Float64 keeps every consumer's
+ * arithmetic identical to computing the bands inline.
+ *
+ * PRECONDITION: `out_low`, `out_mid` and `out_high` are each at least `length` long, and `length` is
+ * `max(len_low, len_mid, len_high)`.
+ *
+ * @param {Float64Array} out_low low-band enveloped samples
+ * @param {Float64Array} out_mid mid-band enveloped samples
+ * @param {Float64Array} out_high high-band enveloped samples
+ * @param {number} length samples to write
+ * @param {number} len_low low-band tail length in samples (silent past it)
+ * @param {number} len_mid mid-band tail length in samples
+ * @param {number} len_high high-band tail length in samples
+ * @param {number} decay_power envelope exponent (higher = faster fade)
+ * @param {number} sample_rate
+ * @param {function():number} random seeded RNG in [0, 1); consumed once per sample
+ */
+export function reverb_band_tails(out_low: Float64Array, out_mid: Float64Array, out_high: Float64Array, length: number, len_low: number, len_mid: number, len_high: number, decay_power: number, sample_rate: number, random: () => number): void;
+/**
+ * Band split frequencies (Hz): low | mid below this, mid | high below the second. Crude one-pole splits —
+ * enough to give the reverb tail per-band timbre (a bright vs. dead room), it is decaying noise, not a
+ * precise crossover. They live beside the kernel that applies them; both impulse-response producers and
+ * {@link EventInstance}'s direct-path crossover re-export/consume them so every band split in the engine
+ * lands on the same two edges.
+ * @type {number}
+ */
+export const LOW_MID_HZ: number;
+export const MID_HIGH_HZ: 2500;
+//# sourceMappingURL=reverb_band_tails.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reverb_band_tails.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/reverb_band_tails.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,iDAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,2CAXW,YAAY,WACZ,YAAY,YACZ,YAAY,UACZ,MAAM,WACN,MAAM,WACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,gBACK,MAAM,QAqC3B;AA5FD;;;;;;;GAOG;AACH,yBAFU,MAAM,CAEc;AAC9B,+BAAgC"}

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

@@ -0,0 +1,93 @@
+/**
+ * Band split frequencies (Hz): low | mid below this, mid | high below the second. Crude one-pole splits —
+ * enough to give the reverb tail per-band timbre (a bright vs. dead room), it is decaying noise, not a
+ * precise crossover. They live beside the kernel that applies them; both impulse-response producers and
+ * {@link EventInstance}'s direct-path crossover re-export/consume them so every band split in the engine
+ * lands on the same two edges.
+ * @type {number}
+ */
+export const LOW_MID_HZ = 250;
+export const MID_HIGH_HZ = 2500;
+
+/**
+ * Longest tail either band-set can produce: the per-band bin counts derived from `decayBands`.
+ *
+ * @param {number} decaySeconds RT60 of one band
+ * @param {number} sampleRate
+ * @returns {number} tail length in samples (at least 1)
+ */
+export function reverb_band_length(decaySeconds, sampleRate) {
+    return Math.max(1, Math.floor(decaySeconds * sampleRate));
+}
+
+/**
+ * Synthesise the THREE decaying-noise band tails a reverb impulse response is made of, writing each band's
+ * enveloped samples into its own output array.
+ *
+ * WHY this exists: the tail model — split one white-noise stream into low/mid/high with a pair of one-pole
+ * filters, then give each band its OWN `(1 − i/len)^power` envelope so a band rings for exactly its own RT60 —
+ * is the acoustic character of the whole reverb path, and it was written out twice: once for the scalar
+ * stereo IR ({@link reverbImpulseResponse}) and once for the B-format directional IR
+ * ({@link foaReverbImpulseResponse}). Only the WRITE-OUT differs (an omni sum vs a per-band
+ * direction-weighted fan into W/X/Y/Z), so retuning the crossover, the filter coefficients or the envelope
+ * shape had to land in both or the two renderers would disagree about what the same room sounds like. The
+ * split is drawn where {@link EventInstance}'s crossover helpers already draw it: shared per-BUFFER
+ * production, per-sample consumption left to the caller (no per-sample callback).
+ *
+ * The bands are energy-preserving: `low + mid + high === noise` before enveloping, so equal RT60s reconstruct
+ * the plain scalar tail exactly.
+ *
+ * Outputs are `Float64Array` rather than `Float32Array` deliberately: the callers sum and re-weight these
+ * values, and rounding each band to float32 first would perturb the sum. Float64 keeps every consumer's
+ * arithmetic identical to computing the bands inline.
+ *
+ * PRECONDITION: `out_low`, `out_mid` and `out_high` are each at least `length` long, and `length` is
+ * `max(len_low, len_mid, len_high)`.
+ *
+ * @param {Float64Array} out_low low-band enveloped samples
+ * @param {Float64Array} out_mid mid-band enveloped samples
+ * @param {Float64Array} out_high high-band enveloped samples
+ * @param {number} length samples to write
+ * @param {number} len_low low-band tail length in samples (silent past it)
+ * @param {number} len_mid mid-band tail length in samples
+ * @param {number} len_high high-band tail length in samples
+ * @param {number} decay_power envelope exponent (higher = faster fade)
+ * @param {number} sample_rate
+ * @param {function():number} random seeded RNG in [0, 1); consumed once per sample
+ */
+export function reverb_band_tails(
+    out_low, out_mid, out_high,
+    length,
+    len_low, len_mid, len_high,
+    decay_power,
+    sample_rate,
+    random
+) {
+    // one-pole smoothing coefficients for the band split: a = 1 − e^(−2π f / fs)
+    const aLow = 1 - Math.exp((-2 * Math.PI * LOW_MID_HZ) / sample_rate);
+    const aHigh = 1 - Math.exp((-2 * Math.PI * MID_HIGH_HZ) / sample_rate);
+
+    let lpLow = 0;
+    let lpHigh = 0;
+
+    for (let i = 0; i < length; i++) {
+
+        const noise = random() * 2 - 1;
+
+        lpLow += aLow * (noise - lpLow);
+        lpHigh += aHigh * (noise - lpHigh);
+
+        // energy-preserving 3-way split: low + mid + high == noise
+        const low = lpLow;
+        const mid = lpHigh - lpLow;
+        const high = noise - lpHigh;
+
+        const envLow = i < len_low ? Math.pow(1 - i / len_low, decay_power) : 0;
+        const envMid = i < len_mid ? Math.pow(1 - i / len_mid, decay_power) : 0;
+        const envHigh = i < len_high ? Math.pow(1 - i / len_high, decay_power) : 0;
+
+        out_low[i] = low * envLow;
+        out_mid[i] = mid * envMid;
+        out_high[i] = high * envHigh;
+    }
+}

package/src/engine/sound/sopra/definition/EventDescriptionSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventDescriptionSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/EventDescriptionSerializationAdapter.js"],"names":[],"mappings":"AAKA;IACI,+BAAyB;IAGzB;;;OAGG;IACH,uCAFW,gBAAgB,QA2B1B;IAED;;;OAGG;IACH,yCAFW,gBAAgB,QA2B1B;CACJ;qDApEoD,4EAA4E;iCAChG,uBAAuB"}
+{"version":3,"file":"EventDescriptionSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/EventDescriptionSerializationAdapter.js"],"names":[],"mappings":"AAOA;IACI,+BAAyB;IAGzB;;;OAGG;IACH,uCAFW,gBAAgB,QAkB1B;IAED;;;OAGG;IACH,yCAFW,gBAAgB,QAkB1B;CACJ;qDAlDoD,4EAA4E;iCAChG,uBAAuB"}

package/src/engine/sound/sopra/definition/EventDescriptionSerializationAdapter.js

@@ -1,5 +1,7 @@
-import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
-import { Keyframe } from "../../../animation/curve/Keyframe.js";
+import {
+    deserialize_animation_curve,
+    serialize_animation_curve
+} from "../../../animation/curve/animation_curve_binary_codec.js";
 import { ObjectBasedClassSerializationAdapter } from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
 import { EventDescription } from "./EventDescription.js";
 
@@ -21,16 +23,7 @@ export class EventDescriptionSerializationAdapter extends ObjectBasedClassSerial
         buffer.writeFloat32(value.distanceMin);
         buffer.writeFloat32(value.distanceMax);
 
-        // AnimationCurve has no binary adapter of its own, so its keyframes are written inline here
-        const keys = value.attenuation.keys;
-        buffer.writeUintVar(keys.length);
-        for (let i = 0; i < keys.length; i++) {
-            const k = keys[i];
-            buffer.writeFloat32(k.time);
-            buffer.writeFloat32(k.value);
-            buffer.writeFloat32(k.inTangent);
-            buffer.writeFloat32(k.outTangent);
-        }
+        serialize_animation_curve(buffer, value.attenuation);
 
         buffer.writeUintVar(value.maxInstances);
         buffer.writeFloat32(value.priority);
@@ -52,16 +45,7 @@ export class EventDescriptionSerializationAdapter extends ObjectBasedClassSerial
         value.distanceMin = buffer.readFloat32();
         value.distanceMax = buffer.readFloat32();
 
-        const curve = new AnimationCurve();
-        const keyCount = buffer.readUintVar();
-        for (let i = 0; i < keyCount; i++) {
-            const time = buffer.readFloat32();
-            const v = buffer.readFloat32();
-            const inTangent = buffer.readFloat32();
-            const outTangent = buffer.readFloat32();
-            curve.add(Keyframe.from(time, v, inTangent, outTangent));
-        }
-        value.attenuation = curve;
+        value.attenuation = deserialize_animation_curve(buffer);
 
         value.maxInstances = buffer.readUintVar();
         value.priority = buffer.readFloat32();

package/src/engine/sound/sopra/definition/clip/BlendContainerAudioClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlendContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/BlendContainerAudioClip.js"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH;IAqBI;;;;OAIG;IACH,uBAJW,mBAAmB,wCACnB;QAAC,SAAS,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,MAAM,CAAC,EAAC,cAAc,EAAE,CAAA;KAAC,GACjE,uBAAuB,CAWnC;IAjCD;;;OAGG;IACH,WAFU,MAAM,CAED;IAEf;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,QAFU,cAAc,EAAE,CAEd;IAkCZ;;;;;;;;MA+BC;IAED;;;OAGG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAkBnB;IAiBD,iCAaC;IAED;;;;;;;;;;;;MASC;IAED;;;;;;;aAWC;;CACJ;;;;mCA7KkC,yBAAyB;+BAF7B,+CAA+C"}
+{"version":3,"file":"BlendContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/BlendContainerAudioClip.js"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH;IAqBI;;;;OAIG;IACH,uBAJW,mBAAmB,wCACnB;QAAC,SAAS,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,MAAM,CAAC,EAAC,cAAc,EAAE,CAAA;KAAC,GACjE,uBAAuB,CAWnC;IAjCD;;;OAGG;IACH,WAFU,MAAM,CAED;IAEf;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,QAFU,cAAc,EAAE,CAEd;IAkCZ;;;;;;;;MA+BC;IAED;;;OAGG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAkBnB;IAqBD,iCAaC;IAED;;;;;;;;;;;;MASC;IAED;;;;;;;aAWC;;CACJ;;;;mCAjLkC,yBAAyB;+BAF7B,+CAA+C"}

package/src/engine/sound/sopra/definition/clip/BlendContainerAudioClip.js

@@ -124,15 +124,19 @@ export class BlendContainerAudioClip extends ContainerAudioClip {
     }
 
     hash() {
+        // super.hash() already folds gain/pitch + children; only this class's own fields go on top.
+        // `blends` MUST be folded here — `equals` compares the curves element-wise, so leaving them out
+        // made two containers differing only in their blend curves compare unequal yet hash identically.
         let h = combine_hash(
             super.hash(),
             computeStringHash(this.parameter),
             computeHashFloat(this.defaultValue)
         );
 
-        const children = this.children;
-        for (let i = 0; i < children.length; i++) {
-            h = combine_hash(h, children[i].hash());
+        const blends = this.blends;
+
+        for (let i = 0; i < blends.length; i++) {
+            h = combine_hash(h, blends[i].hash());
         }
 
         return h;

package/src/engine/sound/sopra/definition/clip/BlendContainerAudioClipSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlendContainerAudioClipSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/BlendContainerAudioClipSerializationAdapter.js"],"names":[],"mappings":"AAKA;IACI,sCAAgC;IAGhC;;;OAGG;IACH,uCAFW,uBAAuB,QA4BjC;IAED;;;OAGG;IACH,yCAFW,uBAAuB,QA6BjC;CACJ;qDAvEoD,+EAA+E;wCAC5F,8BAA8B"}
+{"version":3,"file":"BlendContainerAudioClipSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/BlendContainerAudioClipSerializationAdapter.js"],"names":[],"mappings":"AAOA;IACI,sCAAgC;IAGhC;;;OAGG;IACH,uCAFW,uBAAuB,QAoBjC;IAED;;;OAGG;IACH,yCAFW,uBAAuB,QAoBjC;CACJ;qDAtDoD,+EAA+E;wCAC5F,8BAA8B"}

package/src/engine/sound/sopra/definition/clip/BlendContainerAudioClipSerializationAdapter.js

@@ -1,5 +1,7 @@
-import { AnimationCurve } from "../../../../animation/curve/AnimationCurve.js";
-import { Keyframe } from "../../../../animation/curve/Keyframe.js";
+import {
+    deserialize_animation_curve,
+    serialize_animation_curve
+} from "../../../../animation/curve/animation_curve_binary_codec.js";
 import { ObjectBasedClassSerializationAdapter } from "../../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
 import { BlendContainerAudioClip } from "./BlendContainerAudioClip.js";
 
@@ -17,19 +19,11 @@ export class BlendContainerAudioClipSerializationAdapter extends ObjectBasedClas
         buffer.writeUTF8String(value.parameter);
         buffer.writeFloat32(value.defaultValue);
 
-        // blend curves (parallel to children) written as inline keyframes (AnimationCurve has no adapter)
+        // blend curves, parallel to children
         const blends = value.blends;
         buffer.writeUintVar(blends.length);
         for (let i = 0; i < blends.length; i++) {
-            const keys = blends[i].keys;
-            buffer.writeUintVar(keys.length);
-            for (let k = 0; k < keys.length; k++) {
-                const kf = keys[k];
-                buffer.writeFloat32(kf.time);
-                buffer.writeFloat32(kf.value);
-                buffer.writeFloat32(kf.inTangent);
-                buffer.writeFloat32(kf.outTangent);
-            }
+            serialize_animation_curve(buffer, blends[i]);
         }
 
         const children = value.children;
@@ -52,16 +46,7 @@ export class BlendContainerAudioClipSerializationAdapter extends ObjectBasedClas
         const blendCount = buffer.readUintVar();
         const blends = [];
         for (let i = 0; i < blendCount; i++) {
-            const curve = new AnimationCurve();
-            const keyCount = buffer.readUintVar();
-            for (let k = 0; k < keyCount; k++) {
-                const time = buffer.readFloat32();
-                const v = buffer.readFloat32();
-                const inTangent = buffer.readFloat32();
-                const outTangent = buffer.readFloat32();
-                curve.add(Keyframe.from(time, v, inTangent, outTangent));
-            }
-            blends.push(curve);
+            blends.push(deserialize_animation_curve(buffer));
         }
         value.blends = blends;
 

package/src/engine/sound/sopra/definition/clip/ContainerAudioClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/ContainerAudioClip.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IAEI;;OAEG;IACH,UAFU,iBAAiB,EAAE,CAEf;IAEd;;;;OAIG;IACH,eAHW,iBAAiB,GACf,IAAI,CAQhB;IAED;;;;OAIG;IACH,mBAHW,iBAAiB,EAAE,GACjB,IAAI,CAQhB;IAED,sBAEC;IA6BD;;;;;;OAMG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAqBnB;CACJ;kCAlGiC,wBAAwB"}
+{"version":3,"file":"ContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/ContainerAudioClip.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IAEI;;OAEG;IACH,UAFU,iBAAiB,EAAE,CAEf;IAEd;;;;OAIG;IACH,eAHW,iBAAiB,GACf,IAAI,CAQhB;IAED;;;;OAIG;IACH,mBAHW,iBAAiB,EAAE,GACjB,IAAI,CAQhB;IAED,sBAEC;IA6BD;;;;;;OAMG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAqBnB;CA4BJ;kCA7HiC,wBAAwB"}

package/src/engine/sound/sopra/definition/clip/ContainerAudioClip.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../../../core/assert.js";
+import { combine_hash } from "../../../../../core/collection/array/combine_hash.js";
 import { AbstractAudioClip } from "./AbstractAudioClip.js";
 
 /**
@@ -97,4 +98,31 @@ export class ContainerAudioClip extends AbstractAudioClip {
 
         return true;
     }
+
+    /**
+     * Container hash: the inherited gain/pitch (via `super.hash()`) folded with each child's hash — the
+     * mirror of {@link equals}, which is the class this base owns `children` for.
+     *
+     * This lives HERE rather than in each concrete container because the base is what owns `children`:
+     * every subclass previously copy-pasted the same child fold, which is how {@link BlendContainerAudioClip}
+     * came to fold its `parameter`/`defaultValue` but NOT its `blends` while comparing them in `equals` —
+     * two blend containers differing only in their curves compared unequal but hashed identically. Clip
+     * hashes are load-bearing (`EventDescription` buckets polyphony by event content), so a hash that
+     * ignores a field `equals` inspects corrupts that bucketing.
+     *
+     * Concrete subclasses override and extend this via `super.hash()`, folding ONLY their own fields.
+     *
+     * @returns {number}
+     */
+    hash() {
+        let h = super.hash();
+
+        const children = this.children;
+
+        for (let i = 0; i < children.length; i++) {
+            h = combine_hash(h, children[i].hash());
+        }
+
+        return h;
+    }
 }

package/src/engine/sound/sopra/definition/clip/RandomContainerAudioClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RandomContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/RandomContainerAudioClip.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH;IAqEI;;;;;;OAMG;IACH,uBALW,mBAAmB,oCACnB;QAAC,kBAAkB,CAAC,EAAC,MAAM,CAAC;QAAC,OAAO,CAAC,EAAC,MAAM,EAAE,CAAA;KAAC,GAE7C,wBAAwB,CAapC;IArFD;;;OAGG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;;;;;;;;OAYG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;;;OAKG;IACH,4CAFa,IAAI,CAQhB;IAWD;;;;;;OAMG;IACH,oBAHW,MAAM,EAAE,GACN,IAAI,CAgBhB;IAsBD;;;;OAIG;IACH,cAHW,wBAAwB,GACtB,OAAO,CAuBnB;IAkBD,kCAaC;IAED;;;;;;;;;MAQC;IAED;;;;;;aAQC;IAED;;;;;;;;OAQG;IACH,gDAFa,MAAM,CA6BlB;IAED;;;;;;;;MAQC;CACJ;;;;mCAhOkC,yBAAyB"}
+{"version":3,"file":"RandomContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/RandomContainerAudioClip.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH;IAqEI;;;;;;OAMG;IACH,uBALW,mBAAmB,oCACnB;QAAC,kBAAkB,CAAC,EAAC,MAAM,CAAC;QAAC,OAAO,CAAC,EAAC,MAAM,EAAE,CAAA;KAAC,GAE7C,wBAAwB,CAapC;IArFD;;;OAGG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;;;;;;;;OAYG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;;;OAKG;IACH,4CAFa,IAAI,CAQhB;IAWD;;;;;;OAMG;IACH,oBAHW,MAAM,EAAE,GACN,IAAI,CAgBhB;IAsBD;;;;OAIG;IACH,cAHW,wBAAwB,GACtB,OAAO,CAuBnB;IAcD,kCAaC;IAED;;;;;;;;;MAQC;IAED;;;;;;aAQC;IAED;;;;;;;;OAQG;IACH,gDAFa,MAAM,CA6BlB;IAED;;;;;;;;MAQC;CACJ;;;;mCA5NkC,yBAAyB"}

package/src/engine/sound/sopra/definition/clip/RandomContainerAudioClip.js

@@ -128,13 +128,9 @@ export class RandomContainerAudioClip extends ContainerAudioClip {
     }
 
     hash() {
+        // super.hash() already folds gain/pitch + children; only this class's own fields go on top
         let h = combine_hash(super.hash(), this.avoid_repeating_last);
 
-        const children = this.children;
-        for (let i = 0; i < children.length; i++) {
-            h = combine_hash(h, children[i].hash());
-        }
-
         const weights = this.weights;
         for (let i = 0; i < weights.length; i++) {
             h = combine_hash(h, computeHashFloat(weights[i]));

package/src/engine/sound/sopra/definition/clip/SequenceContainerAudioClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SequenceContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/SequenceContainerAudioClip.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAEI;;;;OAIG;IACH,uBAHW,mBAAmB,GACjB,0BAA0B,CAQtC;IAeD,oCAUC;IAED;;;;;;;MAMC;IAED;;;;aAIC;IAED;;;;;;;;MAyBC;CACJ;;;;mCAvFkC,yBAAyB"}
+{"version":3,"file":"SequenceContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/SequenceContainerAudioClip.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IAEI;;;;OAIG;IACH,uBAHW,mBAAmB,GACjB,0BAA0B,CAQtC;IAID,oCAUC;IAED;;;;;;;MAMC;IAED;;;;aAIC;IAED;;;;;;;;MAyBC;CACJ;;;;mCA5EkC,yBAAyB"}

package/src/engine/sound/sopra/definition/clip/SequenceContainerAudioClip.js

@@ -1,4 +1,3 @@
-import { combine_hash } from "../../../../../core/collection/array/combine_hash.js";
 import { ContainerAudioClip } from "./ContainerAudioClip.js";
 import { deserializeAudioClipFromJSON, serializeAudioClipToJSON } from "../../serialization/sopraJSON.js";
 
@@ -21,18 +20,7 @@ export class SequenceContainerAudioClip extends ContainerAudioClip {
         return r;
     }
 
-    // equals is inherited from ContainerAudioClip (gain/pitch + children) — a Sequence adds no fields.
-
-    hash() {
-        let h = super.hash();
-
-        const children = this.children;
-        for (let i = 0; i < children.length; i++) {
-            h = combine_hash(h, children[i].hash());
-        }
-
-        return h;
-    }
+    // equals AND hash are inherited from ContainerAudioClip (gain/pitch + children) — a Sequence adds no fields.
 
     clone() {
         const r = new SequenceContainerAudioClip();

package/src/engine/sound/sopra/definition/clip/SwitchContainerAudioClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SwitchContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/SwitchContainerAudioClip.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH;IAcI;;;;OAIG;IACH,uBAJW,mBAAmB,gCACnB;QAAC,SAAS,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,CAAA;KAAC,GACvC,wBAAwB,CAUpC;IAzBD;;;OAGG;IACH,WAFU,MAAM,CAED;IAEf;;;OAGG;IACH,cAFU,MAAM,CAEC;IAmCjB;;;;;;;;MAWC;IAED;;;OAGG;IACH,cAHW,wBAAwB,GACtB,OAAO,CAMnB;IAiBD,kCAYC;IAED;;;;;;;;;MAQC;IAED;;;;;;aAMC;;CACJ;;;;mCA7HkC,yBAAyB"}
+{"version":3,"file":"SwitchContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/SwitchContainerAudioClip.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH;IAcI;;;;OAIG;IACH,uBAJW,mBAAmB,gCACnB;QAAC,SAAS,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,CAAA;KAAC,GACvC,wBAAwB,CAUpC;IAzBD;;;OAGG;IACH,WAFU,MAAM,CAED;IAEf;;;OAGG;IACH,cAFU,MAAM,CAEC;IAmCjB;;;;;;;;MAWC;IAED;;;OAGG;IACH,cAHW,wBAAwB,GACtB,OAAO,CAMnB;IAWD,kCAYC;IAED;;;;;;;;;MAQC;IAED;;;;;;aAMC;;CACJ;;;;mCAvHkC,yBAAyB"}

package/src/engine/sound/sopra/definition/clip/SwitchContainerAudioClip.js

@@ -81,18 +81,12 @@ export class SwitchContainerAudioClip extends ContainerAudioClip {
     }
 
     hash() {
-        let h = combine_hash(
+        // super.hash() already folds gain/pitch + children; only this class's own fields go on top
+        return combine_hash(
             super.hash(),
             computeStringHash(this.parameter),
             computeHashFloat(this.defaultValue)
         );
-
-        const children = this.children;
-        for (let i = 0; i < children.length; i++) {
-            h = combine_hash(h, children[i].hash());
-        }
-
-        return h;
     }
 
     clone() {

package/src/engine/sound/sopra/definition/effect/ReverbEffect.d.ts

@@ -6,6 +6,9 @@
  * parameterised by {@link decaySeconds} (tail length) and {@link decayPower} (how fast it fades) — so
  * there is no IR-asset dependency and {@link build} stays synchronous. (Loading an authored IR from the
  * BufferProvider is a possible later alternative; it would make build async.)
+ *
+ * Generation is DETERMINISTIC: a fixed seed drives the noise, so two builds of equal effects produce
+ * bit-identical impulse responses.
  */
 export class ReverbEffect extends AbstractAudioEffect {
     /**

package/src/engine/sound/sopra/definition/effect/ReverbEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReverbEffect.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/ReverbEffect.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH;IAcI;;;OAGG;IACH,2CAHW;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,UAAU,CAAC,EAAC,MAAM,CAAA;KAAC,GACxC,YAAY,CASxB;IAvBD;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAED;IA0Cf;;;OAGG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;IAED,eAKC;IAED,sBAEC;IAED;;;MAKC;IAED;;;aAGC;CACJ;;;;oCAhGmC,0BAA0B"}
+{"version":3,"file":"ReverbEffect.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/ReverbEffect.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;GAWG;AACH;IAcI;;;OAGG;IACH,2CAHW;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,UAAU,CAAC,EAAC,MAAM,CAAA;KAAC,GACxC,YAAY,CASxB;IAvBD;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAED;IAoCf;;;OAGG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;IAED,eAKC;IAED,sBAEC;IAED;;;MAKC;IAED;;;aAGC;CACJ;;;;oCA1GmC,0BAA0B"}

package/src/engine/sound/sopra/definition/effect/ReverbEffect.js

@@ -1,7 +1,22 @@
 import { combine_hash } from "../../../../../core/collection/array/combine_hash.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { computeHashFloat } from "../../../../../core/primitives/numbers/computeHashFloat.js";
+import { reverbImpulseResponse } from "../../../simulation/render/reverbImpulseResponse.js";
 import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
 
+/**
+ * Seed for the procedural impulse response. Fixed (not authorable): the IR is a decaying noise tail whose
+ * audible character comes entirely from `decaySeconds`/`decayPower`, so the noise realisation carries no
+ * design intent — but it must be REPRODUCIBLE. Every other impulse response in the engine is driven by a
+ * seeded RNG (`ProbeReverbRenderer`, `FoaProbeReverbRenderer`); this one used raw `Math.random`, which made
+ * a sopra bus reverb the single non-reproducible piece of audio in a build.
+ * @type {number}
+ */
+const IR_SEED = 1;
+
+// the three equal bands a broadband decay maps onto; reused across builds (read-only to the synthesiser)
+const BROADBAND = new Float32Array(3);
+
 /**
  * Convolution reverb bus insert, backed by a {@link ConvolverNode}. Typically used on a dedicated
  * "reverb" bus that other buses route to via {@link BusDefinition.sends}.
@@ -10,6 +25,9 @@ import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
  * parameterised by {@link decaySeconds} (tail length) and {@link decayPower} (how fast it fades) — so
  * there is no IR-asset dependency and {@link build} stays synchronous. (Loading an authored IR from the
  * BufferProvider is a possible later alternative; it would make build async.)
+ *
+ * Generation is DETERMINISTIC: a fixed seed drives the noise, so two builds of equal effects produce
+ * bit-identical impulse responses.
  */
 export class ReverbEffect extends AbstractAudioEffect {
 
@@ -46,21 +64,15 @@ export class ReverbEffect extends AbstractAudioEffect {
         const convolver = ctx.createConvolver();
         convolver.normalize = true;
 
-        const sampleRate = ctx.sampleRate;
-        const length = Math.max(1, Math.floor(this.decaySeconds * sampleRate));
-        const ir = ctx.createBuffer(2, length, sampleRate);
-
-        for (let channel = 0; channel < ir.numberOfChannels; channel++) {
-            const data = ir.getChannelData(channel);
-
-            for (let i = 0; i < length; i++) {
-                const t = i / length;
-                // white noise shaped by an exponentially-decaying envelope
-                data[i] = (Math.random() * 2 - 1) * Math.pow(1 - t, this.decayPower);
-            }
-        }
+        // A broadband tail is the equal-band case of the acoustic per-band synthesiser: with three equal
+        // RT60s the band split reconstructs the noise and the three envelopes coincide, so this is the same
+        // decaying-noise tail this effect generated inline — now from a SEEDED stream, and sharing one
+        // implementation with the probe-baked reverbs.
+        BROADBAND[0] = this.decaySeconds;
+        BROADBAND[1] = this.decaySeconds;
+        BROADBAND[2] = this.decaySeconds;
 
-        convolver.buffer = ir;
+        convolver.buffer = reverbImpulseResponse(ctx, BROADBAND, this.decayPower, seededRandom(IR_SEED));
 
         return { input: convolver, output: convolver };
     }

package/src/engine/sound/sopra/runtime/BusGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BusGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/BusGraph.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,8BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH;IAkBI;;;OAGG;IACH,iBAHW,gBAAgB,eAChB,SAAS,EAKnB;IAvBD;;;OAGG;IACH,OAFU,IAAI,MAAM,EAAE;QAAC,UAAU,gBAAgB;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,MAAM,EAAE,QAAQ,CAAA;KAAC,CAAC,CAEpE;IAqBlB;;;;OAIG;IACH,mBAFW,eAAe,QAgFzB;IAED;;;OAGG;IACH,QAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,SAAS,CAUrB;IAED;;;;;OAKG;IACH,cAHW,MAAM,GACJ,SAAS,CAUrB;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;OAGG;IACH,cAHW,MAAM,UACN,MAAM,QAWhB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,UACN,MAAM,YACN,MAAM,eACN,MAAM,QAWhB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,UACN,MAAM,gBACN,MAAM,QAYhB;;CACJ"}
+{"version":3,"file":"BusGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/BusGraph.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,8BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH;IAkBI;;;OAGG;IACH,iBAHW,gBAAgB,eAChB,SAAS,EAKnB;IAvBD;;;OAGG;IACH,OAFU,IAAI,MAAM,EAAE;QAAC,UAAU,gBAAgB;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,MAAM,EAAE,QAAQ,CAAA;KAAC,CAAC,CAEpE;IAqBlB;;;;OAIG;IACH,mBAFW,eAAe,QAgFzB;IAED;;;OAGG;IACH,QAHW,MAAM,GACJ,OAAO,CAInB;IAoBD;;;;OAIG;IACH,aAHW,MAAM,GACJ,SAAS,CAIrB;IAED;;;;;OAKG;IACH,cAHW,MAAM,GACJ,SAAS,CAIrB;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,cAHW,MAAM,UACN,MAAM,QAOhB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,UACN,MAAM,YACN,MAAM,eACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,UACN,MAAM,gBACN,MAAM,QAQhB;;CACJ"}

package/src/engine/sound/sopra/runtime/BusGraph.js

@@ -136,18 +136,30 @@ export class BusGraph {
     }
 
     /**
-     * Node that voices/children should connect into for a given bus.
+     * The bus record for `id`, or throw. Every public accessor below addresses a bus by id and an unknown
+     * id is a programming error (a definition set that never declared it), so the lookup-or-throw is
+     * factored here instead of being repeated verbatim in each accessor — one place owns the message and
+     * the "unknown bus is fatal" policy.
      * @param {string} id
-     * @returns {AudioNode}
+     * @returns {{definition: BusDefinition, input: AudioNode, output: GainNode}}
      */
-    getInput(id) {
+    #bus(id) {
         const bus = this.buses.get(id);
 
         if (bus === undefined) {
             throw new Error(`sopra: no bus '${id}'`);
         }
 
-        return bus.input;
+        return bus;
+    }
+
+    /**
+     * Node that voices/children should connect into for a given bus.
+     * @param {string} id
+     * @returns {AudioNode}
+     */
+    getInput(id) {
+        return this.#bus(id).input;
     }
 
     /**
@@ -157,13 +169,7 @@ export class BusGraph {
      * @returns {AudioNode}
      */
     getOutput(id) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
-
-        return bus.output;
+        return this.#bus(id).output;
     }
 
     /**
@@ -171,13 +177,7 @@ export class BusGraph {
      * @returns {number} linear gain
      */
     getVolume(id) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
-
-        return bus.nominal;
+        return this.#bus(id).nominal;
     }
 
     /**
@@ -185,11 +185,7 @@ export class BusGraph {
      * @param {number} linear linear gain
      */
     setVolume(id, linear) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
+        const bus = this.#bus(id);
 
         bus.nominal = linear;
         bus.output.gain.setValueAtTime(linear, 0);
@@ -212,11 +208,7 @@ export class BusGraph {
      * @param {number} [startAfter=0] seconds
      */
     rampVolume(id, linear, duration, startAfter = 0) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
+        const bus = this.#bus(id);
 
         bus.nominal = linear; // a ramp is a nominal fader move; record where it's heading
         rampGain(bus.output.gain, linear, duration, this.#ctx, startAfter);
@@ -230,11 +222,7 @@ export class BusGraph {
      * @param {number} timeConstant seconds
      */
     approachVolume(id, linear, timeConstant) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
+        const bus = this.#bus(id);
 
         // NB: a transient modulation (ducking) — deliberately does NOT update `nominal`, so the duck can
         // capture the true fader position at engage and restore to it on release.

package/src/engine/sound/sopra/runtime/EventInstance.js

@@ -31,7 +31,7 @@ const DEFAULT_MAX_LIFETIME_SECONDS = 60;
  * @returns {number}
  */
 function dbTiltToGain(excessDb) {
-    return excessDb <= 0 ? 1 : Math.pow(10, -excessDb / 20);
+    return excessDb <= 0 ? 1 : dB2Volume(-excessDb);
 }
 
 /**