@woosh/meep-engine 2.154.0 → 2.156.0

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

@@ -0,0 +1,128 @@
+import { combine_hash } from "../../../../../core/collection/array/combine_hash.js";
+import { computeHashFloat } from "../../../../../core/primitives/numbers/computeHashFloat.js";
+import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
+
+/**
+ * Filter type, mapped to a WebAudio {@link BiquadFilterType}.
+ * @enum {number}
+ */
+export const EqFilterType = {
+    Lowpass: 0,
+    Highpass: 1,
+    Bandpass: 2,
+    Lowshelf: 3,
+    Highshelf: 4,
+    Peaking: 5,
+    Notch: 6,
+    Allpass: 7
+};
+
+/**
+ * @type {string[]}
+ */
+const EQ_FILTER_TYPE_TO_BIQUAD = [
+    'lowpass', 'highpass', 'bandpass', 'lowshelf', 'highshelf', 'peaking', 'notch', 'allpass'
+];
+
+/**
+ * Equalizer / filter bus insert, backed by a {@link BiquadFilterNode}.
+ */
+export class EqEffect extends AbstractAudioEffect {
+
+    /**
+     * @type {EqFilterType|number}
+     */
+    filterType = EqFilterType.Peaking;
+
+    /**
+     * Cutoff/center frequency in Hz.
+     * @type {number}
+     */
+    frequency = 350;
+
+    /**
+     * Quality factor.
+     * @type {number}
+     */
+    Q = 1;
+
+    /**
+     * Boost/cut in decibels (only used by peaking / shelf filters).
+     * @type {number}
+     */
+    gainDb = 0;
+
+    /**
+     *
+     * @param {{filterType?:EqFilterType|number, frequency?:number, Q?:number, gainDb?:number}} [options]
+     * @returns {EqEffect}
+     */
+    static from({ filterType = EqFilterType.Peaking, frequency = 350, Q = 1, gainDb = 0 } = {}) {
+        const r = new EqEffect();
+
+        r.filterType = filterType;
+        r.frequency = frequency;
+        r.Q = Q;
+        r.gainDb = gainDb;
+
+        return r;
+    }
+
+    /**
+     * @param {BaseAudioContext} ctx
+     * @returns {{input: AudioNode, output: AudioNode}}
+     */
+    build(ctx) {
+        const node = ctx.createBiquadFilter();
+
+        node.type = EQ_FILTER_TYPE_TO_BIQUAD[this.filterType] ?? 'peaking';
+        node.frequency.value = this.frequency;
+        node.Q.value = this.Q;
+        node.gain.value = this.gainDb;
+
+        return { input: node, output: node };
+    }
+
+    /**
+     *
+     * @param {EqEffect} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.filterType === other.filterType
+            && this.frequency === other.frequency
+            && this.Q === other.Q
+            && this.gainDb === other.gainDb;
+    }
+
+    hash() {
+        return combine_hash(
+            this.filterType,
+            computeHashFloat(this.frequency),
+            computeHashFloat(this.Q),
+            computeHashFloat(this.gainDb)
+        );
+    }
+
+    clone() {
+        return EqEffect.from(this);
+    }
+
+    toJSON() {
+        return {
+            filterType: this.filterType,
+            frequency: this.frequency,
+            Q: this.Q,
+            gainDb: this.gainDb
+        };
+    }
+
+    fromJSON({ filterType = EqFilterType.Peaking, frequency = 350, Q = 1, gainDb = 0 }) {
+        this.filterType = filterType;
+        this.frequency = frequency;
+        this.Q = Q;
+        this.gainDb = gainDb;
+    }
+}
+
+EqEffect.typeName = "SopraEqEffect";

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

@@ -0,0 +1,18 @@
+export class EqEffectSerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof EqEffect;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {EqEffect} value
+     */
+    serialize(buffer: BinaryBuffer, value: EqEffect): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {EqEffect} value
+     */
+    deserialize(buffer: BinaryBuffer, value: EqEffect): void;
+}
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { EqEffect } from "./EqEffect.js";
+//# sourceMappingURL=EqEffectSerializationAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EqEffectSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/EqEffectSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IACI,uBAAiB;IACjB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,QAAQ,QAOlB;IAED;;;OAGG;IACH,yCAFW,QAAQ,QAOlB;CACJ;gDA5B+C,mEAAmE;yBAC1F,eAAe"}

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

@@ -0,0 +1,29 @@
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { EqEffect } from "./EqEffect.js";
+
+export class EqEffectSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = EqEffect;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {EqEffect} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUint8(value.filterType);
+        buffer.writeFloat32(value.frequency);
+        buffer.writeFloat32(value.Q);
+        buffer.writeFloat32(value.gainDb);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {EqEffect} value
+     */
+    deserialize(buffer, value) {
+        value.filterType = buffer.readUint8();
+        value.frequency = buffer.readFloat32();
+        value.Q = buffer.readFloat32();
+        value.gainDb = buffer.readFloat32();
+    }
+}

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

@@ -0,0 +1,49 @@
+/**
+ * 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}.
+ *
+ * The impulse response is generated PROCEDURALLY at build time (an exponentially-decaying noise tail),
+ * 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.)
+ */
+export class ReverbEffect extends AbstractAudioEffect {
+    /**
+     * @param {{decaySeconds?:number, decayPower?:number}} [options]
+     * @returns {ReverbEffect}
+     */
+    static from({ decaySeconds, decayPower }?: {
+        decaySeconds?: number;
+        decayPower?: number;
+    }): ReverbEffect;
+    /**
+     * Reverb tail length in seconds (the generated IR length).
+     * @type {number}
+     */
+    decaySeconds: number;
+    /**
+     * Decay envelope exponent: higher fades the tail faster.
+     * @type {number}
+     */
+    decayPower: number;
+    /**
+     * @param {ReverbEffect} other
+     * @returns {boolean}
+     */
+    equals(other: ReverbEffect): boolean;
+    hash(): number;
+    clone(): ReverbEffect;
+    toJSON(): {
+        decaySeconds: number;
+        decayPower: number;
+    };
+    fromJSON({ decaySeconds, decayPower }: {
+        decaySeconds?: number;
+        decayPower?: number;
+    }): void;
+}
+export namespace ReverbEffect {
+    let typeName: string;
+}
+import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
+//# sourceMappingURL=ReverbEffect.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,101 @@
+import { combine_hash } from "../../../../../core/collection/array/combine_hash.js";
+import { computeHashFloat } from "../../../../../core/primitives/numbers/computeHashFloat.js";
+import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
+
+/**
+ * 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}.
+ *
+ * The impulse response is generated PROCEDURALLY at build time (an exponentially-decaying noise tail),
+ * 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.)
+ */
+export class ReverbEffect extends AbstractAudioEffect {
+
+    /**
+     * Reverb tail length in seconds (the generated IR length).
+     * @type {number}
+     */
+    decaySeconds = 1.5;
+
+    /**
+     * Decay envelope exponent: higher fades the tail faster.
+     * @type {number}
+     */
+    decayPower = 2;
+
+    /**
+     * @param {{decaySeconds?:number, decayPower?:number}} [options]
+     * @returns {ReverbEffect}
+     */
+    static from({ decaySeconds = 1.5, decayPower = 2 } = {}) {
+        const r = new ReverbEffect();
+
+        r.decaySeconds = decaySeconds;
+        r.decayPower = decayPower;
+
+        return r;
+    }
+
+    /**
+     * @param {BaseAudioContext} ctx
+     * @returns {{input: AudioNode, output: AudioNode}}
+     */
+    build(ctx) {
+        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);
+            }
+        }
+
+        convolver.buffer = ir;
+
+        return { input: convolver, output: convolver };
+    }
+
+    /**
+     * @param {ReverbEffect} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.decaySeconds === other.decaySeconds
+            && this.decayPower === other.decayPower;
+    }
+
+    hash() {
+        return combine_hash(
+            computeHashFloat(this.decaySeconds),
+            computeHashFloat(this.decayPower)
+        );
+    }
+
+    clone() {
+        return ReverbEffect.from(this);
+    }
+
+    toJSON() {
+        return {
+            decaySeconds: this.decaySeconds,
+            decayPower: this.decayPower
+        };
+    }
+
+    fromJSON({ decaySeconds = 1.5, decayPower = 2 }) {
+        this.decaySeconds = decaySeconds;
+        this.decayPower = decayPower;
+    }
+}
+
+ReverbEffect.typeName = "SopraReverbEffect";

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

@@ -0,0 +1,18 @@
+export class ReverbEffectSerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof ReverbEffect;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {ReverbEffect} value
+     */
+    serialize(buffer: BinaryBuffer, value: ReverbEffect): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {ReverbEffect} value
+     */
+    deserialize(buffer: BinaryBuffer, value: ReverbEffect): void;
+}
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { ReverbEffect } from "./ReverbEffect.js";
+//# sourceMappingURL=ReverbEffectSerializationAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReverbEffectSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/ReverbEffectSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IACI,2BAAqB;IACrB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,YAAY,QAKtB;IAED;;;OAGG;IACH,yCAFW,YAAY,QAKtB;CACJ;gDAxB+C,mEAAmE;6BACtF,mBAAmB"}

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

@@ -0,0 +1,25 @@
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { ReverbEffect } from "./ReverbEffect.js";
+
+export class ReverbEffectSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = ReverbEffect;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {ReverbEffect} value
+     */
+    serialize(buffer, value) {
+        buffer.writeFloat32(value.decaySeconds);
+        buffer.writeFloat32(value.decayPower);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {ReverbEffect} value
+     */
+    deserialize(buffer, value) {
+        value.decaySeconds = buffer.readFloat32();
+        value.decayPower = buffer.readFloat32();
+    }
+}

package/src/engine/sound/sopra/legacy/soundEmitterToEventDescription.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @param {SoundAttenuationFunction|number} attenuationFunction
+ * @param {number} distanceMin
+ * @param {number} distanceMax
+ * @returns {AnimationCurve} distance→gain curve reproducing the legacy falloff at sampled distances
+ */
+export function attenuationFunctionToCurve(attenuationFunction: SoundAttenuationFunction | number, distanceMin: number, distanceMax: number): AnimationCurve;
+/**
+ * @param {SoundPanningModelType|number} panningModel
+ * @returns {SopraPanningModel|number}
+ */
+export function soundPanningModelToSopra(panningModel: SoundPanningModelType | number): SopraPanningModel | number;
+/**
+ * Translate one legacy SoundTrack (in the context of its emitter) into a sopra EventDescription.
+ * @param {SoundEmitter} emitter
+ * @param {SoundTrack} track
+ * @returns {EventDescription}
+ */
+export function soundTrackToEventDescription(emitter: SoundEmitter, track: SoundTrack): EventDescription;
+/**
+ * Translate all of an emitter's current tracks into EventDescriptions (one per track).
+ * @param {SoundEmitter} emitter
+ * @returns {EventDescription[]}
+ */
+export function soundEmitterToEventDescriptions(emitter: SoundEmitter): EventDescription[];
+import { SoundAttenuationFunction } from "../../ecs/emitter/SoundAttenuationFunction.js";
+import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
+import { SoundPanningModelType } from "../../ecs/emitter/SoundPanningModelType.js";
+import { SopraPanningModel } from "../definition/SopraPanningModel.js";
+import { EventDescription } from "../definition/EventDescription.js";
+//# sourceMappingURL=soundEmitterToEventDescription.d.ts.map

package/src/engine/sound/sopra/legacy/soundEmitterToEventDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soundEmitterToEventDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/legacy/soundEmitterToEventDescription.js"],"names":[],"mappings":"AA2BA;;;;;GAKG;AACH,gEALW,wBAAwB,GAAC,MAAM,eAC/B,MAAM,eACN,MAAM,GACJ,cAAc,CAmB1B;AAED;;;GAGG;AACH,uDAHW,qBAAqB,GAAC,MAAM,GAC1B,iBAAiB,GAAC,MAAM,CAMpC;AAED;;;;;GAKG;AACH,wFAFa,gBAAgB,CAwB5B;AAED;;;;GAIG;AACH,wEAFa,gBAAgB,EAAE,CAU9B;yCArGwC,+CAA+C;+BADzD,4CAA4C;sCAGrC,4CAA4C;kCAKhD,oCAAoC;iCAFrC,mCAAmC"}

package/src/engine/sound/sopra/legacy/soundEmitterToEventDescription.js

@@ -0,0 +1,106 @@
+import { interpolate_irradiance_linear } from "../../../../core/math/physics/irradiance/interpolate_irradiance_linear.js";
+import { interpolate_irradiance_lograrithmic } from "../../../../core/math/physics/irradiance/interpolate_irradiance_lograrithmic.js";
+import { interpolate_irradiance_smith } from "../../../../core/math/physics/irradiance/interpolate_irradiance_smith.js";
+import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
+import { SoundAttenuationFunction } from "../../ecs/emitter/SoundAttenuationFunction.js";
+import { SoundEmitterFlags } from "../../ecs/emitter/SoundEmitterFlags.js";
+import { SoundPanningModelType } from "../../ecs/emitter/SoundPanningModelType.js";
+import { SoundTrackFlags } from "../../ecs/emitter/SoundTrackFlags.js";
+import { buildAttenuationCurve } from "../util/buildAttenuationCurve.js";
+import { EventDescription } from "../definition/EventDescription.js";
+import { SampleAudioClip } from "../definition/clip/SampleAudioClip.js";
+import { SopraPanningModel } from "../definition/SopraPanningModel.js";
+
+/*
+ * Pure translation from the legacy SoundEmitter/SoundTrack data into sopra EventDescriptions. No ECS,
+ * no engine, no live state — just maps authored fields. Volume is intentionally NOT baked here: the
+ * full live gain (emitter.volume × track.volume) is applied by the ECS layer through the instance's
+ * gain (P3.5), so there is one live volume home and no double-counting.
+ */
+
+/**
+ * Translated legacy descriptions get a high instance cap so the legacy "play everything" behaviour is
+ * preserved (the per-event VoiceManager limit effectively never trips).
+ * @type {number}
+ */
+const LEGACY_MAX_INSTANCES = 256;
+
+/**
+ * @param {SoundAttenuationFunction|number} attenuationFunction
+ * @param {number} distanceMin
+ * @param {number} distanceMax
+ * @returns {AnimationCurve} distance→gain curve reproducing the legacy falloff at sampled distances
+ */
+export function attenuationFunctionToCurve(attenuationFunction, distanceMin, distanceMax) {
+    let falloff;
+
+    switch (attenuationFunction) {
+        case SoundAttenuationFunction.Logarithmic:
+            falloff = interpolate_irradiance_lograrithmic;
+            break;
+        case SoundAttenuationFunction.Smith:
+            falloff = interpolate_irradiance_smith;
+            break;
+        case SoundAttenuationFunction.Linear:
+        default:
+            falloff = interpolate_irradiance_linear;
+            break;
+    }
+
+    return buildAttenuationCurve(distanceMin, distanceMax, falloff);
+}
+
+/**
+ * @param {SoundPanningModelType|number} panningModel
+ * @returns {SopraPanningModel|number}
+ */
+export function soundPanningModelToSopra(panningModel) {
+    return panningModel === SoundPanningModelType.EqualPower
+        ? SopraPanningModel.EqualPower
+        : SopraPanningModel.HRTF;
+}
+
+/**
+ * Translate one legacy SoundTrack (in the context of its emitter) into a sopra EventDescription.
+ * @param {SoundEmitter} emitter
+ * @param {SoundTrack} track
+ * @returns {EventDescription}
+ */
+export function soundTrackToEventDescription(emitter, track) {
+    const clip = SampleAudioClip.from(track.url, {
+        usingAlias: track.getFlag(SoundTrackFlags.UsingAliasURL),
+        loop: track.getFlag(SoundTrackFlags.Loop)
+    });
+
+    const is3D = emitter.getFlag(SoundEmitterFlags.Spatialization);
+    const attenuated = emitter.getFlag(SoundEmitterFlags.Attenuation);
+
+    const attenuation = (is3D && attenuated)
+        ? attenuationFunctionToCurve(emitter.attenuation, emitter.distanceMin, emitter.distanceMax)
+        : AnimationCurve.constant(0, 1, 1); // flat-1 = no distance attenuation
+
+    return EventDescription.from(track.url || "", clip, {
+        busId: emitter.channel || "effects",
+        is3D,
+        panningModel: soundPanningModelToSopra(emitter.panningModel),
+        distanceMin: emitter.distanceMin,
+        distanceMax: emitter.distanceMax,
+        attenuation,
+        maxInstances: LEGACY_MAX_INSTANCES
+    });
+}
+
+/**
+ * Translate all of an emitter's current tracks into EventDescriptions (one per track).
+ * @param {SoundEmitter} emitter
+ * @returns {EventDescription[]}
+ */
+export function soundEmitterToEventDescriptions(emitter) {
+    const result = [];
+
+    emitter.tracks.forEach(track => {
+        result.push(soundTrackToEventDescription(emitter, track));
+    });
+
+    return result;
+}

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

@@ -0,0 +1,79 @@
+/**
+ * A {@link BusDefinition.parentId} equal to this means "no parent" — the bus is a root and routes
+ * straight to the engine destination.
+ * @type {string}
+ */
+export const BUS_ROOT_PARENT: string;
+/**
+ * Runtime mixer: instantiates a set of {@link BusDefinition}s into chained WebAudio nodes.
+ *
+ * Each bus is wired `input → effect[0] → … → effect[n] → gain(output)`; the output then connects to
+ * its parent bus's input, or to the engine destination for a root bus (parentId === "").
+ */
+export class BusGraph {
+    /**
+     * @param {BaseAudioContext} ctx
+     * @param {AudioNode} destination engine master destination node
+     */
+    constructor(ctx: BaseAudioContext, destination: AudioNode);
+    /**
+     * id -> { definition, input, output }
+     * @type {Map<string, {definition: BusDefinition, input: AudioNode, output: GainNode}>}
+     */
+    buses: Map<string, {
+        definition: BusDefinition;
+        input: AudioNode;
+        output: GainNode;
+    }>;
+    /**
+     * Build the graph from a flat list of bus definitions. Order-independent: all nodes are created
+     * first, then wired to their parents.
+     * @param {BusDefinition[]} definitions
+     */
+    build(definitions: BusDefinition[]): void;
+    /**
+     * @param {string} id
+     * @returns {boolean}
+     */
+    has(id: string): boolean;
+    /**
+     * Node that voices/children should connect into for a given bus.
+     * @param {string} id
+     * @returns {AudioNode}
+     */
+    getInput(id: string): AudioNode;
+    /**
+     * @param {string} id
+     * @returns {number} linear gain
+     */
+    getVolume(id: string): number;
+    /**
+     * @param {string} id
+     * @param {number} linear linear gain
+     */
+    setVolume(id: string, linear: number): void;
+    /**
+     * @param {string} id
+     * @returns {number} gain in decibels
+     */
+    getVolumeDb(id: string): number;
+    /**
+     * Click-safely ramp a bus's linear volume to `linear` over `duration` seconds (used by mixer
+     * snapshot blends). For an instant change use {@link setVolume}.
+     * @param {string} id
+     * @param {number} linear target linear gain
+     * @param {number} duration seconds
+     * @param {number} [startAfter=0] seconds
+     */
+    rampVolume(id: string, linear: number, duration: number, startAfter?: number): void;
+    /**
+     * Exponentially approach a target linear volume with a time constant (used by ducking attack/
+     * release). Unlike {@link rampVolume} this does not anchor — it's a smooth setTargetAtTime glide.
+     * @param {string} id
+     * @param {number} linear target linear gain
+     * @param {number} timeConstant seconds
+     */
+    approachVolume(id: string, linear: number, timeConstant: number): void;
+    #private;
+}
+//# sourceMappingURL=BusGraph.d.ts.map

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

@@ -0,0 +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;;;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"}