@woosh/meep-engine 2.154.0 → 2.156.0

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

@@ -0,0 +1,98 @@
+import Signal from "../../../../core/events/signal/Signal.js";
+
+/**
+ * Holds live values for named parameters (RTPC). P0 is the minimal store (define/get/set + a change
+ * signal); automation curves binding parameter values to gains/pitch/sends are layered on in P1.
+ */
+export class ParameterStore {
+
+    /**
+     * @type {Map<string, number>}
+     */
+    #values = new Map();
+
+    /**
+     * name -> apply callbacks, invoked with the new value whenever the parameter changes.
+     * @type {Map<string, function(number)[]>}
+     */
+    #bindings = new Map();
+
+    /**
+     * Fires (name, value) whenever a parameter changes.
+     * @type {Signal<string, number>}
+     */
+    onChanged = new Signal();
+
+    /**
+     * Register a parameter with its default value (no-op if already defined).
+     * @param {string} name
+     * @param {number} defaultValue
+     */
+    define(name, defaultValue) {
+        if (!this.#values.has(name)) {
+            this.#values.set(name, defaultValue);
+        }
+    }
+
+    /**
+     * @param {string} name
+     * @returns {boolean}
+     */
+    has(name) {
+        return this.#values.has(name);
+    }
+
+    /**
+     * @param {string} name
+     * @returns {number|undefined}
+     */
+    get(name) {
+        return this.#values.get(name);
+    }
+
+    /**
+     * @param {string} name
+     * @param {number} value
+     */
+    set(name, value) {
+        const previous = this.#values.get(name);
+
+        if (previous === value) {
+            return;
+        }
+
+        this.#values.set(name, value);
+
+        const bindings = this.#bindings.get(name);
+        if (bindings !== undefined) {
+            for (let i = 0; i < bindings.length; i++) {
+                bindings[i](value);
+            }
+        }
+
+        if (this.onChanged.hasHandlers()) {
+            this.onChanged.send2(name, value);
+        }
+    }
+
+    /**
+     * Bind a callback to a parameter; it runs on every change (and once now if the parameter already
+     * has a value). Used to drive bus gains / voice params from an automation curve.
+     * @param {string} name
+     * @param {function(number)} applyFn
+     */
+    bind(name, applyFn) {
+        let list = this.#bindings.get(name);
+
+        if (list === undefined) {
+            list = [];
+            this.#bindings.set(name, list);
+        }
+
+        list.push(applyFn);
+
+        if (this.#values.has(name)) {
+            applyFn(this.#values.get(name));
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Per-source playback state for deterministic clip resolution: a seeded RNG plus an opaque,
+ * per-source scratch store that stateful clips hang their runtime state on (e.g.
+ * {@link RandomContainerAudioClip}'s "avoid repeating last N" history).
+ *
+ * Determinism (D5): seed from a replicated source (entity id + fixedStepTick) so random selection
+ * matches across networked clients. Scratch state persists across re-triggers of the same source
+ * (e.g. footsteps), so reuse one context per emitter rather than per trigger.
+ *
+ * The context deliberately knows nothing about any specific clip type — each clip owns its own
+ * selection algorithm and merely borrows a per-source state slot here, so the shared, immutable clip
+ * *definitions* never hold mutable runtime state.
+ */
+export class SopraPlaybackContext {
+    /**
+     * @param {number} [seed]
+     */
+    constructor(seed?: number);
+    /**
+     * Seeded RNG — a function returning [0, 1) with `setCurrentSeed`/`getCurrentSeed`.
+     * @type {function():number}
+     */
+    random: () => number;
+    /**
+     * Reseed the RNG (e.g. per trigger, from entity id + tick).
+     * @param {number} seed
+     */
+    setSeed(seed: number): void;
+    /**
+     * Per-source scratch state for `owner`, created on first access via `createDefault`. Subsequent
+     * calls with the same `owner` return the same (mutable) value, so an owner can accumulate state
+     * across triggers. State is private to this context — another context built from the same owner
+     * starts fresh.
+     * @template T
+     * @param {object} owner
+     * @param {function():T} createDefault
+     * @returns {T}
+     */
+    getState<T>(owner: object, createDefault: () => T): T;
+    #private;
+}
+//# sourceMappingURL=SopraPlaybackContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SopraPlaybackContext.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/SopraPlaybackContext.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IAgBI;;OAEG;IACH,mBAFW,MAAM,EAIhB;IAnBD;;;OAGG;IACH,cAFqB,MAAM,CAEpB;IAiBP;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;;;;;;;OASG;IACH,mBAJW,MAAM,6BAchB;;CACJ"}

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

@@ -0,0 +1,68 @@
+import { seededRandom } from "../../../../core/math/random/seededRandom.js";
+
+/**
+ * Per-source playback state for deterministic clip resolution: a seeded RNG plus an opaque,
+ * per-source scratch store that stateful clips hang their runtime state on (e.g.
+ * {@link RandomContainerAudioClip}'s "avoid repeating last N" history).
+ *
+ * Determinism (D5): seed from a replicated source (entity id + fixedStepTick) so random selection
+ * matches across networked clients. Scratch state persists across re-triggers of the same source
+ * (e.g. footsteps), so reuse one context per emitter rather than per trigger.
+ *
+ * The context deliberately knows nothing about any specific clip type — each clip owns its own
+ * selection algorithm and merely borrows a per-source state slot here, so the shared, immutable clip
+ * *definitions* never hold mutable runtime state.
+ */
+export class SopraPlaybackContext {
+
+    /**
+     * Seeded RNG — a function returning [0, 1) with `setCurrentSeed`/`getCurrentSeed`.
+     * @type {function():number}
+     */
+    random;
+
+    /**
+     * owner -> that owner's per-source scratch state, created lazily via {@link getState}. Keyed by
+     * the owning object (typically a clip definition), so distinct owners — and distinct contexts —
+     * keep independent state.
+     * @type {Map<object, *>}
+     */
+    #state = new Map();
+
+    /**
+     * @param {number} [seed]
+     */
+    constructor(seed = 0) {
+        this.random = seededRandom(seed);
+    }
+
+    /**
+     * Reseed the RNG (e.g. per trigger, from entity id + tick).
+     * @param {number} seed
+     */
+    setSeed(seed) {
+        this.random.setCurrentSeed(seed);
+    }
+
+    /**
+     * Per-source scratch state for `owner`, created on first access via `createDefault`. Subsequent
+     * calls with the same `owner` return the same (mutable) value, so an owner can accumulate state
+     * across triggers. State is private to this context — another context built from the same owner
+     * starts fresh.
+     * @template T
+     * @param {object} owner
+     * @param {function():T} createDefault
+     * @returns {T}
+     */
+    getState(owner, createDefault) {
+        const existing = this.#state.get(owner);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        const created = createDefault();
+        this.#state.set(owner, created);
+        return created;
+    }
+}

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

@@ -0,0 +1,67 @@
+/**
+ * A single playing sound — one throwaway {@link AudioBufferSourceNode} plus a pooled trim
+ * {@link GainNode}. The source is the only unavoidable per-play allocation (it is single-use); the
+ * trim gain persists across pool reuse.
+ *
+ * Voices are transient runtime objects — never serialized.
+ */
+export class Voice {
+    /**
+     * Per-voice gain (clip + event gain, pre-bus). Reused across plays; created lazily because it
+     * needs an AudioContext.
+     * @type {GainNode|null}
+     */
+    trimGain: GainNode | null;
+    /**
+     * @type {AudioBufferSourceNode|null}
+     */
+    source: AudioBufferSourceNode | null;
+    /**
+     * Context time at which this voice was (scheduled to be) started.
+     * @type {number}
+     */
+    startedAt: number;
+    /**
+     * Resolved linear gain of this voice (used as a stealing-priority hint by the VoiceManager).
+     * @type {number}
+     */
+    gainLinear: number;
+    /**
+     * Invoked with `this` when the source ends naturally (non-looping). A plain function slot (not a
+     * Signal) to stay pool-friendly; defaults to {@link noop}. Set by the owning {@link EventInstance}.
+     * @type {function(Voice)}
+     */
+    onEnded: (arg0: Voice) => any;
+    /**
+     * @returns {boolean}
+     */
+    get active(): boolean;
+    /**
+     * Build (lazily) and start the source, routed into `busInput` via the trim gain.
+     *
+     * @param {BaseAudioContext} ctx
+     * @param {AudioNode} busInput node this voice routes into (a bus chain head)
+     * @param {AudioBuffer} buffer
+     * @param {{gainLinear:number, detuneCents:number, loop:boolean, loopStart:number, loopEnd:number, when:number, offset:number}} params
+     */
+    play(ctx: BaseAudioContext, busInput: AudioNode, buffer: AudioBuffer, params: {
+        gainLinear: number;
+        detuneCents: number;
+        loop: boolean;
+        loopStart: number;
+        loopEnd: number;
+        when: number;
+        offset: number;
+    }): void;
+    /**
+     * Stop and disconnect the source. Safe to call once per started voice.
+     * @param {number} [when=0] context time to stop at
+     */
+    stop(when?: number): void;
+    /**
+     * Return the voice to a clean state for pooled reuse. Keeps the trim gain (disconnected).
+     */
+    reset(): void;
+    #private;
+}
+//# sourceMappingURL=Voice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Voice.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/Voice.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH;IAEI;;;;OAIG;IACH,UAFU,QAAQ,GAAC,IAAI,CAEP;IAEhB;;OAEG;IACH,QAFU,qBAAqB,GAAC,IAAI,CAEtB;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,gBAFmB,KAAK,SAET;IAYf;;OAEG;IACH,sBAEC;IAED;;;;;;;OAOG;IACH,UALW,gBAAgB,YAChB,SAAS,UACT,WAAW,UACX;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,OAAO,CAAC;QAAC,SAAS,EAAC,MAAM,CAAC;QAAC,OAAO,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAA;KAAC,QAiC7H;IAaD;;;OAGG;IACH,YAFW,MAAM,QAchB;IAED;;OAEG;IACH,cAWC;;CACJ"}

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

@@ -0,0 +1,145 @@
+import { noop } from "../../../../core/function/noop.js";
+
+/**
+ * A single playing sound — one throwaway {@link AudioBufferSourceNode} plus a pooled trim
+ * {@link GainNode}. The source is the only unavoidable per-play allocation (it is single-use); the
+ * trim gain persists across pool reuse.
+ *
+ * Voices are transient runtime objects — never serialized.
+ */
+export class Voice {
+
+    /**
+     * Per-voice gain (clip + event gain, pre-bus). Reused across plays; created lazily because it
+     * needs an AudioContext.
+     * @type {GainNode|null}
+     */
+    trimGain = null;
+
+    /**
+     * @type {AudioBufferSourceNode|null}
+     */
+    source = null;
+
+    /**
+     * Context time at which this voice was (scheduled to be) started.
+     * @type {number}
+     */
+    startedAt = 0;
+
+    /**
+     * Resolved linear gain of this voice (used as a stealing-priority hint by the VoiceManager).
+     * @type {number}
+     */
+    gainLinear = 1;
+
+    /**
+     * Invoked with `this` when the source ends naturally (non-looping). A plain function slot (not a
+     * Signal) to stay pool-friendly; defaults to {@link noop}. Set by the owning {@link EventInstance}.
+     * @type {function(Voice)}
+     */
+    onEnded = noop;
+
+    /**
+     * @type {boolean}
+     */
+    #looping = false;
+
+    /**
+     * @type {boolean}
+     */
+    #active = false;
+
+    /**
+     * @returns {boolean}
+     */
+    get active() {
+        return this.#active;
+    }
+
+    /**
+     * Build (lazily) and start the source, routed into `busInput` via the trim gain.
+     *
+     * @param {BaseAudioContext} ctx
+     * @param {AudioNode} busInput node this voice routes into (a bus chain head)
+     * @param {AudioBuffer} buffer
+     * @param {{gainLinear:number, detuneCents:number, loop:boolean, loopStart:number, loopEnd:number, when:number, offset:number}} params
+     */
+    play(ctx, busInput, buffer, params) {
+        // recreate the trim gain only when missing or bound to a different context (the latter only
+        // happens across pooled reuse between AudioContexts, e.g. in tests)
+        if (this.trimGain === null || this.trimGain.context !== ctx) {
+            this.trimGain = ctx.createGain();
+        }
+
+        this.gainLinear = params.gainLinear;
+        this.trimGain.gain.setValueAtTime(params.gainLinear, 0);
+        this.trimGain.connect(busInput);
+
+        const source = ctx.createBufferSource();
+
+        source.buffer = buffer;
+        source.loop = params.loop;
+        source.loopStart = params.loopStart;
+        source.loopEnd = params.loopEnd;
+        source.detune.value = params.detuneCents;
+
+        source.connect(this.trimGain);
+
+        source.onended = () => {
+            this.#handleSourceEnded();
+        };
+
+        source.start(params.when, params.offset);
+
+        this.source = source;
+        this.startedAt = params.when;
+        this.#looping = params.loop;
+        this.#active = true;
+    }
+
+    #handleSourceEnded() {
+        if (this.#looping) {
+            // looping sources only fire 'ended' on explicit stop, which we drive ourselves
+            return;
+        }
+
+        this.#active = false;
+
+        this.onEnded(this);
+    }
+
+    /**
+     * Stop and disconnect the source. Safe to call once per started voice.
+     * @param {number} [when=0] context time to stop at
+     */
+    stop(when = 0) {
+        const source = this.source;
+
+        if (source !== null) {
+            source.onended = null;
+            source.stop(when);
+            source.disconnect();
+
+            this.source = null;
+        }
+
+        this.#active = false;
+    }
+
+    /**
+     * Return the voice to a clean state for pooled reuse. Keeps the trim gain (disconnected).
+     */
+    reset() {
+        this.source = null;
+        this.onEnded = noop;
+        this.startedAt = 0;
+        this.gainLinear = 1;
+        this.#active = false;
+        this.#looping = false;
+
+        if (this.trimGain !== null) {
+            this.trimGain.disconnect();
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Enforces per-event instance limits and voice stealing — the layer that keeps mass entity counts
+ * viable (the engine's stated target). Groups active {@link EventInstance}s by their
+ * {@link EventDescription}; on a new play it makes room within `EventDescription.maxInstances` by
+ * stopping victims per the event's {@link VoiceStealMode}.
+ *
+ * Grouping is keyed by the description's CONTENT (its `hash()`/`equals()`), not by the `id` string —
+ * so two descriptions are "the same event" iff they are equal, and the id need not be unique. (Since
+ * `maxInstances` is part of equality, every instance in a bucket shares the same cap.)
+ *
+ * Defaults are a no-op: maxInstances defaults high, so the limit (and therefore stealing) only kicks
+ * in when content opts into a low limit.
+ */
+export class VoiceManager {
+    /**
+     * @param {EventInstance} instance
+     */
+    register(instance: EventInstance): void;
+    /**
+     * @param {EventInstance} instance
+     */
+    unregister(instance: EventInstance): void;
+    /**
+     * @param {EventDescription} description
+     * @returns {number}
+     */
+    countForEvent(description: EventDescription): number;
+    /**
+     * Ensure there is room to start one more instance of `description`, stealing existing instances
+     * if necessary.
+     * @param {EventDescription} description
+     * @returns {boolean} true if a new instance may start (possibly after stealing); false if the
+     *                    limit is reached and the steal mode is None (the new play should be dropped)
+     */
+    makeRoom(description: EventDescription): boolean;
+    #private;
+}
+//# sourceMappingURL=VoiceManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VoiceManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/VoiceManager.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;GAYG;AACH;IAQI;;OAEG;IACH,wCAIC;IAED;;OAEG;IACH,0CAaC;IAED;;;OAGG;IACH,8CAFa,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,yCAHa,OAAO,CA4BnB;;CAEJ"}

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

@@ -0,0 +1,136 @@
+import { HashMap } from "../../../../core/collection/map/HashMap.js";
+import { VoiceStealMode } from "../definition/VoiceStealMode.js";
+
+/**
+ *
+ * @param {EventInstance} a
+ * @param {EventInstance} b
+ * @returns {number}
+ */
+function by_age(a, b) {
+    return a.startedAt - b.startedAt;
+}
+
+/**
+ *
+ * @param {EventInstance} a
+ * @param {EventInstance} b
+ * @returns {number}
+ */
+function by_gain(a, b) {
+    return a.currentGain - b.currentGain;
+}
+
+/**
+ * @param {Set<EventInstance>} set
+ * @param {VoiceStealMode|number} mode
+ * @param {number} n
+ * @returns {EventInstance[]}
+ */
+function  pickVictims(set, mode, n) {
+    const instances = [...set];
+
+    if (mode === VoiceStealMode.Quietest) {
+        // lowest current (post-attenuation) gain first
+        instances.sort(by_gain);
+    } else {
+        // VoiceStealMode.Oldest (default): earliest-started first
+        instances.sort(by_age);
+    }
+
+    return instances.slice(0, n);
+}
+
+/**
+ * Enforces per-event instance limits and voice stealing — the layer that keeps mass entity counts
+ * viable (the engine's stated target). Groups active {@link EventInstance}s by their
+ * {@link EventDescription}; on a new play it makes room within `EventDescription.maxInstances` by
+ * stopping victims per the event's {@link VoiceStealMode}.
+ *
+ * Grouping is keyed by the description's CONTENT (its `hash()`/`equals()`), not by the `id` string —
+ * so two descriptions are "the same event" iff they are equal, and the id need not be unique. (Since
+ * `maxInstances` is part of equality, every instance in a bucket shares the same cap.)
+ *
+ * Defaults are a no-op: maxInstances defaults high, so the limit (and therefore stealing) only kicks
+ * in when content opts into a low limit.
+ */
+export class VoiceManager {
+
+    /**
+     * event description -> its live instances, keyed by content (hash + equals).
+     * @type {HashMap<EventDescription, Set<EventInstance>>}
+     */
+    #byEvent = new HashMap();
+
+    /**
+     * @param {EventInstance} instance
+     */
+    register(instance) {
+        const set = this.#byEvent.getOrCompute(instance.description, () => new Set());
+
+        set.add(instance);
+    }
+
+    /**
+     * @param {EventInstance} instance
+     */
+    unregister(instance) {
+        const description = instance.description;
+        const set = this.#byEvent.get(description);
+
+        if (set === undefined) {
+            return;
+        }
+
+        set.delete(instance);
+
+        if (set.size === 0) {
+            this.#byEvent.delete(description);
+        }
+    }
+
+    /**
+     * @param {EventDescription} description
+     * @returns {number}
+     */
+    countForEvent(description) {
+        const set = this.#byEvent.get(description);
+
+        return set === undefined ? 0 : set.size;
+    }
+
+    /**
+     * Ensure there is room to start one more instance of `description`, stealing existing instances
+     * if necessary.
+     * @param {EventDescription} description
+     * @returns {boolean} true if a new instance may start (possibly after stealing); false if the
+     *                    limit is reached and the steal mode is None (the new play should be dropped)
+     */
+    makeRoom(description) {
+        const max = description.maxInstances;
+        const set = this.#byEvent.get(description);
+        const count = set === undefined ? 0 : set.size;
+
+        if (count < max) {
+            return true;
+        }
+
+        if (description.stealMode === VoiceStealMode.None) {
+            return false;
+        }
+
+        // free enough slots so that, after adding one, we are within the limit. NB: maxInstances is part
+        // of EventDescription equality, so every instance in a bucket shares the same cap — count is
+        // therefore always exactly `max` here and this steals exactly one. The formula stays general
+        // (don't "simplify" it to a single victim: it's the correct expression of the intent).
+        const victims = pickVictims(set, description.stealMode, count - max + 1);
+
+        for (let i = 0; i < victims.length; i++) {
+            // stop() unregisters the victim via the engine's instance-finished hook
+            victims[i].stop();
+        }
+
+        return true;
+    }
+
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Process-wide shared pool of reusable {@link Voice} objects, built on the generic
+ * {@link ObjectPoolFactory}. There is a single AudioContext in production, so one shared pool is
+ * sufficient; recycling voices (and their long-lived trim {@link GainNode}s) keeps GC churn down at
+ * high voice counts. Only the single-use source node is allocated per play.
+ *
+ * @type {ObjectPoolFactory<Voice>}
+ */
+export const VOICE_POOL: ObjectPoolFactory<Voice>;
+import { ObjectPoolFactory } from "../../../../core/model/object/ObjectPoolFactory.js";
+import { Voice } from "./Voice.js";
+//# sourceMappingURL=VoicePool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VoicePool.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/VoicePool.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,yBAFU,kBAAkB,KAAK,CAAC,CAMhC;kCAfgC,oDAAoD;sBAChE,YAAY"}

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

@@ -0,0 +1,17 @@
+import { noop } from "../../../../core/function/noop.js";
+import { ObjectPoolFactory } from "../../../../core/model/object/ObjectPoolFactory.js";
+import { Voice } from "./Voice.js";
+
+/**
+ * Process-wide shared pool of reusable {@link Voice} objects, built on the generic
+ * {@link ObjectPoolFactory}. There is a single AudioContext in production, so one shared pool is
+ * sufficient; recycling voices (and their long-lived trim {@link GainNode}s) keeps GC churn down at
+ * high voice counts. Only the single-use source node is allocated per play.
+ *
+ * @type {ObjectPoolFactory<Voice>}
+ */
+export const VOICE_POOL = new ObjectPoolFactory(
+    () => new Voice(),
+    noop,
+    voice => voice.reset()
+);

package/src/engine/sound/sopra/serialization/populateSopraSerializationRegistry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Register every sopra definition adapter on a {@link BinarySerializationRegistry}.
+ *
+ * In production this is called from `GameBinarySerializationRegistry.initializeGameBinarySerializationRegistry`
+ * (integration lands in P3); in P0 it backs the round-trip specs. Keeping the list here mirrors the
+ * behavior-tree `populateNodeRegistry` convention.
+ *
+ * @param {BinarySerializationRegistry} registry
+ */
+export function populateSopraSerializationRegistry(registry: BinarySerializationRegistry): void;
+//# sourceMappingURL=populateSopraSerializationRegistry.d.ts.map

package/src/engine/sound/sopra/serialization/populateSopraSerializationRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populateSopraSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/serialization/populateSopraSerializationRegistry.js"],"names":[],"mappings":"AAeA;;;;;;;;GAQG;AACH,gGAiBC"}