@drincs/pixi-vn 1.7.2 → 1.8.0

package/dist/sound.d.ts

@@ -1,32 +1,95 @@
-import { IMediaInstance as IMediaInstance$1, PlayOptions, Options, SoundLibrary, Sound, filters as filters$1 } from '@pixi/sound';
+import { Player, PlayerOptions, ToneAudioNode, Param, ReverbOptions, FeedbackDelayOptions, FreeverbOptions, DelayOptions, PingPongDelayOptions, GateOptions, AutoFilterOptions, BiquadFilterOptions, OnePoleFilterOptions, FeedbackCombFilterOptions, FilterOptions, ChorusOptions, PhaserOptions, TremoloOptions, VibratoOptions, CompressorOptions, MidSideCompressorOptions, MultibandCompressorOptions, LimiterOptions, GreaterThanOptions, GreaterThanZeroOptions, DistortionOptions, BitCrusherOptions, Panner3DOptions, AutoPannerOptions, StereoWidenerOptions, ToneAudioBuffer } from 'tone';
+import { C as CachedMap } from './CachedMap-DZLvJAnA.js';
+import 'lru-cache';
 
-type IMediaInstance = Omit<IMediaInstance$1, "on" | "destroy" | "init" | "off" | "once" | "toString">;
+interface MediaInterface extends Pick<Player, "blockTime" | "disposed" | "loaded" | "loop" | "loopEnd" | "loopStart" | "mute" | "now" | "playbackRate" | "reverse" | "restart" | "start" | "stop" | "chain" | "disconnect" | "volume" | "state"> {
+    /**
+     * Whether the sound is currently paused.
+     */
+    paused: boolean;
+    /**
+     * @deprecated Use {@link mute} instead.
+     */
+    muted: boolean;
+    /**
+     * @deprecated Use {@link playbackRate} instead.
+     */
+    speed: number;
+}
+interface MediaMemory extends Partial<Omit<PlayerOptions, "url" | "volume">> {
+    /**
+     * The volume of this sound in the linear range [0, 1], where 0 is silence
+     * and 1 is full volume. Stored and restored in linear form; converted
+     * to/from Tone.js decibels internally.
+     */
+    volume?: number;
+    elapsed: number | undefined;
+    paused: boolean;
+    delay?: number;
+}
 
-interface SoundOptions extends Omit<Options, "complete" | "loaded" | "sprites" | "source"> {
+interface SoundOptions extends Pick<Partial<PlayerOptions>, "loop" | "autostart" | "fadeIn" | "fadeOut" | "mute" | "loopEnd" | "loopStart" | "reverse" | "playbackRate"> {
+    /**
+     * The volume of this sound in the linear range [0, 1], where 0 is silence
+     * and 1 is full volume.  This is converted to decibels internally before
+     * being passed to the Tone.js Player.
+     */
+    volume?: number;
+    /**
+     * A collection of audio filters/effects to apply to this sound.
+     *
+     * Install "tone" for the full list of available filters.
+     *
+     * @example
+     * ```ts
+     * import * as Tone from "tone";
+     *
+     * const filters = [new Tone.FeedbackDelay("8n", 0.5)];
+     * ```
+     */
+    filters?: ToneAudioNode[];
+    /**
+     * @deprecated Use {@link playbackRate} instead.
+     */
+    speed?: number;
+    /**
+     * @deprecated Use {@link mute} instead.
+     */
+    muted?: boolean;
 }
-interface SoundPlayOptions extends Omit<PlayOptions, "complete" | "loaded"> {
+interface SoundPlayOptions extends SoundOptions {
     /**
-     * The delay in seconds before playback becomes audible or resumes. If specified, the sound will be started immediately but delayed (for example, via pause/unpause) so that it is effectively heard only after the delay. If not specified, the sound will play without any additional delay.
+     * The delay in seconds before playback starts. If specified, playback is
+     * scheduled to begin after the delay has elapsed rather than starting
+     * immediately in a paused state.
      */
     delay?: number;
     /**
-     * Whether the sound is paused. If specified, the sound will be paused or unpaused according to the value. If not specified, the sound will play without being paused or unpaused.
+     * The offset in seconds from the start of the sound at which to begin playback.
      */
-    paused?: boolean;
+    elapsed?: number;
 }
 interface SoundPlayOptionsWithChannel extends SoundPlayOptions {
     /**
-     * The alias of the audio channel to play the sound on. If the channel does not exist, it will be created.
-     * If not specified, the sound will be played on the default channel (see `SoundManagerInterface.defaultChannelAlias`).
+     * The alias of the audio channel to play the sound on. If the channel does
+     * not exist it will be created automatically.
+     * Defaults to `SoundManagerInterface.defaultChannelAlias` ("general").
      */
     channel?: string;
 }
-interface ChannelOptions extends Pick<SoundPlayOptions, "filters" | "muted" | "volume" | "paused"> {
+interface ChannelOptions extends Pick<SoundPlayOptions, "filters" | "muted" | "volume"> {
     /**
      * Whether this channel is a background channel.
-     * Background channels are special channels. Unlike normal channels, media connected to a background channel does not stop when a scene changes, but continues to play in the background.
+     * Background channels are special: media playing on them is not stopped
+     * when a scene changes, but continues in the background.
      */
     background?: boolean;
+    /**
+     * The stereo pan position for this channel in the range [-1, 1].
+     * -1 is full left, 0 is centre, 1 is full right.
+     * Defaults to 0.
+     */
+    pan?: number;
 }
 
 interface AudioChannelInterface {
@@ -42,7 +105,7 @@ interface AudioChannelInterface {
      *        this cannot be reused after it is done playing. Returns a Promise if the sound
      *        has not yet loaded.
      */
-    play(alias: string, options?: SoundPlayOptions): Promise<IMediaInstance>;
+    play(alias: string, options?: SoundPlayOptions): Promise<MediaInterface>;
     /**
      * Plays a sound.
      * @param mediaAlias The media alias reference.
@@ -52,22 +115,12 @@ interface AudioChannelInterface {
      *        this cannot be reused after it is done playing. Returns a Promise if the sound
      *        has not yet loaded.
      */
-    play(mediaAlias: string, soundAlias: string, options?: SoundPlayOptions): Promise<IMediaInstance>;
-    /**
-     * Plays a non-persistent sound on this channel.
-     * The returned media is not tracked by the sound manager and is therefore excluded from save/export state.
-     * @param soundAlias The sound (asset) alias reference.
-     * @param options The options.
-     * @return The sound instance.
-     */
-    playTransient(soundAlias: string, options?: SoundPlayOptions): Promise<IMediaInstance>;
+    play(mediaAlias: string, soundAlias: string, options?: SoundPlayOptions): Promise<MediaInterface>;
     /**
-     * Stops all media instances that were started with {@link playTransient} on this channel.
-     * Instances that have already ended are automatically removed, so this only affects
-     * those that are still playing or paused.
-     * @return Instance for chaining.
+     * The stereo pan position for this channel in the range [-1, 1].
+     * -1 is full left, 0 is centre, 1 is full right.
      */
-    stopTransientAll(): this;
+    pan: number;
     /**
      * The volume of the audio channel, between 0 and 1. This is multiplied with the volume of each sound played through this channel.
      */
@@ -79,7 +132,7 @@ interface AudioChannelInterface {
     /**
      * The MediaInstances currently playing through this channel. This is read-only and cannot be modified directly. Use the play method to add new MediaInstances to this channel.
      */
-    readonly mediaInstances: IMediaInstance[];
+    readonly mediaInstances: MediaInterface[];
     /**
      * Whether this channel is a background channel.
      * Background channels are special channels. Unlike normal channels, media connected to a background channel does not stop when a scene changes, but continues to play in the background.
@@ -95,17 +148,6 @@ interface AudioChannelInterface {
      * @return Instance for chaining.
      */
     pauseAll(): this;
-    /**
-     * Temporarily pauses this channel without mutating each media instance's persisted paused option.
-     * Useful for overlays (for example settings/pause menus) where pause state must not be saved.
-     * @return Instance for chaining.
-     */
-    pauseUnsavedAll(): this;
-    /**
-     * Restores this channel after `pauseUnsavedAll()`, reapplying each media instance's persisted paused option.
-     * @return Instance for chaining.
-     */
-    resumeUnsavedAll(): this;
     /**
      * Resumes any sounds.
      * @return Instance for chaining.
@@ -116,45 +158,128 @@ interface AudioChannelInterface {
      * @return `true` if all sounds are muted.
      */
     toggleMuteAll(): boolean;
+    /**
+     * Useful for inserting channel-wide audio effects such as reverb, delay or EQ.
+     *
+     * Install "tone" to use this method.
+     *
+     * @param nodes One or more Tone.js {@link ToneAudioNode} instances to chain in series.
+     * @return Instance for chaining.
+     *
+     * @example
+     * ```ts
+     * import * as Tone from "tone";
+     *
+     * const channel = sound.findChannel("music");
+     *
+     * // Create a reverb effect and wait for its impulse response to be ready.
+     * const reverb = new Tone.Reverb({ decay: 2.5 });
+     *
+     * // Route the channel through the reverb to the master output.
+     * channel.chain(reverb);
+     * ```
+     */
+    chain(...nodes: ToneAudioNode[]): this;
+    /**
+     * **Advanced** — the raw `Tone.Param<"decibels">` for this channel's volume.
+     *
+     * Unlike the {@link volume} property (which uses a linear 0–1 scale), this
+     * Param works directly in **decibels** and exposes all Tone.js automation
+     * methods such as `rampTo`, `linearRampTo`, and `exponentialRampTo`.
+     *
+     * Use this when you need to smoothly automate volume over time instead of
+     * setting it instantly.
+     *
+     * @example
+     * ```ts
+     * const channel = sound.findChannel("music");
+     *
+     * // Fade the volume from its current level to -12 dB over 3 seconds.
+     * channel.volumeParam.rampTo(-12, 3);
+     *
+     * // Fade to silence over 2 seconds.
+     * channel.volumeParam.rampTo(-Infinity, 2);
+     * ```
+     */
+    readonly volumeParam: Param<"decibels">;
+    /**
+     * **Advanced** — the raw `Tone.Param<"audioRange">` for this channel's
+     * stereo pan position.
+     *
+     * Unlike the {@link pan} property (which sets the value instantly), this
+     * Param exposes all Tone.js automation methods such as `rampTo`,
+     * `linearRampTo`, and `exponentialRampTo`.
+     *
+     * Use this when you need to smoothly automate panning over time instead of
+     * setting it instantly.  Values range from -1 (full left) to 1 (full right).
+     *
+     * @example
+     * ```ts
+     * const channel = sound.findChannel("music");
+     *
+     * // Gradually pan to the left over 3 seconds.
+     * channel.panParam.rampTo(-1, 3);
+     *
+     * // Return to centre over 2 seconds.
+     * channel.panParam.rampTo(0, 2);
+     * ```
+     */
+    readonly panParam: Param<"audioRange">;
 }
 
-type DistortionFilter = {
-    type: "DistortionFilter";
-    amount?: number;
-};
-type EqualizerFilter = {
-    type: "EqualizerFilter";
-    f32?: number;
-    f64?: number;
-    f125?: number;
-    f250?: number;
-    f500?: number;
-    f1k?: number;
-    f2k?: number;
-    f4k?: number;
-    f8k?: number;
-    f16k?: number;
-};
-type MonoFilter = {
-    type: "MonoFilter";
-};
-type ReverbFilter = {
-    type: "ReverbFilter";
-    seconds?: number;
-    decay?: number;
-    reverse?: boolean;
-};
-type StereoFilter = {
-    type: "StereoFilter";
-    pan?: number;
-};
-type StreamFilter = {
-    type: "StreamFilter";
-};
-type TelephoneFilter = {
-    type: "TelephoneFilter";
-};
-type SoundFilterMemory = DistortionFilter | EqualizerFilter | MonoFilter | ReverbFilter | StereoFilter | StreamFilter | TelephoneFilter;
+type SoundFilterMemory = ({
+    filterType: "ReverbFilter";
+} & Omit<Partial<ReverbOptions>, "context">) | ({
+    filterType: "FeedbackDelayFilter";
+} & Omit<Partial<FeedbackDelayOptions>, "context">) | ({
+    filterType: "FreeverbFilter";
+} & Omit<Partial<FreeverbOptions>, "context">) | ({
+    filterType: "DelayFilter";
+} & Omit<Partial<DelayOptions>, "context">) | ({
+    filterType: "PingPongDelayFilter";
+} & Omit<Partial<PingPongDelayOptions>, "context">) | ({
+    filterType: "GateFilter";
+} & Omit<Partial<GateOptions>, "context">) | ({
+    filterType: "AutoFilterFilter";
+} & Omit<Partial<AutoFilterOptions>, "context">) | ({
+    filterType: "BiquadFilterFilter";
+} & Omit<Partial<BiquadFilterOptions>, "context">) | ({
+    filterType: "OnePoleFilterFilter";
+} & Omit<Partial<OnePoleFilterOptions>, "context" | "frequency">) | ({
+    filterType: "FeedbackCombFilterFilter";
+} & Omit<Partial<FeedbackCombFilterOptions>, "context">) | ({
+    filterType: "CustomFilter";
+} & Omit<Partial<FilterOptions>, "context">) | ({
+    filterType: "ChorusFilter";
+} & Omit<Partial<ChorusOptions>, "context">) | ({
+    filterType: "PhaserFilter";
+} & Omit<Partial<PhaserOptions>, "context">) | ({
+    filterType: "TremoloFilter";
+} & Omit<Partial<TremoloOptions>, "context">) | ({
+    filterType: "VibratoFilter";
+} & Omit<Partial<VibratoOptions>, "context">) | ({
+    filterType: "CompressorFilter";
+} & Omit<Partial<CompressorOptions>, "context">) | ({
+    filterType: "MidSideCompressorFilter";
+} & Omit<Partial<MidSideCompressorOptions>, "context">) | ({
+    filterType: "MultibandCompressorFilter";
+} & Omit<Partial<MultibandCompressorOptions>, "context">) | ({
+    filterType: "LimiterFilter";
+} & Omit<Partial<LimiterOptions>, "context">) | ({
+    filterType: "GreaterThanFilter";
+} & Omit<Partial<GreaterThanOptions>, "context">) | ({
+    filterType: "GreaterThanZeroFilter";
+} & Omit<Partial<GreaterThanZeroOptions>, "context">) | ({
+    filterType: "DistortionFilter";
+} & Omit<Partial<DistortionOptions>, "context">) | ({
+    filterType: "BitCrusherFilter";
+} & Omit<Partial<BitCrusherOptions>, "context">) | ({
+    filterType: "Panner3DFilter";
+} & Omit<Partial<Panner3DOptions>, "context">) | ({
+    filterType: "AutoPannerFilter";
+} & Omit<Partial<AutoPannerOptions>, "context">) | ({
+    filterType: "StereoWidenerFilter";
+} & Omit<Partial<StereoWidenerOptions>, "context">);
 
 interface ExportedSound {
     options: SoundOptions;
@@ -172,7 +297,6 @@ interface ExportedSoundPlay extends SoundPlay {
  * Interface exported sounds
  */
 interface SoundGameState {
-    filters?: SoundFilterMemory[];
     /**
      * @deprecated
      */
@@ -184,8 +308,9 @@ interface SoundGameState {
             channelAlias: string;
             soundAlias: string;
             stepCounter: number;
-            options: Omit<SoundPlayOptions, "filters"> & {
+            options: MediaMemory & {
                 filters?: SoundFilterMemory[];
+                delay?: number;
             };
             /**
              * @deprecated Use options.paused instead.
@@ -195,157 +320,177 @@ interface SoundGameState {
     };
 }
 
-interface SoundManagerInterface extends Omit<SoundLibrary, "init" | "close" | "add" | "play" | "volume" | "speed" | "remove" | "exists" | "find" | "stop" | "pause" | "resume" | "pauseAll" | "resumeAll" | "muteAll" | "unmuteAll" | "stopAll" | "removeAll" | "togglePauseAll"> {
+interface SoundManagerInterface {
+    /** Master volume in the range [0, 1]. */
+    volumeAll: number;
     /**
-     * @deprecated You can define sound assets directly in `PIXI.Assets`
+     * @deprecated Global playback speed. This is not a well-supported feature and may be removed in a future release. Use individual sound speed options instead.
      */
-    add(alias: string, options: string): Sound;
+    speedAll: number;
     /**
-     * Plays a sound.
-     * @param alias The media and sound (asset) alias reference.
-     * @param options The options
-     * @return The sound instance,
-     *        this cannot be reused after it is done playing. Returns a Promise if the sound
-     *        has not yet loaded.
+     * The default channel alias used when playing a sound without specifying a
+     * channel. Defaults to `"general"`.
+     */
+    defaultChannelAlias: string;
+    /**
+     * @deprecated Register sound assets directly via `PIXI.Assets` instead.
      */
-    play(alias: string, options?: SoundPlayOptionsWithChannel): Promise<IMediaInstance>;
-    play(mediaAlias: string, soundAlias: string, options?: SoundPlayOptionsWithChannel): Promise<IMediaInstance>;
+    add(alias: string, options: string): void;
     /**
-     * Plays a non-persistent sound (for example UI/menu sounds).
-     * This playback is not tracked in save/export state.
-     * @param alias The sound (asset) alias reference.
+     * Plays a sound.
+     * @param alias The media and sound (asset) alias reference.
      * @param options The options.
-     * @return The sound instance.
+     * @returns The media instance (resolves immediately if already loaded).
      */
-    playTransient(alias: string, options?: SoundPlayOptionsWithChannel): Promise<IMediaInstance>;
+    play(alias: string, options?: SoundPlayOptionsWithChannel): Promise<MediaInterface>;
+    play(mediaAlias: string, soundAlias: string, options?: SoundPlayOptionsWithChannel): Promise<MediaInterface>;
     /**
-     * Stops all transient media instances started with {@link playTransient}.
-     * If `channel` is provided only instances on that channel are stopped;
-     * otherwise all channels are affected.
-     * @param channel Optional channel alias to limit the operation to.
-     * @return Instance for chaining.
+     * Plays a non-persistent ("transient") sound (e.g. UI / menu sounds).
+     * Transient playback is not tracked in save/export state.
      */
-    stopTransientAll(channel?: string): this;
+    playTransient(alias: string, options?: Partial<PlayerOptions>): Promise<Player>;
     /**
-     * Find a media by alias.
-     * @param alias - The media alias reference.
-     * @return Media object.
+     * Find a tracked media instance by alias.
      */
-    find(alias: string): IMediaInstance | undefined;
+    find(alias: string): MediaInterface | undefined;
     /**
-     * Stops a media and removes it from the manager.
-     * @param alias - The media alias reference.
+     * Stop a tracked media instance and remove it from the manager.
      */
     stop(alias: string): void;
     /**
-     * Pauses a media.
-     * @param alias - The media alias reference.
-     * @return Media object.
+     * Pause a tracked media instance.
      */
-    pause(alias: string): IMediaInstance | undefined;
+    pause(alias: string): MediaInterface | undefined;
     /**
-     * Resumes a media.
-     * @param alias - The media alias reference.
-     * @return Media object.
+     * Resume a paused media instance.
      */
-    resume(alias: string): IMediaInstance | undefined;
+    resume(alias: string): MediaInterface | undefined;
+    /** Duration in seconds of the loaded sound with the given alias. */
+    duration(alias: string): number;
+    /** Toggle mute on all sounds. Returns the new muted state. */
+    toggleMuteAll(): boolean;
     /**
-     * Edits the options of an existing sound (asset).
-     * If the asset is not yet loaded, it will be loaded with the new options.
-     */
-    edit(alias: string, options: SoundOptions): Promise<void>;
-    /**
-     * Pauses any playing sounds.
-     * @return Instance for chaining.
+     * Whether all sounds are currently muted. Note that individual channels or media instances may still be muted or unmuted; this is just the global master mute state.
      */
+    readonly muted: boolean;
+    /** Mute all sounds. */
+    muteAll(): this;
+    /** Unmute all sounds. */
+    unmuteAll(): this;
+    /** Stop all sounds. */
+    stopAll(): this;
+    /** Pause all sounds. */
     pauseAll(): this;
-    /**
-     * Resumes any sounds.
-     * @return Instance for chaining.
-     */
+    /** Resume all sounds. */
     resumeAll(): this;
     /**
-     * Temporarily pauses all sounds across all channels (or just the given channel) without
-     * mutating each media instance's persisted paused option.
-     * Useful for overlays (for example settings/pause menus) where pause state must not be saved.
-     * @param channel Optional channel alias to limit the operation to.
-     * @return Instance for chaining.
+     * Temporarily pause all currently-playing sounds (or just those in the given
+     * channel) without persisting the paused state. Useful for overlays / pause
+     * menus.
+     *
+     * Only sounds that are **actively playing** at the time of the call are paused;
+     * sounds that were already paused beforehand are left untouched so that they
+     * remain paused when {@link resumeUnsavedAll} is called later.
+     *
+     * When called without a channel argument all transient players started with
+     * {@link playTransient} are also stopped.
      */
     pauseUnsavedAll(channel?: string): this;
     /**
-     * Restores all channels (or just the given channel) after `pauseUnsavedAll()`,
-     * reapplying each media instance's persisted paused option.
-     * @param channel Optional channel alias to limit the operation to.
-     * @return Instance for chaining.
+     * Resume all sounds (or just those in the given channel) that were paused by
+     * the most recent call to {@link pauseUnsavedAll}. Sounds that were already
+     * paused before `pauseUnsavedAll` was called are **not** resumed.
      */
     resumeUnsavedAll(channel?: string): this;
     /**
-     * Mutes all playing sounds.
-     * @return Instance for chaining.
-     */
-    muteAll(): this;
-    /**
-     * Unmutes all playing sounds.
-     * @return Instance for chaining.
-     */
-    unmuteAll(): this;
-    /**
-     * Stops all sounds.
-     * @return Instance for chaining.
+     * Stop all transient media instances started with {@link playTransient}.
      */
-    stopAll(): this;
-    load(alias: string | string[]): Promise<Sound[]>;
-    backgroundLoad(alias: string | string[]): Promise<void>;
+    stopTransientAll(): this;
+    /** Load one or more sound assets. */
+    load(...alias: string[]): Promise<void>;
+    /** Trigger background loading of one or more sound assets. */
+    backgroundLoad(...alias: string[]): Promise<void>;
+    /** Trigger background loading of a sound bundle. */
     backgroundLoadBundle(alias: string): Promise<void>;
+    /** Stop all sounds and clear internal state. */
     clear(): void;
     /**
-     * Adds a new audio channel with the specified alias(es).
-     * @param alias The alias or aliases for the new channel.
-     * @returns The created AudioChannelInterface instance, or undefined if a channel with the alias already exists.
+     * Add a new audio channel.
+     * Returns the created channel, or `undefined` if the alias already exists.
      */
     addChannel(alias: string | string[], options?: ChannelOptions): AudioChannelInterface | undefined;
     /**
-     * Finds and returns the audio channel associated with the given alias. If the channel does not exist, it will be created.
-     * @param alias The alias of the audio channel to find.
-     * @returns The AudioChannelInterface instance associated with the alias.
+     * Find the channel for the given alias, creating it if it does not yet exist.
      */
     findChannel(alias: string): AudioChannelInterface;
-    /**
-     * Returns an array of all existing audio channels.
-     */
+    /** All registered audio channels. */
     readonly channels: AudioChannelInterface[];
     /**
-     * The default channel alias to use when playing a sound without specifying a channel.
-     * By default, this is set to `GENERAL_CHANNEL` ("general"), but it can be changed to any string; if the channel does not yet exist, it will be created on demand when used.
+     * Export the current sound state, including currently playing sounds and their options, for saving or debugging purposes. This is not guaranteed to be stable across versions and may contain implementation details; it is not intended for use in general application code.
      */
-    defaultChannelAlias: string;
     export(): SoundGameState;
+    /**
+     * Restore a sound state exported by {@link export}. This will stop any currently playing sounds and replace them with the sounds specified in the exported state. This is not guaranteed to be stable across versions and may contain implementation details; it is not intended for use in general application code.
+     */
     restore(data: object): Promise<void>;
 }
 
-declare const filters: {
-    DistortionFilter: typeof filters$1.DistortionFilter;
-    EqualizerFilter: typeof filters$1.EqualizerFilter;
-    MonoFilter: typeof filters$1.MonoFilter;
-    ReverbFilter: typeof filters$1.ReverbFilter;
-    StereoFilter: typeof filters$1.StereoFilter;
-    StreamFilter: typeof filters$1.StreamFilter;
-    TelephoneFilter: typeof filters$1.TelephoneFilter;
-};
+type Time = Parameters<Player["stop"]>[0];
+declare class MediaInstance extends Player implements MediaInterface {
+    readonly alias: string;
+    readonly channelAlias: string;
+    readonly soundAlias: string;
+    readonly stepCounter: number;
+    readonly delay?: number | undefined;
+    constructor(alias: string, channelAlias: string, soundAlias: string, stepCounter: number, options?: Partial<PlayerOptions>, delay?: number | undefined);
+    readonly options: Partial<PlayerOptions>;
+    readonly filters: Set<ToneAudioNode>;
+    /**
+     * Set to `toneNow()` the moment playback is paused; cleared on resume.
+     * Used to compute how long the instance was paused so that
+     * `playStartTime` can be adjusted accordingly.
+     */
+    private pausedAt;
+    /**
+     * Tracks the effective playback start time in Tone's clock, adjusted
+     * after each resume to exclude all time spent paused.
+     * Invariant: `toneNow() - playStartTime` equals actual playback position
+     * while the player is playing.
+     */
+    private playStartTime;
+    get memory(): MediaMemory;
+    set memory(options: MediaMemory);
+    get paused(): boolean;
+    set paused(value: boolean);
+    get muted(): boolean;
+    set muted(value: boolean);
+    get speed(): number;
+    set speed(value: number);
+    stop(time?: Time): this;
+    chain(...nodes: ToneAudioNode[]): this;
+    disconnect(node: ToneAudioNode): this;
+}
 
-declare class SoundManagerStatic {
-    private constructor();
-    static mediaInstances: Map<string, {
-        channelAlias: string;
-        soundAlias: string;
-        instance: IMediaInstance;
-        stepCounter: number;
-        options: SoundPlayOptions;
-    }>;
-    static readonly channels: Map<string, AudioChannelInterface>;
-    static delayTimeoutInstances: [number | NodeJS.Timeout, string][];
+/**
+ * SoundRegistry is a singleton namespace that holds global state for the sound system.
+ * **DO NOT** import this module directly; use `sound`.
+ */
+declare namespace SoundRegistry {
+    const mediaInstances: Map<string, MediaInstance>;
+    const channels: Map<string, AudioChannelInterface>;
+    const transients: Set<Player>;
+    /**
+     * Aliases of {@link mediaInstances} that were paused by `pauseUnsavedAll`.
+     * Used by `resumeUnsavedAll` to only resume the instances it paused, leaving
+     * any previously-paused instances untouched.
+     */
+    const systemPausedAliases: Set<string>;
+    const bufferRegistry: CachedMap<string, ToneAudioBuffer>;
 }
 
+/**
+ * The singleton sound manager instance. Use this to play and manage sounds in your game.
+ */
 declare const sound: SoundManagerInterface;
 
-export { type AudioChannelInterface, type ChannelOptions, type ExportedSound, type ExportedSoundPlay, type IMediaInstance, type SoundFilterMemory, type SoundGameState, SoundManagerStatic, type SoundOptions, type SoundPlay, type SoundPlayOptions, type SoundPlayOptionsWithChannel, filters, sound };
+export { type AudioChannelInterface, type ChannelOptions, type ExportedSound, type ExportedSoundPlay, type MediaInterface, type SoundGameState, type SoundOptions, type SoundPlay, type SoundPlayOptions, type SoundPlayOptionsWithChannel, SoundRegistry, sound };