@woosh/meep-engine 2.169.0 → 2.169.2

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

@@ -4,10 +4,11 @@
  * (`directions`, band-major xyz, the 0…1 anisotropy vectors {@link bakeReverbBands} produces). Driven by a
  * SEEDED rng (reproducible).
  *
- * The synthesis mirrors {@link reverbImpulseResponse}: one white-noise stream is split into three bands
- * (one-pole filters) and each band is given its own exponential decay envelope (a band rings for its RT60).
- * `w` is the omni sum of the enveloped bands — identical to the scalar mono tail. The directional channels
- * are the SAME enveloped bands weighted by each band's arrival-direction component:
+ * The synthesis SHARES the tail kernel with {@link reverbImpulseResponse} ({@link reverb_band_tails}): one
+ * white-noise stream is split into three bands (one-pole filters) and each band is given its own exponential
+ * decay envelope (a band rings for its RT60). `w` is the omni sum of the enveloped bands — identical to the
+ * scalar mono tail. The directional channels are the SAME enveloped bands weighted by each band's
+ * arrival-direction component:
  *
  *   `x[i] = Σ_band bandTail[band][i] · directionX[band]`   (likewise `y`, `z`)
  *

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

@@ -1 +1 @@
-{"version":3,"file":"foaReverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/foaReverbImpulseResponse.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,8CAPW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM;OACZ,WAAW;OAAI,WAAW;OAAI,WAAW;OAAI,WAAW;EAkFvE"}
+{"version":3,"file":"foaReverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/foaReverbImpulseResponse.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8CAPW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM;OACZ,WAAW;OAAI,WAAW;OAAI,WAAW;OAAI,WAAW;EAyEvE"}

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

@@ -1,4 +1,4 @@
-import { LOW_MID_HZ, MID_HIGH_HZ } from "./reverbImpulseResponse.js";
+import { reverb_band_length, reverb_band_tails } from "./reverb_band_tails.js";
 
 /**
  * Build a first-order ambisonic (FOA / B-format) reverb impulse response — four MONO `AudioBuffer`s
@@ -6,10 +6,11 @@ import { LOW_MID_HZ, MID_HIGH_HZ } from "./reverbImpulseResponse.js";
  * (`directions`, band-major xyz, the 0…1 anisotropy vectors {@link bakeReverbBands} produces). Driven by a
  * SEEDED rng (reproducible).
  *
- * The synthesis mirrors {@link reverbImpulseResponse}: one white-noise stream is split into three bands
- * (one-pole filters) and each band is given its own exponential decay envelope (a band rings for its RT60).
- * `w` is the omni sum of the enveloped bands — identical to the scalar mono tail. The directional channels
- * are the SAME enveloped bands weighted by each band's arrival-direction component:
+ * The synthesis SHARES the tail kernel with {@link reverbImpulseResponse} ({@link reverb_band_tails}): one
+ * white-noise stream is split into three bands (one-pole filters) and each band is given its own exponential
+ * decay envelope (a band rings for its RT60). `w` is the omni sum of the enveloped bands — identical to the
+ * scalar mono tail. The directional channels are the SAME enveloped bands weighted by each band's
+ * arrival-direction component:
  *
  *   `x[i] = Σ_band bandTail[band][i] · directionX[band]`   (likewise `y`, `z`)
  *
@@ -40,9 +41,9 @@ export function foaReverbImpulseResponse(
 
     const sampleRate = ctx.sampleRate;
 
-    const lenLow = Math.max(1, Math.floor(decayBands[0] * sampleRate));
-    const lenMid = Math.max(1, Math.floor(decayBands[1] * sampleRate));
-    const lenHigh = Math.max(1, Math.floor(decayBands[2] * sampleRate));
+    const lenLow = reverb_band_length(decayBands[0], sampleRate);
+    const lenMid = reverb_band_length(decayBands[1], sampleRate);
+    const lenHigh = reverb_band_length(decayBands[2], sampleRate);
     const length = Math.max(lenLow, lenMid, lenHigh);
 
     const w = ctx.createBuffer(1, length, sampleRate);
@@ -60,34 +61,25 @@ export function foaReverbImpulseResponse(
     const dxMid = directions[3], dyMid = directions[4], dzMid = directions[5];
     const dxHigh = directions[6], dyHigh = directions[7], dzHigh = directions[8];
 
-    // 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) / sampleRate);
-    const aHigh = 1 - Math.exp((-2 * Math.PI * MID_HIGH_HZ) / sampleRate);
+    // each band's enveloped samples, shared by the omni and directional channels
+    const bandLow = new Float64Array(length);
+    const bandMid = new Float64Array(length);
+    const bandHigh = new Float64Array(length);
+
+    reverb_band_tails(
+        bandLow, bandMid, bandHigh,
+        length,
+        lenLow, lenMid, lenHigh,
+        decayPower, sampleRate, random
+    );
 
-    let lpLow = 0;
-    let lpHigh = 0;
     let sumSqW = 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 < lenLow ? Math.pow(1 - i / lenLow, decayPower) : 0;
-        const envMid = i < lenMid ? Math.pow(1 - i / lenMid, decayPower) : 0;
-        const envHigh = i < lenHigh ? Math.pow(1 - i / lenHigh, decayPower) : 0;
-
-        // each band's enveloped sample, shared by the omni and directional channels
-        const bLow = low * envLow;
-        const bMid = mid * envMid;
-        const bHigh = high * envHigh;
+        const bLow = bandLow[i];
+        const bMid = bandMid[i];
+        const bHigh = bandHigh[i];
 
         const wSample = bLow + bMid + bHigh;
         wData[i] = wSample;

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

@@ -15,12 +15,5 @@
  * @returns {AudioBuffer}
  */
 export function reverbImpulseResponse(ctx: BaseAudioContext, decayBands: Float32Array | number[], decayPower: number, random: () => number): AudioBuffer;
-/**
- * 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. Exported so the directional ({@link foaReverbImpulseResponse}) path splits identically.
- * @type {number}
- */
-export const LOW_MID_HZ: number;
-export const MID_HIGH_HZ: 2500;
+export { LOW_MID_HZ, MID_HIGH_HZ } from "./reverb_band_tails.js";
 //# sourceMappingURL=reverbImpulseResponse.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"reverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/reverbImpulseResponse.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM,GACf,WAAW,CAoDvB;AA3ED;;;;;GAKG;AACH,yBAFU,MAAM,CAEc;AAC9B,+BAAgC"}
+{"version":3,"file":"reverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/reverbImpulseResponse.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM,GACf,WAAW,CA2CvB"}

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

@@ -1,11 +1,10 @@
+import { reverb_band_length, reverb_band_tails } from "./reverb_band_tails.js";
+
 /**
- * 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. Exported so the directional ({@link foaReverbImpulseResponse}) path splits identically.
- * @type {number}
+ * The band split frequencies now live with the kernel that applies them ({@link reverb_band_tails}); they
+ * stay re-exported here because this module is where consumers have always imported them from.
  */
-export const LOW_MID_HZ = 250;
-export const MID_HIGH_HZ = 2500;
+export { LOW_MID_HZ, MID_HIGH_HZ } from "./reverb_band_tails.js";
 
 /**
  * Generate a stereo reverb impulse response from a PER-BAND decay time `[low, mid, high]` (the probe-baked
@@ -32,43 +31,34 @@ export function reverbImpulseResponse(
 
     const sampleRate = ctx.sampleRate;
 
-    const lenLow = Math.max(1, Math.floor(decayBands[0] * sampleRate));
-    const lenMid = Math.max(1, Math.floor(decayBands[1] * sampleRate));
-    const lenHigh = Math.max(1, Math.floor(decayBands[2] * sampleRate));
+    const lenLow = reverb_band_length(decayBands[0], sampleRate);
+    const lenMid = reverb_band_length(decayBands[1], sampleRate);
+    const lenHigh = reverb_band_length(decayBands[2], sampleRate);
     const length = Math.max(lenLow, lenMid, lenHigh);
 
     const ir = ctx.createBuffer(2, length, sampleRate);
 
-    // 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) / sampleRate);
-    const aHigh = 1 - Math.exp((-2 * Math.PI * MID_HIGH_HZ) / sampleRate);
+    // band scratch, allocated once and reused for BOTH channels (they differ only in their noise stream)
+    const bandLow = new Float64Array(length);
+    const bandMid = new Float64Array(length);
+    const bandHigh = new Float64Array(length);
 
     const channel_count = ir.numberOfChannels;
 
     for (let channel = 0; channel < channel_count; channel++) {
         const data = ir.getChannelData(channel);
 
-        let lpLow = 0;
-        let lpHigh = 0;
+        // each channel draws its OWN noise stream, so the stereo pair is decorrelated
+        reverb_band_tails(
+            bandLow, bandMid, bandHigh,
+            length,
+            lenLow, lenMid, lenHigh,
+            decayPower, sampleRate, random
+        );
 
+        // omni: the three enveloped bands summed back together
         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 < lenLow ? Math.pow(1 - i / lenLow, decayPower) : 0;
-            const envMid = i < lenMid ? Math.pow(1 - i / lenMid, decayPower) : 0;
-            const envHigh = i < lenHigh ? Math.pow(1 - i / lenHigh, decayPower) : 0;
-
-            data[i] = low * envLow + mid * envMid + high * envHigh;
-
+            data[i] = bandLow[i] + bandMid[i] + bandHigh[i];
         }
     }
 

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 {
     /**