@woosh/meep-engine 2.155.0 → 2.156.0

package/src/engine/sound/sopra/definition/MixerSnapshot.d.ts

@@ -0,0 +1,51 @@
+/**
+ * A named mixer state: a target gain (dB) for a set of buses. Applying a snapshot sets or click-safely
+ * ramps those buses to the targets — the FMOD/Wwise "snapshot / mixer state" used to shift the whole
+ * mix between game states (combat / ambient / menu / dialogue). Pure serializable definition; the
+ * runtime apply/capture lives on {@link SopraEngine}.
+ */
+export class MixerSnapshot {
+    /**
+     * @param {string} id
+     * @param {{busId: string, gainDb: number}[]} [buses]
+     * @returns {MixerSnapshot}
+     */
+    static from(id: string, buses?: {
+        busId: string;
+        gainDb: number;
+    }[]): MixerSnapshot;
+    /**
+     * @type {string}
+     */
+    id: string;
+    /**
+     * Target gain per bus, in decibels.
+     * @type {{busId: string, gainDb: number}[]}
+     */
+    buses: {
+        busId: string;
+        gainDb: number;
+    }[];
+    /**
+     * @param {MixerSnapshot} other
+     * @returns {boolean}
+     */
+    equals(other: MixerSnapshot): boolean;
+    hash(): number;
+    clone(): MixerSnapshot;
+    toJSON(): {
+        id: string;
+        buses: {
+            busId: string;
+            gainDb: number;
+        }[];
+    };
+    fromJSON({ id, buses }: {
+        id?: string;
+        buses?: any[];
+    }): void;
+}
+export namespace MixerSnapshot {
+    let typeName: string;
+}
+//# sourceMappingURL=MixerSnapshot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MixerSnapshot.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/MixerSnapshot.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;IAaI;;;;OAIG;IACH,gBAJW,MAAM,UACN;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,EAAE,GAC/B,aAAa,CASzB;IAvBD;;OAEG;IACH,IAFU,MAAM,CAER;IAER;;;OAGG;IACH,OAFU;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,EAAE,CAEhC;IAgBX;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAcnB;IAED,eAQC;IAED,uBAEC;IAED;;;;;;MAKC;IAED;;;aAGC;CACJ"}

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

@@ -0,0 +1,83 @@
+import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+
+/**
+ * A named mixer state: a target gain (dB) for a set of buses. Applying a snapshot sets or click-safely
+ * ramps those buses to the targets — the FMOD/Wwise "snapshot / mixer state" used to shift the whole
+ * mix between game states (combat / ambient / menu / dialogue). Pure serializable definition; the
+ * runtime apply/capture lives on {@link SopraEngine}.
+ */
+export class MixerSnapshot {
+
+    /**
+     * @type {string}
+     */
+    id = "";
+
+    /**
+     * Target gain per bus, in decibels.
+     * @type {{busId: string, gainDb: number}[]}
+     */
+    buses = [];
+
+    /**
+     * @param {string} id
+     * @param {{busId: string, gainDb: number}[]} [buses]
+     * @returns {MixerSnapshot}
+     */
+    static from(id, buses = []) {
+        const r = new MixerSnapshot();
+
+        r.id = id;
+        r.buses = buses;
+
+        return r;
+    }
+
+    /**
+     * @param {MixerSnapshot} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this.id !== other.id || this.buses.length !== other.buses.length) {
+            return false;
+        }
+
+        for (let i = 0; i < this.buses.length; i++) {
+            if (this.buses[i].busId !== other.buses[i].busId || this.buses[i].gainDb !== other.buses[i].gainDb) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    hash() {
+        let h = computeStringHash(this.id);
+
+        for (let i = 0; i < this.buses.length; i++) {
+            h = combine_hash(h, computeStringHash(this.buses[i].busId), computeHashFloat(this.buses[i].gainDb));
+        }
+
+        return h;
+    }
+
+    clone() {
+        return MixerSnapshot.from(this.id, this.buses.map(b => ({ busId: b.busId, gainDb: b.gainDb })));
+    }
+
+    toJSON() {
+        return {
+            id: this.id,
+            buses: this.buses.map(b => ({ busId: b.busId, gainDb: b.gainDb }))
+        };
+    }
+
+    fromJSON({ id = "", buses = [] }) {
+        this.id = id;
+        this.buses = buses.map(b => ({ busId: b.busId, gainDb: b.gainDb }));
+    }
+}
+
+MixerSnapshot.typeName = "SopraMixerSnapshot";

package/src/engine/sound/sopra/definition/MixerSnapshotSerializationAdapter.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"MixerSnapshotSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/MixerSnapshotSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IACI,4BAAsB;IACtB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,aAAa,QAWvB;IAED;;;OAGG;IACH,yCAFW,aAAa,QAavB;CACJ;gDAtC+C,gEAAgE;8BAClF,oBAAoB"}

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

@@ -0,0 +1,39 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { MixerSnapshot } from "./MixerSnapshot.js";
+
+export class MixerSnapshotSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = MixerSnapshot;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {MixerSnapshot} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUTF8String(value.id);
+
+        const buses = value.buses;
+        buffer.writeUintVar(buses.length);
+        for (let i = 0; i < buses.length; i++) {
+            buffer.writeUTF8String(buses[i].busId);
+            buffer.writeFloat32(buses[i].gainDb);
+        }
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {MixerSnapshot} value
+     */
+    deserialize(buffer, value) {
+        value.id = buffer.readUTF8String();
+
+        const n = buffer.readUintVar();
+        const buses = [];
+        for (let i = 0; i < n; i++) {
+            const busId = buffer.readUTF8String();
+            const gainDb = buffer.readFloat32();
+            buses.push({ busId, gainDb });
+        }
+        value.buses = buses;
+    }
+}

package/src/engine/sound/sopra/definition/ParameterDefinition.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Whether a parameter has one value for the whole world or a value per playing instance.
+ */
+export type ParameterScope = number;
+export namespace ParameterScope {
+    let Global: number;
+    let Instance: number;
+}
+/**
+ * Declares a named runtime parameter (RTPC). Its live value lives in the {@link ParameterStore};
+ * automation curves bound elsewhere read it.
+ */
+export class ParameterDefinition {
+    /**
+     *
+     * @param {string} name
+     * @param {{min?:number, max?:number, defaultValue?:number, scope?:ParameterScope|number}} [options]
+     * @returns {ParameterDefinition}
+     */
+    static from(name: string, { min, max, defaultValue, scope }?: {
+        min?: number;
+        max?: number;
+        defaultValue?: number;
+        scope?: ParameterScope | number;
+    }): ParameterDefinition;
+    /**
+     * @type {string}
+     */
+    name: string;
+    /**
+     * @type {number}
+     */
+    min: number;
+    /**
+     * @type {number}
+     */
+    max: number;
+    /**
+     * @type {number}
+     */
+    defaultValue: number;
+    /**
+     * @type {ParameterScope|number}
+     */
+    scope: ParameterScope | number;
+    /**
+     *
+     * @param {ParameterDefinition} other
+     * @returns {boolean}
+     */
+    equals(other: ParameterDefinition): boolean;
+    hash(): number;
+    clone(): ParameterDefinition;
+    toJSON(): {
+        name: string;
+        min: number;
+        max: number;
+        defaultValue: number;
+        scope: number;
+    };
+    fromJSON({ name, min, max, defaultValue, scope }: {
+        name?: string;
+        min?: number;
+        max?: number;
+        defaultValue?: number;
+        scope?: number;
+    }): void;
+}
+export namespace ParameterDefinition {
+    let typeName: string;
+}
+//# sourceMappingURL=ParameterDefinition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ParameterDefinition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/ParameterDefinition.js"],"names":[],"mappings":";;;6BAMU,MAAM;;;;;AAOhB;;;GAGG;AACH;IA2BI;;;;;OAKG;IACH,kBAJW,MAAM,sCACN;QAAC,GAAG,CAAC,EAAC,MAAM,CAAC;QAAC,GAAG,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,KAAK,CAAC,EAAC,cAAc,GAAC,MAAM,CAAA;KAAC,GAC5E,mBAAmB,CAY/B;IAzCD;;OAEG;IACH,MAFU,MAAM,CAEN;IAEV;;OAEG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,MAAM,CAEC;IAEjB;;OAEG;IACH,OAFU,cAAc,GAAC,MAAM,CAED;IAoB9B;;;;OAIG;IACH,cAHW,mBAAmB,GACjB,OAAO,CAQnB;IAED,eAQC;IAED,6BAUC;IAED;;;;;;MAQC;IAED;;;;;;aAMC;CACJ"}

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

@@ -0,0 +1,117 @@
+import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+
+/**
+ * Whether a parameter has one value for the whole world or a value per playing instance.
+ * @enum {number}
+ */
+export const ParameterScope = {
+    Global: 0,
+    Instance: 1
+};
+
+/**
+ * Declares a named runtime parameter (RTPC). Its live value lives in the {@link ParameterStore};
+ * automation curves bound elsewhere read it.
+ */
+export class ParameterDefinition {
+
+    /**
+     * @type {string}
+     */
+    name = "";
+
+    /**
+     * @type {number}
+     */
+    min = 0;
+
+    /**
+     * @type {number}
+     */
+    max = 1;
+
+    /**
+     * @type {number}
+     */
+    defaultValue = 0;
+
+    /**
+     * @type {ParameterScope|number}
+     */
+    scope = ParameterScope.Global;
+
+    /**
+     *
+     * @param {string} name
+     * @param {{min?:number, max?:number, defaultValue?:number, scope?:ParameterScope|number}} [options]
+     * @returns {ParameterDefinition}
+     */
+    static from(name, { min = 0, max = 1, defaultValue = 0, scope = ParameterScope.Global } = {}) {
+        const r = new ParameterDefinition();
+
+        r.name = name;
+        r.min = min;
+        r.max = max;
+        r.defaultValue = defaultValue;
+        r.scope = scope;
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {ParameterDefinition} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.name === other.name
+            && this.min === other.min
+            && this.max === other.max
+            && this.defaultValue === other.defaultValue
+            && this.scope === other.scope;
+    }
+
+    hash() {
+        return combine_hash(
+            computeStringHash(this.name),
+            computeHashFloat(this.min),
+            computeHashFloat(this.max),
+            computeHashFloat(this.defaultValue),
+            this.scope
+        );
+    }
+
+    clone() {
+        const r = new ParameterDefinition();
+
+        r.name = this.name;
+        r.min = this.min;
+        r.max = this.max;
+        r.defaultValue = this.defaultValue;
+        r.scope = this.scope;
+
+        return r;
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            min: this.min,
+            max: this.max,
+            defaultValue: this.defaultValue,
+            scope: this.scope
+        };
+    }
+
+    fromJSON({ name = "", min = 0, max = 1, defaultValue = 0, scope = ParameterScope.Global }) {
+        this.name = name;
+        this.min = min;
+        this.max = max;
+        this.defaultValue = defaultValue;
+        this.scope = scope;
+    }
+}
+
+ParameterDefinition.typeName = "SopraParameterDefinition";

package/src/engine/sound/sopra/definition/ParameterDefinitionSerializationAdapter.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ParameterDefinitionSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/ParameterDefinitionSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IACI,kCAA4B;IAC5B,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,mBAAmB,QAQ7B;IAED;;;OAGG;IACH,yCAFW,mBAAmB,QAQ7B;CACJ;gDA9B+C,gEAAgE;oCAC5E,0BAA0B"}

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

@@ -0,0 +1,31 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { ParameterDefinition } from "./ParameterDefinition.js";
+
+export class ParameterDefinitionSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = ParameterDefinition;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {ParameterDefinition} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUTF8String(value.name);
+        buffer.writeFloat32(value.min);
+        buffer.writeFloat32(value.max);
+        buffer.writeFloat32(value.defaultValue);
+        buffer.writeUint8(value.scope);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {ParameterDefinition} value
+     */
+    deserialize(buffer, value) {
+        value.name = buffer.readUTF8String();
+        value.min = buffer.readFloat32();
+        value.max = buffer.readFloat32();
+        value.defaultValue = buffer.readFloat32();
+        value.scope = buffer.readUint8();
+    }
+}

package/src/engine/sound/sopra/definition/SopraPanningModel.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 3D panning algorithm for a spatialized event. Mirrors the legacy SoundPanningModelType.
+ * (Cheaper non-positional options — StereoPanner / none — are a P4 follow-up.)
+ */
+export type SopraPanningModel = number;
+export namespace SopraPanningModel {
+    let HRTF: number;
+    let EqualPower: number;
+}
+/**
+ * @type {string[]} maps {@link SopraPanningModel} to the WebAudio PannerNode.panningModel value
+ */
+export const SOPRA_PANNING_MODEL_TO_WEBAUDIO: string[];
+//# sourceMappingURL=SopraPanningModel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SopraPanningModel.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/SopraPanningModel.js"],"names":[],"mappings":";;;;gCAGU,MAAM;;;;;AAahB;;GAEG;AACH,8CAFU,MAAM,EAAE,CAEoD"}

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

@@ -0,0 +1,20 @@
+/**
+ * 3D panning algorithm for a spatialized event. Mirrors the legacy SoundPanningModelType.
+ * (Cheaper non-positional options — StereoPanner / none — are a P4 follow-up.)
+ * @enum {number}
+ */
+export const SopraPanningModel = {
+    /**
+     * Head-related transfer function — high quality, more expensive (convolution per source).
+     */
+    HRTF: 0,
+    /**
+     * Equal-power panning — cheap, good for distant / many sources.
+     */
+    EqualPower: 1
+};
+
+/**
+ * @type {string[]} maps {@link SopraPanningModel} to the WebAudio PannerNode.panningModel value
+ */
+export const SOPRA_PANNING_MODEL_TO_WEBAUDIO = ['HRTF', 'equalpower'];

package/src/engine/sound/sopra/definition/VoiceStealMode.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Policy for choosing which active voice to stop when an event/bus instance limit is reached.
+ */
+export type VoiceStealMode = number;
+export namespace VoiceStealMode {
+    let None: number;
+    let Oldest: number;
+    let Quietest: number;
+}
+//# sourceMappingURL=VoiceStealMode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VoiceStealMode.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/VoiceStealMode.js"],"names":[],"mappings":";;;6BAEU,MAAM"}

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

@@ -0,0 +1,18 @@
+/**
+ * Policy for choosing which active voice to stop when an event/bus instance limit is reached.
+ * @enum {number}
+ */
+export const VoiceStealMode = {
+    /**
+     * Do not steal — a new trigger over the limit is dropped.
+     */
+    None: 0,
+    /**
+     * Stop the voice that started earliest.
+     */
+    Oldest: 1,
+    /**
+     * Stop the voice with the lowest post-attenuation gain.
+     */
+    Quietest: 2
+};

package/src/engine/sound/sopra/definition/clip/AbstractAudioClip.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Base class for all audio clips.
+ *
+ * A clip is a pure, serializable DEFINITION node — it holds no WebAudio objects and no playback
+ * state. Playback state lives in a transient {@link EventInstance}/{@link Voice}; see the
+ * definition/instance split in `sopra/IMPLEMENTATION_PLAN.md`.
+ *
+ * NOTE: unlike the original stub, there is no `parent` pointer and no `channel` field. Inheritance
+ * of gain/pitch is resolved ONCE, top-down, at voice instantiation (uniform control flow — no
+ * null=inherit sentinels reach the runtime). Routing is decided by {@link EventDescription.busId}.
+ */
+export class AbstractAudioClip {
+    /**
+     * Gain offset in decibel, accumulated additively down the clip tree at voice-instantiation time.
+     * @type {number}
+     */
+    gain: number;
+    /**
+     * Pitch offset in cents, accumulated additively down the clip tree at voice-instantiation time.
+     * @type {number}
+     */
+    pitch: number;
+    /**
+     * @protected
+     * @param {AbstractAudioClip} other
+     */
+    protected copyBaseFrom(other: AbstractAudioClip): void;
+    /**
+     * Base equality: the gain/pitch every clip carries. Subclasses override and extend it via
+     * `super.equals(other)`.
+     * @param {AbstractAudioClip} other
+     * @returns {boolean}
+     */
+    equals(other: AbstractAudioClip): boolean;
+    /**
+     * Base hash: folds in the gain/pitch every clip carries. Subclasses override and extend it via
+     * `super.hash()`.
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * Resolve this clip (and its subtree) into a flat list of timed leaf plays. Overridden by every
+     * concrete clip; children are reached via polymorphic dispatch (no type switching). Gain/pitch
+     * inheritance is accumulated top-down and resolved here ONCE, so the runtime never sees an
+     * inherit sentinel.
+     *
+     * @param {{durationOf: function(SampleAudioClip):number, playback: SopraPlaybackContext, getParameter: function(string):(number|undefined)}} env
+     *        `durationOf` returns a sample's buffer duration; `playback` supplies the seeded RNG and
+     *        random-container history; `getParameter` reads a live RTPC value (used by Switch/Blend
+     *        containers, read once at plan time), returning `undefined` if unset.
+     * @param {number} [gainDb] accumulated gain offset (dB); start with the event's master gain
+     * @param {number} [pitchCents] accumulated pitch offset (cents)
+     * @param {number} [offset] start time of this clip relative to the timeline origin (seconds)
+     * @returns {{plays: {clip: SampleAudioClip, offset: number, gainDb: number, pitchCents: number}[], duration: number}}
+     */
+    planTimeline(env: {
+        durationOf: (arg0: SampleAudioClip) => number;
+        playback: SopraPlaybackContext;
+        getParameter: (arg0: string) => (number | undefined);
+    }, gainDb?: number, pitchCents?: number, offset?: number): {
+        plays: {
+            clip: SampleAudioClip;
+            offset: number;
+            gainDb: number;
+            pitchCents: number;
+        }[];
+        duration: number;
+    };
+    /**
+     * Append every {@link SampleAudioClip} leaf reachable from this clip (across ALL branches) into
+     * `out`. Used to ensure candidate buffers are loaded before the timeline is resolved, so random
+     * selection consumes the RNG exactly once. Default: contributes nothing (overridden by sample
+     * leaves and containers).
+     *
+     * @param {SampleAudioClip[]} [out]
+     * @returns {SampleAudioClip[]}
+     */
+    collectSampleClips(out?: SampleAudioClip[]): SampleAudioClip[];
+    /**
+     * Whether this clip (or its subtree) can produce unbounded playback — i.e. an emitter holding it is
+     * a persistent source, not a one-shot. Used to decide auto-release/lifetime behaviour. Default
+     * false; overridden by looping leaves and containers. Conservative: a container reports looping if
+     * ANY reachable child can loop.
+     * @returns {boolean}
+     */
+    loops(): boolean;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isAudioClip: boolean;
+}
+//# sourceMappingURL=AbstractAudioClip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/AbstractAudioClip.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH;IAEI;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,8BAFW,iBAAiB,QAK3B;IAED;;;;;OAKG;IACH,cAHW,iBAAiB,GACf,OAAO,CAKnB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAOlB;IAED;;;;;;;;;;;;;;OAcG;IACH,kBATW;QAAC,UAAU,6BAA4B,MAAM,CAAC;QAAC,QAAQ,uBAAuB;QAAC,YAAY,SAAW,MAAM,KAAE,CAAC,MAAM,GAAC,SAAS,CAAC,CAAA;KAAC,WAIjI,MAAM,eACN,MAAM,WACN,MAAM,GACJ;QAAC,KAAK,EAAE;YAAC,IAAI,kBAAkB;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAC,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAIpH;IAED;;;;;;;;OAQG;IACH,yBAHW,iBAAiB,GACf,iBAAiB,CAI7B;IAED;;;;;;OAMG;IACH,SAFa,OAAO,CAInB;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEsB;CANtC"}