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

package/index.js

@@ -1,9 +1,9 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { V as Vector3, u as unsupported, L as LiteCompatError, N as Node, M as Matrix, a as Mesh, T as TransformNode, l as liteBackedVector3 } from "./meshes-BkNs_oK5.js";
-import { A, C, b, c, d, e, f, g, G, I, h, Q, i, j, k, m, t, n } from "./meshes-BkNs_oK5.js";
-import { createEngine, onBeforeRender, stopEngine, resizeEngine, setEngineSize, disposeEngine, registerSceneWithShadowSupport, registerScene, startEngine, createArcRotateCamera, attachControl, getCameraPosition, getViewMatrix, getProjectionMatrix, createGeospatialCamera, setGeospatialOrientation, attachGeospatialControls, createFreeCamera, attachFreeControl, markMaterialUboDirty, createPbrMaterial, createSolidTexture2D, createStandardMaterial, setAnimationAdditive, playAnimation, pauseAnimation, goToFrame, stopAnimation, createSceneContext, updateAnimationManager, setFog, setClipPlane, loadDdsEnvironment, loadEnvironment, createDefaultCamera, addToScene, createHemisphericLight, createAnimationManager, enableAnimationBlending, addAnimationGroup, disposeScene, createDirectionalLight, createPointLight, createSpotLight, createCsgFromMesh, csgSubtract, csgIntersect, csgUnion, createMeshFromCsg, createCsg2FromMesh, csg2Subtract, csg2Intersect, csg2Add, createMeshesFromCsg2, disposeCsg2, initializeCsg2Async, createMorphTargets, setMorphTargetWeights, createTransformNode, bakeCurrentTransformIntoVertices, loadSOG, loadSPZ, loadSplat, createTexture2DFromPixels, updateTexture2DFromPixels, loadBasisTexture2D, loadKtxTexture2D, loadTexture2D, getContainerMeshes, loadBabylon, loadGltf, resetVariant, getVariantNames, selectVariant, disposePicker, createGpuPicker, pickAsync, createAxisDragGizmo, attachAxisDragGizmoToNode, disposeAxisDragGizmo, createAxisScaleGizmo, attachAxisScaleGizmoToNode, disposeAxisScaleGizmo, createBoundingBoxGizmo, attachBoundingBoxGizmoToNode, disposeBoundingBoxGizmo, createCameraGizmo, attachCameraGizmoToCamera, disposeCameraGizmo, createLightGizmo, attachLightGizmoToLight, disposeLightGizmo, createPlaneDragGizmo, attachPlaneDragGizmoToNode, disposePlaneDragGizmo, createPlaneRotationGizmo, attachPlaneRotationGizmoToNode, disposePlaneRotationGizmo, createPositionGizmo, setPositionGizmoLocalCoordinates, attachPositionGizmoToNode, disposePositionGizmo, createRotationGizmo, setRotationGizmoLocalCoordinates, attachRotationGizmoToNode, disposeRotationGizmo, createScaleGizmo, setScaleGizmoLocalCoordinates, attachScaleGizmoToNode, disposeScaleGizmo, createUtilityLayer, registerUtilityLayer, disposeUtilityLayer, addBillboardSpriteIndex, updateBillboardSpriteIndex, loadSpriteAtlas, createFacingBillboardSystem, addFacingBillboardSystem, billboardBlendAdditive, billboardBlendAlpha, spriteBlendPremultiplied, spriteBlendAdditive, spriteBlendAlpha, createSprite2DLayer, addSprite2DIndex, createSpriteRenderer, registerSpriteRenderer, updateSprite2DIndex, createPcfSpotlightShadowGenerator, createPcfDirectionalShadowGenerator, createEsmDirectionalShadowGenerator, setShadowTaskCasterMeshes, parseNodeMaterialFromSnippet, createGridMaterial } from "@babylonjs/lite";
+import { V as Vector3, u as unsupported, L as LiteCompatError, N as Node, M as Matrix, a as Mesh, T as TransformNode, l as liteBackedVector3, Q as Quaternion } from "./meshes-a59_KvbH.js";
+import { A, C, b, c, d, e, f, g, G, I, h, i, j, k, m, t, n } from "./meshes-a59_KvbH.js";
+import { createEngine, onBeforeRender, stopEngine, resizeEngine, setEngineSize, disposeEngine, registerSceneWithShadowSupport, registerScene, startEngine, createArcRotateCamera, attachControl, getCameraPosition, getViewMatrix, getProjectionMatrix, createGeospatialCamera, setGeospatialOrientation, attachGeospatialControls, createFreeCamera, attachFreeControl, markMaterialUboDirty, createPbrMaterial, createSolidTexture2D, createStandardMaterial, setAnimationAdditive, playAnimation, pauseAnimation, goToFrame, stopAnimation, createSceneContext, updateAnimationManager, setFog, setClipPlane, loadDdsEnvironment, loadEnvironment, createDefaultCamera, addToScene, createHemisphericLight, createAnimationManager, enableAnimationBlending, addAnimationGroup, disposeScene, createDirectionalLight, createPointLight, createSpotLight, createCsgFromMesh, csgSubtract, csgIntersect, csgUnion, createMeshFromCsg, createCsg2FromMesh, csg2Subtract, csg2Intersect, csg2Add, createMeshesFromCsg2, disposeCsg2, initializeCsg2Async, createMorphTargets, setMorphTargetWeights, createTransformNode, bakeCurrentTransformIntoVertices, loadSOG, loadSPZ, loadSplat, createTexture2DFromPixels, updateTexture2DFromPixels, loadBasisTexture2D, loadKtxTexture2D, loadTexture2D, getContainerMeshes, loadBabylon, loadGltf, resetVariant, getVariantNames, selectVariant, disposePicker, createGpuPicker, pickAsync, createAxisDragGizmo, attachAxisDragGizmoToNode, disposeAxisDragGizmo, createAxisScaleGizmo, attachAxisScaleGizmoToNode, disposeAxisScaleGizmo, createBoundingBoxGizmo, attachBoundingBoxGizmoToNode, disposeBoundingBoxGizmo, createCameraGizmo, attachCameraGizmoToCamera, disposeCameraGizmo, createLightGizmo, attachLightGizmoToLight, disposeLightGizmo, createPlaneDragGizmo, attachPlaneDragGizmoToNode, disposePlaneDragGizmo, createPlaneRotationGizmo, attachPlaneRotationGizmoToNode, disposePlaneRotationGizmo, createPositionGizmo, setPositionGizmoLocalCoordinates, attachPositionGizmoToNode, disposePositionGizmo, createRotationGizmo, setRotationGizmoLocalCoordinates, attachRotationGizmoToNode, disposeRotationGizmo, createScaleGizmo, setScaleGizmoLocalCoordinates, attachScaleGizmoToNode, disposeScaleGizmo, createUtilityLayer, registerUtilityLayer, disposeUtilityLayer, addBillboardSpriteIndex, updateBillboardSpriteIndex, loadSpriteAtlas, createFacingBillboardSystem, addFacingBillboardSystem, billboardBlendAdditive, billboardBlendAlpha, spriteBlendPremultiplied, spriteBlendAdditive, spriteBlendAlpha, createSprite2DLayer, addSprite2DIndex, createSpriteRenderer, registerSpriteRenderer, updateSprite2DIndex, createPcfSpotlightShadowGenerator, createPcfDirectionalShadowGenerator, createEsmDirectionalShadowGenerator, setShadowTaskCasterMeshes, parseNodeMaterialFromSnippet, createGridMaterial, getByteFrequencyData, getFloatFrequencyData, getByteTimeDomainData, getFloatTimeDomainData, enableAnalyzer, setSpatialPosition, setSpatialOrientation, enableSpatial, setSpatialListenerPosition, setSpatialListener, updateSpatialAudio, enableStereo, setStereoPan, disposeAudioBus, setBusVolume, getMasterVolume, setMasterVolume, unlockAudioEngineAsync, createSoundAsync, createSoundBufferAsync, createStreamingSoundAsync, createAudioBusAsync, createSoundSourceAsync, createMicrophoneSoundSourceAsync, disposeAudioEngine, createAudioEngineAsync, disposeSoundSource, setSoundSourceVolume, playSound, pauseSound, resumeSound, stopSound, disposeSound, setSoundVolume, playStreamingSound, pauseStreamingSound, resumeStreamingSound, stopStreamingSound, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, disposeStreamingSound, setStreamingSoundVolume } from "@babylonjs/lite";
 class Color3 {
   constructor(r = 0, g2 = 0, b2 = 0) {
     this.r = r;
@@ -2132,7 +2132,7 @@ class AnimationGroup {
   get animatables() {
     if (this._lite) {
       const frameRate = this._lite.frameRate ?? 60;
-      return [{ masterFrame: this._lite.currentFrame * frameRate }];
+      return [{ masterFrame: this._lite.currentTime * frameRate }];
     }
     return [];
   }
@@ -2157,7 +2157,7 @@ class AnimationGroup {
     if (this._lite) {
       const frameRate = this._lite.frameRate ?? 60;
       if (from !== void 0) {
-        this._lite.currentFrame = from / frameRate;
+        this._lite.currentTime = from / frameRate;
       }
       this._lite.speedRatio = speedRatio;
       this._lite.loopAnimation = loop;
@@ -5694,6 +5694,1143 @@ function setByPath(target, path, value) {
   }
   current[parts[parts.length - 1]] = value;
 }
+const SoundState = {
+  Stopping: 0,
+  Stopped: 1,
+  Starting: 2,
+  Started: 3,
+  FailedToStart: 4,
+  Paused: 5
+};
+const AudioParameterRampShape = {
+  Linear: "linear",
+  Exponential: "exponential",
+  Logarithmic: "logarithmic",
+  None: "none"
+};
+const SpatialAudioAttachmentType = {
+  Position: 1,
+  Rotation: 2,
+  PositionAndRotation: 3
+};
+function toLiteRamp(options) {
+  if (!options) {
+    return void 0;
+  }
+  return { duration: options.duration, shape: options.shape };
+}
+function readNodePosition(node) {
+  var _a;
+  if (!node) {
+    return null;
+  }
+  return ((_a = node.getAbsolutePosition) == null ? void 0 : _a.call(node)) ?? node.absolutePosition ?? node.position ?? null;
+}
+function readNodeRotation(node) {
+  return (node == null ? void 0 : node.rotationQuaternion) ?? null;
+}
+class AbstractAudioNode {
+  constructor(engine) {
+    /** The engine that owns this node. */
+    __publicField(this, "engine");
+    /** Fires when this node is disposed. */
+    __publicField(this, "onDisposeObservable", new Observable());
+    this.engine = engine;
+  }
+  /** Disposes the node. */
+  dispose() {
+    this.onDisposeObservable.notifyObservers(this);
+    this.onDisposeObservable.clear();
+  }
+}
+class AbstractNamedAudioNode extends AbstractAudioNode {
+  constructor(name, engine) {
+    super(engine);
+    /** Fires when {@link name} changes. */
+    __publicField(this, "onNameChangedObservable", new Observable());
+    __publicField(this, "_name");
+    this._name = name;
+    engine._addNode(this);
+  }
+  /** The node name. */
+  get name() {
+    return this._name;
+  }
+  set name(value) {
+    const oldName = this._name;
+    if (oldName === value) {
+      return;
+    }
+    this._name = value;
+    this.onNameChangedObservable.notifyObservers({ newName: value, oldName, node: this });
+  }
+  dispose() {
+    this.engine._removeNode(this);
+    this.onNameChangedObservable.clear();
+    super.dispose();
+  }
+}
+class AbstractAudioOutNode extends AbstractNamedAudioNode {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_volume", 1);
+    __publicField(this, "_analyzer", null);
+  }
+  /** The node output volume. */
+  get volume() {
+    return this._volume;
+  }
+  set volume(value) {
+    this.setVolume(value);
+  }
+  /** Lazily-built audio analyzer for this node's output. */
+  get analyzer() {
+    return this._analyzer ?? (this._analyzer = new AbstractAudioAnalyzer(this._spatialHost()));
+  }
+  /** Sets the volume, optionally ramping. */
+  setVolume(value, options) {
+    this._volume = value;
+    this._applyVolume(value, options);
+  }
+  dispose() {
+    var _a;
+    (_a = this._analyzer) == null ? void 0 : _a.dispose();
+    this._analyzer = null;
+    super.dispose();
+  }
+}
+class AbstractStereoAudio {
+  /** @internal */
+  constructor(host) {
+    __publicField(this, "_host");
+    __publicField(this, "_pan", 0);
+    __publicField(this, "_enabled", false);
+    this._host = host;
+  }
+  /** Stereo pan, `-1` (left) to `1` (right). */
+  get pan() {
+    return this._pan;
+  }
+  set pan(value) {
+    this._pan = value;
+    if (!this._enabled) {
+      enableStereo(this._host, { pan: value });
+      this._enabled = true;
+    } else {
+      setStereoPan(this._host, value);
+    }
+  }
+}
+class AbstractAudioAnalyzer {
+  /** @internal */
+  constructor(host) {
+    __publicField(this, "_host");
+    __publicField(this, "_fftSize", 2048);
+    __publicField(this, "_minDecibels", -100);
+    __publicField(this, "_maxDecibels", -30);
+    __publicField(this, "_smoothing", 0.8);
+    __publicField(this, "_enabled", false);
+    this._host = host;
+  }
+  /** FFT window size. */
+  get fftSize() {
+    return this._fftSize;
+  }
+  set fftSize(value) {
+    this._fftSize = value;
+    this._reapply();
+  }
+  /** Number of frequency bins (`fftSize / 2`). */
+  get frequencyBinCount() {
+    return this._fftSize / 2;
+  }
+  /** Whether the analyzer is enabled. */
+  get isEnabled() {
+    return this._enabled;
+  }
+  /** Minimum dB. */
+  get minDecibels() {
+    return this._minDecibels;
+  }
+  set minDecibels(value) {
+    this._minDecibels = value;
+    this._reapply();
+  }
+  /** Maximum dB. */
+  get maxDecibels() {
+    return this._maxDecibels;
+  }
+  set maxDecibels(value) {
+    this._maxDecibels = value;
+    this._reapply();
+  }
+  /** Time-averaging constant `[0, 1]`. */
+  get smoothing() {
+    return this._smoothing;
+  }
+  set smoothing(value) {
+    this._smoothing = value;
+    this._reapply();
+  }
+  /** Builds (enables) the analyzer tap. */
+  async enableAsync() {
+    this._apply();
+  }
+  /** Returns the byte frequency-domain data. Empty when disabled. */
+  getByteFrequencyData() {
+    if (!this._enabled) {
+      return new Uint8Array(0);
+    }
+    const out = new Uint8Array(this.frequencyBinCount);
+    getByteFrequencyData(this._host, out);
+    return out;
+  }
+  /** Returns the float frequency-domain data. Empty when disabled. */
+  getFloatFrequencyData() {
+    if (!this._enabled) {
+      return new Float32Array(0);
+    }
+    const out = new Float32Array(this.frequencyBinCount);
+    getFloatFrequencyData(this._host, out);
+    return out;
+  }
+  /** Returns the byte time-domain data. Empty when disabled. */
+  getByteTimeDomainData() {
+    if (!this._enabled) {
+      return new Uint8Array(0);
+    }
+    const out = new Uint8Array(this._fftSize);
+    getByteTimeDomainData(this._host, out);
+    return out;
+  }
+  /** Returns the float time-domain data. Empty when disabled. */
+  getFloatTimeDomainData() {
+    if (!this._enabled) {
+      return new Float32Array(0);
+    }
+    const out = new Float32Array(this._fftSize);
+    getFloatTimeDomainData(this._host, out);
+    return out;
+  }
+  /** Disposes the analyzer (Lite tears it down with the host). */
+  dispose() {
+    this._enabled = false;
+  }
+  _apply() {
+    enableAnalyzer(this._host, {
+      fftSize: this._fftSize,
+      minDecibels: this._minDecibels,
+      maxDecibels: this._maxDecibels,
+      smoothing: this._smoothing
+    });
+    this._enabled = true;
+  }
+  _reapply() {
+    if (this._enabled) {
+      this._apply();
+    }
+  }
+}
+class AbstractSpatialAudio {
+  /** @internal */
+  constructor(host) {
+    __publicField(this, "_host");
+    __publicField(this, "_enabled", false);
+    __publicField(this, "_position", new Vector3(0, 0, 0));
+    __publicField(this, "_orientation", new Vector3(1, 0, 0));
+    __publicField(this, "_rotationQuaternion", new Quaternion(0, 0, 0, 1));
+    /** Cone inner angle, radians. */
+    __publicField(this, "coneInnerAngle", 2 * Math.PI);
+    /** Cone outer angle, radians. */
+    __publicField(this, "coneOuterAngle", 2 * Math.PI);
+    /** Volume outside the cone. */
+    __publicField(this, "coneOuterVolume", 0);
+    /** Distance attenuation model. */
+    __publicField(this, "distanceModel", "linear");
+    /** Max distance. */
+    __publicField(this, "maxDistance", 1e4);
+    /** Reference / min distance. */
+    __publicField(this, "minDistance", 1);
+    /** Minimum time between auto-updates, seconds. */
+    __publicField(this, "minUpdateTime", 0);
+    /** Enable left/right panning. */
+    __publicField(this, "panningEnabled", true);
+    /** Panning algorithm. */
+    __publicField(this, "panningModel", "equalpower");
+    /** Roll-off factor. */
+    __publicField(this, "rolloffFactor", 1);
+    /** Whether following a scene node. */
+    __publicField(this, "useBoundingBox", false);
+    /** Which transform components are followed. */
+    __publicField(this, "attachmentType", SpatialAudioAttachmentType.PositionAndRotation);
+    __publicField(this, "_attachedNode", null);
+    this._host = host;
+  }
+  /** Source world position. */
+  get position() {
+    return this._position;
+  }
+  set position(value) {
+    this._position = value;
+    this._ensure();
+    setSpatialPosition(this._host, value);
+  }
+  /** Source facing direction. */
+  get orientation() {
+    return this._orientation;
+  }
+  set orientation(value) {
+    this._orientation = value;
+    this._ensure();
+    setSpatialOrientation(this._host, value);
+  }
+  /** Source rotation quaternion. */
+  get rotationQuaternion() {
+    return this._rotationQuaternion;
+  }
+  set rotationQuaternion(value) {
+    this._rotationQuaternion = value;
+    this._reapply();
+  }
+  /** Whether attached to a scene node. */
+  get isAttached() {
+    return this._attachedNode !== null;
+  }
+  /** The scene node this source follows, if any. */
+  get attachedNode() {
+    return this._attachedNode;
+  }
+  /** Follows a scene node's world transform. */
+  attach(sceneNode, useBoundingBox = false, attachmentType = SpatialAudioAttachmentType.PositionAndRotation) {
+    this._attachedNode = sceneNode;
+    this.useBoundingBox = useBoundingBox;
+    this.attachmentType = attachmentType;
+    this._ensure();
+    this.update();
+  }
+  /** Stops following a scene node. */
+  detach() {
+    this._attachedNode = null;
+  }
+  /** Pulls the attached node's current world position/rotation into the source. */
+  update() {
+    const node = this._attachedNode;
+    if (!node) {
+      return;
+    }
+    let dirty = false;
+    if ((this.attachmentType & SpatialAudioAttachmentType.Position) !== 0) {
+      const pos = readNodePosition(node);
+      if (pos) {
+        this._position = new Vector3(pos.x, pos.y, pos.z);
+        dirty = true;
+      }
+    }
+    if ((this.attachmentType & SpatialAudioAttachmentType.Rotation) !== 0) {
+      const quat = readNodeRotation(node);
+      if (quat) {
+        this._rotationQuaternion = new Quaternion(quat.x, quat.y, quat.z, quat.w);
+        dirty = true;
+      }
+    }
+    if (dirty) {
+      enableSpatial(this._host, this._options());
+      this._enabled = true;
+    }
+  }
+  /** Disposes the spatial sub-node (Lite tears it down with the host). */
+  dispose() {
+    this._attachedNode = null;
+    this._enabled = false;
+  }
+  _ensure() {
+    if (!this._enabled) {
+      enableSpatial(this._host, this._options());
+      this._enabled = true;
+    }
+  }
+  _reapply() {
+    if (this._enabled) {
+      enableSpatial(this._host, this._options());
+    }
+  }
+  _options() {
+    return {
+      position: this._position,
+      orientation: this._orientation,
+      rotationQuaternion: this._rotationQuaternion,
+      panningEnabled: this.panningEnabled,
+      panningModel: this.panningModel,
+      distanceModel: this.distanceModel,
+      minDistance: this.minDistance,
+      maxDistance: this.maxDistance,
+      rolloffFactor: this.rolloffFactor,
+      coneInnerAngle: this.coneInnerAngle,
+      coneOuterAngle: this.coneOuterAngle,
+      coneOuterVolume: this.coneOuterVolume
+    };
+  }
+}
+class AbstractSpatialAudioListener {
+  /** @internal */
+  constructor(engine) {
+    __publicField(this, "_engine");
+    __publicField(this, "_position", new Vector3(0, 0, 0));
+    __publicField(this, "_rotation", new Vector3(0, 0, 0));
+    __publicField(this, "_rotationQuaternion", new Quaternion(0, 0, 0, 1));
+    __publicField(this, "_attachedNode", null);
+    /** Minimum time between auto-updates, seconds. */
+    __publicField(this, "minUpdateTime", 0);
+    this._engine = engine;
+  }
+  /** Whether attached to a scene node. */
+  get isAttached() {
+    return this._attachedNode !== null;
+  }
+  /** The scene node the listener follows, if any. */
+  get attachedNode() {
+    return this._attachedNode;
+  }
+  /** Listener world position. */
+  get position() {
+    return this._position;
+  }
+  set position(value) {
+    this._position = value;
+    setSpatialListenerPosition(this._engine, value);
+  }
+  /** Listener Euler rotation. */
+  get rotation() {
+    return this._rotation;
+  }
+  set rotation(value) {
+    this._rotation = value;
+  }
+  /** Listener rotation quaternion. */
+  get rotationQuaternion() {
+    return this._rotationQuaternion;
+  }
+  set rotationQuaternion(value) {
+    this._rotationQuaternion = value;
+    setSpatialListener(this._engine, { rotationQuaternion: value });
+  }
+  /** Follows a scene node's world transform. */
+  attach(sceneNode) {
+    this._attachedNode = sceneNode;
+    this.update();
+  }
+  /** Stops following a scene node. */
+  detach() {
+    this._attachedNode = null;
+  }
+  /** Pulls the attached node's current world position/rotation into the listener. */
+  update() {
+    const node = this._attachedNode;
+    const pos = readNodePosition(node);
+    if (pos) {
+      this._position = new Vector3(pos.x, pos.y, pos.z);
+      setSpatialListenerPosition(this._engine, pos);
+    }
+    const quat = readNodeRotation(node);
+    if (quat) {
+      this._rotationQuaternion = new Quaternion(quat.x, quat.y, quat.z, quat.w);
+      setSpatialListener(this._engine, { rotationQuaternion: this._rotationQuaternion });
+    }
+    updateSpatialAudio(this._engine);
+  }
+}
+class AbstractAudioBus extends AbstractAudioOutNode {
+}
+class AudioBus extends AbstractAudioBus {
+  /** @internal */
+  constructor(engine, lite, outBus, volume = 1) {
+    super(lite.name, engine);
+    /** @internal The backing Lite bus. */
+    __publicField(this, "_lite");
+    __publicField(this, "_spatial", null);
+    __publicField(this, "_stereo", null);
+    __publicField(this, "_outBus");
+    this._lite = lite;
+    this._outBus = outBus;
+    this._volume = volume;
+  }
+  /** The output bus this bus routes to. */
+  get outBus() {
+    return this._outBus;
+  }
+  set outBus(value) {
+    if (this._outBus === value) {
+      return;
+    }
+    rerouteLiteOutBus(this._lite, unwrapBus(value) ?? null);
+    this._outBus = value;
+  }
+  /** Lazily-built spatial sub-property. */
+  get spatial() {
+    return this._spatial ?? (this._spatial = new AbstractSpatialAudio(this._lite));
+  }
+  /** Lazily-built stereo sub-property. */
+  get stereo() {
+    return this._stereo ?? (this._stereo = new AbstractStereoAudio(this._lite));
+  }
+  getClassName() {
+    return "AudioBus";
+  }
+  dispose() {
+    disposeAudioBus(this._lite);
+    super.dispose();
+  }
+  _applyVolume(value, options) {
+    setBusVolume(this._lite, value, toLiteRamp(options));
+  }
+  _spatialHost() {
+    return this._lite;
+  }
+}
+class MainAudioBus extends AbstractAudioBus {
+  /** @internal */
+  constructor(engine, lite) {
+    super(lite.name, engine);
+    /** @internal The backing Lite main bus. */
+    __publicField(this, "_lite");
+    this._lite = lite;
+  }
+  getClassName() {
+    return "MainAudioBus";
+  }
+  _applyVolume(value, options) {
+    setBusVolume(this._lite, value, toLiteRamp(options));
+  }
+  _spatialHost() {
+    return unsupported("MainAudioBus.analyzer", "Main buses have no analyzer; attach one to a sound or generic AudioBus instead.");
+  }
+}
+class AbstractSoundSource extends AbstractAudioOutNode {
+  constructor(name, engine, outBus) {
+    super(name, engine);
+    __publicField(this, "_spatial", null);
+    __publicField(this, "_stereo", null);
+    __publicField(this, "_outBus");
+    this._outBus = outBus;
+  }
+  /** The output bus this source routes to. */
+  get outBus() {
+    return this._outBus;
+  }
+  set outBus(value) {
+    if (this._outBus === value) {
+      return;
+    }
+    rerouteLiteOutBus(this._spatialHost(), unwrapBus(value) ?? null);
+    this._outBus = value;
+  }
+  /** Lazily-built spatial sub-property. */
+  get spatial() {
+    return this._spatial ?? (this._spatial = new AbstractSpatialAudio(this._spatialHost()));
+  }
+  /** Lazily-built stereo sub-property. */
+  get stereo() {
+    return this._stereo ?? (this._stereo = new AbstractStereoAudio(this._spatialHost()));
+  }
+}
+class SoundSource extends AbstractSoundSource {
+  /** @internal */
+  constructor(engine, lite, outBus, volume = 1) {
+    super(lite.name, engine, outBus);
+    /** @internal The backing Lite input source. */
+    __publicField(this, "_lite");
+    this._lite = lite;
+    this._volume = volume;
+  }
+  getClassName() {
+    return "SoundSource";
+  }
+  dispose() {
+    disposeSoundSource(this._lite);
+    super.dispose();
+  }
+  _applyVolume(value, options) {
+    setSoundSourceVolume(this._lite, value, toLiteRamp(options));
+  }
+  _spatialHost() {
+    return this._lite;
+  }
+}
+class AbstractSound extends AbstractSoundSource {
+  constructor(name, engine, outBus) {
+    super(name, engine, outBus);
+    /** Fires when the sound finishes (all instances ended). */
+    __publicField(this, "onEndedObservable", new Observable());
+    engine._addSound(this);
+  }
+  dispose() {
+    this.engine._removeSound(this);
+    this.onEndedObservable.clear();
+    super.dispose();
+  }
+}
+class StaticSoundBuffer {
+  /** @internal */
+  constructor(engine, lite, name = "StaticSoundBuffer") {
+    /** The engine that owns this buffer. */
+    __publicField(this, "engine");
+    /** The buffer name. */
+    __publicField(this, "name");
+    /** @internal The backing Lite sound buffer. */
+    __publicField(this, "_lite");
+    this.engine = engine;
+    this._lite = lite;
+    this.name = name;
+  }
+  /** Sample rate, Hz. */
+  get sampleRate() {
+    return this._lite.sampleRate;
+  }
+  /** Length in sample frames. */
+  get length() {
+    return this._lite.length;
+  }
+  /** Duration, seconds. */
+  get duration() {
+    return this._lite.duration;
+  }
+  /** Number of channels. */
+  get channelCount() {
+    return this._lite.channelCount;
+  }
+  /** Clones the buffer. Lite buffers are immutable, so the clone shares the data. */
+  clone(options) {
+    return new StaticSoundBuffer(this.engine, this._lite, (options == null ? void 0 : options.name) ?? this.name);
+  }
+}
+class StaticSound extends AbstractSound {
+  /** @internal */
+  constructor(engine, lite, buffer, outBus, autoplay, name, volume = 1) {
+    super(name ?? lite.name ?? "Sound", engine, outBus);
+    /** @internal The backing Lite static sound. */
+    __publicField(this, "_lite");
+    __publicField(this, "_autoplay");
+    __publicField(this, "_buffer");
+    this._lite = lite;
+    this._buffer = buffer;
+    this._autoplay = autoplay;
+    this._volume = volume;
+    lite.onEnded.add(() => this.onEndedObservable.notifyObservers(this));
+  }
+  /** The decoded buffer this sound plays. */
+  get buffer() {
+    return this._buffer;
+  }
+  get activeInstancesCount() {
+    return this._lite.instanceCount;
+  }
+  get autoplay() {
+    return this._autoplay;
+  }
+  get state() {
+    return this._lite.state;
+  }
+  get loop() {
+    return this._lite._options.loop;
+  }
+  set loop(value) {
+    this._lite._options.loop = value;
+  }
+  get startOffset() {
+    return this._lite._options.startOffset;
+  }
+  set startOffset(value) {
+    this._lite._options.startOffset = value;
+  }
+  get maxInstances() {
+    return this._lite._options.maxInstances;
+  }
+  set maxInstances(value) {
+    this._lite._options.maxInstances = value;
+  }
+  get duration() {
+    return this._lite._options.duration;
+  }
+  set duration(value) {
+    this._lite._options.duration = value;
+  }
+  get loopStart() {
+    return this._lite._options.loopStart;
+  }
+  set loopStart(value) {
+    this._lite._options.loopStart = value;
+  }
+  get loopEnd() {
+    return this._lite._options.loopEnd;
+  }
+  set loopEnd(value) {
+    this._lite._options.loopEnd = value;
+  }
+  get pitch() {
+    return this._lite._options.pitch;
+  }
+  set pitch(value) {
+    this._lite._options.pitch = value;
+    for (const instance of this._lite._instances) {
+      if (instance._sourceNode) {
+        instance._sourceNode.detune.value = value;
+      }
+    }
+  }
+  get playbackRate() {
+    return this._lite._options.playbackRate;
+  }
+  set playbackRate(value) {
+    this._lite._options.playbackRate = value;
+    for (const instance of this._lite._instances) {
+      if (instance._sourceNode) {
+        instance._sourceNode.playbackRate.value = value;
+      }
+    }
+  }
+  get currentTime() {
+    return this.startOffset;
+  }
+  set currentTime(value) {
+    this.startOffset = value;
+  }
+  play(options) {
+    playSound(this._lite, options);
+  }
+  pause() {
+    pauseSound(this._lite);
+  }
+  resume(options) {
+    resumeSound(this._lite, options);
+  }
+  stop(options) {
+    stopSound(this._lite, options);
+  }
+  /** Clones the sound (shares the decoded buffer). */
+  async cloneAsync(options) {
+    const outBus = (options == null ? void 0 : options.outBus) ?? this._outBus ?? void 0;
+    return this.engine.createSoundAsync(this.name, this._buffer, { outBus });
+  }
+  getClassName() {
+    return "StaticSound";
+  }
+  dispose() {
+    disposeSound(this._lite);
+    super.dispose();
+  }
+  _applyVolume(value, options) {
+    setSoundVolume(this._lite, value, toLiteRamp(options));
+  }
+  _spatialHost() {
+    return this._lite;
+  }
+}
+class StreamingSound extends AbstractSound {
+  /** @internal */
+  constructor(engine, lite, outBus, options, name) {
+    super(name ?? lite.name ?? "Sound", engine, outBus);
+    /** @internal The backing Lite streaming sound. */
+    __publicField(this, "_lite");
+    __publicField(this, "_autoplay");
+    __publicField(this, "_loop");
+    __publicField(this, "_startOffset");
+    __publicField(this, "_maxInstances");
+    this._lite = lite;
+    this._autoplay = options.autoplay ?? false;
+    this._loop = options.loop ?? false;
+    this._startOffset = options.startOffset ?? 0;
+    this._maxInstances = options.maxInstances ?? Infinity;
+    this._volume = options.volume ?? 1;
+    lite.onEnded.add(() => this.onEndedObservable.notifyObservers(this));
+  }
+  /** Number of instances configured to preload. */
+  get preloadCount() {
+    return this._lite._options.preloadCount;
+  }
+  /** Number of instances that have finished preloading. */
+  get preloadCompletedCount() {
+    return this._lite.preloadCompletedCount;
+  }
+  get activeInstancesCount() {
+    return this._lite.instanceCount;
+  }
+  get autoplay() {
+    return this._autoplay;
+  }
+  get state() {
+    return this._lite.state;
+  }
+  get loop() {
+    return this._loop;
+  }
+  set loop(value) {
+    this._loop = value;
+    this._lite._options.loop = value;
+  }
+  get startOffset() {
+    return this._startOffset;
+  }
+  set startOffset(value) {
+    this._startOffset = value;
+    this._lite._options.startOffset = value;
+  }
+  get maxInstances() {
+    return this._maxInstances;
+  }
+  set maxInstances(value) {
+    this._maxInstances = value;
+    this._lite._options.maxInstances = value;
+  }
+  get currentTime() {
+    return this._startOffset;
+  }
+  set currentTime(value) {
+    this.startOffset = value;
+  }
+  play(options) {
+    playStreamingSound(this._lite, options);
+  }
+  pause() {
+    pauseStreamingSound(this._lite);
+  }
+  resume(options) {
+    resumeStreamingSound(this._lite, options);
+  }
+  stop() {
+    stopStreamingSound(this._lite);
+  }
+  /** Preloads a single instance. */
+  preloadInstanceAsync() {
+    return preloadStreamingInstanceAsync(this._lite);
+  }
+  /** Preloads `count` instances. */
+  preloadInstancesAsync(count) {
+    return preloadStreamingInstancesAsync(this._lite, count);
+  }
+  getClassName() {
+    return "StreamingSound";
+  }
+  dispose() {
+    disposeStreamingSound(this._lite);
+    super.dispose();
+  }
+  _applyVolume(value, options) {
+    setStreamingSoundVolume(this._lite, value, toLiteRamp(options));
+  }
+  _spatialHost() {
+    return this._lite;
+  }
+}
+const FormatMimeTypes = {
+  aac: "audio/aac",
+  ac3: "audio/ac3",
+  flac: "audio/flac",
+  m4a: "audio/mp4",
+  mp3: 'audio/mpeg; codecs="mp3"',
+  mp4: "audio/mp4",
+  ogg: 'audio/ogg; codecs="vorbis"',
+  wav: "audio/wav",
+  webm: 'audio/webm; codecs="vorbis"'
+};
+function unwrapBus(bus) {
+  if (!bus) {
+    return void 0;
+  }
+  return bus._lite;
+}
+function liteBusInputNode(bus) {
+  return "_graph" in bus ? bus._graph._in : bus._in;
+}
+function rerouteLiteOutBus(host, newOutBus) {
+  const out = host._graph._out;
+  const oldOutBus = host._outBus;
+  if (oldOutBus) {
+    try {
+      out.disconnect(liteBusInputNode(oldOutBus));
+    } catch {
+    }
+  }
+  if (newOutBus) {
+    out.connect(liteBusInputNode(newOutBus));
+  }
+  host._outBus = newOutBus;
+}
+function unwrapBufferSource(source) {
+  if (source instanceof StaticSoundBuffer) {
+    return source._lite;
+  }
+  return source;
+}
+const _AudioEngineV2 = class _AudioEngineV2 {
+  /** @internal */
+  constructor(lite) {
+    /** Fires when a named node is added to the engine. */
+    __publicField(this, "onNodeAddedObservable", new Observable());
+    /** Fires when a named node is removed from the engine. */
+    __publicField(this, "onNodeRemovedObservable", new Observable());
+    /** Fires when the engine is disposed. */
+    __publicField(this, "onDisposeObservable", new Observable());
+    /** @internal The backing Lite audio engine. */
+    __publicField(this, "_lite");
+    __publicField(this, "_sounds", /* @__PURE__ */ new Set());
+    __publicField(this, "_nodes", /* @__PURE__ */ new Set());
+    __publicField(this, "_defaultMainBus", null);
+    __publicField(this, "_listener", null);
+    __publicField(this, "_mainOut", null);
+    this._lite = lite;
+    _AudioEngineV2._Instances.push(this);
+  }
+  /** All live audio engines. */
+  static get Instances() {
+    return _AudioEngineV2._Instances;
+  }
+  /** The audio context's current time, seconds. */
+  get currentTime() {
+    return this._lite.currentTime;
+  }
+  /** The context state. */
+  get state() {
+    return this._lite.state;
+  }
+  /** Master output volume. */
+  get volume() {
+    return getMasterVolume(this._lite);
+  }
+  set volume(value) {
+    setMasterVolume(this._lite, value);
+  }
+  /** Default parameter ramp duration, seconds. */
+  get parameterRampDuration() {
+    return this._lite._rampDuration;
+  }
+  set parameterRampDuration(value) {
+    this._lite._rampDuration = value;
+  }
+  /** The default main bus all sounds route to. */
+  get defaultMainBus() {
+    return this._defaultMainBus ?? (this._defaultMainBus = new MainAudioBus(this, this._lite._mainBus));
+  }
+  /** The spatial-audio listener (the "ears"). */
+  get listener() {
+    return this._listener ?? (this._listener = new AbstractSpatialAudioListener(this._lite));
+  }
+  /** The engine output node. */
+  get mainOut() {
+    return this._mainOut ?? (this._mainOut = new MainOutNode(this));
+  }
+  /** All live sounds. */
+  get sounds() {
+    return Array.from(this._sounds);
+  }
+  /** All live named nodes. */
+  get nodes() {
+    return this._nodes;
+  }
+  /** Sets the master volume, optionally ramping. */
+  setVolume(value, options) {
+    setMasterVolume(this._lite, value, toLiteRamp(options));
+  }
+  /** Whether the given audio format/extension can be decoded. */
+  isFormatValid(format) {
+    const mimeType = FormatMimeTypes[format.toLowerCase()];
+    if (mimeType === void 0) {
+      return false;
+    }
+    if (typeof Audio === "undefined") {
+      return true;
+    }
+    return new Audio().canPlayType(mimeType) !== "";
+  }
+  /** Suspends the engine context. */
+  async pauseAsync() {
+    const ctx = this._lite._ctx;
+    if (typeof ctx.suspend === "function" && ctx.state === "running") {
+      await ctx.suspend();
+    }
+  }
+  /** Resumes the engine context. */
+  async resumeAsync() {
+    await unlockAudioEngineAsync(this._lite);
+  }
+  /** Resumes the engine context (alias of {@link resumeAsync}). */
+  async unlockAsync() {
+    await unlockAudioEngineAsync(this._lite);
+  }
+  /** Creates a buffer-backed sound. */
+  async createSoundAsync(name, source, options) {
+    const liteOptions = toLiteStaticSoundOptions(name, options);
+    const lite = await createSoundAsync(this._lite, unwrapBufferSource(source), liteOptions);
+    const buffer = new StaticSoundBuffer(this, lite.buffer, name);
+    return new StaticSound(this, lite, buffer, (options == null ? void 0 : options.outBus) ?? this.defaultMainBus, (options == null ? void 0 : options.autoplay) ?? false, name, (options == null ? void 0 : options.volume) ?? 1);
+  }
+  /** Creates a decoded sound buffer. */
+  async createSoundBufferAsync(source, options) {
+    const lite = await createSoundBufferAsync(this._lite, unwrapBufferSource(source), { skipCodecCheck: options == null ? void 0 : options.skipCodecCheck });
+    return new StaticSoundBuffer(this, lite);
+  }
+  /** Creates a streaming, media-element-backed sound. */
+  async createStreamingSoundAsync(name, source, options) {
+    const liteOptions = {
+      autoplay: options == null ? void 0 : options.autoplay,
+      loop: options == null ? void 0 : options.loop,
+      maxInstances: options == null ? void 0 : options.maxInstances,
+      outBus: unwrapBus(options == null ? void 0 : options.outBus),
+      preloadCount: options == null ? void 0 : options.preloadCount,
+      startOffset: options == null ? void 0 : options.startOffset,
+      volume: options == null ? void 0 : options.volume
+    };
+    const lite = await createStreamingSoundAsync(this._lite, source, liteOptions);
+    return new StreamingSound(this, lite, (options == null ? void 0 : options.outBus) ?? this.defaultMainBus, options ?? {}, name);
+  }
+  /** Creates a generic mixer bus. */
+  async createBusAsync(name, options) {
+    const lite = await createAudioBusAsync(this._lite, name, {
+      volume: options == null ? void 0 : options.volume,
+      outBus: unwrapBus(options == null ? void 0 : options.outBus)
+    });
+    return new AudioBus(this, lite, (options == null ? void 0 : options.outBus) ?? this.defaultMainBus, (options == null ? void 0 : options.volume) ?? 1);
+  }
+  /**
+   * 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.
+   */
+  async createMainBusAsync(_name, _options) {
+    return this.defaultMainBus;
+  }
+  /** Wraps an arbitrary Web Audio node as a sound source. */
+  async createSoundSourceAsync(name, source, options) {
+    const lite = await createSoundSourceAsync(this._lite, source, {
+      name,
+      outBus: unwrapBus(options == null ? void 0 : options.outBus),
+      outBusAutoDefault: options == null ? void 0 : options.outBusAutoDefault,
+      volume: options == null ? void 0 : options.volume
+    });
+    return new SoundSource(this, lite, (options == null ? void 0 : options.outBus) ?? null, (options == null ? void 0 : options.volume) ?? 1);
+  }
+  /** Creates a microphone-backed sound source. */
+  async createMicrophoneSoundSourceAsync(name, options) {
+    const lite = await createMicrophoneSoundSourceAsync(this._lite, {
+      name,
+      outBus: unwrapBus(options == null ? void 0 : options.outBus),
+      outBusAutoDefault: options == null ? void 0 : options.outBusAutoDefault,
+      volume: options == null ? void 0 : options.volume
+    });
+    return new SoundSource(this, lite, (options == null ? void 0 : options.outBus) ?? null, (options == null ? void 0 : options.volume) ?? 1);
+  }
+  /** Disposes the engine and all its sounds/buses. */
+  dispose() {
+    disposeAudioEngine(this._lite);
+    this.onDisposeObservable.notifyObservers(this);
+    this.onDisposeObservable.clear();
+    this.onNodeAddedObservable.clear();
+    this.onNodeRemovedObservable.clear();
+    this._sounds.clear();
+    this._nodes.clear();
+    const i2 = _AudioEngineV2._Instances.indexOf(this);
+    if (i2 !== -1) {
+      _AudioEngineV2._Instances.splice(i2, 1);
+    }
+    if (LastCreatedEngine === this) {
+      LastCreatedEngine = null;
+    }
+  }
+  /** @internal */
+  _addSound(sound) {
+    this._sounds.add(sound);
+  }
+  /** @internal */
+  _removeSound(sound) {
+    this._sounds.delete(sound);
+  }
+  /** @internal */
+  _addNode(node) {
+    this._nodes.add(node);
+    this.onNodeAddedObservable.notifyObservers(node);
+  }
+  /** @internal */
+  _removeNode(node) {
+    if (this._nodes.delete(node)) {
+      this.onNodeRemovedObservable.notifyObservers(node);
+    }
+  }
+};
+__publicField(_AudioEngineV2, "_Instances", []);
+let AudioEngineV2 = _AudioEngineV2;
+class MainOutNode extends AbstractAudioNode {
+  constructor(engine) {
+    super(engine);
+  }
+  getClassName() {
+    return "_MainAudioOut";
+  }
+}
+function toLiteStaticSoundOptions(_name, options) {
+  return {
+    autoplay: options == null ? void 0 : options.autoplay,
+    duration: options == null ? void 0 : options.duration,
+    loop: options == null ? void 0 : options.loop,
+    loopEnd: options == null ? void 0 : options.loopEnd,
+    loopStart: options == null ? void 0 : options.loopStart,
+    maxInstances: options == null ? void 0 : options.maxInstances,
+    outBus: unwrapBus(options == null ? void 0 : options.outBus),
+    pitch: options == null ? void 0 : options.pitch,
+    playbackRate: options == null ? void 0 : options.playbackRate,
+    startOffset: options == null ? void 0 : options.startOffset,
+    volume: options == null ? void 0 : options.volume,
+    skipCodecCheck: options == null ? void 0 : options.skipCodecCheck
+  };
+}
+function toLiteEngineOptions(options) {
+  return {
+    audioContext: options == null ? void 0 : options.audioContext,
+    volume: options == null ? void 0 : options.volume,
+    parameterRampDuration: options == null ? void 0 : options.parameterRampDuration,
+    resumeOnInteraction: options == null ? void 0 : options.resumeOnInteraction,
+    resumeOnPause: options == null ? void 0 : options.resumeOnPause,
+    resumeOnPauseRetryInterval: options == null ? void 0 : options.resumeOnPauseRetryInterval
+  };
+}
+let LastCreatedEngine = null;
+const OnAudioEngineV2CreatedObservable = new Observable();
+function LastCreatedAudioEngine() {
+  return LastCreatedEngine;
+}
+function resolveEngine(engine) {
+  const resolved = engine ?? LastCreatedEngine;
+  if (!resolved) {
+    return unsupported("AudioV2 factory", "No audio engine available. Call CreateAudioEngineAsync(...) first or pass an engine.");
+  }
+  return resolved;
+}
+async function CreateAudioEngineAsync(options) {
+  const lite = await createAudioEngineAsync(toLiteEngineOptions(options));
+  const engine = new AudioEngineV2(lite);
+  LastCreatedEngine = engine;
+  OnAudioEngineV2CreatedObservable.notifyObservers(engine);
+  return engine;
+}
+function CreateSoundAsync(name, source, options, engine) {
+  return resolveEngine(engine).createSoundAsync(name, source, options);
+}
+function CreateSoundBufferAsync(source, options, engine) {
+  return resolveEngine(engine).createSoundBufferAsync(source, options);
+}
+function CreateStreamingSoundAsync(name, source, options, engine) {
+  return resolveEngine(engine).createStreamingSoundAsync(name, source, options);
+}
+function CreateAudioBusAsync(name, options, engine) {
+  return resolveEngine(engine).createBusAsync(name, options);
+}
+function CreateMainAudioBusAsync(name, options, engine) {
+  return resolveEngine(engine).createMainBusAsync(name, options);
+}
+function CreateSoundSourceAsync(name, source, options, engine) {
+  return resolveEngine(engine).createSoundSourceAsync(name, source, options);
+}
+function CreateMicrophoneSoundSourceAsync(name, options, engine) {
+  return resolveEngine(engine).createMicrophoneSoundSourceAsync(name, options);
+}
 class MultiMaterial {
   constructor() {
     unsupported("MultiMaterial", "Babylon Lite uses one material per renderable. Split the mesh geometry by material into separate meshes instead.");
@@ -5962,9 +7099,19 @@ class SceneOptimizer {
 }
 export {
   AbstractAssetTask,
+  AbstractAudioAnalyzer,
+  AbstractAudioBus,
+  AbstractAudioNode,
+  AbstractAudioOutNode,
   AbstractEngine,
   A as AbstractMesh,
+  AbstractNamedAudioNode,
   AbstractScene,
+  AbstractSound,
+  AbstractSoundSource,
+  AbstractSpatialAudio,
+  AbstractSpatialAudioListener,
+  AbstractStereoAudio,
   Action,
   ActionManager,
   ActionManagerTriggers,
@@ -5981,7 +7128,10 @@ export {
   ArcRotateCamera,
   AssetContainer,
   AssetsManager,
+  AudioBus,
   AudioEngine,
+  AudioEngineV2,
+  AudioParameterRampShape,
   AutoRotationBehavior,
   Axis,
   AxisDragGizmo,
@@ -6015,12 +7165,20 @@ export {
   ColorGradient,
   Condition,
   Constants,
+  CreateAudioBusAsync,
+  CreateAudioEngineAsync,
   C as CreateBox,
   b as CreateCylinder,
   c as CreateDisc,
   d as CreateGround,
+  CreateMainAudioBusAsync,
+  CreateMicrophoneSoundSourceAsync,
   e as CreatePlane,
+  CreateSoundAsync,
+  CreateSoundBufferAsync,
+  CreateSoundSourceAsync,
   f as CreateSphere,
+  CreateStreamingSoundAsync,
   g as CreateTorus,
   CubeTexture,
   CubicEase,
@@ -6072,6 +7230,7 @@ export {
   InitializeCSG2Async,
   I as InstancedMesh,
   KHR_materials_variants,
+  LastCreatedAudioEngine,
   Layer,
   Light,
   LightGizmo,
@@ -6079,6 +7238,7 @@ export {
   LiteCompatError,
   LoadAssetContainerAsync,
   Logger,
+  MainAudioBus,
   Material,
   Matrix,
   Mesh,
@@ -6093,6 +7253,7 @@ export {
   NullEngine,
   OBJFileLoader,
   Observable,
+  OnAudioEngineV2CreatedObservable,
   OutlineRenderer,
   PBRAnisotropicConfiguration,
   PBRClearCoatConfiguration,
@@ -6121,7 +7282,7 @@ export {
   PushMaterial,
   QuadraticEase,
   QuarticEase,
-  Q as Quaternion,
+  Quaternion,
   QuinticEase,
   RawTexture,
   Ray,
@@ -6149,7 +7310,10 @@ export {
   SmartArray,
   SolidParticleSystem,
   Sound,
+  SoundSource,
+  SoundState,
   Space,
+  SpatialAudioAttachmentType,
   SpotLight,
   Sprite,
   SpriteManager,
@@ -6157,6 +7321,9 @@ export {
   SpritePackedManager,
   SpriteRenderer,
   StandardMaterial,
+  StaticSound,
+  StaticSoundBuffer,
+  StreamingSound,
   StringDictionary,
   Tags,
   TargetCamera,