@jgengine/shell 0.18.1 → 0.21.0

package/dist/audio/audioEngine.js

@@ -1,14 +1,18 @@
 import { distance3, resolveEmitterGain } from "@jgengine/core/audio/audioFalloff";
+import { dopplerRate } from "@jgengine/core/audio/doppler";
 import { patchDuration } from "@jgengine/core/audio/synth";
+import { createVoiceAllocator } from "@jgengine/core/audio/voiceAllocator";
 import { createDisposer } from "@jgengine/core/game/defineGame";
-import { clampLoopGain, clampLoopRate } from "./loopParams.js";
+import { clampLoopCutoff, clampLoopGain, clampLoopRate, MIN_LOOP_CUTOFF, MAX_LOOP_CUTOFF } from "./loopParams.js";
 import { MusicDirector } from "./musicDirector.js";
 import { createNoiseBuffer, realizeSynthPatch } from "./synthEngine.js";
 /** setTargetAtTime time constant (~20 ms) for zipper-free live rate/gain ramps on retained loops (#1051). */
 const LOOP_PARAM_SMOOTH_TC = 0.02;
+const ZERO_VELOCITY = { x: 0, y: 0, z: 0 };
 function createNoopEngine() {
     return {
         setListenerPose: () => undefined,
+        setVoiceLimit: () => undefined,
         playOneShot: () => undefined,
         playLoop: () => null,
         playMusic: () => undefined,
@@ -42,25 +46,38 @@ function setPannerPosition(panner, position) {
 }
 function createPanner(context, spatial, position) {
     const panner = context.createPanner();
-    panner.panningModel = spatial.panning === "hrtf" ? "HRTF" : "equalpower";
-    panner.distanceModel = "inverse";
-    if (spatial.refDistance !== undefined)
-        panner.refDistance = spatial.refDistance;
-    if (spatial.maxDistance !== undefined)
-        panner.maxDistance = spatial.maxDistance;
-    if (spatial.rolloff !== undefined)
-        panner.rolloffFactor = spatial.rolloff;
-    if (spatial.coneInner !== undefined)
-        panner.coneInnerAngle = spatial.coneInner;
-    if (spatial.coneOuter !== undefined)
-        panner.coneOuterAngle = spatial.coneOuter;
-    if (spatial.coneOuterGain !== undefined)
-        panner.coneOuterGain = spatial.coneOuterGain;
-    setPannerPosition(panner, position);
+    try {
+        panner.panningModel = spatial.panning === "hrtf" ? "HRTF" : "equalpower";
+        panner.distanceModel = "inverse";
+        if (spatial.refDistance !== undefined)
+            panner.refDistance = spatial.refDistance;
+        if (spatial.maxDistance !== undefined)
+            panner.maxDistance = spatial.maxDistance;
+        if (spatial.rolloff !== undefined)
+            panner.rolloffFactor = spatial.rolloff;
+        if (spatial.coneInner !== undefined)
+            panner.coneInnerAngle = spatial.coneInner;
+        if (spatial.coneOuter !== undefined)
+            panner.coneOuterAngle = spatial.coneOuter;
+        if (spatial.coneOuterGain !== undefined)
+            panner.coneOuterGain = spatial.coneOuterGain;
+        setPannerPosition(panner, position);
+    }
+    catch (error) {
+        panner.disconnect();
+        throw error;
+    }
     return panner;
 }
+/**
+ * Game-owned sound catalog playback with bounded SFX reservations, spatial panning, and shared buses.
+ * @capability bounded-spatial-audio play positional or flat cues with listener orientation, voice budgets, and per-source cleanup
+ */
 export function createAudioEngine(config = {}) {
     const sounds = config.sounds ?? {};
+    const allocator = config.voiceAllocator ?? createVoiceAllocator({ maxTotal: config.maxVoices, overflow: config.voiceOverflow });
+    let disposed = false;
+    const activeVoices = new Map();
     const busDefs = config.buses ?? {};
     const AudioContextCtor = resolveAudioContextCtor();
     if (AudioContextCtor === undefined)
@@ -80,9 +97,15 @@ export function createAudioEngine(config = {}) {
         let node = busGains.get(busId);
         if (node === undefined) {
             node = context.createGain();
-            node.gain.value = busDefs[busId]?.gain ?? 1;
-            node.connect(masterGain);
-            busGains.set(busId, node);
+            try {
+                node.gain.value = busDefs[busId]?.gain ?? 1;
+                node.connect(masterGain);
+                busGains.set(busId, node);
+            }
+            catch (error) {
+                node.disconnect();
+                throw error;
+            }
         }
         return node;
     }
@@ -140,36 +163,69 @@ export function createAudioEngine(config = {}) {
         return pending;
     }
     let listenerPosition = { x: 0, y: 0, z: 0 };
+    let listenerVelocity = { x: 0, y: 0, z: 0 };
+    const nyquist = context.sampleRate / 2;
     const activeSpatialUpdaters = new Set();
-    const activeLoops = new Set();
-    const NOOP_HANDLE = {
-        setPosition: () => undefined,
-        setRate: () => undefined,
-        setGain: () => undefined,
-        stop: () => undefined,
-    };
     function playInternal(soundId, position, loop) {
+        if (disposed)
+            return null;
         const sound = sounds[soundId];
-        if (sound === undefined)
+        if (sound === undefined || (sound.synth === undefined && sound.url === undefined))
             return null;
-        const bus = busGainNode(sound.bus);
-        const currentPosition = position ?? listenerPosition;
-        // A one-shot synth cue realises its decaying voices live and is fire-and-forget.
+        const allocation = allocator.request(soundId, sound.priority, sound.maxVoices);
+        if (!allocation.ok)
+            return null;
+        for (const id of allocation.stolen)
+            activeVoices.get(id)?.();
+        const voiceId = allocation.voiceId;
+        let bus;
+        try {
+            bus = busGainNode(sound.bus);
+        }
+        catch {
+            allocator.release(voiceId);
+            return null;
+        }
+        const currentPosition = { ...(position ?? listenerPosition) };
         if (sound.synth !== undefined && !loop) {
-            const cueGain = context.createGain();
-            cueGain.gain.value = sound.spatial === undefined
-                ? resolveEmitterGain(distance3(currentPosition, listenerPosition), sound, 1)
-                : sound.gain ?? 1;
-            if (sound.spatial !== undefined) {
-                const panner = createPanner(context, sound.spatial, currentPosition);
-                cueGain.connect(panner);
-                panner.connect(bus);
+            let cueGain = null;
+            let panner = null;
+            let playback = null;
+            let stopped = false;
+            function updateGain() {
+                if (cueGain === null)
+                    return;
+                cueGain.gain.value = panner === null
+                    ? resolveEmitterGain(distance3(currentPosition, listenerPosition), sound, 1)
+                    : sound.gain ?? 1;
             }
-            else {
-                cueGain.connect(bus);
+            function stop() {
+                if (stopped)
+                    return;
+                stopped = true;
+                activeVoices.delete(voiceId);
+                activeSpatialUpdaters.delete(updateGain);
+                allocator.release(voiceId);
+                playback?.stop();
+                cueGain?.disconnect();
+                panner?.disconnect();
             }
-            realizeSynthPatch(context, cueGain, sharedNoiseBuffer(), sound.synth);
-            return NOOP_HANDLE;
+            activeVoices.set(voiceId, stop);
+            try {
+                cueGain = context.createGain();
+                const spatial = sound.positional === false ? undefined : sound.spatial;
+                panner = spatial === undefined ? null : createPanner(context, spatial, currentPosition);
+                updateGain();
+                cueGain.connect(panner ?? bus);
+                panner?.connect(bus);
+                playback = realizeSynthPatch(context, cueGain, sharedNoiseBuffer(), sound.synth);
+                activeSpatialUpdaters.add(updateGain);
+                playback.onEnded(stop);
+            }
+            catch {
+                stop();
+            }
+            return null;
         }
         // Everything else resolves to one AudioBuffer we loop/play: sample URL, or a synth patch rendered once.
         let bufferPromise;
@@ -179,79 +235,142 @@ export function createAudioEngine(config = {}) {
             bufferPromise = loadBuffer(sound.url);
         else
             return null;
-        return playBufferSource(sound, bus, bufferPromise, currentPosition, loop);
+        return playBufferSource(sound, bus, bufferPromise, currentPosition, loop, voiceId);
     }
-    function playBufferSource(sound, bus, bufferPromise, initialPosition, loop) {
+    function playBufferSource(sound, bus, bufferPromise, initialPosition, loop, voiceId) {
         const disposer = createDisposer();
-        let currentPosition = initialPosition;
+        let currentPosition = { ...initialPosition };
+        let stopped = false;
+        const spatial = sound.positional === false ? undefined : sound.spatial;
         // Live control state, applied on source creation so updates that race the async buffer load stick.
         let currentRate = 1;
         let currentUserGain = 1;
+        let currentLowpass = MAX_LOOP_CUTOFF;
+        let currentHighpass = MIN_LOOP_CUTOFF;
+        let currentVelocity = { x: 0, y: 0, z: 0 };
+        const dopplerFactor = loop ? sound.doppler ?? 0 : 0;
         let sourceNode = null;
+        let lowpassNode = null;
+        let highpassNode = null;
         let userGainNode = null;
         let falloffGain = null;
         let pannerNode = null;
+        function effectiveRate() {
+            if (dopplerFactor === 0)
+                return currentRate;
+            const shift = dopplerRate([listenerPosition.x, listenerPosition.y, listenerPosition.z], [listenerVelocity.x, listenerVelocity.y, listenerVelocity.z], [currentPosition.x, currentPosition.y, currentPosition.z], [currentVelocity.x, currentVelocity.y, currentVelocity.z], { factor: dopplerFactor });
+            return clampLoopRate(currentRate * shift);
+        }
+        function applyRate() {
+            if (sourceNode !== null)
+                sourceNode.playbackRate.setTargetAtTime(effectiveRate(), context.currentTime, LOOP_PARAM_SMOOTH_TC);
+        }
         function updateFalloff() {
-            if (falloffGain !== null && sound.spatial === undefined) {
+            if (falloffGain !== null && spatial === undefined) {
                 falloffGain.gain.value = resolveEmitterGain(distance3(currentPosition, listenerPosition), sound, 1);
             }
             if (pannerNode !== null)
                 setPannerPosition(pannerNode, currentPosition);
+            if (dopplerFactor !== 0)
+                applyRate();
         }
+        disposer.onDispose(() => {
+            if (sourceNode !== null)
+                sourceNode.onended = null;
+            try {
+                sourceNode?.stop();
+            }
+            catch {
+            }
+            sourceNode?.disconnect();
+            lowpassNode?.disconnect();
+            highpassNode?.disconnect();
+            userGainNode?.disconnect();
+            falloffGain?.disconnect();
+            pannerNode?.disconnect();
+            sourceNode = null;
+            lowpassNode = null;
+            highpassNode = null;
+            userGainNode = null;
+            falloffGain = null;
+            pannerNode = null;
+        });
         void bufferPromise.then((buffer) => {
-            if (buffer === null)
+            if (stopped || disposed)
+                return;
+            if (buffer === null) {
+                handle.stop();
                 return;
+            }
             const src = context.createBufferSource();
+            sourceNode = src;
             src.buffer = buffer;
             src.loop = loop || (sound.loop ?? false);
-            src.playbackRate.value = currentRate;
-            // source → per-loop user gain (setGain) → distance falloff → bus
+            src.playbackRate.value = effectiveRate();
+            // Spatial panners own distance attenuation; the scalar stage keeps only authored gain.
             const uGain = context.createGain();
+            userGainNode = uGain;
             uGain.gain.value = currentUserGain;
             const fGain = context.createGain();
+            falloffGain = fGain;
             fGain.gain.value = resolveEmitterGain(distance3(currentPosition, listenerPosition), sound, 1);
-            src.connect(uGain);
+            if (loop) {
+                const lp = context.createBiquadFilter();
+                lowpassNode = lp;
+                lp.type = "lowpass";
+                lp.frequency.value = clampLoopCutoff(currentLowpass, MAX_LOOP_CUTOFF, nyquist);
+                const hp = context.createBiquadFilter();
+                highpassNode = hp;
+                hp.type = "highpass";
+                hp.frequency.value = clampLoopCutoff(currentHighpass, MIN_LOOP_CUTOFF, nyquist);
+                src.connect(lp);
+                lp.connect(hp);
+                hp.connect(uGain);
+            }
+            else {
+                src.connect(uGain);
+            }
             uGain.connect(fGain);
-            if (sound.spatial !== undefined) {
-                const panner = createPanner(context, sound.spatial, currentPosition);
-                fGain.gain.value = 1;
+            if (spatial !== undefined) {
+                const panner = createPanner(context, spatial, currentPosition);
+                pannerNode = panner;
+                fGain.gain.value = sound.gain ?? 1;
                 fGain.connect(panner);
                 panner.connect(bus);
-                pannerNode = panner;
             }
             else {
                 fGain.connect(bus);
             }
+            src.onended = () => handle.stop();
             src.start();
-            sourceNode = src;
-            userGainNode = uGain;
-            falloffGain = fGain;
-            disposer.onDispose(() => {
-                try {
-                    src.stop();
-                }
-                catch {
-                }
-                src.disconnect();
-                uGain.disconnect();
-                fGain.disconnect();
-                pannerNode?.disconnect();
-                sourceNode = null;
-                userGainNode = null;
-                falloffGain = null;
-            });
-        });
-        if (loop)
-            activeSpatialUpdaters.add(updateFalloff);
+        }).catch(() => handle.stop());
+        activeSpatialUpdaters.add(updateFalloff);
         const handle = {
+            isPlaying: () => !stopped,
             setPosition(next) {
-                currentPosition = next;
+                if (stopped)
+                    return;
+                currentPosition = { ...next };
                 updateFalloff();
             },
             setRate(rate) {
                 currentRate = clampLoopRate(rate);
-                if (sourceNode !== null)
-                    sourceNode.playbackRate.setTargetAtTime(currentRate, context.currentTime, LOOP_PARAM_SMOOTH_TC);
+                applyRate();
+            },
+            setLowpass(hz) {
+                currentLowpass = clampLoopCutoff(hz, MAX_LOOP_CUTOFF, nyquist);
+                if (lowpassNode !== null)
+                    lowpassNode.frequency.setTargetAtTime(currentLowpass, context.currentTime, LOOP_PARAM_SMOOTH_TC);
+            },
+            setHighpass(hz) {
+                currentHighpass = clampLoopCutoff(hz, MIN_LOOP_CUTOFF, nyquist);
+                if (highpassNode !== null)
+                    highpassNode.frequency.setTargetAtTime(currentHighpass, context.currentTime, LOOP_PARAM_SMOOTH_TC);
+            },
+            setVelocity(velocity) {
+                currentVelocity = { ...velocity };
+                if (dopplerFactor !== 0)
+                    applyRate();
             },
             setGain(gain) {
                 currentUserGain = clampLoopGain(gain);
@@ -259,19 +378,31 @@ export function createAudioEngine(config = {}) {
                     userGainNode.gain.setTargetAtTime(currentUserGain, context.currentTime, LOOP_PARAM_SMOOTH_TC);
             },
             stop() {
+                if (stopped)
+                    return;
+                stopped = true;
                 activeSpatialUpdaters.delete(updateFalloff);
-                activeLoops.delete(handle);
+                activeVoices.delete(voiceId);
+                allocator.release(voiceId);
                 disposer.dispose();
             },
         };
-        if (loop)
-            activeLoops.add(handle);
+        activeVoices.set(voiceId, () => handle.stop());
         return handle;
     }
     return {
+        setVoiceLimit(maxTotal, overflow) {
+            if (disposed)
+                return;
+            for (const id of allocator.retune({ maxTotal, overflow }))
+                activeVoices.get(id)?.();
+        },
         setListenerPose(position) {
+            if (disposed)
+                return;
             const pose = "position" in position ? position : { position, forward: { x: 0, y: 0, z: -1 }, up: { x: 0, y: 1, z: 0 } };
-            listenerPosition = pose.position;
+            listenerPosition = { ...pose.position };
+            listenerVelocity = "velocity" in pose && pose.velocity !== undefined ? { ...pose.velocity } : ZERO_VELOCITY;
             const listener = context.listener;
             setAudioParam(listener.positionX, pose.position.x);
             setAudioParam(listener.positionY, pose.position.y);
@@ -286,6 +417,8 @@ export function createAudioEngine(config = {}) {
                 updateGain();
         },
         playOneShot(soundId, position) {
+            if (disposed)
+                return;
             void context.resume().catch(() => undefined);
             playInternal(soundId, position, false);
         },
@@ -293,23 +426,38 @@ export function createAudioEngine(config = {}) {
             return playInternal(soundId, position, true);
         },
         playMusic(themeId, options) {
+            if (disposed)
+                return;
             void context.resume().catch(() => undefined);
             musicDirector()?.crossfadeTo(themeId, options);
         },
         setBusGain(busId, gain) {
+            if (disposed)
+                return;
             busGainNode(busId).gain.value = gain;
         },
         setMasterGain(gain) {
+            if (disposed)
+                return;
             masterGain.gain.value = gain;
         },
         resume() {
+            if (disposed)
+                return;
             void context.resume().catch(() => undefined);
         },
         dispose() {
-            for (const handle of [...activeLoops])
-                handle.stop();
+            if (disposed)
+                return;
+            disposed = true;
+            for (const stop of [...activeVoices.values()])
+                stop();
             activeSpatialUpdaters.clear();
             director?.dispose();
+            for (const node of busGains.values())
+                node.disconnect();
+            busGains.clear();
+            masterGain.disconnect();
             void context.close().catch(() => undefined);
         },
     };

package/dist/audio/audioWire.d.ts

@@ -17,6 +17,9 @@ type AudioLoopSetPayload = {
     rate?: number;
     gain?: number;
     at?: readonly [number, number, number];
+    velocity?: readonly [number, number, number];
+    lowpass?: number;
+    highpass?: number;
 };
 type AudioLoopStopPayload = {
     id: string;

package/dist/audio/audioWire.js

@@ -19,8 +19,8 @@ export function attachAudioEventWire(events, audioEngine) {
     const offLoopStart = events.on("audio.loopStart", ({ id, sound, at }) => {
         const existing = loops.get(id);
         if (existing !== undefined) {
-            // Same sound: idempotent — keep the running source so a per-tick re-issue never clicks.
-            if (existing.sound === sound)
+            // Keep active/pending loops; a stolen voice can retry on the next explicit start.
+            if (existing.sound === sound && existing.handle.isPlaying?.() !== false)
                 return;
             existing.handle.stop();
             loops.delete(id);
@@ -29,7 +29,7 @@ export function attachAudioEventWire(events, audioEngine) {
         if (handle !== null)
             loops.set(id, { sound, handle });
     });
-    const offLoopSet = events.on("audio.loopSet", ({ id, rate, gain, at }) => {
+    const offLoopSet = events.on("audio.loopSet", ({ id, rate, gain, at, velocity, lowpass, highpass }) => {
         const entry = loops.get(id);
         // Unknown id: a live update may race a stop — silently drop it.
         if (entry === undefined)
@@ -40,6 +40,12 @@ export function attachAudioEventWire(events, audioEngine) {
             entry.handle.setGain(gain);
         if (at !== undefined)
             entry.handle.setPosition({ x: at[0], y: at[1], z: at[2] });
+        if (velocity !== undefined)
+            entry.handle.setVelocity({ x: velocity[0], y: velocity[1], z: velocity[2] });
+        if (lowpass !== undefined)
+            entry.handle.setLowpass(lowpass);
+        if (highpass !== undefined)
+            entry.handle.setHighpass(highpass);
     });
     const offLoopStop = events.on("audio.loopStop", ({ id }) => {
         const entry = loops.get(id);

package/dist/audio/loopParams.d.ts

@@ -18,3 +18,42 @@ export declare function clampLoopRate(rate: number): number;
  * @internal — the audio engine applies this; game code sets gain through `ctx.game.audio.setLoop`.
  */
 export declare function clampLoopGain(gain: number): number;
+/** Lowest live filter cutoff, Hz. */
+export declare const MIN_LOOP_CUTOFF = 10;
+/** Highest live filter cutoff, Hz; the engine also caps it at the context's Nyquist frequency. */
+export declare const MAX_LOOP_CUTOFF = 22050;
+/**
+ * Clamp a loop filter cutoff into `MIN_LOOP_CUTOFF`–`min(MAX_LOOP_CUTOFF, nyquist)` Hz. Non-finite input
+ * falls back to `fallback` (the open, transparent end of that filter).
+ * @internal — the audio engine applies this; game code sets cutoffs through `ctx.game.audio.setLoop`.
+ */
+export declare function clampLoopCutoff(hz: number, fallback: number, nyquist?: number): number;
+/** Smoothed listener velocity estimate from per-frame camera positions. @internal */
+export interface ListenerVelocityTrack {
+    last: {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+    velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/** @internal */
+export declare function createListenerVelocityTrack(): ListenerVelocityTrack;
+/**
+ * Advance the listener velocity estimate by one frame: the position delta over `dt`, eased with a
+ * ~50 ms time constant so frame-time jitter does not warble doppler. A cut resets it to zero.
+ * @internal
+ */
+export declare function stepListenerVelocity(track: ListenerVelocityTrack, position: {
+    x: number;
+    y: number;
+    z: number;
+}, dt: number): {
+    x: number;
+    y: number;
+    z: number;
+};

package/dist/audio/loopParams.js

@@ -26,3 +26,46 @@ export function clampLoopGain(gain) {
         return 0;
     return Math.min(1, Math.max(0, gain));
 }
+/** Lowest live filter cutoff, Hz. */
+export const MIN_LOOP_CUTOFF = 10;
+/** Highest live filter cutoff, Hz; the engine also caps it at the context's Nyquist frequency. */
+export const MAX_LOOP_CUTOFF = 22050;
+/**
+ * Clamp a loop filter cutoff into `MIN_LOOP_CUTOFF`–`min(MAX_LOOP_CUTOFF, nyquist)` Hz. Non-finite input
+ * falls back to `fallback` (the open, transparent end of that filter).
+ * @internal — the audio engine applies this; game code sets cutoffs through `ctx.game.audio.setLoop`.
+ */
+export function clampLoopCutoff(hz, fallback, nyquist = MAX_LOOP_CUTOFF) {
+    const max = Math.min(MAX_LOOP_CUTOFF, nyquist);
+    if (!Number.isFinite(hz))
+        return Math.min(max, Math.max(MIN_LOOP_CUTOFF, fallback));
+    return Math.min(max, Math.max(MIN_LOOP_CUTOFF, hz));
+}
+/** @internal */
+export function createListenerVelocityTrack() {
+    return { last: null, velocity: { x: 0, y: 0, z: 0 } };
+}
+/** Camera jumps faster than this (world units/s) are cuts or teleports, not motion, and reset the estimate. */
+const MAX_LISTENER_SPEED = 400;
+/**
+ * Advance the listener velocity estimate by one frame: the position delta over `dt`, eased with a
+ * ~50 ms time constant so frame-time jitter does not warble doppler. A cut resets it to zero.
+ * @internal
+ */
+export function stepListenerVelocity(track, position, dt) {
+    const last = track.last;
+    track.last = { x: position.x, y: position.y, z: position.z };
+    if (last === null || !(dt > 0))
+        return track.velocity;
+    const vx = (position.x - last.x) / dt;
+    const vy = (position.y - last.y) / dt;
+    const vz = (position.z - last.z) / dt;
+    if (Math.hypot(vx, vy, vz) > MAX_LISTENER_SPEED) {
+        track.velocity = { x: 0, y: 0, z: 0 };
+        return track.velocity;
+    }
+    const blend = 1 - Math.exp(-dt / 0.05);
+    const v = track.velocity;
+    track.velocity = { x: v.x + (vx - v.x) * blend, y: v.y + (vy - v.y) * blend, z: v.z + (vz - v.z) * blend };
+    return track.velocity;
+}

package/dist/audio/synthEngine.d.ts

@@ -1,9 +1,15 @@
 import type { SynthPatch } from "@jgengine/core/audio/synth";
 /** Build the shared 1-second mono white-noise buffer every noise voice samples from. */
 export declare function createNoiseBuffer(ctx: BaseAudioContext): AudioBuffer;
+/** Scheduled procedural sources; stopping releases their source/filter/envelope graph. */
+export interface SynthPlayback {
+    stop(): void;
+    /** Called once after every source ends; late subscribers are notified immediately. */
+    onEnded(callback: () => void): void;
+}
 /**
  * Realise a procedural cue on Web Audio: every voice is scheduled at
  * `ctx.currentTime + delay` into `out`, summed into one one-shot. `noiseBuf` is
  * the shared buffer from {@link createNoiseBuffer}.
  */
-export declare function realizeSynthPatch(ctx: BaseAudioContext, out: AudioNode, noiseBuf: AudioBuffer, patch: SynthPatch): void;
+export declare function realizeSynthPatch(ctx: BaseAudioContext, out: AudioNode, noiseBuf: AudioBuffer, patch: SynthPatch): SynthPlayback;