@babylonjs/inspector 9.0.0 → 9.1.0

package/lib/index.js

@@ -1,4 +1,4 @@
-export { A as Accordion, g as AccordionSection, l as AccordionSectionItem, m as AttachDebugLayer, n as BooleanBadgePropertyLine, o as BoundProperty, p as BuiltInsExtensionFeed, B as Button, h as ButtonLine, q as Checkbox, C as CheckboxPropertyLine, r as ChildWindow, s as Collapse, t as Color3GradientComponent, v as Color3GradientList, w as Color3PropertyLine, x as Color4GradientComponent, y as Color4GradientList, z as Color4PropertyLine, D as ColorPickerPopup, E as ColorStepGradientComponent, F as ComboBox, G as ComboBoxPropertyLine, H as ConstructorFactory, I as ConvertOptions, J as DebugServiceIdentity, K as DetachDebugLayer, O as DraggableLine, Q as Dropdown, R as EntitySelector, U as ErrorBoundary, W as ExtensibleAccordion, X as FactorGradientComponent, Y as FactorGradientList, Z as FileUploadLine, _ as GetPropertyDescriptor, $ as GizmoServiceIdentity, a0 as HexPropertyLine, a1 as InfoLabel, a2 as InputHexField, a3 as InputHsvField, a4 as Inspector, a5 as InterceptFunction, a6 as InterceptProperty, a7 as IsPropertyReadonly, a8 as LineContainer, k as Link, a9 as LinkPropertyLine, L as LinkToEntity, aa as LinkToEntityPropertyLine, ab as List, ac as MakeDialogTeachingMoment, ad as MakeLazyComponent, ae as MakePopoverTeachingMoment, af as MakePropertyHook, ag as MakeTeachingMoment, ah as MaterialSelector, M as MessageBar, ai as NodeSelector, aj as NumberDropdown, ak as NumberDropdownPropertyLine, N as NumberInputPropertyLine, al as ObservableCollection, am as Pane, an as PlaceholderPropertyLine, P as Popover, ao as PositionedPopover, ap as PropertiesServiceIdentity, aq as Property, ar as PropertyContext, as as PropertyLine, at as QuaternionPropertyLine, au as RotationVectorPropertyLine, d as SceneContextIdentity, av as SceneExplorerServiceIdentity, aw as SearchBar, ax as SearchBox, ay as SelectionServiceDefinition, e as SelectionServiceIdentity, az as SettingsServiceIdentity, aA as SettingsStore, aB as SettingsStoreIdentity, c as ShellServiceIdentity, aC as ShowInspector, aD as SidePaneContainer, aE as SkeletonSelector, aF as Slider, aG as SpinButton, S as SpinButtonPropertyLine, aH as StatsServiceIdentity, aI as StringDropdown, aJ as StringDropdownPropertyLine, aK as StringifiedPropertyLine, aL as Switch, aM as SwitchPropertyLine, aN as SyncedSliderInput, aO as SyncedSliderPropertyLine, aP as TeachingMoment, aQ as TextAreaPropertyLine, aR as TextInput, T as TextInputPropertyLine, aS as TextPropertyLine, aT as Textarea, aU as TextureSelector, aV as TextureUpload, aW as Theme, aX as ThemeServiceIdentity, aY as ToastProvider, aZ as ToggleButton, i as ToolsServiceIdentity, a_ as Tooltip, a$ as UploadButton, b0 as Vector2PropertyLine, V as Vector3PropertyLine, b1 as Vector4PropertyLine, b2 as WatcherServiceIdentity, b3 as useAngleConverters, b4 as useAsyncResource, b5 as useColor3Property, b6 as useColor4Property, b7 as useEventListener, b8 as useEventfulState, a as useInterceptObservable, b9 as useKeyListener, ba as useKeyState, bb as useObservableCollection, f as useObservableState, bc as useOrderedObservableCollection, bd as usePollingObservable, b as useProperty, be as usePropertyChangedNotifier, bf as useQuaternionProperty, bg as useResource, bh as useSetting, bi as useTheme, bj as useThemeMode, u as useToast, bk as useVector3Property } from './index-DuVF9zYN.js';
+export { A as Accordion, i as AccordionSection, l as AccordionSectionItem, m as AttachDebugLayer, n as BooleanBadgePropertyLine, o as BoundProperty, p as BuiltInsExtensionFeed, B as Button, j as ButtonLine, q as Checkbox, C as CheckboxPropertyLine, r as ChildWindow, s as Collapse, t as Color3GradientComponent, v as Color3GradientList, w as Color3PropertyLine, x as Color4GradientComponent, y as Color4GradientList, z as Color4PropertyLine, D as ColorPickerPopup, E as ColorStepGradientComponent, F as ComboBox, G as ComboBoxPropertyLine, H as ConstructorFactory, I as ConvertOptions, J as DebugServiceIdentity, K as DetachDebugLayer, O as DraggableLine, Q as Dropdown, R as EntitySelector, U as ErrorBoundary, W as ExtensibleAccordion, X as FactorGradientComponent, Y as FactorGradientList, Z as FileUploadLine, _ as GetPropertyDescriptor, $ as GizmoServiceIdentity, a0 as HexPropertyLine, a1 as InfoLabel, a2 as InputHexField, a3 as InputHsvField, a4 as Inspector, a5 as InterceptFunction, a6 as InterceptProperty, a7 as IsPropertyReadonly, a8 as LineContainer, L as Link, a9 as LinkPropertyLine, c as LinkToEntity, aa as LinkToEntityPropertyLine, ab as List, ac as MakeDialogTeachingMoment, ad as MakeLazyComponent, ae as MakePopoverTeachingMoment, af as MakePropertyHook, ag as MakeTeachingMoment, ah as MaterialSelector, M as MessageBar, ai as NodeSelector, aj as NumberDropdown, ak as NumberDropdownPropertyLine, N as NumberInputPropertyLine, al as ObservableCollection, am as Pane, an as PlaceholderPropertyLine, P as Popover, ao as PositionedPopover, ap as PropertiesServiceIdentity, aq as Property, ar as PropertyContext, as as PropertyLine, at as QuaternionPropertyLine, au as RotationVectorPropertyLine, f as SceneContextIdentity, av as SceneExplorerServiceIdentity, aw as SearchBar, ax as SearchBox, ay as SelectionServiceDefinition, g as SelectionServiceIdentity, az as SettingsServiceIdentity, aA as SettingsStoreIdentity, S as ShellServiceIdentity, aB as ShowInspector, aC as SidePaneContainer, aD as SkeletonSelector, aE as Slider, aF as SpinButton, d as SpinButtonPropertyLine, aG as StatsServiceIdentity, aH as StringDropdown, aI as StringDropdownPropertyLine, aJ as StringifiedPropertyLine, aK as Switch, aL as SwitchPropertyLine, aM as SyncedSliderInput, aN as SyncedSliderPropertyLine, aO as TeachingMoment, aP as TextAreaPropertyLine, aQ as TextInput, T as TextInputPropertyLine, aR as TextPropertyLine, aS as Textarea, aT as TextureSelector, aU as TextureUpload, aV as Theme, aW as ThemeServiceIdentity, aX as ToastProvider, aY as ToggleButton, k as ToolsServiceIdentity, aZ as Tooltip, a_ as UploadButton, a$ as Vector2PropertyLine, V as Vector3PropertyLine, b0 as Vector4PropertyLine, b1 as WatcherServiceIdentity, b2 as useAngleConverters, b3 as useAsyncResource, b4 as useColor3Property, b5 as useColor4Property, b6 as useEventListener, b7 as useEventfulState, b as useInterceptObservable, b8 as useKeyListener, b9 as useKeyState, ba as useObservableCollection, h as useObservableState, bb as useOrderedObservableCollection, bc as usePollingObservable, e as useProperty, bd as usePropertyChangedNotifier, be as useQuaternionProperty, bf as useResource, bg as useSetting, bh as useTheme, bi as useThemeMode, a as useToast, bj as useVector3Property } from './index-BCbXjPTn.js';
 import 'react/jsx-runtime';
 import 'react';
 import '@fluentui/react-components';
@@ -124,15 +124,15 @@ import '@babylonjs/core/Bones/skeleton.js';
 import '@babylonjs/core/Sprites/sprite.js';
 import '@babylonjs/core/Sprites/spriteManager.js';
 import '@babylonjs/core/Misc/textureTools.js';
-import '@babylonjs/core/Materials/Textures/baseTexture.js';
-import '@babylonjs/core/Materials/Textures/multiRenderTarget.js';
-import '@babylonjs/core/Materials/Textures/renderTargetTexture.js';
-import '@babylonjs/core/Materials/Textures/thinTexture.js';
 import '@babylonjs/core/Events/keyboardEvents.js';
 import '@babylonjs/core/Events/pointerEvents.js';
 import '@babylonjs/core/Materials/Textures/htmlElementTexture.js';
 import '@babylonjs/core/Materials/shaderMaterial.js';
 import '@babylonjs/core/Meshes/Builders/planeBuilder.js';
+import '@babylonjs/core/Materials/Textures/baseTexture.js';
+import '@babylonjs/core/Materials/Textures/multiRenderTarget.js';
+import '@babylonjs/core/Materials/Textures/renderTargetTexture.js';
+import '@babylonjs/core/Materials/Textures/thinTexture.js';
 import '@babylonjs/core/Rendering/boundingBoxRenderer.js';
 import '@babylonjs/core/PostProcesses/RenderPipeline/postProcessRenderPipelineManagerSceneComponent.js';
 import '@babylonjs/core/Sprites/spriteSceneComponent.js';

package/lib/inspector.d.ts

@@ -0,0 +1,41 @@
+import { type IDisposable, type IReadonlyObservable, type Scene } from "@babylonjs/core/index.js";
+import { type ModularToolOptions } from "./modularTool";
+type LayoutMode = "inline" | "overlay";
+/**
+ * Options for configuring the inspector.
+ */
+export 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.
+ */
+export type InspectorToken = IDisposable & {
+    /**
+     * Whether the inspector has been disposed.
+     */
+    readonly isDisposed: boolean;
+    /**
+     * An observable that fires when the inspector is disposed.
+     */
+    readonly onDisposed: IReadonlyObservable<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.
+ */
+export declare function ShowInspector(scene: Scene, options?: Partial<InspectorOptions>): InspectorToken;
+export {};

package/lib/instrumentation/functionInstrumentation.d.ts

@@ -0,0 +1,20 @@
+import { type IDisposable } from "@babylonjs/core/index.js";
+/**
+ * Hooks that can be registered on a function to intercept its execution.
+ */
+export type FunctionHooks<Args extends unknown[] = unknown[]> = {
+    /**
+     * This function will be called after the hooked function is called.
+     * @param args The arguments that were passed to the original function.
+     */
+    afterCall?: (...args: Args) => void;
+};
+/**
+ * Intercepts a function on an object and allows you to add hooks that will be called during function execution.
+ * @param target The object containing the function to intercept.
+ * @param propertyKey The key of the property that is a function (this is the function that will be intercepted).
+ * @param hooks The hooks to call during the function execution.
+ * @returns A disposable that removes the hooks when disposed and returns the object to its original state.
+ */
+export declare function InterceptFunction<T extends object, K extends keyof T>(target: T, propertyKey: string extends K ? never : number extends K ? never : symbol extends K ? never : K, hooks: NonNullable<T[K]> extends (...args: infer Args) => unknown ? FunctionHooks<Args> : FunctionHooks): IDisposable;
+export declare function InterceptFunction<T extends object>(target: T, propertyKey: keyof T, hooks: FunctionHooks): IDisposable;

package/lib/instrumentation/propertyInstrumentation.d.ts

@@ -0,0 +1,33 @@
+import { type IDisposable, type Nullable } from "@babylonjs/core/index.js";
+/**
+ * Gets the property descriptor for a property on an object, including inherited properties.
+ * @param target The object containing the property.
+ * @param propertyKey The key of the property to get the descriptor for.
+ * @returns The owner of the property (which may be different from the target in the case of inheritance) along with the property descriptor, or null if the property is not found.
+ */
+export declare function GetPropertyDescriptor<T extends object>(target: T, propertyKey: keyof T): Nullable<[owner: object, descriptor: PropertyDescriptor]>;
+/**
+ * Checks if a property is readonly.
+ * @param propertyDescriptor The property descriptor to check.
+ * @returns True if the property is readonly, false otherwise.
+ */
+export declare function IsPropertyReadonly(propertyDescriptor: PropertyDescriptor): boolean;
+/**
+ * Hooks that can be registered on a property to intercept its setter.
+ */
+export type PropertyHooks<T = unknown> = {
+    /**
+     * This function will be called after the hooked property is set.
+     * @param value The new value that was set on the property.
+     */
+    afterSet?: (value: T) => void;
+};
+/**
+ * Intercepts a property on an object and allows you to add hooks that will be called when the property is get or set.
+ * @param target The object containing the property to intercept.
+ * @param propertyKey The key of the property to intercept.
+ * @param hooks The hooks to call when the property is get or set.
+ * @returns A disposable that removes the hooks when disposed and returns the object to its original state.
+ */
+export 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;
+export declare function InterceptProperty<T extends object>(target: T, propertyKey: keyof T, hooks: PropertyHooks): IDisposable;

package/lib/legacy/debugLayer.d.ts

@@ -0,0 +1,24 @@
+import { type IInspectorOptions } from "@babylonjs/core/index.js";
+import { DebugLayer } from "@babylonjs/core/Debug/debugLayer.js";
+declare class DebugLayerEx extends DebugLayer {
+    show(config?: IInspectorOptions): Promise<DebugLayer>;
+}
+declare const DebugLayerExKey: unique symbol;
+declare module "@babylonjs/core/scene.js" {
+    interface Scene {
+        /**
+         * @internal
+         * Backing field
+         */
+        [DebugLayerExKey]?: DebugLayerEx;
+    }
+}
+/**
+ * Attaches Inspector v2 to Scene.debugLayer.
+ */
+export declare function AttachDebugLayer(): void;
+/**
+ * Detaches Inspector v2 from Scene.debugLayer.
+ */
+export declare function DetachDebugLayer(): void;
+export {};

package/lib/legacy/inspectableCustomPropertiesService.d.ts

@@ -0,0 +1,3 @@
+import { type ServiceDefinition } from "../modularity/serviceDefinition";
+import { type IPropertiesService } from "../services/panes/properties/propertiesService";
+export declare const LegacyInspectableObjectPropertiesServiceDefinition: ServiceDefinition<[], [IPropertiesService]>;

package/lib/legacy/inspector.d.ts

@@ -0,0 +1,39 @@
+import { type IInspectorOptions as InspectorV1Options, type Scene } from "@babylonjs/core/index.js";
+import { type InspectorOptions as InspectorV2Options } from "../inspector";
+import { Observable } from "@babylonjs/core/Misc/observable.js";
+type PropertyChangedEvent = {
+    object: any;
+    property: string;
+    value: any;
+    initialValue: any;
+    allowNullValue?: boolean;
+};
+/**
+ * Converts Inspector v1 options to Inspector v2 options.
+ * @param v1Options Inspector v1 options.
+ * @returns Inspector v2 options.
+ */
+export declare function ConvertOptions(v1Options: Partial<InspectorV1Options>): Partial<InspectorV2Options>;
+/**
+ * @deprecated This class only exists for backward compatibility. Use the module-level ShowInspector function instead.
+ */
+export declare class Inspector {
+    private static _CurrentInstance;
+    private static _PopupToggler;
+    private static _SidePaneOpenCounter;
+    private static get _OpenedPane();
+    static readonly OnSelectionChangeObservable: Observable<any>;
+    static readonly OnPropertyChangedObservable: Observable<PropertyChangedEvent>;
+    private static readonly _OnMarkLineContainerObservable;
+    static MarkLineContainerTitleForHighlighting(title: string): void;
+    static MarkMultipleLineContainerTitlesForHighlighting(titles: string[]): void;
+    static PopupEmbed(): void;
+    static PopupSceneExplorer(): void;
+    static PopupInspector(): void;
+    static get IsVisible(): boolean;
+    static Show(scene: Scene, userOptions: Partial<InspectorV1Options>): void;
+    private static _Show;
+    static Hide(): void;
+    private static _SetNewScene;
+}
+export {};

package/lib/legacy/legacy.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Attaches Inspector v2 to the global INSPECTOR and BABYLON.Inspector.
+ */
+export declare function AttachInspectorGlobals(): void;
+/**
+ * Detaches Inspector v2 from the global INSPECTOR and BABYLON.Inspector.
+ */
+export declare function DetachInspectorGlobals(): void;
+export * from "../index";

package/lib/legacy/propertiesSectionMapping.d.ts

@@ -0,0 +1,99 @@
+export declare const LegacyPropertiesSectionMapping: {
+    readonly GENERAL: "General";
+    readonly CUSTOM: "Custom";
+    readonly COMMANDS: "Commands";
+    readonly DEBUG: "Debug";
+    readonly ADVANCED: "Advanced";
+    readonly PROPERTIES: "Properties";
+    readonly TRANSFORMATIONS: "Transform";
+    readonly TRANSFORMS: "Transform";
+    readonly TRANSFORM: "Transform";
+    readonly ANIMATION: "Animation";
+    readonly "ANIMATION RANGES": "Animation Ranges";
+    readonly ANIMATIONS: "Animation";
+    readonly "ANIMATION GENERAL CONTROL": "Animation Control";
+    readonly CONTROLS: "Control";
+    readonly INFOS: "Info";
+    readonly COLLISIONS: "Collision";
+    readonly LIMITS: "Limits";
+    readonly BEHAVIORS: "Behaviors";
+    readonly TRANSPARENCY: "Transparency";
+    readonly STENCIL: "Stencil";
+    readonly "STENCIL - FRONT": "Stencil Front";
+    readonly "STENCIL - BACK": "Stencil Back";
+    readonly TEXTURES: "Textures";
+    readonly "LIGHTING & COLORS": "Lighting & Colors";
+    readonly LEVELS: "Levels";
+    readonly "NORMAL MAP": "Normal Map";
+    readonly RENDERING: "Rendering";
+    readonly CHANNELS: "Channels";
+    readonly "METALLIC WORKFLOW": "Metallic Workflow";
+    readonly "CLEAR COAT": "Clear Coat";
+    readonly IRIDESCENCE: "Iridescence";
+    readonly ANISOTROPIC: "Anisotropic";
+    readonly SHEEN: "Sheen";
+    readonly SUBSURFACE: "Subsurface";
+    readonly BASE: "Base";
+    readonly SPECULAR: "Specular";
+    readonly COAT: "Coat";
+    readonly FUZZ: "Fuzz";
+    readonly EMISSION: "Emission";
+    readonly "THIN FILM": "Thin Film";
+    readonly GEOMETRY: "Geometry";
+    readonly SKY: "Sky";
+    readonly CHILDREN: "Children";
+    readonly DISPLAY: "Display";
+    readonly "DISPLAY OPTIONS": "Display Options";
+    readonly "NODE GEOMETRY": "Node Geometry";
+    readonly "MORPH TARGETS": "Morph Targets";
+    readonly PHYSICS: "Physics";
+    readonly OCCLUSIONS: "Occlusions";
+    readonly "EDGE RENDERING": "Edge Rendering";
+    readonly "OUTLINE & OVERLAY": "Outlines & Overlays";
+    readonly SETUP: "Setup";
+    readonly SHADOWS: "Shadows";
+    readonly "SHADOW GENERATOR": "Shadow Generator";
+    readonly "NODE PARTICLE EDITOR": "Node Particle Editor";
+    readonly FILE: "File";
+    readonly SNIPPET: "Snippet";
+    readonly ATTRACTORS: "Attractors";
+    readonly IMPOSTORS: "Impostors";
+    readonly EMITTER: "Emitter";
+    readonly SIZE: "Size";
+    readonly LIFETIME: "Lifetime";
+    readonly COLORS: "Color";
+    readonly ROTATION: "Rotation";
+    readonly SPRITESHEET: "Spritesheet";
+    readonly CELLS: "Cells";
+    readonly CELL: "Cell";
+    readonly SCALE: "Scale";
+    readonly CONFIGURATION: "Configuration";
+    readonly BLOOM: "Bloom";
+    readonly "CHROMATIC ABERRATION": "Chromatic Aberration";
+    readonly "DEPTH OF FIELD": "Depth of Field";
+    readonly FXAA: "FXAA";
+    readonly "GLOW LAYER": "Glow Layer";
+    readonly GRAIN: "Grain";
+    readonly "IMAGE PROCESSING": "Image Processing";
+    readonly SHARPEN: "Sharpen";
+    readonly OPTIONS: "Options";
+    readonly SSAO: "SSAO";
+    readonly Denoiser: "Denoiser";
+    readonly SSR: "SSR";
+    readonly "Voxel Shadows": "Voxel Shadows";
+    readonly "Screenspace Shadows": "Screenspace Shadows";
+    readonly "Automatic thickness computation": "Automatic Thickness Computation";
+    readonly Blur: "Blur";
+    readonly Attenuations: "Attenuations";
+    readonly "Color space": "Color Space";
+    readonly "RENDERING MODE": "Rendering";
+    readonly ENVIRONMENT: "Environment";
+    readonly "MATERIAL IMAGE PROCESSING": "Material Image Processing";
+    readonly PREVIEW: "Preview";
+    readonly "ADVANCED TEXTURE PROPERTIES": "Advanced Texture Properties";
+    readonly TASKS: "Tasks";
+    readonly METADATA: "Metadata";
+    readonly "XMP METADATA": "XMP Metadata";
+    readonly VARIANTS: "Variants";
+    readonly INPUTS: "Inputs";
+};

package/lib/misc/arrayUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function GroupBy<T, K>(items: T[], getKey: (item: T) => K): {
+    key: K;
+    items: T[];
+}[];

package/lib/misc/assert.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Asserts that the given value is truthy.
+ * @param value The value to check.
+ */
+export declare function Assert(value: unknown): asserts value;

package/lib/misc/graphUtils.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Performs a topological sort on a graph.
+ * @param graph The set of nodes that make up the graph.
+ * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
+ * @param onSortedNode A function that is called for each node in the sorted order.
+ * @remarks
+ * This function allocates. Do not use it in the hot path. Instead use an instance of GraphUtils.
+ */
+export declare function SortGraph<NodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT>, onSortedNode: (node: NodeT) => void): void;
+/**
+ * Traverses a graph.
+ * @param graph The set of nodes that make up the graph.
+ * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
+ * @param onBeforeTraverse A function that is called before traversing each node.
+ * @param onAfterTraverse A function that is called after traversing each node.
+ * @remarks
+ * This function allocates. Do not use it in the hot path. Instead use an instance of GraphUtils.
+ */
+export declare function TraverseGraph<NodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT> | null | undefined, onBeforeTraverse?: (node: NodeT) => void, onAfterTraverse?: (node: NodeT) => void): void;
+/**
+ * A utility class for performing graph operations.
+ * @remarks
+ * The class allocates new objects, but each operation (e.g. sort, traverse) is allocation free. This is useful when used in the hot path.
+ */
+export declare class GraphUtils<DefaultNodeT = unknown> {
+    private readonly _traversalState;
+    private _isTraversing;
+    /**
+     * Performs a topological sort on a graph.
+     * @param graph The set of nodes that make up the graph.
+     * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
+     * @param onSortedNode A function that is called for each node in the sorted order.
+     */
+    sort<NodeT extends DefaultNodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT>, onSortedNode: (node: NodeT) => void): void;
+    /**
+     * Traverses a graph.
+     * @param graph The set of nodes that make up the graph.
+     * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
+     * @param onBeforeTraverse A function that is called before traversing each node.
+     * @param onAfterTraverse A function that is called after traversing each node.
+     */
+    traverse<NodeT extends DefaultNodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT> | null | undefined, onBeforeTraverse?: (node: NodeT) => void, onAfterTraverse?: (node: NodeT) => void): void;
+    private _traverseCore;
+}

package/lib/misc/nodeGeometryEditor.d.ts

@@ -0,0 +1,3 @@
+import { type Mesh, type NodeGeometry, type Nullable, type Scene } from "@babylonjs/core/index.js";
+export declare function GetNodeGeometry(mesh: Mesh): Nullable<NodeGeometry>;
+export declare function EditNodeGeometry(nodeGeometry: NodeGeometry, hostScene: Scene): Promise<void>;

package/lib/misc/nodeMaterialEditor.d.ts

@@ -0,0 +1,2 @@
+import { type NodeMaterial } from "@babylonjs/core/index.js";
+export declare function EditNodeMaterial(material: NodeMaterial): Promise<void>;

package/lib/misc/nodeParticleEditor.d.ts

@@ -0,0 +1,2 @@
+import { type ParticleSystem } from "@babylonjs/core/index.js";
+export declare function EditParticleSystem(particleSystem: ParticleSystem): Promise<void>;

package/lib/misc/nodeRenderGraphEditor.d.ts

@@ -0,0 +1,2 @@
+import { type NodeRenderGraph } from "@babylonjs/core/index.js";
+export declare function EditNodeRenderGraph(nodeRenderGraph: NodeRenderGraph): Promise<void>;

package/lib/misc/observableCollection.d.ts

@@ -0,0 +1,23 @@
+import { type IDisposable, type IReadonlyObservable } from "@babylonjs/core/index.js";
+/**
+ * A collection of items that can be observed for changes.
+ */
+export declare class ObservableCollection<T> {
+    private readonly _items;
+    private readonly _keys;
+    private readonly _observable;
+    /**
+     * An observable that notifies observers when the collection changes.
+     */
+    get observable(): IReadonlyObservable<void>;
+    /**
+     * The items in the collection.
+     */
+    get items(): readonly T[];
+    /**
+     * Adds an item to the collection.
+     * @param item The item to add.
+     * @returns A disposable that removes the item from the collection when disposed.
+     */
+    add(item: T): IDisposable;
+}

package/lib/misc/snippetUtils.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Shared utilities for snippet server operations (save/load).
+ */
+/**
+ * Persist a snippet ID to local storage for quick reuse.
+ * @param storageKey The local storage key to use.
+ * @param snippetId The snippet ID to persist.
+ * @param maxItems Maximum number of items to store (default 50).
+ */
+export declare function PersistSnippetId(storageKey: string, snippetId: string, maxItems?: number): void;
+/**
+ * Configuration for saving to the snippet server.
+ */
+export type SaveToSnippetConfig = {
+    /** The base URL of the snippet server. */
+    snippetUrl: string;
+    /** The current snippet ID (if updating an existing snippet). */
+    currentSnippetId?: string;
+    /** The serialized content to save. */
+    content: string;
+    /** The key name for the payload (e.g., "particleSystem", "spriteManager"). */
+    payloadKey: string;
+    /** Optional local storage key for persisting snippet IDs. */
+    storageKey?: string;
+    /** Optional friendly name for the entity type (used in alerts). */
+    entityName?: string;
+};
+/**
+ * Result from saving to the snippet server.
+ */
+export type SaveToSnippetResult = {
+    /** The new snippet ID. */
+    snippetId: string;
+    /** The previous snippet ID (or "_BLANK" if none). */
+    oldSnippetId: string;
+};
+/**
+ * Save content to the snippet server.
+ * @param config Configuration for the save operation.
+ * @returns Promise resolving to the save result.
+ */
+export declare function SaveToSnippetServer(config: SaveToSnippetConfig): Promise<SaveToSnippetResult>;
+/**
+ * Configuration for loading from the snippet server.
+ */
+export type LoadFromSnippetConfig = {
+    /** The base URL of the snippet server. */
+    snippetUrl: string;
+    /** The snippet ID to load. */
+    snippetId: string;
+    /** Optional friendly name for the entity type (used in alerts). */
+    entityName?: string;
+};
+/**
+ * Load content from the snippet server.
+ * @param config Configuration for the load operation.
+ * @returns Promise resolving to the parsed response object.
+ */
+export declare function LoadFromSnippetServer(config: LoadFromSnippetConfig): Promise<any>;
+/**
+ * Prompt the user for a snippet ID.
+ * @param message The prompt message.
+ * @returns The trimmed snippet ID, or null if cancelled/empty.
+ */
+export declare function PromptForSnippetId(message?: string): string | null;
+/**
+ * Notify the playground about a snippet ID change (for code replacement).
+ * NOTE this is an anti-pattern, instead playground should hook in and observe changes / update its own code
+ * This is a legacy approach and should not be copied elsewhere
+ * @param oldSnippetId The previous snippet ID.
+ * @param newSnippetId The new snippet ID.
+ * @param parseMethodName The name of the parse method (e.g., "SpriteManager.ParseFromSnippetAsync").
+ */
+export declare function NotifyPlaygroundOfSnippetChange(oldSnippetId: string, newSnippetId: string, parseMethodName: string): void;

package/lib/misc/textureTools.d.ts

@@ -0,0 +1,34 @@
+import { type BaseTexture } from "@babylonjs/core/index.js";
+/**
+ * Defines which channels of the texture to retrieve with {@link TextureHelper.GetTextureDataAsync}.
+ */
+export type TextureChannelsToDisplay = {
+    /**
+     * True if the red channel should be included.
+     */
+    R: boolean;
+    /**
+     * True if the green channel should be included.
+     */
+    G: boolean;
+    /**
+     * True if the blue channel should be included.
+     */
+    B: boolean;
+    /**
+     * True if the alpha channel should be included.
+     */
+    A: boolean;
+};
+/**
+ * Gets the data of the specified texture by rendering it to an intermediate RGBA texture and retrieving the bytes from it.
+ * This is convenient to get 8-bit RGBA values for a texture in a GPU compressed format.
+ * @param texture the source texture
+ * @param width the width of the result, which does not have to match the source texture width
+ * @param height the height of the result, which does not have to match the source texture height
+ * @param faceOrLayer if the texture has multiple faces, the face index to use for the source. For 2D array textures, this is the layer index.
+ * @param channels a filter for which of the RGBA channels to return in the result
+ * @param lod if the texture has multiple LODs, the lod index to use for the source
+ * @returns the 8-bit texture data
+ */
+export declare function ApplyChannelsToTextureDataAsync(texture: BaseTexture, width: number, height: number, faceOrLayer: number, channels: TextureChannelsToDisplay, lod?: number): Promise<Uint8Array>;

package/lib/modularTool.d.ts

@@ -0,0 +1,37 @@
+import { type IDisposable } from "@babylonjs/core/index.js";
+import { type IExtensionFeed } from "./extensibility/extensionFeed";
+import { type WeaklyTypedServiceDefinition } from "./modularity/serviceContainer";
+import { type ShellServiceOptions } from "./services/shellService";
+import { type ThemeMode } from "./services/themeService";
+export type ModularToolOptions = {
+    /**
+     * The namespace for the tool, used for scoping persisted settings and other storage.
+     */
+    namespace: string;
+    /**
+     * The container element where the tool will be rendered.
+     */
+    containerElement: HTMLElement;
+    /**
+     * The service definitions to be registered with the tool.
+     */
+    serviceDefinitions: readonly WeaklyTypedServiceDefinition[];
+    /**
+     * The theme mode to use. If not specified, the default is "system", which uses the system/browser preference, and the last used mode is persisted.
+     */
+    themeMode?: ThemeMode;
+    /**
+     * Whether to show the theme selector in the toolbar. Default is true.
+     */
+    showThemeSelector?: boolean;
+    /**
+     * The extension feeds that provide optional extensions the user can install.
+     */
+    extensionFeeds?: readonly IExtensionFeed[];
+} & ShellServiceOptions;
+/**
+ * Creates a modular tool with a base set of common tool services, including the toolbar/side pane basic UI layout.
+ * @param options The options for the tool.
+ * @returns A token that can be used to dispose of the tool.
+ */
+export declare function MakeModularTool(options: ModularToolOptions): IDisposable;

package/lib/modularity/serviceContainer.d.ts

@@ -0,0 +1,41 @@
+import { type IDisposable } from "@babylonjs/core/index.js";
+import { type IService, type ServiceDefinition } from "./serviceDefinition";
+export type WeaklyTypedServiceDefinition = Omit<ServiceDefinition<IService<symbol>[] | [], IService<symbol>[] | []>, "factory"> & {
+    /**
+     * A factory function responsible for creating a service instance.
+     */
+    factory: (...args: any) => ReturnType<ServiceDefinition<IService<symbol>[] | [], IService<symbol>[] | []>["factory"]>;
+};
+/**
+ * A service container manages the lifetimes of a set of services.
+ * It takes care of instantiating the services in the correct order based on their dependencies,
+ * passing dependencies through to services, and disposing of services when the container is disposed.
+ */
+export declare class ServiceContainer implements IDisposable {
+    private readonly _friendlyName;
+    private _isDisposed;
+    private readonly _serviceDefinitions;
+    private readonly _serviceDependents;
+    private readonly _serviceInstances;
+    constructor(_friendlyName: string);
+    /**
+     * Adds a set of service definitions in the service container.
+     * The services are sorted based on their dependencies.
+     * @param args The service definitions to register, and optionally an abort signal.
+     * @returns A disposable that will remove the service definition from the service container.
+     */
+    addServicesAsync(...args: WeaklyTypedServiceDefinition[] | [...serviceDefinitions: WeaklyTypedServiceDefinition[], abortSignal: AbortSignal]): Promise<IDisposable>;
+    /**
+     * Registers a service definition in the service container.
+     * @param serviceDefinition The service definition to register.
+     * @param abortSignal An optional abort signal.
+     * @returns A disposable that will remove the service definition from the service container.
+     */
+    addServiceAsync<Produces extends IService<symbol>[] = [], Consumes extends IService<symbol>[] = []>(serviceDefinition: ServiceDefinition<Produces, Consumes>, abortSignal?: AbortSignal): Promise<IDisposable>;
+    private _addServiceAsync;
+    private _removeService;
+    /**
+     * Disposes the service container and all contained services.
+     */
+    dispose(): void;
+}