@babylonjs/inspector 8.53.0 → 8.53.1

package/lib/index.d.ts

@@ -1,9 +1,9 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { ComponentType, ComponentProps, FunctionComponent, PropsWithChildren, ForwardRefExoticComponent, RefAttributes, MouseEventHandler, HTMLProps, Ref, Component, ReactNode, ErrorInfo, DependencyList, Dispatch, SetStateAction, MouseEvent, ElementRef, ReactElement } from 'react';
+import { ComponentType, ComponentProps, ForwardRefExoticComponent, RefAttributes, FunctionComponent, PropsWithChildren, MouseEventHandler, HTMLProps, Ref, Component, ReactNode, ErrorInfo, DependencyList, Dispatch, SetStateAction, MouseEvent, ElementRef, ReactElement } from 'react';
 import { Nullable as Nullable$2 } from '@babylonjs/core/types.js';
 import { IDisposable as IDisposable$1, Nullable as Nullable$1, Scene as Scene$1, IReadonlyObservable as IReadonlyObservable$1, Observable as Observable$1, Camera as Camera$1, Light as Light$1, IInspectorOptions as IInspectorOptions$1 } from '@babylonjs/core/index.js';
-import { FluentProviderProps, PositioningImperativeRef, OnOpenChangeData, Theme as Theme$1, SpinnerProps, PositioningShorthand } from '@fluentui/react-components';
+import { FluentProviderProps, OnOpenChangeData, PositioningImperativeRef, Theme as Theme$1, SpinnerProps, PositioningShorthand } from '@fluentui/react-components';
 import { Color3 as Color3$1, Color4 as Color4$1 } from '@babylonjs/core/Maths/math.color.js';
 import { Vector3 as Vector3$1, Quaternion as Quaternion$1 } from '@babylonjs/core/Maths/math.vector.js';
 import * as _fluentui_tokens from '@fluentui/tokens';
@@ -347,6 +347,9 @@ type ServiceDefinition<Produces extends IService<symbol>[] = [], Consumes extend
     consumes: ExtractContractIdentities<Consumes>;
 });
 
+/**
+ * Describes a section within a dynamic accordion that can be added at runtime.
+ */
 type DynamicAccordionSection = Readonly<{
     /**
      * A unique identity for the section, which can be referenced by section content.
@@ -363,6 +366,9 @@ type DynamicAccordionSection = Readonly<{
      */
     collapseByDefault?: boolean;
 }>;
+/**
+ * Describes content that belongs to a section within a dynamic accordion.
+ */
 type DynamicAccordionSectionContent<ContextT> = Readonly<{
     /**
      * A unique key for the the content.
@@ -384,9 +390,22 @@ type DynamicAccordionSectionContent<ContextT> = Readonly<{
         context: ContextT;
     }>;
 }>;
+/**
+ * Imperative handle for controlling section highlights on the extensible accordion.
+ */
 type SectionsImperativeRef = {
+    /**
+     * Highlights the specified sections, collapsing all others until the context changes.
+     * @param sections The identity strings of the sections to highlight.
+     */
     highlightSections: (sections: readonly string[]) => void;
 };
+/**
+ * An accordion component that supports dynamically adding sections and section content at runtime.
+ * Combines statically defined children sections with dynamically registered sections and content.
+ * @param props The accordion props including sections, section content, context, and an optional imperative ref.
+ * @returns The extensible accordion component.
+ */
 declare function ExtensibleAccordion<ContextT = unknown>(props: PropsWithChildren<{
     sections: readonly DynamicAccordionSection[];
     sectionContent: readonly DynamicAccordionSectionContent<ContextT>[];
@@ -394,6 +413,9 @@ declare function ExtensibleAccordion<ContextT = unknown>(props: PropsWithChildre
     sectionsRef?: Ref<SectionsImperativeRef>;
 } & AccordionProps>): react_jsx_runtime.JSX.Element;
 
+/**
+ * The unique identity symbol for the scene context service.
+ */
 declare const SceneContextIdentity: unique symbol;
 /**
  * SceneContext provides the current scene, but could have different implementations depending on the context (e.g. inspector, sandbox, etc.)
@@ -409,26 +431,67 @@ interface ISceneContext extends IService<typeof SceneContextIdentity> {
     readonly currentSceneObservable: IReadonlyObservable$1<Nullable$1<Scene$1>>;
 }
 
+/**
+ * The unique identity symbol for the settings store service.
+ */
 declare const SettingsStoreIdentity: unique symbol;
+/**
+ * Describes a setting by its key and default value.
+ */
 type SettingDescriptor<T> = {
+    /**
+     * The unique key used to identify this setting in the store.
+     */
     readonly key: string;
+    /**
+     * The default value to use when the setting has not been explicitly set.
+     */
     readonly defaultValue: T;
 };
+/**
+ * Provides a key-value store for persisting user settings.
+ */
 interface ISettingsStore extends IService<typeof SettingsStoreIdentity> {
+    /**
+     * An observable that notifies when a setting has changed, providing the key of the changed setting.
+     */
     onChanged: IReadonlyObservable$1<string>;
+    /**
+     * Reads a setting from the store.
+     * @param descriptor The descriptor of the setting to read.
+     * @returns The current value of the setting, or the default value if it has not been set.
+     */
     readSetting<T>(descriptor: SettingDescriptor<T>): T;
+    /**
+     * Writes a setting to the store.
+     * @param descriptor The descriptor of the setting to write.
+     * @param value The value to write.
+     */
     writeSetting<T>(descriptor: SettingDescriptor<T>, value: T): void;
 }
+/**
+ * Default implementation of {@link ISettingsStore} that persists settings using browser local storage.
+ */
 declare class SettingsStore implements ISettingsStore {
     private readonly _namespace;
     private readonly _onChanged;
+    /**
+     * Creates a new settings store.
+     * @param _namespace A namespace used to scope the settings keys to avoid collisions with other stores.
+     */
     constructor(_namespace: string);
     get onChanged(): IReadonlyObservable$1<Readonly<string>>;
     readSetting<T>(descriptor: SettingDescriptor<T>): T;
     writeSetting<T>(descriptor: SettingDescriptor<T>, value: T): void;
 }
 
+/**
+ * Represents a horizontal location in the shell layout.
+ */
 type HorizontalLocation = "left" | "right";
+/**
+ * Represents a vertical location in the shell layout.
+ */
 type VerticalLocation = "top" | "bottom";
 type TeachingMomentInfo = boolean | {
     readonly title: string;
@@ -553,6 +616,9 @@ type CentralContentDefinition = {
      */
     order?: number;
 };
+/**
+ * The unique identity symbol for the shell service.
+ */
 declare const ShellServiceIdentity: unique symbol;
 /**
  * Provides a shell for the application, including toolbars, side panes, and central content.
@@ -634,6 +700,9 @@ type ShellServiceOptions = {
     }>;
 };
 
+/**
+ * The unique identity symbol for the settings service.
+ */
 declare const SettingsServiceIdentity: unique symbol;
 /**
  * Allows new sections or content to be added to the Settings pane.
@@ -651,6 +720,9 @@ interface ISettingsService extends IService<typeof SettingsServiceIdentity> {
     addSectionContent(content: DynamicAccordionSectionContent<Scene$1>): IDisposable$1;
 }
 
+/**
+ * The unique identity symbol for the selection service.
+ */
 declare const SelectionServiceIdentity: unique symbol;
 /**
  * Tracks the currently selected entity.
@@ -665,7 +737,7 @@ interface ISelectionService extends IService<typeof SelectionServiceIdentity> {
      */
     readonly onSelectedEntityChanged: IReadonlyObservable$1<void>;
 }
-declare const SelectionServiceDefinition: ServiceDefinition<[ISelectionService], [IShellService, ISettingsStore, ISettingsService]>;
+declare const SelectionServiceDefinition: ServiceDefinition<[ISelectionService], [IShellService, ISettingsStore, ISettingsService, ISceneContext]>;
 
 /** Props for the LinkToEntity component */
 type LinkToEntityProps = {
@@ -691,6 +763,9 @@ declare const LinkToEntity: FunctionComponent<LinkToEntityProps>;
  */
 declare const LinkToEntityPropertyLine: FunctionComponent<PropertyLineProps<string> & LinkToEntityProps>;
 
+/**
+ * Information about how to display an entity in the Scene Explorer tree.
+ */
 type EntityDisplayInfo = Partial<IDisposable$1> & Readonly<{
     /**
      * The name of the entity to display in the Scene Explorer tree.
@@ -725,6 +800,9 @@ type SceneExplorerDragDropConfig<T> = Readonly<{
      */
     onDrop: (draggedEntity: T, targetEntity: T | null) => void;
 }>;
+/**
+ * Describes a section in the Scene Explorer (e.g. "Nodes", "Materials", etc.).
+ */
 type SceneExplorerSection<T extends object> = Readonly<{
     /**
      * The display name of the section (e.g. "Nodes", "Materials", etc.).
@@ -795,6 +873,9 @@ type ContextMenuCommand = {
 };
 type CommandMode = NonNullable<(InlineCommand | ContextMenuCommand)["mode"]>;
 type CommandType = (ActionCommand | ToggleCommand)["type"];
+/**
+ * Describes a command that can be executed on entities or sections in the Scene Explorer.
+ */
 type SceneExplorerCommand<ModeT extends CommandMode = CommandMode, TypeT extends CommandType = CommandType> = Partial<IDisposable$1> & Readonly<{
     /**
      * The display name of the command (e.g. "Delete", "Rename", etc.).
@@ -815,6 +896,9 @@ type SceneExplorerCommand<ModeT extends CommandMode = CommandMode, TypeT extends
      */
     onChange?: IReadonlyObservable$1<unknown>;
 }> & (ModeT extends "inline" ? InlineCommand : ContextMenuCommand) & (TypeT extends "action" ? ActionCommand : ToggleCommand);
+/**
+ * Provides a command for a specific entity or section context in the Scene Explorer.
+ */
 type SceneExplorerCommandProvider<ContextT, ModeT extends CommandMode = CommandMode, TypeT extends CommandType = CommandType> = Readonly<{
     /**
      * An optional order for the section, relative to other commands.
@@ -851,6 +935,9 @@ declare const ToggleCommand: FunctionComponent<{
     command: SceneExplorerCommand<"inline", "toggle">;
 }>;
 
+/**
+ * Props for the {@link ErrorBoundary} component.
+ */
 type ErrorBoundaryProps = {
     /** Child components to render */
     children: ReactNode;
@@ -883,6 +970,11 @@ declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryS
  */
 declare const SidePaneContainer: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
 
+/**
+ * A themed Fluent UI provider that applies the current theme mode (light or dark).
+ * @param props Fluent provider props, plus an optional `invert` flag to swap the theme.
+ * @returns The themed Fluent UI provider component.
+ */
 declare const Theme: FunctionComponent<FluentProviderProps & {
     invert?: boolean;
 }>;
@@ -920,7 +1012,13 @@ declare function MakePopoverTeachingMoment(name: string): (suppress?: boolean) =
     readonly reset: () => void;
 };
 
+/**
+ * The state returned by the teaching moment hook.
+ */
 type TeachingMomentState = ReturnType<ReturnType<typeof MakePopoverTeachingMoment>>;
+/**
+ * Props for the {@link TeachingMoment} component.
+ */
 type TeachingMomentProps = Pick<TeachingMomentState, "shouldDisplay" | "positioningRef" | "onOpenChange"> & {
     title: string;
     description: string;
@@ -932,16 +1030,34 @@ type TeachingMomentProps = Pick<TeachingMomentState, "shouldDisplay" | "position
  */
 declare const TeachingMoment: FunctionComponent<TeachingMomentProps>;
 
+/**
+ * Describes a property change event, including the entity, the property key, and the old and new values.
+ */
 type PropertyChangeInfo = {
+    /** The entity whose property was changed. */
     readonly entity: unknown;
+    /** The key of the property that was changed. */
     readonly propertyKey: PropertyKey;
+    /** The value of the property before the change. */
     readonly oldValue: unknown;
+    /** The value of the property after the change. */
     readonly newValue: unknown;
 };
+/**
+ * Context that provides an observable for property change notifications within the inspector.
+ */
 type PropertyContext = {
+    /** An observable that fires whenever a property is changed through the inspector UI. */
     readonly onPropertyChanged: Observable$1<PropertyChangeInfo>;
 };
+/**
+ * React context for accessing the property change observable.
+ */
 declare const PropertyContext: react.Context<PropertyContext | undefined>;
+/**
+ * Hook that returns a callback to notify the property context when a property has been changed.
+ * @returns A function that accepts (entity, propertyKey, oldValue, newValue) and notifies observers.
+ */
 declare function usePropertyChangedNotifier(): <ObjectT, PropertyT extends keyof ObjectT>(entity: ObjectT, propertyKey: PropertyT, oldValue: ObjectT[PropertyT], newValue: ObjectT[PropertyT]) => void;
 
 type WeaklyTypedServiceDefinition = Omit<ServiceDefinition<IService<symbol>[] | [], IService<symbol>[] | []>, "factory"> & {
@@ -1195,6 +1311,11 @@ declare function useResource<T extends IDisposable$1 | null | undefined>(factory
  */
 declare function useAsyncResource<T extends IDisposable$1 | null | undefined>(factory: (abortSignal: AbortSignal) => Promise<T>, deps?: DependencyList): T | undefined;
 
+/**
+ * Hook that reads and writes a setting from the settings store.
+ * @param descriptor The setting descriptor that identifies the setting and its default value.
+ * @returns A tuple of [currentValue, setValue, resetValue] similar to React's useState.
+ */
 declare function useSetting<T>(descriptor: SettingDescriptor<T>): [T, Dispatch<SetStateAction<T>>, () => void];
 /**
  * Gets functions used to convert to/from display values for angles based on the current settings.
@@ -1202,7 +1323,13 @@ declare function useSetting<T>(descriptor: SettingDescriptor<T>): [T, Dispatch<S
  */
 declare function useAngleConverters(): readonly [(angle: number, wrap?: boolean) => number, (angle: number, wrap?: boolean) => number, boolean];
 
+/**
+ * Represents the theme mode preference.
+ */
 type ThemeMode = "system" | "light" | "dark";
+/**
+ * The unique identity symbol for the theme service.
+ */
 declare const ThemeServiceIdentity: unique symbol;
 /**
  * Exposes the current theme used by the application.
@@ -1230,14 +1357,26 @@ interface IThemeService extends IService<typeof ThemeServiceIdentity> {
     readonly onChanged: IReadonlyObservable$1<void>;
 }
 
+/**
+ * Hook that provides the current theme mode state and controls for changing it.
+ * @returns An object with the current dark mode state, theme mode, and functions to set or toggle the theme.
+ */
 declare function useThemeMode(): {
     readonly isDarkMode: boolean;
     readonly themeMode: ThemeMode;
     readonly setThemeMode: (mode: ThemeMode) => void;
     readonly toggleThemeMode: () => void | undefined;
 };
+/**
+ * Hook that returns the current Fluent UI theme based on the active theme mode.
+ * @param invert If true, inverts the theme (returns light theme in dark mode and vice versa). Defaults to false.
+ * @returns The current Fluent UI theme object.
+ */
 declare function useTheme(invert?: boolean): _fluentui_tokens.Theme;
 
+/**
+ * Hooks that can be registered on a function to intercept its execution.
+ */
 type FunctionHooks<Args extends unknown[] = unknown[]> = {
     /**
      * This function will be called after the hooked function is called.
@@ -1268,6 +1407,9 @@ declare function GetPropertyDescriptor<T extends object>(target: T, propertyKey:
  * @returns True if the property is readonly, false otherwise.
  */
 declare function IsPropertyReadonly(propertyDescriptor: PropertyDescriptor): boolean;
+/**
+ * Hooks that can be registered on a property to intercept its setter.
+ */
 type PropertyHooks<T = unknown> = {
     /**
      * This function will be called after the hooked property is set.
@@ -1285,6 +1427,9 @@ type PropertyHooks<T = unknown> = {
 declare function InterceptProperty<T extends object, K extends keyof T>(target: T, propertyKey: string extends K ? never : number extends K ? never : symbol extends K ? never : K, hooks: PropertyHooks<NonNullable<T[K]>>): IDisposable$1;
 declare function InterceptProperty<T extends object>(target: T, propertyKey: keyof T, hooks: PropertyHooks): IDisposable$1;
 
+/**
+ * The unique identity symbol for the properties service.
+ */
 declare const PropertiesServiceIdentity: unique symbol;
 type PropertiesSectionContent<EntityT> = {
     /**
@@ -1325,6 +1470,9 @@ interface IPropertiesService extends IService<typeof PropertiesServiceIdentity>
     readonly onPropertyChanged: IReadonlyObservable$1<PropertyChangeInfo>;
 }
 
+/**
+ * The unique identity symbol for the scene explorer service.
+ */
 declare const SceneExplorerServiceIdentity: unique symbol;
 /**
  * Allows new sections or commands to be added to the scene explorer pane.
@@ -1347,6 +1495,9 @@ interface ISceneExplorerService extends IService<typeof SceneExplorerServiceIden
     addSectionCommand<T extends string>(command: SceneExplorerCommandProvider<T, "contextMenu">): IDisposable$1;
 }
 
+/**
+ * The unique identity symbol for the debug service.
+ */
 declare const DebugServiceIdentity: unique symbol;
 /**
  * Allows new sections or content to be added to the debug pane.
@@ -1364,6 +1515,9 @@ interface IDebugService extends IService<typeof DebugServiceIdentity> {
     addSectionContent(content: DynamicAccordionSectionContent<Scene$1>): IDisposable$1;
 }
 
+/**
+ * The unique identity symbol for the stats service.
+ */
 declare const StatsServiceIdentity: unique symbol;
 /**
  * Allows new sections or content to be added to the stats pane.
@@ -1381,6 +1535,9 @@ interface IStatsService extends IService<typeof StatsServiceIdentity> {
     addSectionContent(content: DynamicAccordionSectionContent<Scene$1>): IDisposable$1;
 }
 
+/**
+ * The unique identity symbol for the tools service.
+ */
 declare const ToolsServiceIdentity: unique symbol;
 /**
  * A service that provides tools for the user to generate artifacts or perform actions on entities.
@@ -1398,29 +1555,107 @@ interface IToolsService extends IService<typeof ToolsServiceIdentity> {
     addSectionContent(content: DynamicAccordionSectionContent<Scene$2>): IDisposable$2;
 }
 
+/**
+ * The unique identity symbol for the watcher service.
+ */
 declare const WatcherServiceIdentity: unique symbol;
+/**
+ * Watches for property changes on objects, using either interception, polling, or manual refresh.
+ */
 interface IWatcherService extends IService<typeof WatcherServiceIdentity> {
+    /**
+     * Watches a property on an object and calls the callback whenever it changes.
+     * @param target The object containing the property to watch.
+     * @param propertyKey The key of the property to watch.
+     * @param onChanged A callback that is called with the new value when the property changes.
+     * @returns A disposable that stops watching when disposed.
+     */
     watchProperty<T extends object, K extends keyof T>(target: T, propertyKey: string extends K ? never : number extends K ? never : symbol extends K ? never : K, onChanged: (value: NonNullable<T[K]>) => void): IDisposable$1;
+    /**
+     * Watches a property on an object and calls the callback whenever it changes.
+     * @param target The object containing the property to watch.
+     * @param propertyKey The key of the property to watch.
+     * @param onChanged A callback that is called with the new value when the property changes.
+     * @returns A disposable that stops watching when disposed.
+     */
     watchProperty<T extends object>(target: T, propertyKey: keyof T, onChanged: (value: unknown) => void): IDisposable$1;
+    /**
+     * Manually triggers a refresh of all watched properties.
+     */
     refresh(): void;
 }
 
 type Reference<T> = {
     value: T;
 } & IDisposable$1;
+/**
+ * Represents the available gizmo manipulation modes.
+ */
 type GizmoMode = "translate" | "rotate" | "scale" | "boundingBox";
+/**
+ * The unique identity symbol for the gizmo service.
+ */
 declare const GizmoServiceIdentity: unique symbol;
+/**
+ * Manages gizmos for manipulating objects in the scene, including shared utility layers
+ * and camera/light gizmo lifecycle.
+ */
 interface IGizmoService extends IService<typeof GizmoServiceIdentity> {
+    /**
+     * Gets a ref-counted utility layer for the specified scene. The layer is shared across consumers
+     * and disposed when the last reference is released.
+     * @param scene The scene to get the utility layer for.
+     * @param layer An optional layer name to differentiate between multiple utility layers.
+     * @returns A ref-counted reference to the utility layer. Dispose to release.
+     */
     getUtilityLayer(scene: Scene$1, layer?: string): Reference<UtilityLayerRenderer$1>;
+    /**
+     * Gets a ref-counted camera gizmo for the specified camera.
+     * @param camera The camera to get the gizmo for.
+     * @returns A ref-counted reference to the camera gizmo. Dispose to release.
+     */
     getCameraGizmo(camera: Camera$1): Reference<CameraGizmo>;
+    /**
+     * Gets a ref-counted light gizmo for the specified light.
+     * @param light The light to get the gizmo for.
+     * @returns A ref-counted reference to the light gizmo. Dispose to release.
+     */
     getLightGizmo(light: Light$1): Reference<LightGizmo>;
+    /**
+     * Gets all camera gizmos currently active for the specified scene.
+     * @param scene The scene to get camera gizmos for.
+     * @returns A readonly array of camera gizmos.
+     */
     getCameraGizmos(scene: Scene$1): readonly CameraGizmo[];
+    /**
+     * Gets all light gizmos currently active for the specified scene.
+     * @param scene The scene to get light gizmos for.
+     * @returns A readonly array of light gizmos.
+     */
     getLightGizmos(scene: Scene$1): readonly LightGizmo[];
+    /**
+     * Gets or sets the current gizmo mode (translate, rotate, scale, or boundingBox), or undefined if no gizmo mode is active.
+     */
     gizmoMode: GizmoMode | undefined;
+    /**
+     * An observable that notifies when the gizmo mode changes.
+     */
     readonly onGizmoModeChanged: IReadonlyObservable$1<void>;
+    /**
+     * Gets or sets the coordinates mode for gizmos (local or world).
+     */
     coordinatesMode: GizmoCoordinatesMode;
+    /**
+     * An observable that notifies when the coordinates mode changes.
+     */
     readonly onCoordinatesModeChanged: IReadonlyObservable$1<void>;
+    /**
+     * Gets or sets the camera used by gizmos, or null to use the default scene camera.
+     */
     gizmoCamera: Camera$1 | null;
+    /**
+     * An observable that notifies when the gizmo camera changes.
+     */
     readonly onCameraGizmoChanged: IReadonlyObservable$1<void>;
 }
 
@@ -1452,14 +1687,42 @@ type ModularToolOptions = {
 } & ShellServiceOptions;
 
 type LayoutMode = "inline" | "overlay";
-type InspectorOptions = Omit<ModularToolOptions, "toolbarMode"> & {
+/**
+ * Options for configuring the inspector.
+ */
+type InspectorOptions = Omit<ModularToolOptions, "namespace" | "toolbarMode"> & {
+    /**
+     * Whether to automatically resize the engine when the inspector layout changes. Defaults to true.
+     */
     autoResizeEngine?: boolean;
+    /**
+     * The layout mode for the inspector.
+     * - "inline": The inspector is embedded within the same container as the rendering canvas, and re-hosts the canvas.
+     * - "overlay": The inspector is rendered as an overlay on top of the rendering canvas.
+     * Defaults to "overlay".
+     */
     layoutMode?: LayoutMode;
 };
+/**
+ * A token returned by {@link ShowInspector} that can be used to dispose the inspector
+ * and observe its disposal.
+ */
 type InspectorToken = IDisposable$1 & {
+    /**
+     * Whether the inspector has been disposed.
+     */
     readonly isDisposed: boolean;
+    /**
+     * An observable that fires when the inspector is disposed.
+     */
     readonly onDisposed: IReadonlyObservable$1<void>;
 };
+/**
+ * Shows the inspector for the specified scene.
+ * @param scene The scene to inspect.
+ * @param options Optional configuration for the inspector.
+ * @returns An {@link InspectorToken} that can be disposed to hide the inspector.
+ */
 declare function ShowInspector(scene: Scene$1, options?: Partial<InspectorOptions>): InspectorToken;
 
 type PropertyChangedEvent = {
@@ -8653,10 +8916,6 @@ declare class IntersectionInfo {
  * https://www.khronos.org/opengl/wiki/Uniform_Buffer_Object
  */
 declare class UniformBuffer {
-    /** @internal */
-    static _UpdatedUbosInFrame: {
-        [name: string]: number;
-    };
     private _engine;
     private _buffer;
     private _buffers;
@@ -24082,14 +24341,10 @@ declare abstract class ThinWebGPUEngine extends AbstractEngine {
     /** @internal */
     dbgSanityChecks: boolean;
     /** @internal */
-    dbgVerboseLogsNumFrames: number;
-    /** @internal */
     dbgLogIfNotDrawWrapper: boolean;
     /** @internal */
     dbgShowEmptyEnableEffectCalls: boolean;
     /** @internal */
-    dbgVerboseLogsForFirstFrames: boolean;
-    /** @internal */
     _textureHelper: WebGPUTextureManager;
     /** @internal */
     _cacheRenderPipeline: WebGPUCacheRenderPipeline;
@@ -24107,6 +24362,14 @@ declare abstract class ThinWebGPUEngine extends AbstractEngine {
     _timestampQuery: WebGPUTimestampQuery;
     /** @internal */
     _timestampIndex: number;
+    /** @internal */
+    _showGPUDebugMarkersLog: boolean;
+    /** @internal */
+    _debugStackRenderEncoder: string[];
+    /** @internal */
+    _debugStackRenderPass: string[];
+    /** @internal */
+    _debugNumPopPending: number;
     /**
      * Gets the GPU time spent in the main render pass for the last frame rendered (in nanoseconds).
      * You have to enable the "timestamp-query" extension in the engine constructor options and set engine.enableGPUTimingMeasurements = true.
@@ -24131,6 +24394,7 @@ declare abstract class ThinWebGPUEngine extends AbstractEngine {
      * @internal
      */
     _generateMipmaps(texture: InternalTexture, commandEncoder?: GPUCommandEncoder): void;
+    protected _debugPushPendingGroups(forRenderPass: boolean): void;
 }
 
 /** @internal */
@@ -25637,6 +25901,7 @@ declare class WebGPUEngine extends ThinWebGPUEngine {
     private _dummyIndexBuffer;
     private _colorWriteLocal;
     private _forceEnableEffect;
+    private _internalFrameCounter;
     /**
      * Gets or sets the snapshot rendering mode
      */
@@ -27286,7 +27551,7 @@ declare class RenderingGroup {
      * @param renderTransparentMeshes
      * @param customRenderTransparentSubMeshes
      */
-    render(customRenderFunction: Nullable<(opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>) => void>, renderSprites: boolean, renderParticles: boolean, activeMeshes: Nullable<AbstractMesh[]>, renderDepthOnlyMeshes?: boolean, renderOpaqueMeshes?: boolean, renderAlphaTestMeshes?: boolean, renderTransparentMeshes?: boolean, customRenderTransparentSubMeshes?: (transparentSubMeshes: SmartArray<SubMesh>) => void): void;
+    render(customRenderFunction: Nullable<(opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>) => void>, renderSprites: boolean, renderParticles: boolean, activeMeshes: Nullable<AbstractMesh[]>, renderDepthOnlyMeshes?: boolean, renderOpaqueMeshes?: boolean, renderAlphaTestMeshes?: boolean, renderTransparentMeshes?: boolean, customRenderTransparentSubMeshes?: (transparentSubMeshes: SmartArray<SubMesh>, renderingGroup?: RenderingGroup) => void): void;
     /**
      * Renders the opaque submeshes in the order from the opaqueSortCompareFn.
      * @param subMeshes The submeshes to render
@@ -27476,7 +27741,7 @@ declare class RenderingManager {
      * Renders the entire managed groups. This is used by the scene or the different render targets.
      * @internal
      */
-    render(customRenderFunction: Nullable<(opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>) => void>, activeMeshes: Nullable<AbstractMesh[]>, renderParticles: boolean, renderSprites: boolean, renderDepthOnlyMeshes?: boolean, renderOpaqueMeshes?: boolean, renderAlphaTestMeshes?: boolean, renderTransparentMeshes?: boolean, customRenderTransparentSubMeshes?: (transparentSubMeshes: SmartArray<SubMesh>) => void): void;
+    render(customRenderFunction: Nullable<(opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>) => void>, activeMeshes: Nullable<AbstractMesh[]>, renderParticles: boolean, renderSprites: boolean, renderDepthOnlyMeshes?: boolean, renderOpaqueMeshes?: boolean, renderAlphaTestMeshes?: boolean, renderTransparentMeshes?: boolean, customRenderTransparentSubMeshes?: (transparentSubMeshes: SmartArray<SubMesh>, renderingGroup?: RenderingGroup) => void): void;
     /**
      * Resets the different information of the group to prepare a new frame
      * @internal
@@ -33920,7 +34185,13 @@ declare const enum PhysicsMaterialCombineMode {
      * min( valueA , valueB )
      */
     MINIMUM = 1,
+    /** The final value will be the larger of the two:
+     * max( valueA , valueB )
+     */
     MAXIMUM = 2,
+    /** The final value will be the arithmetic mean of the two values:
+     * (valueA + valueB) / 2
+     */
     ARITHMETIC_MEAN = 3,
     /**
      * The final value will be the product of the two values:
@@ -34083,18 +34354,56 @@ declare class GroundMesh extends Mesh {
 
 /** How a specific axis can be constrained */
 declare const enum PhysicsConstraintAxisLimitMode {
+    /**
+     * The axis is not restricted at all
+     */
     FREE = 0,
+    /**
+     * The axis has a minimum/maximum limit
+     */
     LIMITED = 1,
+    /**
+     * The axis allows no relative movement of the pivots
+     */
     LOCKED = 2
 }
 /** The constraint specific axis to use when setting Friction, `ConstraintAxisLimitMode`, max force, ... */
 declare const enum PhysicsConstraintAxis {
+    /**
+     * Translation along the primary axis of the constraint (i.e. the
+     * direction specified by PhysicsConstraintParameters.axisA/axisB)
+     */
     LINEAR_X = 0,
+    /**
+     * Translation along the second axis of the constraint (i.e. the
+     * direction specified by PhysicsConstraintParameters.perpAxisA/perpAxisB)
+     */
     LINEAR_Y = 1,
+    /**
+     * Translation along the third axis of the constraint. This axis is
+     * computed from the cross product of axisA/axisB and perpAxisA/perpAxisB)
+     */
     LINEAR_Z = 2,
+    /**
+     * Rotation around the primary axis of the constraint (i.e. the
+     * axis specified by PhysicsConstraintParameters.axisA/axisB)
+     */
     ANGULAR_X = 3,
+    /**
+     * Rotation around the second axis of the constraint (i.e. the
+     * axis specified by PhysicsConstraintParameters.perpAxisA/perpAxisB)
+     */
     ANGULAR_Y = 4,
+    /**
+     * Rotation around the third axis of the constraint. This axis is
+     * computed from the cross product of axisA/axisB and perpAxisA/perpAxisB)
+     */
     ANGULAR_Z = 5,
+    /**
+     * A 3D distance limit; similar to specifying the LINEAR_X/Y/Z axes
+     * individually, but the distance calculation uses all three axes
+     * simultaneously, instead of individually.
+     */
     LINEAR_DISTANCE = 6
 }
 /** Type of Constraint */
@@ -34125,7 +34434,16 @@ declare const enum PhysicsConstraintType {
      * up between both bodies, allowing no relative movement.
      */
     LOCK = 5,
+    /**
+     * A prismatic will lock the rotations of the bodies, and allow translation
+     * only along one axis
+     */
     PRISMATIC = 6,
+    /**
+     * A generic constraint; this starts with no limits on how the bodies can
+     * move relative to each other, but limits can be added via the PhysicsConstraint
+     * interfaces. This can be used to specify a large variety of constraints
+     */
     SIX_DOF = 7
 }
 /** Type of Shape */
@@ -34182,7 +34500,7 @@ interface IBasePhysicsCollisionEvent {
  */
 interface IPhysicsCollisionEvent extends IBasePhysicsCollisionEvent {
     /**
-     * World position where the collision occured
+     * World position where the collision occurred
      */
     point: Nullable<Vector3>;
     /**
@@ -34223,7 +34541,7 @@ interface PhysicsShapeParameters {
      */
     rotation?: Quaternion;
     /**
-     * Dimesion extention for the box
+     * Dimension extents for the box
      */
     extents?: Vector3;
     /**
@@ -34292,7 +34610,7 @@ interface PhysicsConstraintParameters {
      */
     perpAxisB?: Vector3;
     /**
-     * The maximum distance that can seperate the two pivots.
+     * The maximum distance that can separate the two pivots.
      * Only used for DISTANCE constraints
      */
     maxDistance?: number;
@@ -34330,7 +34648,7 @@ interface PhysicsMassProperties {
      * The principal moments of inertia of this object
      * for a unit mass. This determines how easy it is
      * for the body to rotate. A value of zero on any
-     * axis will be used as infinite interia about that
+     * axis will be used as infinite inertia about that
      * axis.
      *
      * If not provided, the physics engine will compute
@@ -34671,6 +34989,9 @@ declare class CastingResult {
      * Gets if there was a hit
      */
     get hasHit(): boolean;
+    /**
+     * The index of the original triangle which was hit. Will be -1 if contact point is not on a mesh shape
+     */
     get triangleIndex(): number;
     /**
      * Sets the hit data
@@ -34685,7 +35006,7 @@ declare class CastingResult {
     reset(): void;
 }
 /**
- * Interface for the size containing width and height
+ * Interface for 3D coordinates
  */
 interface IXYZ {
     /**
@@ -43188,6 +43509,7 @@ declare class WebXRCamera extends FreeCamera {
     private _referenceQuaternion;
     private _referencedPosition;
     private _trackingState;
+    private _onWorldScaleFactorChanged;
     /**
      * This will be triggered after the first XR Frame initialized the camera,
      * including the right number of views and their rendering parameters
@@ -43424,6 +43746,7 @@ declare class WebXRInput implements IDisposable {
     private _frameObserver;
     private _sessionEndedObserver;
     private _sessionInitObserver;
+    private _currentXRSession;
     /**
      * Event when a controller has been connected/added
      */
@@ -47068,6 +47391,9 @@ declare class WebXRExperienceHelper implements IDisposable {
     private _supported;
     private _spectatorMode;
     private _lastTimestamp;
+    private _spectatorStateChangedObserver;
+    private _spectatorXRFrameObserver;
+    private _spectatorAfterRenderObserver;
     /**
      * Camera used to render xr content
      */
@@ -47134,6 +47460,7 @@ declare class WebXRExperienceHelper implements IDisposable {
      * Disable spectator mode for desktop VR experiences.
      */
     disableSpecatatorMode(): void;
+    private _clearSpectatorObservers;
     private _switchSpectatorMode;
     private _nonXRToXRCamera;
     private _setState;
@@ -49778,8 +50105,6 @@ interface EngineFeatures {
     forceVertexBufferStrideAndOffsetMultiple4Bytes: boolean;
     /** @internal */
     _checkNonFloatVertexBuffersDontRecreatePipelineContext: boolean;
-    /** @internal */
-    _collectUbosUpdatedInFrame: boolean;
 }
 
 /**
@@ -50370,8 +50695,6 @@ declare abstract class FrameGraphTask {
      * The (texture) dependencies of the task (optional).
      */
     dependencies?: Set<FrameGraphTextureHandle>;
-    /** @internal */
-    _disableDebugMarkers: boolean;
     /**
      * Records the task in the frame graph. Use this function to add content (render passes, ...) to the task.
      * @param skipCreationOfDisabledPasses If true, the disabled passe(s) won't be created.
@@ -51878,8 +52201,7 @@ declare class FrameGraphObjectRendererTask extends FrameGraphTaskMultiRenderTarg
     protected _getTargetHandles(): FrameGraphTextureHandle[];
     protected _prepareRendering(context: FrameGraphRenderContext, depthEnabled: boolean): Nullable<number[]>;
     protected _setLightsForShadow(): void;
-    protected _renderTransparentMeshesWithOIT(transparentSubMeshes: SmartArray<SubMesh>): void;
-    protected _sceneHasClusteredLights(): boolean;
+    protected _renderTransparentMeshesWithOIT(transparentSubMeshes: SmartArray<SubMesh>, renderingGroup: RenderingGroup): void;
 }
 
 /**
@@ -57034,7 +57356,7 @@ declare module "../../Meshes/transformNode" {
         /** @internal */
         _physicsBody: Nullable<PhysicsBody>;
         /**
-         * @see
+         * Gets or sets the physics body associated with this node.
          */
         physicsBody: Nullable<PhysicsBody>;
         /**