@babylonjs/lite-compat 1.5.0-preview → 1.6.0-preview

package/index.d.ts

@@ -1,6 +1,7 @@
 import { AnimationGroup as AnimationGroup_2 } from '@babylonjs/lite';
 import { AnisotropyProps } from '@babylonjs/lite';
 import { AssetContainer as AssetContainer_2 } from '@babylonjs/lite';
+import { AudioGraphHost } from '@babylonjs/lite';
 import { ClearCoatProps } from '@babylonjs/lite';
 import { EngineContext } from '@babylonjs/lite';
 import { EngineOptions } from '@babylonjs/lite';
@@ -26,6 +27,78 @@ export declare abstract class AbstractAssetTask {
     /** Run the task. Subclasses populate their result fields here. */
     abstract runAsync(): Promise<void>;
 
+/** Babylon.js `AbstractAudioAnalyzer` — the `sound.analyzer` / `bus.analyzer` sub-property. */
+export declare class AbstractAudioAnalyzer {
+    private readonly _host;
+    private _fftSize;
+    private _minDecibels;
+    private _maxDecibels;
+    private _smoothing;
+    private _enabled;
    /** FFT window size. */
+    get fftSize(): AudioAnalyzerFFTSizeType;
+    set fftSize(value: AudioAnalyzerFFTSizeType);
+    /** Number of frequency bins (`fftSize / 2`). */
+    get frequencyBinCount(): number;
+    /** Whether the analyzer is enabled. */
+    get isEnabled(): boolean;
+    /** Minimum dB. */
+    get minDecibels(): number;
+    set minDecibels(value: number);
+    /** Maximum dB. */
+    get maxDecibels(): number;
+    set maxDecibels(value: number);
+    /** Time-averaging constant `[0, 1]`. */
+    get smoothing(): number;
+    set smoothing(value: number);
+    /** Builds (enables) the analyzer tap. */
+    enableAsync(): Promise<void>;
+    /** Returns the byte frequency-domain data. Empty when disabled. */
+    getByteFrequencyData(): Uint8Array;
+    /** Returns the float frequency-domain data. Empty when disabled. */
+    getFloatFrequencyData(): Float32Array;
+    /** Returns the byte time-domain data. Empty when disabled. */
+    getByteTimeDomainData(): Uint8Array;
+    /** Returns the float time-domain data. Empty when disabled. */
+    getFloatTimeDomainData(): Float32Array;
+    /** Disposes the analyzer (Lite tears it down with the host). */
+    dispose(): void;
+    private _apply;
+    private _reapply;
+}
+
+/** Babylon.js `AbstractAudioBus` — base class for both bus kinds. */
+export declare abstract class AbstractAudioBus extends AbstractAudioOutNode {
+}
+
+/** Babylon.js `AbstractAudioNode` — the root of the AudioV2 node hierarchy. */
+export declare abstract class AbstractAudioNode {
+    /** The engine that owns this node. */
+    readonly engine: AudioEngineV2;
+    /** Fires when this node is disposed. */
+    readonly onDisposeObservable: Observable<AbstractAudioNode>;
+    protected constructor(engine: AudioEngineV2);
+    /** Disposes the node. */
+    dispose(): void;
+    /** The class name (mirrors Babylon.js `getClassName()`). */
+    abstract getClassName(): string;
+}
+
+/**
+ * Babylon.js `AbstractAudioOutNode` — a named node with a volume and a lazily
+ * created analyzer.
+ */
+export declare abstract class AbstractAudioOutNode extends AbstractNamedAudioNode {
+    protected _volume: number;
+    private _analyzer;
+    /** The node output volume. */
+    get volume(): number;
+    set volume(value: number);
+    /** Lazily-built audio analyzer for this node's output. */
+    get analyzer(): AbstractAudioAnalyzer;
+    /** Sets the volume, optionally ramping. */
+    setVolume(value: number, options?: Partial<IAudioParameterRampOptions> | null): void;
+    dispose(): void;
+
 export declare abstract class AbstractEngine {
    protected readonly _canvas: RenderCanvas;
     private readonly _options;
     protected readonly _scenes: Scene[];
@@ -170,6 +243,18 @@ export declare class AbstractMesh extends TransformNode {
    private _material;
     dispose(): void;
 }
 
+/** Babylon.js `AbstractNamedAudioNode` — an `AbstractAudioNode` with a mutable name. */
+export declare abstract class AbstractNamedAudioNode extends AbstractAudioNode {
+    /** Fires when {@link name} changes. */
+    readonly onNameChangedObservable: Observable<IAudioNodeNameChange>;
+    private _name;
+    protected constructor(name: string, engine: AudioEngineV2);
+    /** The node name. */
+    get name(): string;
+    set name(value: string);
+    dispose(): void;
+}
+
 export declare abstract class AbstractScene {
    /**
      * Babylon.js `scene.meshes`. Babylon Lite does not expose a public scene-mesh
      * registry, so this tracks the meshes the compat layer creates against a scene
@@ -211,6 +296,150 @@ export declare abstract class AbstractScene {
    /**
     getNodeById(id: string): Node_2 | null;
 }
 
+/** Babylon.js `AbstractSound` — a playable sound (static or streaming). */
+export declare abstract class AbstractSound extends AbstractSoundSource {
+    /** Fires when the sound finishes (all instances ended). */
+    readonly onEndedObservable: Observable<AbstractSound>;
+    protected constructor(name: string, engine: AudioEngineV2, outBus: PrimaryAudioBus | null);
+    /** Number of live playing instances. */
+    abstract get activeInstancesCount(): number;
+    /** Whether the sound auto-plays on creation. */
+    abstract get autoplay(): boolean;
+    /** Current playback state. */
+    abstract get state(): SoundState;
+    /** Whether the sound loops. */
+    abstract get loop(): boolean;
+    abstract set loop(value: boolean);
+    /** Start offset, seconds. */
+    abstract get startOffset(): number;
+    abstract set startOffset(value: number);
+    /** Maximum simultaneous instances. */
+    abstract get maxInstances(): number;
+    abstract set maxInstances(value: number);
+    /** Current playback time of the newest instance, seconds. */
+    abstract get currentTime(): number;
+    abstract set currentTime(value: number);
+    /** Plays the sound. */
+    abstract play(options?: Partial<IStaticSoundPlayOptions & IStreamingSoundPlayOptions>): void;
+    /** Pauses the sound. */
+    abstract pause(): void;
+    /** Resumes the sound. */
+    abstract resume(options?: Partial<IStaticSoundPlayOptions & IStreamingSoundPlayOptions>): void;
+    /** Stops the sound. */
+    abstract stop(options?: Partial<IStaticSoundStopOptions>): void;
+    dispose(): void;
+}
+
+/** Babylon.js `AbstractSoundSource` — an out-node with an output bus + spatial/stereo. */
+export declare abstract class AbstractSoundSource extends AbstractAudioOutNode {
+    private _spatial;
+    private _stereo;
+    protected _outBus: PrimaryAudioBus | null;
+    protected constructor(name: string, engine: AudioEngineV2, outBus: PrimaryAudioBus | null);
+    /** The output bus this source routes to. */
+    get outBus(): PrimaryAudioBus | null;
+    set outBus(value: PrimaryAudioBus | null);
+    /** Lazily-built spatial sub-property. */
+    get spatial(): AbstractSpatialAudio;
+    /** Lazily-built stereo sub-property. */
+    get stereo(): AbstractStereoAudio;
+}
+
+/** Babylon.js `AbstractSpatialAudio` — the `sound.spatial` / `bus.spatial` sub-property. */
+export declare class AbstractSpatialAudio {
+    private readonly _host;
+    private _enabled;
+    private _position;
+    private _orientation;
+    private _rotationQuaternion;
+    /** Cone inner angle, radians. */
+    coneInnerAngle: number;
+    /** Cone outer angle, radians. */
+    coneOuterAngle: number;
+    /** Volume outside the cone. */
+    coneOuterVolume: number;
+    /** Distance attenuation model. */
+    distanceModel: DistanceModelType;
+    /** Max distance. */
+    maxDistance: number;
+    /** Reference / min distance. */
+    minDistance: number;
+    /** Minimum time between auto-updates, seconds. */
+    minUpdateTime: number;
+    /** Enable left/right panning. */
+    panningEnabled: boolean;
+    /** Panning algorithm. */
+    panningModel: PanningModelType;
+    /** Roll-off factor. */
+    rolloffFactor: number;
+    /** Whether following a scene node. */
+    useBoundingBox: boolean;
+    /** Which transform components are followed. */
+    attachmentType: SpatialAudioAttachmentType;
+    private _attachedNode;
    /** Source world position. */
+    get position(): Vector3;
+    set position(value: Vector3);
+    /** Source facing direction. */
+    get orientation(): Vector3;
+    set orientation(value: Vector3);
+    /** Source rotation quaternion. */
+    get rotationQuaternion(): Quaternion;
+    set rotationQuaternion(value: Quaternion);
+    /** Whether attached to a scene node. */
+    get isAttached(): boolean;
+    /** The scene node this source follows, if any. */
+    get attachedNode(): SpatialNodeLike | null;
+    /** Follows a scene node's world transform. */
+    attach(sceneNode: SpatialNodeLike | null, useBoundingBox?: boolean, attachmentType?: SpatialAudioAttachmentType): void;
+    /** Stops following a scene node. */
+    detach(): void;
+    /** Pulls the attached node's current world position/rotation into the source. */
+    update(): void;
+    /** Disposes the spatial sub-node (Lite tears it down with the host). */
+    dispose(): void;
+    private _ensure;
+    private _reapply;
+    private _options;
+}
+
+/** Babylon.js `AbstractSpatialAudioListener` — the engine's `listener` (the "ears"). */
+export declare class AbstractSpatialAudioListener {
+    private readonly _engine;
+    private _position;
+    private _rotation;
+    private _rotationQuaternion;
+    private _attachedNode;
+    /** Minimum time between auto-updates, seconds. */
+    minUpdateTime: number;
    /** Whether attached to a scene node. */
+    get isAttached(): boolean;
+    /** The scene node the listener follows, if any. */
+    get attachedNode(): SpatialNodeLike | null;
+    /** Listener world position. */
+    get position(): Vector3;
+    set position(value: Vector3);
+    /** Listener Euler rotation. */
+    get rotation(): Vector3;
+    set rotation(value: Vector3);
+    /** Listener rotation quaternion. */
+    get rotationQuaternion(): Quaternion;
+    set rotationQuaternion(value: Quaternion);
+    /** Follows a scene node's world transform. */
+    attach(sceneNode: SpatialNodeLike | null): void;
+    /** Stops following a scene node. */
+    detach(): void;
+    /** Pulls the attached node's current world position/rotation into the listener. */
+    update(): void;
+}
+
+/** Babylon.js `AbstractStereoAudio` — the `sound.stereo` / `bus.stereo` sub-property. */
+export declare class AbstractStereoAudio {
+    private readonly _host;
+    private _pan;
+    private _enabled;
    /** Stereo pan, `-1` (left) to `1` (right). */
+    get pan(): number;
+    set pan(value: number);
+}
+
 /** Base class for actions. `execute` is implemented by subclasses. */
 export declare abstract class Action {
     trigger: number;
@@ -496,10 +725,110 @@ export declare class AssetsManager {
     loadAsync(): Promise<AbstractAssetTask[]>;
 }
 
+/** FFT window sizes accepted by the analyzer (mirrors `AudioAnalyzerFFTSizeType`). */
+export declare type AudioAnalyzerFFTSizeType = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096 | 8192 | 16384 | 32768;
+
+/** Babylon.js `AudioBus` — a generic mixer bus. */
+export declare class AudioBus extends AbstractAudioBus {
    private _spatial;
+    private _stereo;
+    private _outBus;
    /** The output bus this bus routes to. */
+    get outBus(): PrimaryAudioBus | null;
+    set outBus(value: PrimaryAudioBus | null);
+    /** Lazily-built spatial sub-property. */
+    get spatial(): AbstractSpatialAudio;
+    /** Lazily-built stereo sub-property. */
+    get stereo(): AbstractStereoAudio;
+    getClassName(): string;
+    dispose(): void;
+    protected _applyVolume(value: number, options?: Partial<IAudioParameterRampOptions> | null): void;
+    protected _spatialHost(): AudioGraphHost;
+}
+
 export declare class AudioEngine {
     constructor();
 }
 
+/**
+ * Babylon.js `AudioEngineV2` — the AudioV2 engine. Backed by a Lite audio engine.
+ * Created via {@link CreateAudioEngineAsync}.
+ */
+export declare class AudioEngineV2 {
+    private static _Instances;
+    /** All live audio engines. */
+    static get Instances(): readonly AudioEngineV2[];
+    /** Fires when a named node is added to the engine. */
+    readonly onNodeAddedObservable: Observable<AbstractNamedAudioNode>;
+    /** Fires when a named node is removed from the engine. */
+    readonly onNodeRemovedObservable: Observable<AbstractNamedAudioNode>;
+    /** Fires when the engine is disposed. */
+    readonly onDisposeObservable: Observable<AudioEngineV2>;
    private readonly _sounds;
+    private readonly _nodes;
+    private _defaultMainBus;
+    private _listener;
+    private _mainOut;
    /** The audio context's current time, seconds. */
+    get currentTime(): number;
+    /** The context state. */
+    get state(): AudioEngineV2State;
+    /** Master output volume. */
+    get volume(): number;
+    set volume(value: number);
+    /** Default parameter ramp duration, seconds. */
+    get parameterRampDuration(): number;
+    set parameterRampDuration(value: number);
+    /** The default main bus all sounds route to. */
+    get defaultMainBus(): MainAudioBus | null;
+    /** The spatial-audio listener (the "ears"). */
+    get listener(): AbstractSpatialAudioListener;
+    /** The engine output node. */
+    get mainOut(): AbstractAudioNode;
+    /** All live sounds. */
+    get sounds(): readonly AbstractSound[];
+    /** All live named nodes. */
+    get nodes(): ReadonlySet<AbstractNamedAudioNode>;
+    /** Sets the master volume, optionally ramping. */
+    setVolume(value: number, options?: Partial<IAudioParameterRampOptions>): void;
+    /** Whether the given audio format/extension can be decoded. */
+    isFormatValid(format: string): boolean;
+    /** Suspends the engine context. */
+    pauseAsync(): Promise<void>;
+    /** Resumes the engine context. */
+    resumeAsync(): Promise<void>;
+    /** Resumes the engine context (alias of {@link resumeAsync}). */
+    unlockAsync(): Promise<void>;
+    /** Creates a buffer-backed sound. */
+    createSoundAsync(name: string, source: StaticSoundSource, options?: Partial<IStaticSoundOptions>): Promise<StaticSound>;
+    /** Creates a decoded sound buffer. */
+    createSoundBufferAsync(source: StaticSoundSource, options?: Partial<IStaticSoundBufferOptions>): Promise<StaticSoundBuffer>;
+    /** Creates a streaming, media-element-backed sound. */
+    createStreamingSoundAsync(name: string, source: HTMLMediaElement | string | string[], options?: Partial<IStreamingSoundOptions>): Promise<StreamingSound>;
+    /** Creates a generic mixer bus. */
+    createBusAsync(name: string, options?: Partial<IAudioBusOptions>): Promise<AudioBus>;
+    /**
+     * Creates a main bus. Babylon Lite builds a single default main bus per engine
+     * and does not expose creating additional ones, so this resolves the default
+     * main bus.
+     */
+    createMainBusAsync(_name: string, _options?: Partial<IMainAudioBusOptions>): Promise<MainAudioBus>;
+    /** Wraps an arbitrary Web Audio node as a sound source. */
+    createSoundSourceAsync(name: string, source: AudioNode, options?: Partial<ISoundSourceOptions>): Promise<SoundSource>;
+    /** Creates a microphone-backed sound source. */
+    createMicrophoneSoundSourceAsync(name: string, options?: Partial<ISoundSourceOptions>): Promise<SoundSource>;
+    /** Disposes the engine and all its sounds/buses. */
+    dispose(): void;
+
+/** Engine context state (mirrors `AudioEngineV2State`). */
+export declare type AudioEngineV2State = "closed" | "interrupted" | "running" | "suspended";
+
+/** Ramp shape used when changing an audio parameter (mirrors `AudioParameterRampShape`). */
+export declare const AudioParameterRampShape: {
+    readonly Linear: "linear";
+    readonly Exponential: "exponential";
+    readonly Logarithmic: "logarithmic";
+    readonly None: "none";
+};
+
+export declare type AudioParameterRampShape = (typeof AudioParameterRampShape)[keyof typeof AudioParameterRampShape];
+
 /** Idle auto-rotation of an `ArcRotateCamera` (spins `alpha` when not interacting). */
 export declare class AutoRotationBehavior implements Behavior<ArcRotateCamera> {
     readonly name = "AutoRotation";
@@ -809,6 +1138,12 @@ export declare const Constants: {
     readonly TEXTURE_MIRROR_ADDRESSMODE: 2;
 };
 
+/** Babylon.js `CreateAudioBusAsync`. */
+export declare function CreateAudioBusAsync(name: string, options?: Partial<IAudioBusOptions>, engine?: AudioEngineV2 | null): Promise<AudioBus>;
+
+/** Babylon.js `CreateAudioEngineAsync` — creates and initialises an AudioV2 engine. */
+export declare function CreateAudioEngineAsync(options?: Partial<IWebAudioEngineOptions>): Promise<AudioEngineV2>;
+
 /** Babylon.js `CreateBox(name, options, scene)` (boxBuilder). */
 export declare function CreateBox(name: string, options: BoxOptions, scene: Scene): Mesh;
 
@@ -821,12 +1156,30 @@ export declare function CreateDisc(name: string, options: object, scene: Scene):
 /** Babylon.js `CreateGround(name, options, scene)` (groundBuilder). */
 export declare function CreateGround(name: string, options: GroundOptions, scene: Scene): Mesh;
 
+/** Babylon.js `CreateMainAudioBusAsync`. */
+export declare function CreateMainAudioBusAsync(name: string, options?: Partial<IMainAudioBusOptions>, engine?: AudioEngineV2 | null): Promise<MainAudioBus>;
+
+/** Babylon.js `CreateMicrophoneSoundSourceAsync`. */
+export declare function CreateMicrophoneSoundSourceAsync(name: string, options?: Partial<ISoundSourceOptions>, engine?: AudioEngineV2 | null): Promise<SoundSource>;
+
 /** Babylon.js `CreatePlane(name, options, scene)` (planeBuilder). */
 export declare function CreatePlane(name: string, options: PlaneOptions, scene: Scene): Mesh;
 
+/** Babylon.js `CreateSoundAsync`. */
+export declare function CreateSoundAsync(name: string, source: StaticSoundSource, options?: Partial<IStaticSoundOptions>, engine?: AudioEngineV2 | null): Promise<StaticSound>;
+
+/** Babylon.js `CreateSoundBufferAsync`. */
+export declare function CreateSoundBufferAsync(source: StaticSoundSource, options?: Partial<IStaticSoundBufferOptions>, engine?: AudioEngineV2 | null): Promise<StaticSoundBuffer>;
+
+/** Babylon.js `CreateSoundSourceAsync`. */
+export declare function CreateSoundSourceAsync(name: string, source: AudioNode, options?: Partial<ISoundSourceOptions>, engine?: AudioEngineV2 | null): Promise<SoundSource>;
+
 /** Babylon.js `CreateSphere(name, options, scene)` (sphereBuilder). */
 export declare function CreateSphere(name: string, options: SphereOptions, scene: Scene): Mesh;
 
+/** Babylon.js `CreateStreamingSoundAsync`. */
+export declare function CreateStreamingSoundAsync(name: string, source: HTMLMediaElement | string | string[], options?: Partial<IStreamingSoundOptions>, engine?: AudioEngineV2 | null): Promise<StreamingSound>;
+
 /** Babylon.js `CreateTorus(name, options, scene)` (torusBuilder). */
 export declare function CreateTorus(name: string, options: object, scene: Scene): Mesh;
 
@@ -1348,6 +1701,20 @@ export declare class HighlightLayer {
     constructor();
 }
 
+/** Babylon.js `IAbstractSoundOptions` (subset). */
+export declare interface IAbstractSoundOptions extends Partial<IVolumeAudioOptions> {
+    /** Play immediately once ready. Defaults to `false`. */
+    autoplay?: boolean;
+    /** Maximum simultaneous instances. Defaults to `Infinity`. */
+    maxInstances?: number;
+    /** Loop playback. Defaults to `false`. */
+    loop?: boolean;
+    /** Start offset in seconds. Defaults to `0`. */
+    startOffset?: number;
+    /** Output bus. */
+    outBus?: PrimaryAudioBus;
+}
+
 export declare interface IAnimationKey {
     frame: number;
     value: number | number[];
@@ -1355,6 +1722,52 @@ export declare interface IAnimationKey {
     interpolation?: number;
 }
 
+/** Babylon.js `IAudioAnalyzerOptions`. */
+export declare interface IAudioAnalyzerOptions {
+    /** Build the analyzer immediately. Defaults to `false`. */
+    analyzerEnabled: boolean;
+    /** FFT window size. Defaults to `2048`. */
+    analyzerFFTSize: AudioAnalyzerFFTSizeType;
+    /** Minimum dB. Defaults to `-100`. */
+    analyzerMinDecibels: number;
+    /** Maximum dB. Defaults to `-30`. */
+    analyzerMaxDecibels: number;
+    /** Time-averaging constant `[0, 1]`. Defaults to `0.8`. */
+    analyzerSmoothing: number;
+}
+
+/** Babylon.js `IAudioBusOptions` (subset). */
+export declare interface IAudioBusOptions extends Partial<IVolumeAudioOptions> {
+    /** Output bus. Defaults to the engine's default main bus. */
+    outBus?: PrimaryAudioBus;
+}
+
+/** Babylon.js `IAudioEngineV2Options` (subset backed by Lite). */
+export declare interface IAudioEngineV2Options {
+    /** Default parameter ramp duration, in seconds. Defaults to `0.01`. */
+    parameterRampDuration: number;
+    /** Initial output volume. Defaults to `1`. */
+    volume: number;
+}
+
+/** Payload for `AbstractNamedAudioNode.onNameChangedObservable`. */
+export declare interface IAudioNodeNameChange {
+    /** The new name. */
+    newName: string;
+    /** The previous name. */
+    oldName: string;
+    /** The node whose name changed. */
+    node: AbstractNamedAudioNode;
+}
+
+/** Babylon.js `IAudioParameterRampOptions`. */
+export declare interface IAudioParameterRampOptions {
+    /** Ramp time, in seconds. */
+    duration: number;
+    /** Ramp shape. */
+    shape: AudioParameterRampShape;
+}
+
 /** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
 export declare interface IGPUMultiPickingInfo {
     meshes: Array<PickableMesh | null>;
@@ -1378,6 +1791,10 @@ export declare class ImageProcessingConfiguration {
     static readonly TONEMAPPING_KHR_PBR_NEUTRAL = 2;
 }
 
+/** Babylon.js `IMainAudioBusOptions`. */
+export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOptions> {
+}
+
 /** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
 export declare function ImportMeshAsync(source: string, scene: Scene, _options?: unknown): Promise<ImportResult>;
 
@@ -1409,6 +1826,140 @@ export declare class InstancedMesh {
     constructor();
 }
 
+/** Babylon.js `ISoundSourceOptions` (subset). */
+export declare interface ISoundSourceOptions extends Partial<IVolumeAudioOptions> {
+    /** Name. */
+    name?: string;
+    /** Output bus. */
+    outBus?: PrimaryAudioBus | null;
+    /** Auto-assign the default main bus when `outBus` is null. */
+    outBusAutoDefault?: boolean;
+}
+
+/** Babylon.js `ISpatialAudioOptions` (subset backed by Lite). */
+export declare interface ISpatialAudioOptions {
+    /** Build spatial immediately. */
+    spatialEnabled: boolean;
+    /** Cone inner angle, radians. */
+    spatialConeInnerAngle: number;
+    /** Cone outer angle, radians. */
+    spatialConeOuterAngle: number;
+    /** Volume outside the cone. */
+    spatialConeOuterVolume: number;
+    /** Distance attenuation model. */
+    spatialDistanceModel: DistanceModelType;
+    /** Max distance. */
+    spatialMaxDistance: number;
+    /** Reference / min distance. */
+    spatialMinDistance: number;
+    /** Source facing direction. */
+    spatialOrientation: Vector3;
+    /** Enable left/right panning. */
+    spatialPanningEnabled: boolean;
+    /** Panning algorithm. */
+    spatialPanningModel: PanningModelType;
+    /** Source world position. */
+    spatialPosition: Vector3;
+    /** Roll-off factor. */
+    spatialRolloffFactor: number;
+    /** Source rotation quaternion. */
+    spatialRotationQuaternion: Quaternion;
+}
+
+/** Babylon.js `IStaticSoundBufferOptions`. */
+export declare interface IStaticSoundBufferOptions {
+    /** Skip codec checks when the source is a URL list. Defaults to `false`. */
+    skipCodecCheck: boolean;
+}
+
+/** Babylon.js `IStaticSoundCloneOptions`. */
+export declare interface IStaticSoundCloneOptions {
+    /** Clone the underlying buffer (Lite reuses the same buffer). Defaults to `false`. */
+    cloneBuffer?: boolean;
+    /** Output bus for the clone. */
+    outBus?: PrimaryAudioBus | null;
+}
+
+/** Babylon.js `IStaticSoundOptions`. */
+export declare interface IStaticSoundOptions extends IAbstractSoundOptions, Partial<IStaticSoundBufferOptions> {
+    /** Play duration in seconds (`0` = full). */
+    duration?: number;
+    /** Loop end, seconds. */
+    loopEnd?: number;
+    /** Loop start, seconds. */
+    loopStart?: number;
+    /** Detune in cents. */
+    pitch?: number;
+    /** Playback rate multiplier. */
+    playbackRate?: number;
+}
+
+/** Babylon.js `IStaticSoundPlayOptions`. */
+export declare interface IStaticSoundPlayOptions {
+    /** Loop playback. */
+    loop?: boolean;
+    /** Start offset in seconds. */
+    startOffset?: number;
+    /** Play duration in seconds. */
+    duration?: number;
+    /** Loop start, seconds. */
+    loopStart?: number;
+    /** Loop end, seconds. */
+    loopEnd?: number;
+    /** Per-instance volume. */
+    volume?: number;
+    /** Delay before playback, seconds. */
+    waitTime?: number;
+}
+
+/** Babylon.js `IStaticSoundStopOptions`. */
+export declare interface IStaticSoundStopOptions {
+    /** Delay before stopping, seconds. */
+    waitTime?: number;
+}
+
+/** Babylon.js `IStereoAudioOptions`. */
+export declare interface IStereoAudioOptions {
+    /** Build stereo immediately. Defaults to `false`. */
+    stereoEnabled: boolean;
+    /** Pan `-1` (left) to `1` (right). Defaults to `0`. */
+    stereoPan: number;
+}
+
+/** Babylon.js `IStreamingSoundOptions`. */
+export declare interface IStreamingSoundOptions extends IAbstractSoundOptions {
+    /** Number of instances to preload. Defaults to `1`. */
+    preloadCount?: number;
+}
+
+/** Babylon.js `IStreamingSoundPlayOptions`. */
+export declare interface IStreamingSoundPlayOptions {
+    /** Loop playback. */
+    loop?: boolean;
+    /** Start offset in seconds. */
+    startOffset?: number;
+    /** Per-instance volume. */
+    volume?: number;
+}
+
+/** Babylon.js `IVolumeAudioOptions`. */
+export declare interface IVolumeAudioOptions {
+    /** Volume / gain. Defaults to `1`. */
+    volume: number;
+}
+
+/** Babylon.js `IWebAudioEngineOptions`. */
+export declare interface IWebAudioEngineOptions extends IAudioEngineV2Options {
+    /** An existing audio context (pass an `OfflineAudioContext` for headless rendering). */
+    audioContext: BaseAudioContext;
+    /** Auto-resume the context on user interaction. Defaults to `true`. */
+    resumeOnInteraction: boolean;
+    /** Auto-resume the context if the browser pauses playback. Defaults to `true`. */
+    resumeOnPause: boolean;
+    /** Retry interval (ms) for `resumeOnPause`. Defaults to `1000`. */
+    resumeOnPauseRetryInterval: number;
+}
+
 /**
  * Babylon.js `KHR_materials_variants` extension helpers. Mirrors the static
  * surface ported code calls (`SelectVariant` / `GetAvailableVariants` / `Reset`)
@@ -1423,6 +1974,9 @@ export declare const KHR_materials_variants: {
     Reset(rootMesh: unknown): void;
 };
 
+/** Babylon.js `LastCreatedAudioEngine()` — the most recently created engine, if any. */
+export declare function LastCreatedAudioEngine(): AudioEngineV2 | null;
+
 export declare class Layer {
     constructor();
 }
@@ -1511,6 +2065,12 @@ export declare const Logger: {
     Error(message: string): void;
 };
 
+/** Babylon.js `MainAudioBus` — a bus that connects directly to the engine output. */
+export declare class MainAudioBus extends AbstractAudioBus {
    getClassName(): string;
+    protected _applyVolume(value: number, options?: Partial<IAudioParameterRampOptions> | null): void;
+    protected _spatialHost(): AudioGraphHost;
+}
+
 /** Babylon.js `Material` — base class for all materials. */
 export declare abstract class Material {
     name: string;
@@ -1833,6 +2393,9 @@ export declare class Observable<T> {
  */
 declare type ObserverCallback<T> = (eventData: T) => void;
 
+/** Babylon.js `OnAudioEngineV2CreatedObservable` — fires when an engine is created. */
+export declare const OnAudioEngineV2CreatedObservable: Observable<AudioEngineV2>;
+
 export declare class OutlineRenderer {
     constructor();
 }
@@ -2147,6 +2710,9 @@ export declare class PredicateCondition extends Condition {
     isValid(): boolean;
 }
 
+/** A bus a sound or bus can output to (mirrors AudioV2 `PrimaryAudioBus`). */
+export declare type PrimaryAudioBus = MainAudioBus | AudioBus;
+
 /** Babylon.js `PushMaterial` — intermediate base; behaves like {@link Material} here. */
 export declare abstract class PushMaterial extends Material {
     getClassName(): string;
@@ -2607,12 +3173,65 @@ export declare class Sound {
     constructor();
 }
 
+/** A live input source (e.g. microphone) wrapping a Lite `AudioInputSource`. */
+export declare class SoundSource extends AbstractSoundSource {
    getClassName(): string;
+    dispose(): void;
+    protected _applyVolume(value: number, options?: Partial<IAudioParameterRampOptions> | null): void;
+    protected _spatialHost(): AudioGraphHost;
+}
+
+/** Playback state of a sound (mirrors `@babylonjs/core` `SoundState`). */
+export declare const SoundState: {
+    readonly Stopping: 0;
+    readonly Stopped: 1;
+    readonly Starting: 2;
+    readonly Started: 3;
+    readonly FailedToStart: 4;
+    readonly Paused: 5;
+};
+
+export declare type SoundState = (typeof SoundState)[keyof typeof SoundState];
+
 export declare enum Space {
     LOCAL = 0,
     WORLD = 1,
     BONE = 2
 }
 
+/** Which transform components a spatial sound/listener follows (mirrors `SpatialAudioAttachmentType`). */
+export declare const SpatialAudioAttachmentType: {
+    readonly Position: 1;
+    readonly Rotation: 2;
+    readonly PositionAndRotation: 3;
+};
+
+export declare type SpatialAudioAttachmentType = (typeof SpatialAudioAttachmentType)[keyof typeof SpatialAudioAttachmentType];
+
+/** A node that can have a world transform (subset of the compat `Node`). */
+export declare interface SpatialNodeLike {
+    getAbsolutePosition?: () => {
+        x: number;
+        y: number;
+        z: number;
+    };
+    absolutePosition?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotationQuaternion?: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    } | null;
+}
+
 declare interface SphereOptions {
     diameter?: number;
     segments?: number;
@@ -2790,10 +3409,102 @@ export declare class StandardMaterial extends PushMaterial {
    constructor(nam
     private _bumpTexture;
     private _emissiveTexture;
 
+/** Babylon.js `StaticSound` — a buffer-backed sound wrapping a Lite `StaticSound`. */
+export declare class StaticSound extends AbstractSound {
    private readonly _autoplay;
+    private _buffer;
    /** The decoded buffer this sound plays. */
+    get buffer(): StaticSoundBuffer;
+    get activeInstancesCount(): number;
+    get autoplay(): boolean;
+    get state(): SoundState;
+    get loop(): boolean;
+    set loop(value: boolean);
+    get startOffset(): number;
+    set startOffset(value: number);
+    get maxInstances(): number;
+    set maxInstances(value: number);
+    get duration(): number;
+    set duration(value: number);
+    get loopStart(): number;
+    set loopStart(value: number);
+    get loopEnd(): number;
+    set loopEnd(value: number);
+    get pitch(): number;
+    set pitch(value: number);
+    get playbackRate(): number;
+    set playbackRate(value: number);
+    get currentTime(): number;
+    set currentTime(value: number);
+    play(options?: Partial<IStaticSoundPlayOptions>): void;
+    pause(): void;
+    resume(options?: Partial<IStaticSoundPlayOptions>): void;
+    stop(options?: Partial<IStaticSoundStopOptions>): void;
+    /** Clones the sound (shares the decoded buffer). */
+    cloneAsync(options?: Partial<IStaticSoundCloneOptions>): Promise<StaticSound>;
+    getClassName(): string;
+    dispose(): void;
+    protected _applyVolume(value: number, options?: Partial<IAudioParameterRampOptions> | null): void;
+    protected _spatialHost(): AudioGraphHost;
+}
+
+/** Babylon.js `StaticSoundBuffer` — a decoded buffer wrapping a Lite `SoundBuffer`. */
+export declare class StaticSoundBuffer {
+    /** The engine that owns this buffer. */
+    readonly engine: AudioEngineV2;
+    /** The buffer name. */
+    name: string;
    /** Sample rate, Hz. */
+    get sampleRate(): number;
+    /** Length in sample frames. */
+    get length(): number;
+    /** Duration, seconds. */
+    get duration(): number;
+    /** Number of channels. */
+    get channelCount(): number;
+    /** Clones the buffer. Lite buffers are immutable, so the clone shares the data. */
+    clone(options?: Partial<{
+        name: string;
+    }>): StaticSoundBuffer;
+}
+
+/** Source accepted by `createSoundAsync` / `createSoundBufferAsync`. */
+export declare type StaticSoundSource = ArrayBuffer | AudioBuffer | StaticSoundBuffer | string | string[];
+
 export declare class STLFileLoader {
     constructor();
 }
 
+/** Babylon.js `StreamingSound` — a media-element-backed sound. */
+export declare class StreamingSound extends AbstractSound {
    private readonly _autoplay;
+    private _loop;
+    private _startOffset;
+    private _maxInstances;
    /** Number of instances configured to preload. */
+    get preloadCount(): number;
+    /** Number of instances that have finished preloading. */
+    get preloadCompletedCount(): number;
+    get activeInstancesCount(): number;
+    get autoplay(): boolean;
+    get state(): SoundState;
+    get loop(): boolean;
+    set loop(value: boolean);
+    get startOffset(): number;
+    set startOffset(value: number);
+    get maxInstances(): number;
+    set maxInstances(value: number);
+    get currentTime(): number;
+    set currentTime(value: number);
+    play(options?: Partial<IStreamingSoundPlayOptions>): void;
+    pause(): void;
+    resume(options?: Partial<IStreamingSoundPlayOptions>): void;
+    stop(): void;
+    /** Preloads a single instance. */
+    preloadInstanceAsync(): Promise<void>;
+    /** Preloads `count` instances. */
+    preloadInstancesAsync(count: number): Promise<void>;
+    getClassName(): string;
+    dispose(): void;
+    protected _applyVolume(value: number, options?: Partial<IAudioParameterRampOptions> | null): void;
+    protected _spatialHost(): AudioGraphHost;
+}
+
 /** A string-keyed dictionary with the Babylon.js `StringDictionary` surface. */
 export declare class StringDictionary<T> {
     private _store;