@babylonjs/inspector 9.25.0 → 9.26.1

package/lib/{reflectorService-CPunL_Qs.js → reflectorService-CUFxJIMt.js}

@@ -1,21 +1,21 @@
 import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
-import { T as TextInputPropertyLine, N as NumberInputPropertyLine, j as ButtonLine, k as ToolsServiceIdentity } from './index-CgagLRQT.js';
+import { T as TextInputPropertyLine, N as NumberInputPropertyLine, j as ButtonLine, k as ToolsServiceIdentity } from './index-DvyGGbVg.js';
 import { useState, useRef, useCallback } from 'react';
 import { Reflector } from '@babylonjs/core/Misc/reflector.js';
 import { PlugConnectedRegular } from '@fluentui/react-icons';
-import '@fluentui/react-components';
-import '@babylonjs/core/Maths/math.color.js';
-import '@babylonjs/core/Maths/math.vector.js';
 import '@babylonjs/core/Misc/observable.js';
-import '@babylonjs/core/Misc/typeStore.js';
+import '@fluentui/react-components';
 import '@babylonjs/core/Misc/dataStorage.js';
-import '@babylonjs/core/Misc/logger.js';
-import '@fluentui/react-motion-components-preview';
 import '@babylonjs/core/Misc/asyncLock.js';
 import '@babylonjs/core/Misc/deferred.js';
 import '@fluentui-contrib/react-resize-handle';
-import '@fluentui-contrib/react-virtualizer';
+import '@fluentui/react-motion-components-preview';
+import '@babylonjs/core/Misc/logger.js';
+import 'react-dom/client';
+import '@babylonjs/core/Maths/math.color.js';
+import '@babylonjs/core/Maths/math.vector.js';
 import '@babylonjs/core/Misc/uniqueIdGenerator.js';
+import '@fluentui-contrib/react-virtualizer';
 import '@babylonjs/addons/msdfText/fontAsset.js';
 import '@babylonjs/addons/msdfText/textRenderer.js';
 import '@babylonjs/core/Debug/physicsViewer.js';
@@ -36,7 +36,6 @@ import '@babylonjs/core/Misc/PerformanceViewer/performanceViewerSceneExtension.j
 import '@babylonjs/core/Misc/pressureObserverWrapper.js';
 import '@babylonjs/core/Maths/math.scalar.js';
 import '@babylonjs/core/Misc/PerformanceViewer/performanceViewerCollector.js';
-import '@babylonjs/core/Maths/math.scalar.functions.js';
 import '@babylonjs/core/Engines/abstractEngine.js';
 import '@babylonjs/core/Bones/bone.js';
 import '@babylonjs/core/Cameras/camera.js';
@@ -48,10 +47,14 @@ import '@babylonjs/core/Gizmos/spatialAudioGizmo.js';
 import '@babylonjs/core/Lights/light.js';
 import '@babylonjs/core/Meshes/abstractMesh.js';
 import '@babylonjs/core/node.js';
-import 'react-dom/client';
 import '@babylonjs/core/Misc/screenshotTools.js';
 import '@babylonjs/core/Layers/selectionOutlineLayer.js';
 import '@babylonjs/core/Meshes/GaussianSplatting/gaussianSplattingMesh.js';
+import '@babylonjs/core/SmartAssets/smartAssetManager.pure.js';
+import '@babylonjs/core/Loading/Plugins/babylonFileLoader.js';
+import '@babylonjs/core/Meshes/mesh.js';
+import '@babylonjs/core/Misc/sceneSerializer.js';
+import '@babylonjs/core/SmartAssets/smartAssetSerializer.js';
 import '@babylonjs/core/Animations/animationGroup.js';
 import '@babylonjs/core/Animations/animation.js';
 import '@babylonjs/core/Animations/animationPropertiesOverride.js';
@@ -70,9 +73,9 @@ import '@babylonjs/core/Cameras/freeCamera.js';
 import '@babylonjs/core/Cameras/geospatialCamera.js';
 import '@babylonjs/core/Cameras/targetCamera.js';
 import '@babylonjs/core/scene.js';
+import '@babylonjs/core/FlowGraph/flowGraph.js';
 import '@babylonjs/core/FrameGraph/frameGraph.js';
 import '@babylonjs/core/FrameGraph/Node/nodeRenderGraph.js';
-import '@babylonjs/core/FlowGraph/flowGraph.js';
 import '@babylonjs/core/Lights/Clustered/clusteredLightContainer.js';
 import '@babylonjs/core/Lights/directionalLight.js';
 import '@babylonjs/core/Lights/hemisphericLight.js';
@@ -99,7 +102,6 @@ import '@babylonjs/core/Materials/PBR/pbrMaterial.js';
 import '@babylonjs/core/Materials/Node/Blocks/gradientBlock.js';
 import '@babylonjs/core/Materials/Node/Enums/nodeMaterialBlockConnectionPointTypes.js';
 import '@babylonjs/core/Misc/gradients.js';
-import '@babylonjs/core/Meshes/mesh.js';
 import '@babylonjs/core/Debug/skeletonViewer.js';
 import '@babylonjs/core/Meshes/buffer.js';
 import '@babylonjs/core/Meshes/Builders/linesBuilder.js';
@@ -138,6 +140,7 @@ import '@babylonjs/core/Maths/colorTemperature.functions.js';
 import '@babylonjs/core/Bones/skeleton.js';
 import '@babylonjs/core/Sprites/sprite.js';
 import '@babylonjs/core/Sprites/spriteManager.js';
+import '@babylonjs/core/Maths/math.scalar.functions.js';
 import '@babylonjs/core/Misc/textureTools.js';
 import '@babylonjs/core/Events/keyboardEvents.js';
 import '@babylonjs/core/Events/pointerEvents.js';
@@ -151,7 +154,6 @@ import '@babylonjs/core/Materials/Textures/renderTargetTexture.js';
 import '@babylonjs/core/Materials/Textures/thinTexture.js';
 import '@babylonjs/core/AudioV2/abstractAudio/mainAudioBus.js';
 import '@babylonjs/core/FlowGraph/flowGraphCoordinator.js';
-import '@babylonjs/core/SmartAssets/smartAssetManager.pure.js';
 import '@babylonjs/core/Rendering/boundingBoxRenderer.js';
 import '@babylonjs/core/PostProcesses/RenderPipeline/postProcessRenderPipelineManagerSceneComponent.js';
 import '@babylonjs/core/Sprites/spriteSceneComponent.js';
@@ -159,10 +161,7 @@ import '@babylonjs/core/Materials/Textures/dynamicTexture.js';
 import '@babylonjs/core/Misc/equirectangularCapture.js';
 import '@babylonjs/core/Misc/sceneRecorder.js';
 import '@babylonjs/core/Misc/videoRecorder.js';
-import '@babylonjs/core/Misc/sceneSerializer.js';
 import '@babylonjs/core/Misc/environmentTextureTools.js';
-import '@babylonjs/core/Loading/Plugins/babylonFileLoader.js';
-import '@babylonjs/core/SmartAssets/smartAssetSerializer.js';
 import '@babylonjs/core/Loading/sceneLoader.js';
 import '@babylonjs/core/Misc/filesInput.js';
 import '@babylonjs/loaders/glTF/2.0/glTFLoaderExtensionRegistry.js';
@@ -209,4 +208,4 @@ var reflectorService = {
 };
 
 export { ReflectorServiceDefinition, reflectorService as default };
-//# sourceMappingURL=reflectorService-CPunL_Qs.js.map
+//# sourceMappingURL=reflectorService-CUFxJIMt.js.map

package/lib/{reflectorService-CPunL_Qs.js.map → reflectorService-CUFxJIMt.js.map}

@@ -1 +1 @@
-{"version":3,"file":"reflectorService-CPunL_Qs.js","sources":["../../../../../../../../dev/inspector-v2/src/components/tools/reflectorTools.tsx","../../../../../../../../dev/inspector-v2/src/services/panes/tools/reflectorService.tsx"],"sourcesContent":["import { ButtonLine } from \"shared-ui-components/fluent/hoc/buttonLine\";\r\nimport { useState, useCallback, useRef, type FunctionComponent } from \"react\";\r\nimport { type Scene } from \"core/scene\";\r\nimport { TextInputPropertyLine, NumberInputPropertyLine } from \"shared-ui-components/fluent/hoc/propertyLines/inputPropertyLine\";\r\nimport { Reflector } from \"core/Misc/reflector\";\r\nimport { PlugConnectedRegular } from \"@fluentui/react-icons\";\r\n\r\nexport const ReflectorTools: FunctionComponent<{ scene: Scene }> = ({ scene }) => {\r\n    const [hostname, setHostname] = useState(\"localhost\");\r\n    const [port, setPort] = useState(1234);\r\n    const reflectorRef = useRef<Reflector | null>(null);\r\n\r\n    const connectReflector = useCallback(() => {\r\n        if (reflectorRef.current) {\r\n            reflectorRef.current.close();\r\n        }\r\n\r\n        reflectorRef.current = new Reflector(scene, hostname, port);\r\n    }, [scene, hostname, port]);\r\n\r\n    return (\r\n        <>\r\n            <TextInputPropertyLine label=\"Hostname\" value={hostname} onChange={(value) => setHostname(value)} />\r\n            <NumberInputPropertyLine label=\"Port\" value={port} onChange={(value) => setPort(value)} forceInt />\r\n            <ButtonLine label=\"Connect\" icon={PlugConnectedRegular} onClick={connectReflector} />\r\n        </>\r\n    );\r\n};\r\n","import { type ServiceDefinition } from \"shared-ui-components/modularTool/modularity/serviceDefinition\";\r\nimport { ToolsServiceIdentity, type IToolsService } from \"../toolsService\";\r\nimport { type IDisposable } from \"core/scene\";\r\nimport { ReflectorTools } from \"../../../components/tools/reflectorTools\";\r\n\r\nexport const ReflectorServiceDefinition: ServiceDefinition<[], [IToolsService]> = {\r\n    friendlyName: \"Reflector Tools\",\r\n    consumes: [ToolsServiceIdentity],\r\n    factory: (toolsService) => {\r\n        const contentRegistrations: IDisposable[] = [];\r\n\r\n        // Reflector content\r\n        contentRegistrations.push(\r\n            toolsService.addSectionContent({\r\n                key: \"Reflector\",\r\n                section: \"Reflector\",\r\n                component: ({ context }) => <ReflectorTools scene={context} />,\r\n            })\r\n        );\r\n\r\n        return {\r\n            dispose: () => {\r\n                contentRegistrations.forEach((registration) => registration.dispose());\r\n            },\r\n        };\r\n    },\r\n};\r\n\r\nexport default {\r\n    serviceDefinitions: [ReflectorServiceDefinition],\r\n} as const;\r\n"],"names":["_jsxs","_Fragment","_jsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,MAAM,cAAc,GAAwC,CAAC,EAAE,KAAK,EAAE,KAAI;IAC7E,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC;IACrD,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC;AACtC,IAAA,MAAM,YAAY,GAAG,MAAM,CAAmB,IAAI,CAAC;AAEnD,IAAA,MAAM,gBAAgB,GAAG,WAAW,CAAC,MAAK;AACtC,QAAA,IAAI,YAAY,CAAC,OAAO,EAAE;AACtB,YAAA,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE;QAChC;AAEA,QAAA,YAAY,CAAC,OAAO,GAAG,IAAI,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC;IAC/D,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;AAE3B,IAAA,QACIA,IAAA,CAAAC,QAAA,EAAA,EAAA,QAAA,EAAA,CACIC,GAAA,CAAC,qBAAqB,IAAC,KAAK,EAAC,UAAU,EAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,KAAK,KAAK,WAAW,CAAC,KAAK,CAAC,EAAA,CAAI,EACpGA,GAAA,CAAC,uBAAuB,EAAA,EAAC,KAAK,EAAC,MAAM,EAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,KAAK,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAA,IAAA,EAAA,CAAG,EACnGA,GAAA,CAAC,UAAU,EAAA,EAAC,KAAK,EAAC,SAAS,EAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,gBAAgB,EAAA,CAAI,CAAA,EAAA,CACtF;AAEX,CAAC;;ACtBM,MAAM,0BAA0B,GAA2C;AAC9E,IAAA,YAAY,EAAE,iBAAiB;IAC/B,QAAQ,EAAE,CAAC,oBAAoB,CAAC;AAChC,IAAA,OAAO,EAAE,CAAC,YAAY,KAAI;QACtB,MAAM,oBAAoB,GAAkB,EAAE;;AAG9C,QAAA,oBAAoB,CAAC,IAAI,CACrB,YAAY,CAAC,iBAAiB,CAAC;AAC3B,YAAA,GAAG,EAAE,WAAW;AAChB,YAAA,OAAO,EAAE,WAAW;AACpB,YAAA,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,KAAKA,GAAA,CAAC,cAAc,EAAA,EAAC,KAAK,EAAE,OAAO,EAAA,CAAI;AACjE,SAAA,CAAC,CACL;QAED,OAAO;YACH,OAAO,EAAE,MAAK;AACV,gBAAA,oBAAoB,CAAC,OAAO,CAAC,CAAC,YAAY,KAAK,YAAY,CAAC,OAAO,EAAE,CAAC;YAC1E,CAAC;SACJ;IACL,CAAC;;AAGL,uBAAe;IACX,kBAAkB,EAAE,CAAC,0BAA0B,CAAC;CAC1C;;;;"}
+{"version":3,"file":"reflectorService-CUFxJIMt.js","sources":["../../../../../../../../dev/inspector-v2/src/components/tools/reflectorTools.tsx","../../../../../../../../dev/inspector-v2/src/services/panes/tools/reflectorService.tsx"],"sourcesContent":["import { ButtonLine } from \"shared-ui-components/fluent/hoc/buttonLine\";\r\nimport { useState, useCallback, useRef, type FunctionComponent } from \"react\";\r\nimport { type Scene } from \"core/scene\";\r\nimport { TextInputPropertyLine, NumberInputPropertyLine } from \"shared-ui-components/fluent/hoc/propertyLines/inputPropertyLine\";\r\nimport { Reflector } from \"core/Misc/reflector\";\r\nimport { PlugConnectedRegular } from \"@fluentui/react-icons\";\r\n\r\nexport const ReflectorTools: FunctionComponent<{ scene: Scene }> = ({ scene }) => {\r\n    const [hostname, setHostname] = useState(\"localhost\");\r\n    const [port, setPort] = useState(1234);\r\n    const reflectorRef = useRef<Reflector | null>(null);\r\n\r\n    const connectReflector = useCallback(() => {\r\n        if (reflectorRef.current) {\r\n            reflectorRef.current.close();\r\n        }\r\n\r\n        reflectorRef.current = new Reflector(scene, hostname, port);\r\n    }, [scene, hostname, port]);\r\n\r\n    return (\r\n        <>\r\n            <TextInputPropertyLine label=\"Hostname\" value={hostname} onChange={(value) => setHostname(value)} />\r\n            <NumberInputPropertyLine label=\"Port\" value={port} onChange={(value) => setPort(value)} forceInt />\r\n            <ButtonLine label=\"Connect\" icon={PlugConnectedRegular} onClick={connectReflector} />\r\n        </>\r\n    );\r\n};\r\n","import { type ServiceDefinition } from \"shared-ui-components/modularTool/modularity/serviceDefinition\";\r\nimport { ToolsServiceIdentity, type IToolsService } from \"../toolsService\";\r\nimport { type IDisposable } from \"core/scene\";\r\nimport { ReflectorTools } from \"../../../components/tools/reflectorTools\";\r\n\r\nexport const ReflectorServiceDefinition: ServiceDefinition<[], [IToolsService]> = {\r\n    friendlyName: \"Reflector Tools\",\r\n    consumes: [ToolsServiceIdentity],\r\n    factory: (toolsService) => {\r\n        const contentRegistrations: IDisposable[] = [];\r\n\r\n        // Reflector content\r\n        contentRegistrations.push(\r\n            toolsService.addSectionContent({\r\n                key: \"Reflector\",\r\n                section: \"Reflector\",\r\n                component: ({ context }) => <ReflectorTools scene={context} />,\r\n            })\r\n        );\r\n\r\n        return {\r\n            dispose: () => {\r\n                contentRegistrations.forEach((registration) => registration.dispose());\r\n            },\r\n        };\r\n    },\r\n};\r\n\r\nexport default {\r\n    serviceDefinitions: [ReflectorServiceDefinition],\r\n} as const;\r\n"],"names":["_jsxs","_Fragment","_jsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,MAAM,cAAc,GAAwC,CAAC,EAAE,KAAK,EAAE,KAAI;IAC7E,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC;IACrD,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC;AACtC,IAAA,MAAM,YAAY,GAAG,MAAM,CAAmB,IAAI,CAAC;AAEnD,IAAA,MAAM,gBAAgB,GAAG,WAAW,CAAC,MAAK;AACtC,QAAA,IAAI,YAAY,CAAC,OAAO,EAAE;AACtB,YAAA,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE;QAChC;AAEA,QAAA,YAAY,CAAC,OAAO,GAAG,IAAI,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC;IAC/D,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;AAE3B,IAAA,QACIA,IAAA,CAAAC,QAAA,EAAA,EAAA,QAAA,EAAA,CACIC,GAAA,CAAC,qBAAqB,IAAC,KAAK,EAAC,UAAU,EAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,KAAK,KAAK,WAAW,CAAC,KAAK,CAAC,EAAA,CAAI,EACpGA,GAAA,CAAC,uBAAuB,EAAA,EAAC,KAAK,EAAC,MAAM,EAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,KAAK,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAA,IAAA,EAAA,CAAG,EACnGA,GAAA,CAAC,UAAU,EAAA,EAAC,KAAK,EAAC,SAAS,EAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,gBAAgB,EAAA,CAAI,CAAA,EAAA,CACtF;AAEX,CAAC;;ACtBM,MAAM,0BAA0B,GAA2C;AAC9E,IAAA,YAAY,EAAE,iBAAiB;IAC/B,QAAQ,EAAE,CAAC,oBAAoB,CAAC;AAChC,IAAA,OAAO,EAAE,CAAC,YAAY,KAAI;QACtB,MAAM,oBAAoB,GAAkB,EAAE;;AAG9C,QAAA,oBAAoB,CAAC,IAAI,CACrB,YAAY,CAAC,iBAAiB,CAAC;AAC3B,YAAA,GAAG,EAAE,WAAW;AAChB,YAAA,OAAO,EAAE,WAAW;AACpB,YAAA,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,KAAKA,GAAA,CAAC,cAAc,EAAA,EAAC,KAAK,EAAE,OAAO,EAAA,CAAI;AACjE,SAAA,CAAC,CACL;QAED,OAAO;YACH,OAAO,EAAE,MAAK;AACV,gBAAA,oBAAoB,CAAC,OAAO,CAAC,CAAC,YAAY,KAAK,YAAY,CAAC,OAAO,EAAE,CAAC;YAC1E,CAAC;SACJ;IACL,CAAC;;AAGL,uBAAe;IACX,kBAAkB,EAAE,CAAC,0BAA0B,CAAC;CAC1C;;"}

package/lib/services/panes/explorer/explorerPane.d.ts

@@ -0,0 +1,79 @@
+import { type IDisposable, type IReadonlyObservable, type Nullable } from "@babylonjs/core/index.js";
+import { type ComponentType } from "react";
+import { type ExplorerCommandProvider, type ExplorerNodeDescription } from "../../../components/explorer/explorerModel";
+import { type ExplorerNodeProvider } from "./explorerService";
+import { type ISelectionService } from "../../selectionService";
+import { type IShellService } from "@babylonjs/shared-ui-components/modularTool/services/shellService.js";
+import { type IReadonlyObservableCollection } from "@babylonjs/shared-ui-components/modularTool/misc/observableCollection.js";
+/**
+ * Describes an Explorer side pane, including the services it needs and the hierarchy it displays.
+ *
+ * This is intentionally not a service: products (such as the Full/BJS Inspector's Scene Explorer or the
+ * Babylon Lite engine explorer) own their pane directly and use this to share the common pane plumbing.
+ * @internal
+ */
+export type ExplorerPaneOptions = Readonly<{
+    /**
+     * The unique key of the side pane.
+     */
+    key: string;
+    /**
+     * The title displayed on the side pane.
+     */
+    title: string;
+    /**
+     * Gets the root object of the hierarchy (e.g. a Scene for the Full Inspector, or an engine for
+     * the Babylon Lite Inspector). It is displayed as the root node, and nothing is rendered while
+     * it is null. This is re-evaluated whenever `onRootChanged` notifies.
+     */
+    getRoot: () => Nullable<object>;
+    /**
+     * The name displayed for the root node (e.g. "Scene" or "Engine").
+     */
+    rootLabel: string;
+    /**
+     * An optional icon component to render for the root node.
+     */
+    rootIcon?: ComponentType<{
+        entity: object;
+    }>;
+    /**
+     * An optional observable that notifies when the object returned by `getRoot` changes. Products
+     * with a fixed root (such as the Babylon Lite Inspector, which inspects a single engine for the
+     * lifetime of the pane) can omit it.
+     */
+    onRootChanged?: IReadonlyObservable<unknown>;
+    /**
+     * Enumerates the top level nodes of the hierarchy (excluding the root node, which represents the
+     * object being inspected and is added automatically). This is re-invoked whenever the Explorer
+     * rebuilds its tree, so it should always reflect the current state.
+     */
+    getNodes: () => readonly ExplorerNodeDescription[];
+    /**
+     * An optional observable that notifies when the set of nodes returned by `getNodes` changes
+     * (e.g. a new top level node was added). Changes within an already described node are
+     * communicated through that node's own change observables instead.
+     */
+    onNodesChanged?: IReadonlyObservable<void>;
+    /**
+     * Optional providers that contribute nodes beneath compatible entity-backed nodes.
+     */
+    nodeProviders?: IReadonlyObservableCollection<ExplorerNodeProvider<object>>;
+    /**
+     * Optional command providers for nodes that represent an entity.
+     */
+    itemCommandProviders?: IReadonlyObservableCollection<ExplorerCommandProvider<object>>;
+    /**
+     * Optional command providers for group nodes (the command context is the group's display name).
+     */
+    groupCommandProviders?: IReadonlyObservableCollection<ExplorerCommandProvider<string, "contextMenu">>;
+}>;
+/**
+ * Registers an Explorer side pane that enables browsing a hierarchy and executing commands on its entities.
+ * @param shellService The shell service the pane is added to.
+ * @param selectionService The selection service used to read and update the selected entity.
+ * @param options Options describing the pane, its root object, and the hierarchy it displays.
+ * @returns A disposable that removes the pane.
+ * @internal
+ */
+export declare function CreateExplorerPaneRegistration(shellService: IShellService, selectionService: ISelectionService, options: ExplorerPaneOptions): IDisposable;

package/lib/services/panes/explorer/explorerService.d.ts

@@ -0,0 +1,80 @@
+import { type IDisposable, type IReadonlyObservable } from "@babylonjs/core/index.js";
+import { type ExplorerCommandProvider, type ExplorerNodeDescription } from "../../../components/explorer/explorerModel";
+import { type IReadonlyObservableCollection } from "@babylonjs/shared-ui-components/modularTool/misc/observableCollection.js";
+import { type IService } from "@babylonjs/shared-ui-components/modularTool/modularity/serviceDefinition.js";
+/**
+ * The unique identity symbol for the product-neutral Explorer service.
+ * @experimental
+ */
+export declare const ExplorerServiceIdentity: unique symbol;
+/**
+ * Contributes Explorer nodes beneath compatible entity-backed parent nodes.
+ *
+ * Providers return ordinary {@link ExplorerNodeDescription}s, so each contribution may contain arbitrary
+ * nested groups and items. Providers attach by parent entity rather than node id because structural groups
+ * are presentation details owned by product adapters.
+ * @experimental
+ */
+export type ExplorerNodeProvider<T extends object> = Readonly<{
+    /** Controls this provider's position relative to other providers attached to the same parent. */
+    order?: number;
+    /** Returns whether this provider supports the parent entity. */
+    predicate: (parent: unknown) => parent is T;
+    /** Gets the Explorer nodes contributed beneath the parent entity. */
+    getNodes: (parent: T) => readonly ExplorerNodeDescription[];
+    /** Optionally notifies when the nodes returned by this provider may have changed. */
+    onChanged?: IReadonlyObservable<unknown>;
+}>;
+/**
+ * Allows hierarchy and commands to be contributed to an Explorer without depending on a product-specific API.
+ *
+ * The item/group terminology intentionally matches `ExplorerNodeKind`. Product adapters may expose
+ * domain-specific aliases (such as entity/section), but a generic Explorer group is not necessarily a scene section.
+ * @experimental
+ */
+export interface IExplorerService extends IService<typeof ExplorerServiceIdentity> {
+    /**
+     * Adds a provider that contributes nodes beneath compatible entity-backed Explorer nodes.
+     * @param provider The node provider to add.
+     * @returns A disposable that removes the node provider.
+     */
+    addNodeProvider<T extends object>(provider: ExplorerNodeProvider<T>): IDisposable;
+    /**
+     * Adds a command that can be executed on Explorer item nodes.
+     * @param command The command provider to add.
+     * @returns A disposable that removes the command provider.
+     */
+    addItemCommand<T extends object>(command: ExplorerCommandProvider<T>): IDisposable;
+    /**
+     * Adds a context-menu command that can be executed on Explorer group nodes.
+     * @param command The command provider to add.
+     * @returns A disposable that removes the command provider.
+     */
+    addGroupCommand<T extends string>(command: ExplorerCommandProvider<T, "contextMenu">): IDisposable;
+}
+/**
+ * The shared Explorer service implementation and the command collections consumed by an Explorer pane.
+ * @internal
+ */
+export type ExplorerServiceState = IExplorerService & Readonly<{
+    nodeProviders: IReadonlyObservableCollection<ExplorerNodeProvider<object>>;
+    itemCommandProviders: IReadonlyObservableCollection<ExplorerCommandProvider<object>>;
+    groupCommandProviders: IReadonlyObservableCollection<ExplorerCommandProvider<string, "contextMenu">>;
+    dispose: () => void;
+}>;
+/**
+ * Creates the product-neutral Explorer contribution service.
+ * @returns The service implementation and its observable contribution collections.
+ * @internal
+ */
+export declare function CreateExplorerService(): ExplorerServiceState;
+/**
+ * Combines product-owned children with shared provider contributions and recursively enables contributions
+ * beneath every entity-backed descendant.
+ * @param parent The entity represented by the parent node, if any.
+ * @param children The children owned by the product adapter.
+ * @param providers The shared node providers registered with the Explorer.
+ * @returns The combined child node descriptions.
+ * @internal
+ */
+export declare function GetExplorerNodeChildren(parent: object | undefined, children: readonly ExplorerNodeDescription[], providers: readonly ExplorerNodeProvider<object>[]): readonly ExplorerNodeDescription[];

package/lib/services/panes/scene/sceneExplorerService.d.ts

@@ -4,12 +4,16 @@ import { type IService, type ServiceDefinition } from "@babylonjs/shared-ui-comp
 import { type ISceneContext } from "../../sceneContext";
 import { type ISelectionService } from "../../selectionService";
 import { type IShellService } from "@babylonjs/shared-ui-components/modularTool/services/shellService.js";
+import { type IExplorerService } from "../explorer/explorerService";
 /**
  * The unique identity symbol for the scene explorer service.
  */
 export declare const SceneExplorerServiceIdentity: unique symbol;
 /**
  * Allows new sections or commands to be added to the scene explorer pane.
+ *
+ * Entity and section commands are Full Inspector conveniences over the product-neutral item and group command APIs.
+ * They remain scene-specific so other Explorer products do not have to model their groups as scene sections.
  */
 export interface ISceneExplorerService extends IService<typeof SceneExplorerServiceIdentity> {
     /**
@@ -29,6 +33,7 @@ export interface ISceneExplorerService extends IService<typeof SceneExplorerServ
     addSectionCommand<T extends string>(command: SceneExplorerCommandProvider<T, "contextMenu">): IDisposable;
 }
 /**
- * Provides a scene explorer pane that enables browsing the scene graph and executing commands on entities.
+ * Adapts the Babylon.js scene section/entity model onto the generic Explorer, and owns the "Scene Explorer"
+ * pane that enables browsing the scene graph and executing commands on entities.
  */
-export declare const SceneExplorerServiceDefinition: ServiceDefinition<[ISceneExplorerService], [ISceneContext, IShellService, ISelectionService]>;
+export declare const SceneExplorerServiceDefinition: ServiceDefinition<[ISceneExplorerService, IExplorerService], [ISceneContext, IShellService, ISelectionService]>;

package/lib/services/sceneSelectionService.d.ts

@@ -0,0 +1,11 @@
+import { type ServiceDefinition } from "@babylonjs/shared-ui-components/modularTool/modularity/serviceDefinition.js";
+import { type ISceneContext } from "./sceneContext";
+import { type ISelectionService } from "./selectionService";
+/**
+ * Selects the scene by default when the Babylon.js Inspector starts.
+ *
+ * The selection service itself is product agnostic (it starts with no selection), so this Babylon.js
+ * specific service owns the notion of "the scene is what is selected when nothing else is". It does not
+ * produce a service contract: it only wires the scene context to the selection service at startup.
+ */
+export declare const SceneSelectionServiceDefinition: ServiceDefinition<[], [ISceneContext, ISelectionService]>;

package/lib/services/selectionService.d.ts

@@ -1,7 +1,6 @@
 import { type IReadonlyObservable, type Nullable } from "@babylonjs/core/index.js";
 import { type IService, type ServiceDefinition } from "@babylonjs/shared-ui-components/modularTool/modularity/serviceDefinition.js";
 import { type ISettingsService } from "@babylonjs/shared-ui-components/modularTool/services/settingsService.js";
-import { type ISceneContext } from "./sceneContext";
 import { type ISettingsStore } from "@babylonjs/shared-ui-components/modularTool/services/settingsStore.js";
 import { type IShellService } from "@babylonjs/shared-ui-components/modularTool/services/shellService.js";
 /**
@@ -21,4 +20,8 @@ export interface ISelectionService extends IService<typeof SelectionServiceIdent
      */
     readonly onSelectedEntityChanged: IReadonlyObservable<void>;
 }
-export declare const SelectionServiceDefinition: ServiceDefinition<[ISelectionService], [IShellService, ISettingsStore, ISettingsService, ISceneContext]>;
+/**
+ * Tracks the currently selected entity. This service is product agnostic: it starts with no selection,
+ * and each product decides which entity (if any) is selected by default.
+ */
+export declare const SelectionServiceDefinition: ServiceDefinition<[ISelectionService], [IShellService, ISettingsStore, ISettingsService]>;

package/lib/services/watcherService.d.ts

@@ -4,6 +4,31 @@ import { type ISettingsService } from "@babylonjs/shared-ui-components/modularTo
 import { type ISettingsStore } from "@babylonjs/shared-ui-components/modularTool/services/settingsStore.js";
 import { type IShellService } from "@babylonjs/shared-ui-components/modularTool/services/shellService.js";
 import { type IReactContextService } from "@babylonjs/shared-ui-components/modularTool/services/reactContextService.js";
+type InterceptSettings = {
+    mode: "intercept";
+};
+type PollingSettings = {
+    mode: "polling";
+    interval: number;
+};
+type ManualSettings = {
+    mode: "manual";
+};
+type WatcherSettings = InterceptSettings | PollingSettings | ManualSettings;
+type WatcherServiceOptions = {
+    /**
+     * The watcher settings used when no settings have been persisted.
+     */
+    defaultSettings?: WatcherSettings;
+    /**
+     * The watcher modes supported by this Inspector target.
+     */
+    supportedModes?: readonly WatcherSettings["mode"][];
+    /**
+     * The fallback interval for computed values when interception is the preferred mode.
+     */
+    computedValuePollingInterval?: number;
+};
 /**
  * The unique identity symbol for the watcher service.
  */
@@ -28,11 +53,29 @@ export interface IWatcherService extends IService<typeof WatcherServiceIdentity>
      * @returns A disposable that stops watching when disposed.
      */
     watchProperty<T extends object>(target: T, propertyKey: keyof T, onChanged: (value: unknown) => void): IDisposable;
+    /**
+     * Watches a computed value and calls the callback whenever it changes. Computed values use fallback
+     * polling when interception is preferred, the configured interval in polling mode, and explicit
+     * refreshes in manual mode.
+     * @param getValue A function that returns the current value.
+     * @param onChanged A callback that is called with the new value when it changes.
+     * @param equals An optional equality comparison. Defaults to {@link Object.is}.
+     * @returns A disposable that stops watching when disposed.
+     */
+    watchValue<T>(getValue: () => T, onChanged: (value: T) => void, equals?: (left: T, right: T) => boolean): IDisposable;
     /**
      * Manually triggers a refresh of all watched properties.
      */
     refresh(): void;
 }
-export declare const WatcherServiceDefinition: ServiceDefinition<[IWatcherService], [ISettingsStore, IReactContextService]>;
-export declare const WatcherSettingsServiceDefinition: ServiceDefinition<[], [ISettingsService]>;
-export declare const WatcherRefreshToolbarServiceDefinition: ServiceDefinition<[], [IWatcherService, ISettingsStore, IShellService]>;
+/**
+ * Creates the watcher services for a specific Inspector target.
+ * @param options Options that control the default and supported watcher modes.
+ * @returns Service definitions for watching values, configuring the watcher, and manually refreshing it.
+ */
+export declare function MakeWatcherServiceDefinitions(options?: WatcherServiceOptions): {
+    readonly watcherServiceDefinition: ServiceDefinition<[IWatcherService], [ISettingsStore, IReactContextService]>;
+    readonly watcherSettingsServiceDefinition: ServiceDefinition<[], [ISettingsService]>;
+    readonly watcherRefreshToolbarServiceDefinition: ServiceDefinition<[], [IWatcherService, ISettingsStore, IShellService]>;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@babylonjs/inspector",
-    "version": "9.25.0",
+    "version": "9.26.1",
     "main": "lib/index.js",
     "module": "lib/index.js",
     "esnext": "lib/index.js",
@@ -10,6 +10,10 @@
             "types": "./lib/index.d.ts",
             "default": "./lib/index.js"
         },
+        "./lite": {
+            "types": "./lib/lite/index.d.ts",
+            "default": "./lib/lite/index.js"
+        },
         "./package.json": "./package.json"
     },
     "bin": {
@@ -36,6 +40,7 @@
         "@babylonjs/core": "^9.0.0",
         "@babylonjs/gui": "^9.0.0",
         "@babylonjs/gui-editor": "^9.0.0",
+        "@babylonjs/lite": "^1.27.0",
         "@babylonjs/loaders": "^9.0.0",
         "@babylonjs/materials": "^9.0.0",
         "@babylonjs/node-editor": "^9.0.0",
@@ -53,7 +58,13 @@
         "react-dom": ">=16.14.0 <20.0.0",
         "usehooks-ts": "^3.1.1"
     },
+    "peerDependenciesMeta": {
+        "@babylonjs/lite": {
+            "optional": true
+        }
+    },
     "devDependencies": {
+        "@babylonjs/lite": "1.27.0",
         "@dev/build-tools": "^1.0.0",
         "@dev/inspector": "1.0.0",
         "@rollup/plugin-alias": "^5.1.0",

package/readme.md

@@ -22,6 +22,16 @@ import { ShowInspector } from "@babylonjs/inspector";
 ShowInspector(scene);
 ```
 
+### Babylon Lite
+
+The initial Babylon Lite Inspector can display the surfaces and rendering contexts associated with an engine:
+
+```ts
+import { ShowInspector } from "@babylonjs/inspector/lite";
+
+ShowInspector(engine);
+```
+
 ## Headless Inspectable (No UI)
 
 You can make a scene inspectable for the CLI without showing the Inspector UI by calling `StartInspectable`: