@babylonjs/inspector 9.16.1 → 9.16.2

package/lib/{index-DG9gOJk5.js → index-DhgT03HX.js}

@@ -145,6 +145,7 @@ import { MultiRenderTarget } from '@babylonjs/core/Materials/Textures/multiRende
 import { RenderTargetTexture } from '@babylonjs/core/Materials/Textures/renderTargetTexture.js';
 import { ThinTexture } from '@babylonjs/core/Materials/Textures/thinTexture.js';
 import { MainAudioBus } from '@babylonjs/core/AudioV2/abstractAudio/mainAudioBus.js';
+import { FindSmartAssetKeyForObject, SerializeSmartAssetManagerMap, GetSmartAssetTextureExtensions, GetAllSmartAssets, RemoveSmartAssetAsync, RegisterSmartAsset, LoadAllSmartAssetsAsync, LoadSmartAssetAsync, GetSmartAssetManager, LoadSmartAssetTextureAsync, ReloadSmartAssetAsync, UnloadSmartAssetAsync } from '@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';
@@ -154,7 +155,6 @@ import { SceneRecorder } from '@babylonjs/core/Misc/sceneRecorder.js';
 import { VideoRecorder } from '@babylonjs/core/Misc/videoRecorder.js';
 import { SceneSerializer } from '@babylonjs/core/Misc/sceneSerializer.js';
 import { EnvironmentTextureTools } from '@babylonjs/core/Misc/environmentTextureTools.js';
-import { FindSmartAssetKeyForObject, SerializeSmartAssetManagerMap, GetSmartAssetTextureExtensions, GetAllSmartAssets, RemoveSmartAssetAsync, RegisterSmartAsset, LoadAllSmartAssetsAsync, LoadSmartAssetAsync, GetSmartAssetManager, LoadSmartAssetTextureAsync, ReloadSmartAssetAsync, UnloadSmartAssetAsync } from '@babylonjs/core/SmartAssets/smartAssetManager.pure.js';
 import '@babylonjs/core/Loading/Plugins/babylonFileLoader.js';
 import { ReadJsonSourceAsync, ResolveAssetUrl, DeserializeSmartAssetMap } from '@babylonjs/core/SmartAssets/smartAssetSerializer.js';
 import { ImportAnimationsAsync, SceneLoader } from '@babylonjs/core/Loading/sceneLoader.js';
@@ -8805,7 +8805,7 @@ function MakeModularTool(options) {
                 }
                 // Register the extension list service (for browsing/installing extensions) if extension feeds are provided.
                 if (extensionFeeds.length > 0) {
-                    const { ExtensionListServiceDefinition } = await import('./extensionsListService-C6UitRwb.js');
+                    const { ExtensionListServiceDefinition } = await import('./extensionsListService-PdjX95Wt.js');
                     serviceContainer.addService(ExtensionListServiceDefinition);
                 }
                 // Register all external services (that make up a unique tool).
@@ -8946,14 +8946,14 @@ const DefaultInspectorExtensionFeed = new BuiltInsExtensionFeed("Inspector", [
         description: "Adds a new panel for easy creation of various Babylon assets. This is a WIP extension...expect changes!",
         keywords: ["creation", "tools"],
         ...BabylonWebResources,
-        getExtensionModuleAsync: async () => await import('./quickCreateToolsService-xvSzPXeJ.js'),
+        getExtensionModuleAsync: async () => await import('./quickCreateToolsService-D5JrCb-u.js'),
     },
     {
         name: "Reflector",
         description: "Connects to the Reflector Bridge for real-time scene synchronization with the Babylon.js Sandbox.",
         keywords: ["reflector", "bridge", "sync", "sandbox", "tools"],
         ...BabylonWebResources,
-        getExtensionModuleAsync: async () => await import('./reflectorService-CVK7MlrU.js'),
+        getExtensionModuleAsync: async () => await import('./reflectorService-Ce2pbz5D.js'),
     },
 ]);
 
@@ -21867,7 +21867,7 @@ const BaseTextureCharacteristicProperties = (props) => {
     const displayFormat = FindTextureFormat(format === -1 ? Constants.TEXTUREFORMAT_RGBA : format);
     const displayType = FindTextureType(type === -1 ? Constants.TEXTURETYPE_UNSIGNED_BYTE : type);
     const maxAnisotropy = texture.getScene()?.getEngine().getCaps().maxAnisotropy ?? 1;
-    return (jsxs(Fragment, { children: [texture.is2DArray && jsx(TextPropertyLine, { label: "Layers", value: depth?.toString() ?? "?" }), texture.is3D && jsx(TextPropertyLine, { label: "Depth", value: depth?.toString() ?? "?" }), jsx(TextPropertyLine, { label: "Format", value: displayFormat?.label ?? "unknown" }), !displayFormat?.hideType && !displayFormat?.compressed && jsx(TextPropertyLine, { label: "Type", value: displayType?.label ?? "unknown" }), !!displayFormat?.normalizable && !displayFormat?.compressed && displayType?.normalizable != undefined && (jsx(BooleanBadgePropertyLine, { label: "Normalized", value: displayType.normalizable })), jsx(BooleanBadgePropertyLine, { label: "Compressed", value: displayFormat?.compressed ?? false }), jsx(BooleanBadgePropertyLine, { label: "sRGB Buffers", value: useSRGBBuffer ?? false }), jsx(BoundProperty, { component: BooleanBadgePropertyLine, label: "Gamma Space", target: texture, propertyKey: "gammaSpace" }), jsx(BoundProperty, { component: BooleanBadgePropertyLine, label: "Has Alpha", target: texture, propertyKey: "hasAlpha" }), jsx(BoundProperty, { component: SwitchPropertyLine, label: "Alpha from RGB", target: texture, propertyKey: "getAlphaFromRGB" }), jsx(BooleanBadgePropertyLine, { label: "3D", value: texture.is3D }), jsx(BooleanBadgePropertyLine, { label: "2D Array", value: texture.is2DArray }), jsx(BooleanBadgePropertyLine, { label: "Cube", value: texture.isCube }), jsx(BooleanBadgePropertyLine, { label: "Render Target", value: texture.isRenderTarget }), jsx(BooleanBadgePropertyLine, { label: "Mipmaps", value: !texture.noMipmap }), jsx(TextPropertyLine, { label: "Samples", value: samples.toString() }), jsx(BoundProperty, { component: SyncedSliderPropertyLine, label: "UV Set", target: texture, propertyKey: "coordinatesIndex", min: 0, max: 3, step: 1 }), jsx(BoundProperty, { component: NumberDropdownPropertyLine, label: "Mode", target: texture, propertyKey: "coordinatesMode", options: CoordinatesMode }), jsx(BoundProperty, { component: SyncedSliderPropertyLine, label: "Level", target: texture, propertyKey: "level", min: 0, max: 2, step: 0.01 }), jsx(BoundProperty, { component: SyncedSliderPropertyLine, label: "Anisotropy", target: texture, propertyKey: "anisotropicFilteringLevel", min: 1, max: maxAnisotropy, step: 1 })] }));
+    return (jsxs(Fragment, { children: [texture.is2DArray && jsx(TextPropertyLine, { label: "Layers", value: depth?.toString() ?? "?" }), texture.is3D && jsx(TextPropertyLine, { label: "Depth", value: depth?.toString() ?? "?" }), jsx(TextPropertyLine, { label: "Format", value: displayFormat?.label ?? "unknown" }), !displayFormat?.hideType && !displayFormat?.compressed && jsx(TextPropertyLine, { label: "Type", value: displayType?.label ?? "unknown" }), !!displayFormat?.normalizable && !displayFormat?.compressed && displayType?.normalizable != undefined && (jsx(BooleanBadgePropertyLine, { label: "Normalized", value: displayType.normalizable })), jsx(BooleanBadgePropertyLine, { label: "Compressed", value: displayFormat?.compressed ?? false }), jsx(BooleanBadgePropertyLine, { label: "sRGB Buffers", value: useSRGBBuffer ?? false }), jsx(BoundProperty, { component: BooleanBadgePropertyLine, label: "Gamma Space", target: texture, propertyKey: "gammaSpace" }), jsx(BoundProperty, { component: SwitchPropertyLine, label: "Has Alpha", target: texture, propertyKey: "hasAlpha" }), jsx(BoundProperty, { component: SwitchPropertyLine, label: "Alpha from RGB", target: texture, propertyKey: "getAlphaFromRGB" }), jsx(BooleanBadgePropertyLine, { label: "3D", value: texture.is3D }), jsx(BooleanBadgePropertyLine, { label: "2D Array", value: texture.is2DArray }), jsx(BooleanBadgePropertyLine, { label: "Cube", value: texture.isCube }), jsx(BooleanBadgePropertyLine, { label: "Render Target", value: texture.isRenderTarget }), jsx(BooleanBadgePropertyLine, { label: "Mipmaps", value: !texture.noMipmap }), jsx(TextPropertyLine, { label: "Samples", value: samples.toString() }), jsx(BoundProperty, { component: SyncedSliderPropertyLine, label: "UV Set", target: texture, propertyKey: "coordinatesIndex", min: 0, max: 3, step: 1 }), jsx(BoundProperty, { component: NumberDropdownPropertyLine, label: "Mode", target: texture, propertyKey: "coordinatesMode", options: CoordinatesMode }), jsx(BoundProperty, { component: SyncedSliderPropertyLine, label: "Level", target: texture, propertyKey: "level", min: 0, max: 2, step: 0.01 }), jsx(BoundProperty, { component: SyncedSliderPropertyLine, label: "Anisotropy", target: texture, propertyKey: "anisotropicFilteringLevel", min: 1, max: maxAnisotropy, step: 1 })] }));
 };
 const BaseTextureTransformProperties = (props) => {
     const { texture } = props;
@@ -21906,7 +21906,25 @@ const TexturePreviewProperties = (props) => {
 };
 const TextureGeneralProperties = (props) => {
     const { texture } = props;
-    return (jsx(Fragment, { children: jsx(BooleanBadgePropertyLine, { label: "Invert Y", description: "If true, the texture is stored as inverted on Y", value: texture.invertY }) }));
+    const invertY = useProperty(texture, "invertY");
+    const url = useProperty(texture, "url");
+    const notifyPropertyChanged = usePropertyChangedNotifier();
+    // invertY is applied at upload time (UNPACK_FLIP_Y), so changing it requires re-uploading the source
+    // image. That is only valid for a plain Texture loaded from a URL. Subclasses that reuse this section
+    // (VideoTexture, DynamicTexture, RenderTargetTexture, etc.) either report a different class name or have
+    // no source URL to reload, so for those invertY is surfaced as read-only.
+    const canToggleInvertY = texture.getClassName() === "Texture" && !!url;
+    return (jsx(Fragment, { children: canToggleInvertY ? (jsx(Property, { component: SwitchPropertyLine, label: "Invert Y", description: "If true, the texture is stored as inverted on Y", propertyPath: "invertY", value: invertY, onChange: (value) => {
+                const oldValue = texture.invertY;
+                // invertY is baked into the uploaded texel data, so re-upload the texture to apply it.
+                // updateURL releases only the underlying GPU texture and reuses this same Texture
+                // instance, so all scene references (materials, nodes) stay intact.
+                texture._invertY = value;
+                texture.updateURL(texture.url, texture._buffer);
+                // Property does not bind onChange, so forward the change to the Inspector's
+                // property-change pipeline (e.g. for override capture on .babylonproj projects).
+                notifyPropertyChanged(texture, "invertY", oldValue, value);
+            } })) : (jsx(BooleanBadgePropertyLine, { label: "Invert Y", description: "If true, the texture is stored as inverted on Y", value: invertY })) }));
 };
 const TextureTransformProperties = (props) => {
     const { texture } = props;
@@ -22078,10 +22096,10 @@ const TexturePropertiesServiceDefinition = {
 
 const TransformProperties = (props) => {
     const { transform } = props;
-    const quatRotation = useQuaternionProperty(transform, "rotationQuaternion");
+    const quatRotation = useProperty(transform, "rotationQuaternion");
     const [useDegrees] = useSetting(UseDegreesSettingDescriptor);
     const [useEuler] = useSetting(UseEulerSettingDescriptor);
-    return (jsxs(Fragment, { children: [jsx(BoundProperty, { component: Vector3PropertyLine, label: "Position", target: transform, propertyKey: "position" }), quatRotation ? (jsx(Property, { component: QuaternionPropertyLine, label: "Rotation", propertyPath: "rotationQuaternion", value: quatRotation, onChange: (val) => (transform.rotationQuaternion = val), useDegrees: useDegrees, useEuler: useEuler })) : (jsx(BoundProperty, { component: RotationVectorPropertyLine, label: "Rotation", target: transform, propertyKey: "rotation", useDegrees: useDegrees })), jsx(BoundProperty, { component: Vector3PropertyLine, label: "Scaling", target: transform, propertyKey: "scaling", step: 0.1 })] }));
+    return (jsxs(Fragment, { children: [jsx(BoundProperty, { component: Vector3PropertyLine, label: "Position", target: transform, propertyKey: "position" }), quatRotation ? (jsx(BoundProperty, { component: QuaternionPropertyLine, label: "Rotation", target: transform, propertyKey: "rotationQuaternion", propertyPath: "rotationQuaternion", defaultValue: null, useDegrees: useDegrees, useEuler: useEuler })) : (jsx(BoundProperty, { component: RotationVectorPropertyLine, label: "Rotation", target: transform, propertyKey: "rotation", useDegrees: useDegrees })), jsx(BoundProperty, { component: Vector3PropertyLine, label: "Scaling", target: transform, propertyKey: "scaling", step: 0.1 })] }));
 };
 
 const TransformPropertiesServiceDefinition = {
@@ -22827,1554 +22845,2064 @@ const MaterialExplorerServiceDefinition = {
     },
 };
 
-function IsCameraFrameGraphTask(task) {
-    return task.camera instanceof Camera;
+const OverrideManagerKey = Symbol("babylonjs:overrideManager");
+const OverrideManagerInternals = new WeakMap();
+const OnOverrideManagerCreatedObservable = new Observable();
+/**
+ * Creates a new OverrideManager state object and attaches it to the scene.
+ *
+ * Internal: callers should use {@link GetOverrideManager} which returns the
+ * existing manager when one is already attached.
+ * @param scene - The scene this manager operates on.
+ * @returns The created override manager state.
+ */
+function CreateOverrideManager(scene) {
+    const manager = {
+        scene,
+        onChangedObservable: new Observable(),
+    };
+    const internal = {
+        overrides: [],
+        originalValues: new Map(),
+        sceneDisposeObserver: null,
+    };
+    OverrideManagerInternals.set(manager, internal);
+    if (!scene.metadata) {
+        scene.metadata = {};
+    }
+    scene.metadata[OverrideManagerKey] = manager;
+    // Auto-dispose when the scene is disposed so the manager doesn't outlive it.
+    internal.sceneDisposeObserver = scene.onDisposeObservable.add(() => DisposeOverrideManager(manager));
+    OnOverrideManagerCreatedObservable.notifyObservers(manager);
+    return manager;
 }
-function IsNodesSectionType(node) {
-    return node instanceof TransformNode || node instanceof Camera || node instanceof Light;
+/**
+ * Returns the OverrideManager attached to the given scene, creating and
+ * attaching one if none exists.
+ * @param scene - The scene to look up or attach a manager to.
+ * @returns The existing or newly created OverrideManager.
+ */
+function GetOverrideManager(scene) {
+    const existing = scene.metadata?.[OverrideManagerKey];
+    if (existing) {
+        return existing;
+    }
+    return CreateOverrideManager(scene);
 }
-const NodeExplorerServiceDefinition = {
-    friendlyName: "Node Explorer",
-    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, GizmoServiceIdentity, WatcherServiceIdentity],
-    factory: (sceneExplorerService, sceneContext, gizmoService, watcherService) => {
-        const scene = sceneContext.currentScene;
-        if (!scene) {
-            return undefined;
+/**
+ * Adds an override entry and immediately applies it.
+ * If an override with the same target coordinates already exists, it is replaced.
+ *
+ * When the caller has already mutated the target (e.g. an Inspector edit),
+ * pass `{ originalValue }` containing the property's prior value — this seeds
+ * the original-value map (so {@link RemoveOverride} can restore it) and skips
+ * the redundant apply step.
+ * @param scene - The scene whose override registry to update.
+ * @param entry - The override to add.
+ * @param options - Optional behavior modifiers; see {@link AddOverrideOptions}.
+ */
+function AddOverride(scene, entry, options) {
+    const manager = GetOverrideManager(scene);
+    const internal = GetOverrideInternals(manager);
+    RemoveMatchingOverride(internal, entry.targetType, entry.targetName, entry.targetIndex, entry.propertyPath);
+    internal.overrides.push(entry);
+    if (options && "originalValue" in options) {
+        // Caller already applied the new value. Seed the captured original from
+        // their pre-edit snapshot — otherwise ApplyOverrideEntry would capture
+        // the post-edit value and RemoveOverride would have nothing to restore.
+        const origKey = MakeOriginalValueKey(entry.targetType, entry.targetName, entry.targetIndex, entry.propertyPath);
+        if (!internal.originalValues.has(origKey)) {
+            internal.originalValues.set(origKey, CloneValue(options.originalValue));
         }
-        const nodeMovedObservable = new Observable();
-        // Set of all nodes known to be in the scene, rebuilt each time getRootEntities
-        // is called. Used by getEntityDisplayInfo to detect orphaned ancestor nodes.
-        const knownSceneNodes = new Set();
-        const sectionRegistration = sceneExplorerService.addSection({
-            displayName: "Nodes",
-            order: 100 /* DefaultSectionsOrder.Nodes */,
-            getRootEntities: () => {
-                const rootNodes = new Set(scene.rootNodes);
-                knownSceneNodes.clear();
-                // Ensure all nodes in the scene are reachable in the explorer, even if their
-                // parent was removed from the scene or is not a type shown in the Nodes section.
-                for (const node of [...scene.meshes, ...scene.transformNodes, ...scene.cameras, ...scene.lights]) {
-                    knownSceneNodes.add(node);
-                    if (!node.parent) {
-                        continue;
-                    }
-                    if (!IsNodesSectionType(node.parent)) {
-                        // Parent is not a type shown in the Nodes section (e.g. a Bone).
-                        // Treat this node as a root so it still appears in the explorer.
-                        rootNodes.add(node);
-                    }
-                    else {
-                        // Walk up through Nodes-section-type parents to find the topmost ancestor.
-                        // If that ancestor was removed from the scene (not in rootNodes), add it
-                        // so the entire subtree remains visible in the explorer.
-                        let ancestor = node.parent;
-                        while (ancestor.parent && IsNodesSectionType(ancestor.parent)) {
-                            ancestor = ancestor.parent;
-                        }
-                        rootNodes.add(ancestor);
-                    }
-                }
-                // Lights within a clustered light container are not included in Scene.lights or Scene.rootNodes.
-                // If they also have no parent, then they won't show up anywhere, so show them as root nodes.
-                for (const light of scene.lights) {
-                    if (light instanceof ClusteredLightContainer) {
-                        for (const childLight of light.lights) {
-                            knownSceneNodes.add(childLight);
-                            if (!childLight.parent) {
-                                rootNodes.add(childLight);
-                            }
-                        }
-                    }
+    }
+    else {
+        ApplyOverrideEntry(manager, internal, entry);
+    }
+    manager.onChangedObservable.notifyObservers();
+}
+/**
+ * Removes a single override matching the given coordinates. Restores the
+ * original value if one was captured.
+ * @param scene - The scene whose override registry to update.
+ * @param targetType - The target type.
+ * @param targetName - The target object name.
+ * @param targetIndex - The target index among same-named siblings.
+ * @param propertyPath - The property path to un-override.
+ * @returns True if an override was removed.
+ */
+function RemoveOverride(scene, targetType, targetName, targetIndex, propertyPath) {
+    const manager = GetOverrideManager(scene);
+    const internal = GetOverrideInternals(manager);
+    const idx = FindOverrideIndex(internal, targetType, targetName, targetIndex, propertyPath);
+    if (idx < 0) {
+        return false;
+    }
+    internal.overrides.splice(idx, 1);
+    const origKey = MakeOriginalValueKey(targetType, targetName, targetIndex, propertyPath);
+    const original = internal.originalValues.get(origKey);
+    if (original !== undefined) {
+        const target = ResolveTarget(manager.scene, targetType, targetName, targetIndex);
+        if (target) {
+            SetNestedProperty(target, propertyPath, original);
+        }
+        internal.originalValues.delete(origKey);
+    }
+    manager.onChangedObservable.notifyObservers();
+    return true;
+}
+/**
+ * Returns all overrides currently registered with the scene.
+ * @param scene - The scene whose override registry to read.
+ * @returns A read-only array of override entries.
+ */
+function GetOverrides(scene) {
+    return GetOverrideInternals(GetOverrideManager(scene)).overrides;
+}
+/**
+ * Removes all overrides, optionally restoring original values.
+ * @param scene - The scene whose override registry to clear.
+ * @param restoreOriginals - If true, restores all captured original values.
+ */
+function ClearOverrides(scene, restoreOriginals = false) {
+    const manager = GetOverrideManager(scene);
+    const internal = GetOverrideInternals(manager);
+    if (restoreOriginals) {
+        // Snapshot the entries so we can restore each original without firing
+        // an onChangedObservable notification per entry; consumers only need
+        // one signal that the registry was emptied.
+        const entries = [...internal.overrides];
+        internal.overrides.length = 0;
+        for (const entry of entries) {
+            const origKey = MakeOriginalValueKey(entry.targetType, entry.targetName, entry.targetIndex, entry.propertyPath);
+            const original = internal.originalValues.get(origKey);
+            if (original !== undefined) {
+                const target = ResolveTarget(manager.scene, entry.targetType, entry.targetName, entry.targetIndex);
+                if (target) {
+                    SetNestedProperty(target, entry.propertyPath, original);
                 }
-                return [...rootNodes];
-            },
-            getEntityChildren: (node) => node.getChildren(),
-            getEntityDisplayInfo: (node) => {
-                const onChangeObservable = new Observable();
-                const nameHookToken = watcherService.watchProperty(node, "name", () => onChangeObservable.notifyObservers());
-                const parentHookToken = watcherService.watchProperty(node, "parent", () => nodeMovedObservable.notifyObservers(node));
-                // A node is "not in the scene" if it is a Nodes-section type but is not
-                // a known scene node. This handles nodes that were removed from the scene
-                // but still appear because a descendant is in the scene. Nodes from the
-                // !IsNodesSectionType(parent) branch are unaffected because they always
-                // come from the scene's tracking lists. Clustered light children are also
-                // unaffected because they are added to knownSceneNodes explicitly.
-                const validationError = IsNodesSectionType(node) && !knownSceneNodes.has(node) ? "This entity is not in the scene but is shown because a descendant is still in the scene." : undefined;
-                return {
-                    get name() {
-                        return node.name || `Unnamed ${node.getClassName()}`;
-                    },
-                    validationError,
-                    onChange: onChangeObservable,
-                    dispose: () => {
-                        nameHookToken.dispose();
-                        parentHookToken.dispose();
-                        onChangeObservable.clear();
-                    },
-                };
-            },
-            entityIcon: ({ entity: node }) => node instanceof AbstractMesh ? (jsx(MeshIcon, { color: tokens.colorPaletteBlueForeground2 })) : node instanceof TransformNode ? (jsx(MyLocationRegular, { color: tokens.colorPaletteBlueForeground2 })) : node instanceof Camera ? (jsx(CameraRegular, { color: tokens.colorPaletteGreenForeground2 })) : node instanceof ClusteredLightContainer ? (jsx(BubbleMultipleRegular, { color: tokens.colorPaletteYellowForeground2 })) : node instanceof Light ? (jsx(LightbulbRegular, { color: tokens.colorPaletteYellowForeground2 })) : (jsx(Fragment, {})),
-            getEntityAddedObservables: () => [
-                scene.onNewMeshAddedObservable,
-                scene.onNewTransformNodeAddedObservable,
-                scene.onNewCameraAddedObservable,
-                scene.onNewLightAddedObservable,
-            ],
-            getEntityRemovedObservables: () => [
-                scene.onMeshRemovedObservable,
-                scene.onTransformNodeRemovedObservable,
-                scene.onCameraRemovedObservable,
-                scene.onLightRemovedObservable,
-            ],
-            getEntityMovedObservables: () => [nodeMovedObservable],
-            dragDropConfig: {
-                canDrag: (node) => node instanceof Node$1,
-                canDrop: (draggedNode, targetNode) => {
-                    // Can't drop on self
-                    if (targetNode === draggedNode) {
-                        return false;
-                    }
-                    // Can't drop on a descendant
-                    if (targetNode !== null && targetNode.isDescendantOf(draggedNode)) {
-                        return false;
-                    }
-                    // Can drop onto section root (null) only if node has a parent
-                    if (targetNode === null) {
-                        return draggedNode.parent !== null;
-                    }
-                    return true;
-                },
-                onDrop: (draggedNode, targetNode) => {
-                    if (draggedNode.parent === targetNode) {
-                        return;
-                    }
-                    // Use setParent for TransformNodes to preserve world transform
-                    if (draggedNode instanceof TransformNode) {
-                        draggedNode.setParent(targetNode);
-                    }
-                    else {
-                        draggedNode.parent = targetNode;
-                    }
-                },
-            },
-        });
-        const abstractMeshBoundingBoxCommandRegistration = sceneExplorerService.addEntityCommand({
-            predicate: (entity) => entity instanceof AbstractMesh && entity.getTotalVertices() > 0,
-            order: 1000 /* DefaultCommandsOrder.MeshBoundingBox */,
-            getCommand: (mesh) => {
-                const onChangeObservable = new Observable();
-                const showBoundingBoxHook = watcherService.watchProperty(mesh, "showBoundingBox", () => onChangeObservable.notifyObservers());
-                return {
-                    type: "toggle",
-                    get displayName() {
-                        return `${mesh.showBoundingBox ? "Hide" : "Show"} Bounding Box`;
-                    },
-                    icon: () => (mesh.showBoundingBox ? jsx(BorderOutsideRegular, {}) : jsx(BorderNoneRegular, {})),
-                    get isEnabled() {
-                        return mesh.showBoundingBox;
-                    },
-                    set isEnabled(enabled) {
-                        mesh.showBoundingBox = enabled;
-                    },
-                    onChange: onChangeObservable,
-                    dispose: () => {
-                        showBoundingBoxHook.dispose();
-                        onChangeObservable.clear();
-                    },
-                };
-            },
-        });
-        const abstractMeshVisibilityCommandRegistration = sceneExplorerService.addEntityCommand({
-            predicate: (entity) => entity instanceof AbstractMesh && entity.getTotalVertices() > 0,
-            order: 1100 /* DefaultCommandsOrder.MeshVisibility */,
-            getCommand: (mesh) => {
-                const onChangeObservable = new Observable();
-                const isVisibleHook = watcherService.watchProperty(mesh, "isVisible", () => onChangeObservable.notifyObservers());
-                return {
-                    type: "toggle",
-                    get displayName() {
-                        return `${mesh.isVisible ? "Hide" : "Show"} Mesh`;
-                    },
-                    icon: () => (mesh.isVisible ? jsx(EyeRegular, {}) : jsx(EyeOffRegular, {})),
-                    hotKey: {
-                        keyCode: "Space",
-                        control: true,
-                    },
-                    get isEnabled() {
-                        return !mesh.isVisible;
-                    },
-                    set isEnabled(enabled) {
-                        mesh.isVisible = !enabled;
-                    },
-                    onChange: onChangeObservable,
-                    dispose: () => {
-                        isVisibleHook.dispose();
-                        onChangeObservable.clear();
-                    },
-                };
-            },
-        });
-        const getActiveCamera = () => (scene.frameGraph ? FindMainCamera(scene.frameGraph) : scene.activeCamera);
-        const activeCameraCommandRegistration = sceneExplorerService.addEntityCommand({
-            predicate: (entity) => entity instanceof Camera,
-            order: 700 /* DefaultCommandsOrder.CameraActive */,
-            getCommand: (camera) => {
-                const scene = camera.getScene();
-                const onChangeObservable = new Observable();
-                const activeCameraChangedObserver = scene.onActiveCameraChanged.add(() => {
-                    onChangeObservable.notifyObservers();
-                });
-                return {
-                    type: "toggle",
-                    displayName: "Activate and Attach Controls",
-                    icon: () => {
-                        return getActiveCamera() === camera ? jsx(VideoFilled, {}) : jsx(VideoRegular, {});
-                    },
-                    get isEnabled() {
-                        return getActiveCamera() === camera;
-                    },
-                    set isEnabled(enabled) {
-                        const activeCamera = getActiveCamera();
-                        if (enabled && activeCamera !== camera) {
-                            if (scene.frameGraph) {
-                                void (async (frameGraph) => {
-                                    let updated = false;
-                                    const nrg = frameGraph.getLinkedNodeRenderGraph();
-                                    if (nrg) {
-                                        updated = await nrg.replaceCameraAsync(activeCamera, camera);
-                                    }
-                                    else {
-                                        for (const task of frameGraph.tasks) {
-                                            if (IsCameraFrameGraphTask(task)) {
-                                                task.camera = camera;
-                                                updated = true;
-                                            }
-                                        }
-                                    }
-                                    if (updated) {
-                                        activeCamera?.detachControl();
-                                        camera.attachControl(true);
-                                        onChangeObservable.notifyObservers();
-                                    }
-                                })(scene.frameGraph);
-                            }
-                            else {
-                                activeCamera?.detachControl();
-                                scene.activeCamera = camera;
-                                camera.attachControl(true);
-                            }
-                        }
-                    },
-                    onChange: onChangeObservable,
-                    dispose: () => {
-                        activeCameraChangedObserver.remove();
-                        onChangeObservable.clear();
-                    },
-                };
-            },
-        });
-        function addGizmoCommand(nodeClass, getGizmoRef) {
-            return sceneExplorerService.addEntityCommand({
-                predicate: (entity) => entity instanceof nodeClass,
-                order: 800 /* DefaultCommandsOrder.GizmoActive */,
-                getCommand: (node) => {
-                    const onChangeObservable = new Observable();
-                    let gizmoRef = null;
-                    return {
-                        type: "toggle",
-                        get displayName() {
-                            return `Turn ${gizmoRef ? "Off" : "On"} Gizmo`;
-                        },
-                        icon: () => (gizmoRef ? jsx(EyeRegular, {}) : jsx(EyeOffRegular, {})),
-                        get isEnabled() {
-                            return !!gizmoRef;
-                        },
-                        set isEnabled(enabled) {
-                            if (enabled) {
-                                if (!gizmoRef) {
-                                    gizmoRef = getGizmoRef(node);
-                                    onChangeObservable.notifyObservers();
-                                }
-                            }
-                            else {
-                                if (gizmoRef) {
-                                    gizmoRef.dispose();
-                                    gizmoRef = null;
-                                    onChangeObservable.notifyObservers();
-                                }
-                            }
-                        },
-                        onChange: onChangeObservable,
-                        dispose: () => {
-                            onChangeObservable.clear();
-                        },
-                    };
-                },
-            });
+            }
+        }
+        internal.originalValues.clear();
+        manager.onChangedObservable.notifyObservers();
+        return;
+    }
+    internal.overrides.length = 0;
+    internal.originalValues.clear();
+    manager.onChangedObservable.notifyObservers();
+}
+/**
+ * Updates the target coordinates on the override matching a specific (type,
+ * old-name, old-index) so it follows an entity rename. Used by capture services
+ * to keep overrides attached to a specific object after the user renames it.
+ *
+ * Only the override at the exact `(targetType, oldName, oldIndex)` slot is
+ * updated, so other same-named siblings keep their own overrides untouched.
+ *
+ * @param scene - The scene whose override registry to update.
+ * @param targetType - The target type.
+ * @param oldName - The previous name of the renamed entity.
+ * @param oldIndex - The previous index of the renamed entity among same-named siblings.
+ * @param newName - The new name of the renamed entity.
+ * @param newIndex - The new index of the renamed entity among same-named siblings.
+ */
+function RenameOverrideTarget(scene, targetType, oldName, oldIndex, newName, newIndex) {
+    const manager = GetOverrideManager(scene);
+    const internal = GetOverrideInternals(manager);
+    let changed = false;
+    for (let i = 0; i < internal.overrides.length; i++) {
+        const entry = internal.overrides[i];
+        if (entry.targetType === targetType && entry.targetName === oldName && entry.targetIndex === oldIndex) {
+            internal.overrides[i] = { ...entry, targetName: newName, targetIndex: newIndex };
+            changed = true;
+        }
+    }
+    // Update original-value keys to match the new identity
+    const oldPrefix = `${targetType}::${oldName}::${oldIndex}::`;
+    const newPrefix = `${targetType}::${newName}::${newIndex}::`;
+    for (const [origKey, value] of Array.from(internal.originalValues.entries())) {
+        if (origKey.startsWith(oldPrefix)) {
+            const propertyPath = origKey.substring(oldPrefix.length);
+            internal.originalValues.set(newPrefix + propertyPath, value);
+            internal.originalValues.delete(origKey);
+        }
+    }
+    if (changed) {
+        manager.onChangedObservable.notifyObservers();
+    }
+}
+/**
+ * Rewrites override *values* that reference an entity by name when that entity
+ * has been renamed. Mirrors {@link RenameOverrideTarget} but operates on the
+ * `value` field rather than the `targetName` field, so overrides whose value
+ * is `"ref:oldName"` (material/light/camera references) or `"texture:oldName"`
+ * (non-SmartAsset texture references) follow the rename instead of silently
+ * pointing at a non-existent entity.
+ *
+ * SmartAsset texture references (`"samTexture:<key>"`) are unaffected because
+ * the SmartAsset key is decoupled from the texture's runtime `name` field.
+ *
+ * @param scene - The scene whose override registry to update.
+ * @param valueScheme - Which encoded-reference prefix to rewrite: `"ref"` for
+ * material/light/camera references, `"texture"` for non-SAM textures.
+ * @param oldName - The previous name embedded in the reference.
+ * @param newName - The new name embedded in the reference.
+ */
+function RenameOverrideValueReferences(scene, valueScheme, oldName, newName) {
+    if (oldName === newName) {
+        return;
+    }
+    const manager = GetOverrideManager(scene);
+    const internal = GetOverrideInternals(manager);
+    const oldValue = `${valueScheme}:${oldName}`;
+    const newValue = `${valueScheme}:${newName}`;
+    let changed = false;
+    for (let i = 0; i < internal.overrides.length; i++) {
+        const entry = internal.overrides[i];
+        if (entry.value === oldValue) {
+            internal.overrides[i] = { ...entry, value: newValue };
+            changed = true;
+        }
+    }
+    if (changed) {
+        manager.onChangedObservable.notifyObservers();
+    }
+}
+// ── Application ──
+/**
+ * Applies all overrides to their current targets in the scene.
+ *
+ * Call this after any scene mutation that might have invalidated previously
+ * applied state (asset reload, object recreation, project load). The override
+ * manager does not auto-subscribe to other scene subsystems — coordination is
+ * the caller's responsibility, which keeps the override system independent.
+ * @param scene - The scene whose overrides to apply.
+ */
+function ApplyAllOverrides(scene) {
+    const manager = GetOverrideManager(scene);
+    const internal = GetOverrideInternals(manager);
+    for (const entry of SortNameOverridesFirst(internal.overrides)) {
+        // Apply each override in isolation: a single failing entry (e.g. a
+        // stale property path, or a target whose shape changed) must not abort
+        // the remaining overrides.
+        try {
+            ApplyOverrideEntry(manager, internal, entry);
+        }
+        catch (e) {
+            Logger.Warn(`OverrideManager: failed to apply override type="${entry.targetType}" name="${entry.targetName}" prop="${entry.propertyPath}": ${e}`);
+        }
+    }
+}
+/**
+ * Returns a copy of the entries ordered so that `name` overrides are applied
+ * first. Renames must run before other overrides because targets (and
+ * reference values like `ref:<name>`) are resolved by name: applying a rename
+ * first ensures subsequent overrides resolve against the new names.
+ * @param entries - The override entries to order.
+ * @returns A new array with `name` overrides first, otherwise stable order.
+ */
+function SortNameOverridesFirst(entries) {
+    const nameOverrides = [];
+    const rest = [];
+    for (const entry of entries) {
+        if (entry.propertyPath === "name") {
+            nameOverrides.push(entry);
+        }
+        else {
+            rest.push(entry);
+        }
+    }
+    return [...nameOverrides, ...rest];
+}
+// ── Serialization ──
+/**
+ * Serializes all overrides to a JSON-compatible array.
+ * The on-disk shape is identical to the in-memory `IOverrideEntry`.
+ * @param scene - The scene whose overrides to serialize.
+ * @returns An array of override entries (shallow copies).
+ */
+function SerializeOverrides(scene) {
+    const internal = GetOverrideInternals(GetOverrideManager(scene));
+    return internal.overrides.map((o) => ({ ...o }));
+}
+/**
+ * Loads overrides from a serialized array and applies them.
+ * @param scene - The scene whose override registry to populate.
+ * @param data - Array of override entries.
+ */
+function DeserializeAndApplyOverrides(scene, data) {
+    if (!Array.isArray(data)) {
+        throw new Error("OverrideManager: Expected an array of override entries.");
+    }
+    for (const entry of SortNameOverridesFirst(data)) {
+        if (!entry.targetType || entry.targetName === undefined || typeof entry.targetIndex !== "number" || !entry.propertyPath || entry.value === undefined) {
+            Logger.Warn("OverrideManager: Skipping invalid override entry.");
+            continue;
+        }
+        AddOverride(scene, entry);
+    }
+}
+// ── Lifecycle ──
+/**
+ * Disposes the manager, clearing all overrides and detaching it from its scene.
+ * Safe to call multiple times; subsequent calls are no-ops. Automatically invoked when the
+ * owning scene is disposed.
+ * @param manager - The override manager state.
+ */
+function DisposeOverrideManager(manager) {
+    const internal = OverrideManagerInternals.get(manager);
+    if (!internal) {
+        return;
+    }
+    OverrideManagerInternals.delete(manager);
+    if (internal.sceneDisposeObserver) {
+        manager.scene.onDisposeObservable.remove(internal.sceneDisposeObserver);
+        internal.sceneDisposeObserver = null;
+    }
+    internal.overrides.length = 0;
+    internal.originalValues.clear();
+    manager.onChangedObservable.clear();
+    if (manager.scene.metadata) {
+        delete manager.scene.metadata[OverrideManagerKey];
+    }
+}
+// ── Private ──
+function GetOverrideInternals(manager) {
+    const internal = OverrideManagerInternals.get(manager);
+    if (!internal) {
+        throw new Error("OverrideManager: Unknown manager state.");
+    }
+    return internal;
+}
+/**
+ * Applies a single override entry to its target, capturing the original value
+ * on the first application so {@link RemoveOverride} can restore it later.
+ * @param manager - The override manager owning the entry.
+ * @param internal - The manager's internal state.
+ * @param entry - The override to apply.
+ */
+function ApplyOverrideEntry(manager, internal, entry) {
+    const target = ResolveTarget(manager.scene, entry.targetType, entry.targetName, entry.targetIndex);
+    if (!target) {
+        Logger.Warn(`OverrideManager: target not found for type="${entry.targetType}" name="${entry.targetName}" index=${entry.targetIndex} prop="${entry.propertyPath}"`);
+        return; // Target not loaded yet — override will be applied on next ApplyAllOverrides
+    }
+    // Capture original value before first override
+    const origKey = MakeOriginalValueKey(entry.targetType, entry.targetName, entry.targetIndex, entry.propertyPath);
+    if (!internal.originalValues.has(origKey)) {
+        const currentValue = GetNestedProperty(target, entry.propertyPath);
+        if (currentValue !== undefined) {
+            internal.originalValues.set(origKey, CloneValue(currentValue));
+        }
+    }
+    const resolvedValue = ResolveOverrideValue(manager.scene, entry.value);
+    SetNestedProperty(target, entry.propertyPath, resolvedValue);
+}
+/**
+ * Locates a scene object by (targetType, targetName, targetIndex). The scene
+ * collection is filtered to objects matching `targetName`; the N-th survivor
+ * (per `targetIndex`) is returned. Falls back to the first match if the index
+ * is out of range — useful when the scene shape has changed since capture.
+ * @param scene - The scene to search.
+ * @param targetType - The override target type.
+ * @param targetName - The target object name (or "" for scene-level).
+ * @param targetIndex - The target's position among same-named siblings.
+ * @returns The matching scene object, or null if not found.
+ */
+function ResolveTarget(scene, targetType, targetName, targetIndex) {
+    // Scene-level overrides target the scene itself
+    if (targetType === "scene") {
+        return scene;
+    }
+    const collection = GetCollection$1(scene, targetType);
+    if (!collection) {
+        return null;
+    }
+    const matches = collection.filter((obj) => obj.name === targetName);
+    if (matches.length === 0) {
+        return null;
+    }
+    return (matches[targetIndex] ?? matches[0]);
+}
+/**
+ * Returns the scene collection corresponding to an override target type.
+ * @param scene - The scene to inspect.
+ * @param targetType - The target type.
+ * @returns The collection, or null if the type has no collection.
+ */
+function GetCollection$1(scene, targetType) {
+    switch (targetType) {
+        case "meshes":
+            return scene.meshes;
+        case "transformNodes":
+            return scene.transformNodes;
+        case "materials":
+            return scene.materials;
+        case "textures":
+            return scene.textures;
+        case "lights":
+            return scene.lights;
+        case "cameras":
+            return scene.cameras;
+        case "animationGroups":
+            return scene.animationGroups;
+        default:
+            return null;
+    }
+}
+/**
+ * Resolves an override value, expanding string references like "ref:name",
+ * "samTexture:key", or "texture:name" into the actual scene object they refer to.
+ * @param scene - The scene used to look up references.
+ * @param value - The serialized override value.
+ * @returns The runtime value to assign to the target property.
+ */
+function ResolveOverrideValue(scene, value) {
+    if (typeof value === "string") {
+        if (value.startsWith("ref:")) {
+            return ResolveObjectReference(scene, value.substring(4));
+        }
+        if (value.startsWith("samTexture:")) {
+            return ResolveSamTextureReference(scene, value.substring(11));
+        }
+        if (value.startsWith("texture:")) {
+            return ResolveTextureReference(scene, value.substring(8));
+        }
+    }
+    // Number arrays are passed through as-is. SetNestedProperty will use
+    // the live target's `fromArray` method (Vector3, Color3, etc.) to push
+    // values in-place, preserving the math instance identity.
+    return value;
+}
+/**
+ * Resolves a "ref:name" value by looking up a scene object by name. Materials,
+ * lights, and cameras are searched first, then transform nodes and meshes
+ * (both valid parent references).
+ * @param scene - The scene to search.
+ * @param name - The object name to resolve.
+ * @returns The matching object, or undefined if not found.
+ */
+function ResolveObjectReference(scene, name) {
+    const collections = [scene.materials, scene.lights, scene.cameras, scene.transformNodes, scene.meshes];
+    for (const collection of collections) {
+        const match = collection.find((item) => item.name === name);
+        if (match) {
+            return match;
+        }
+    }
+    Logger.Warn(`OverrideManager: Object reference "${name}" not found in scene.`);
+    return undefined;
+}
+/**
+ * Resolves a "texture:name" value by looking up a texture in the scene by name.
+ * @param scene - The scene to search.
+ * @param name - The texture name to resolve.
+ * @returns The matching texture, or undefined if not found.
+ */
+function ResolveTextureReference(scene, name) {
+    const tex = scene.textures.find((t) => t.name === name);
+    if (tex) {
+        return tex;
+    }
+    Logger.Warn(`OverrideManager: Texture reference "${name}" not found.`);
+    return undefined;
+}
+/**
+ * Resolves a "samTexture:key" value by looking up a SmartAsset-tracked texture
+ * by its registry key. The SAM key is stable across save/load whereas the
+ * texture's `name` (for SAM textures, the blob URL) changes on every reload,
+ * so this is the only reliable way to round-trip texture references on
+ * user-uploaded SmartAsset textures.
+ * @param scene - The scene to search.
+ * @param key - The SmartAsset key to resolve.
+ * @returns The matching texture, or undefined if not found.
+ */
+function ResolveSamTextureReference(scene, key) {
+    const tex = scene.textures.find((t) => FindSmartAssetKeyForObject(scene, t) === key);
+    if (tex) {
+        return tex;
+    }
+    Logger.Warn(`OverrideManager: SmartAsset texture "${key}" not found.`);
+    return undefined;
+}
+/**
+ * Finds the index of an override matching the given coordinates.
+ * @param internal - The manager's internal state.
+ * @param targetType - The target type.
+ * @param targetName - The target object name.
+ * @param targetIndex - The target index among same-named siblings.
+ * @param propertyPath - The property path.
+ * @returns The matching index, or -1 if none found.
+ */
+function FindOverrideIndex(internal, targetType, targetName, targetIndex, propertyPath) {
+    return internal.overrides.findIndex((o) => o.targetType === targetType && o.targetName === targetName && o.targetIndex === targetIndex && o.propertyPath === propertyPath);
+}
+/**
+ * Removes any existing override that matches the given coordinates. Used by
+ * {@link AddOverride} to enforce one entry per (type, name, index, property).
+ * @param internal - The manager's internal state.
+ * @param targetType - The target type.
+ * @param targetName - The target object name.
+ * @param targetIndex - The target index among same-named siblings.
+ * @param propertyPath - The property path.
+ */
+function RemoveMatchingOverride(internal, targetType, targetName, targetIndex, propertyPath) {
+    const idx = FindOverrideIndex(internal, targetType, targetName, targetIndex, propertyPath);
+    if (idx >= 0) {
+        internal.overrides.splice(idx, 1);
+    }
+}
+/**
+ * Creates a unique key for storing original values.
+ * @param targetType - The override target type.
+ * @param targetName - The target object name.
+ * @param targetIndex - The target index among same-named siblings.
+ * @param propertyPath - The property path.
+ * @returns A composite string key uniquely identifying the original value slot.
+ */
+function MakeOriginalValueKey(targetType, targetName, targetIndex, propertyPath) {
+    return `${targetType}::${targetName}::${targetIndex}::${propertyPath}`;
+}
+/**
+ * Gets a nested property from an object using a dot-separated path.
+ * @param obj - The root object to traverse.
+ * @param path - The dot-separated property path.
+ * @returns The value at the path, or undefined if any segment is missing.
+ */
+function GetNestedProperty(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined || typeof current !== "object") {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Sets a nested property on an object using a dot-separated path.
+ *
+ * When the value is a number array and the existing property is a Babylon
+ * math type (Vector*, Quaternion, Color3/4, Matrix), uses the math type's
+ * `fromArray` method to mutate it in place — preserving the live instance
+ * identity that consumers may already hold references to. Otherwise falls
+ * back to direct property replacement.
+ *
+ * Getter-only accessors (e.g. `Texture.invertY`) cannot be assigned directly —
+ * doing so throws in strict mode. For those, the backing field (`_<name>`) is
+ * written instead when present, and load-time texture properties are re-applied
+ * via a re-upload (see {@link ReapplyLoadTimeTextureProperty}). Truly read-only
+ * properties with no backing field are skipped with a warning.
+ * @param obj - The root object to mutate.
+ * @param path - The dot-separated property path.
+ * @param value - The new value to assign.
+ */
+function SetNestedProperty(obj, path, value) {
+    const parts = path.split(".");
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (current === null || current === undefined || typeof current !== "object") {
+            return;
+        }
+        current = current[parts[i]];
+    }
+    if (current === null || current === undefined || typeof current !== "object") {
+        return;
+    }
+    const target = current;
+    const lastPart = parts[parts.length - 1];
+    const existing = target[lastPart];
+    if (Array.isArray(value) && existing && typeof existing === "object" && typeof existing.fromArray === "function") {
+        existing.fromArray(value);
+        return;
+    }
+    // Guard against getter-only accessors: assigning to one throws in strict
+    // mode (ES modules are strict), which would otherwise abort the whole apply
+    // batch. Write the backing field instead, then re-apply if it is a
+    // load-time texture property.
+    const accessor = FindAccessorDescriptor(target, lastPart);
+    if (accessor && accessor.get && !accessor.set) {
+        const backingField = `_${lastPart}`;
+        if (backingField in target) {
+            target[backingField] = value;
+            ReapplyLoadTimeTextureProperty(target, lastPart);
+        }
+        else {
+            Logger.Warn(`OverrideManager: property "${lastPart}" is read-only and has no backing field; skipping.`);
+        }
+        return;
+    }
+    target[lastPart] = value;
+}
+/**
+ * Walks the prototype chain to find the property descriptor for `key`, so
+ * accessor (getter/setter) properties defined on a class prototype can be
+ * detected. Returns undefined if the property is a plain data field.
+ * @param obj - The object to inspect.
+ * @param key - The property name.
+ * @returns The property descriptor, or undefined if none is found.
+ */
+function FindAccessorDescriptor(obj, key) {
+    let proto = obj;
+    while (proto) {
+        const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+        if (descriptor) {
+            return descriptor;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return undefined;
+}
+/**
+ * Re-applies a texture property that only takes effect at upload time (such as
+ * `invertY`, which is baked into the GPU texel data via `UNPACK_FLIP_Y`).
+ * Writing the backing field alone does not re-flip an already-loaded texture,
+ * so this re-uploads the source via `updateURL`, which releases only the GPU
+ * texture and reuses the same texture instance (all scene references stay
+ * intact). Duck-typed so this module stays decoupled from the Texture class,
+ * and a no-op for anything that is not a URL-loaded texture.
+ * @param target - The object whose property was written.
+ * @param propertyName - The property that was written.
+ */
+function ReapplyLoadTimeTextureProperty(target, propertyName) {
+    if (propertyName !== "invertY") {
+        return;
+    }
+    if (typeof target.updateURL === "function" && typeof target.url === "string" && target.url) {
+        try {
+            target.updateURL(target.url, target._buffer ?? null);
         }
-        const cameraGizmoCommandRegistration = addGizmoCommand(Camera, gizmoService.getCameraGizmo.bind(gizmoService));
-        const lightEnabledCommandRegistration = sceneExplorerService.addEntityCommand({
-            predicate: (entity) => entity instanceof Light,
-            order: 700 /* DefaultCommandsOrder.LightActive */,
-            getCommand: (light) => {
-                return {
-                    type: "toggle",
-                    get displayName() {
-                        return `Turn Light ${light.isEnabled() ? "Off" : "On"}`;
-                    },
-                    icon: () => (light.isEnabled() ? jsx(FlashlightRegular, {}) : jsx(FlashlightOffRegular, {})),
-                    get isEnabled() {
-                        return !light.isEnabled();
-                    },
-                    set isEnabled(enabled) {
-                        light.setEnabled(!enabled);
-                    },
-                    onChange: light.onEnabledStateChangedObservable,
-                };
-            },
-        });
-        const lightGizmoCommandRegistration = addGizmoCommand(Light, gizmoService.getLightGizmo.bind(gizmoService));
-        const editNodeGeometryCommandRegistration = sceneExplorerService.addEntityCommand({
-            predicate: (entity) => entity instanceof Mesh && !!GetNodeGeometry(entity),
-            order: 1100 /* DefaultCommandsOrder.EditNodeGeometry */,
-            getCommand: (mesh) => {
-                return {
-                    type: "action",
-                    displayName: "Edit in Node Geometry Editor",
-                    icon: () => jsx(EditRegular, {}),
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    execute: async () => {
-                        const nodeGeometry = GetNodeGeometry(mesh);
-                        if (nodeGeometry) {
-                            await EditNodeGeometry(nodeGeometry, mesh.getScene());
-                        }
-                    },
-                };
-            },
-        });
-        return {
-            dispose: () => {
-                sectionRegistration.dispose();
-                abstractMeshBoundingBoxCommandRegistration.dispose();
-                abstractMeshVisibilityCommandRegistration.dispose();
-                activeCameraCommandRegistration.dispose();
-                cameraGizmoCommandRegistration.dispose();
-                lightEnabledCommandRegistration.dispose();
-                lightGizmoCommandRegistration.dispose();
-                editNodeGeometryCommandRegistration.dispose();
-            },
-        };
-    },
-};
+        catch (e) {
+            Logger.Warn(`OverrideManager: failed to re-upload texture to apply "${propertyName}": ${e}`);
+        }
+    }
+}
+/**
+ * Snapshots a value for original-value tracking.
+ *
+ * Scene entities (textures, materials, meshes, etc.) are stored by reference
+ * because cloning them would register unwanted duplicates in the scene.
+ * Plain math types (Vector3, Color3, etc.) are cloned so mutations to the
+ * live object don't corrupt the saved original.
+ * @param value - The value to snapshot.
+ * @returns The snapshot value (cloned for plain math types, by reference for entities).
+ */
+function CloneValue(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value !== "object") {
+        return value;
+    }
+    if (typeof value.getScene === "function") {
+        return value;
+    }
+    if ("clone" in value && typeof value.clone === "function") {
+        return value.clone();
+    }
+    return { ...value };
+}
 
-const ParticleSystemExplorerServiceDefinition = {
-    friendlyName: "Particle System Explorer",
-    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
-    factory: (sceneExplorerService, sceneContext, watcherService) => {
-        const scene = sceneContext.currentScene;
-        if (!scene) {
-            return undefined;
+/**
+ * Creates a fresh capture state. One is created per attached scene so identities
+ * never leak across scenes.
+ * @returns A new, empty capture state.
+ */
+function CreateCaptureState() {
+    return { previousIdentity: new WeakMap(), originalIdentity: new WeakMap() };
+}
+/**
+ * Handles a single Inspector property change, recording the corresponding
+ * override. Name changes are handled specially so renames persist and other
+ * overrides follow the rename.
+ * @param scene - The active scene.
+ * @param state - The capture state for this scene.
+ * @param change - The captured property change.
+ */
+function HandleCapturedPropertyChange(scene, state, change) {
+    const { entity, propertyKey, oldValue, newValue } = change;
+    if (propertyKey === "name" && typeof newValue === "string") {
+        HandleRename(scene, state, entity, oldValue, newValue);
+        return;
+    }
+    if (propertyKey === "id") {
+        return;
+    }
+    RecordEntityPropertyOverride(scene, entity, String(propertyKey), newValue, oldValue, state);
+}
+/**
+ * Records (or replaces) an override for a single property edit on a scene
+ * entity. Also usable directly by non-Inspector edit paths (e.g. scene-explorer
+ * commands like the visibility eye toggle, or drag-to-reparent) that mutate an
+ * entity without going through the Inspector's property change pipeline.
+ *
+ * The caller is expected to have already applied `newValue` to the entity;
+ * `oldValue` is recorded as the pre-edit original so the override can be
+ * reverted later.
+ * @param scene - The active scene.
+ * @param entity - The mutated entity.
+ * @param propertyPath - The dot-separated property path that changed.
+ * @param newValue - The new (already-applied) value.
+ * @param oldValue - The pre-edit value, recorded as the override's original.
+ * @param state - Optional capture state; when provided, entity identities are
+ * seeded so subsequent renames can be tracked.
+ */
+function RecordEntityPropertyOverride(scene, entity, propertyPath, newValue, oldValue, state) {
+    let targetType = ClassifyEntity(entity, scene);
+    let targetName;
+    let targetIndex;
+    let finalPath = propertyPath;
+    if (targetType !== null) {
+        if (targetType === "scene") {
+            targetName = "";
+            targetIndex = 0;
+        }
+        else {
+            targetName = GetEntityName(entity);
+            targetIndex = ComputeTargetIndex(scene, targetType, entity, targetName);
+            if (state && targetName) {
+                SeedIdentity(state, entity, targetName, targetIndex);
+            }
+        }
+    }
+    else {
+        // Sub-object: check if this is a property of a known parent
+        const parentInfo = FindParentEntity(entity, scene);
+        if (!parentInfo) {
+            return;
+        }
+        targetType = parentInfo.targetType;
+        targetName = parentInfo.targetName;
+        targetIndex = parentInfo.targetIndex;
+        finalPath = `${parentInfo.parentProperty}.${propertyPath}`;
+    }
+    const serializedValue = SerializeOverrideValueForCapture(newValue, scene);
+    if (serializedValue === undefined) {
+        return;
+    }
+    // The caller has already written `newValue` to the entity, so pass
+    // `oldValue` so the manager records the true pre-edit value.
+    AddOverride(scene, { targetType, targetName, targetIndex, propertyPath: finalPath, value: serializedValue }, { originalValue: oldValue });
+}
+/**
+ * Handles an entity rename. Records the rename as a `name` override keyed on the
+ * entity's original (first-seen) name so it round-trips through a project
+ * reload, and moves any other overrides / value references to follow the new
+ * current name.
+ * @param scene - The active scene.
+ * @param state - The capture state for this scene.
+ * @param entity - The renamed entity.
+ * @param oldValue - The name before the rename.
+ * @param newValue - The name after the rename.
+ */
+function HandleRename(scene, state, entity, oldValue, newValue) {
+    const targetType = ClassifyEntity(entity, scene);
+    if (targetType === null || targetType === "scene") {
+        return;
+    }
+    const entityObject = entity;
+    const previous = state.previousIdentity.get(entityObject);
+    const oldName = typeof oldValue === "string" ? oldValue : previous?.name;
+    if (oldName !== undefined && oldName !== newValue) {
+        // The entity already has the new name, so compute its new index among same-named siblings.
+        const newIndex = ComputeTargetIndex(scene, targetType, entity, newValue);
+        // Move existing overrides (and value references) to follow the current name.
+        if (previous) {
+            RenameOverrideTarget(scene, targetType, previous.name, previous.index, newValue, newIndex);
+            const valueScheme = targetType === "textures" ? "texture" : "ref";
+            RenameOverrideValueReferences(scene, valueScheme, previous.name, newValue);
+        }
+        // Record the rename as an override keyed on the entity's ORIGINAL name.
+        let original = state.originalIdentity.get(entityObject);
+        if (!original) {
+            // First time we've seen this entity, and its first observed edit is a rename, so its
+            // pre-rename index among same-named siblings can't be read directly (it already carries
+            // `newValue`). Fall back to the count of siblings that still hold `oldName`, which places
+            // the entity last in that group — correct for the common case where duplicate names come
+            // from append-ordered imports (e.g. re-importing a glTF) and the renamed one was added
+            // last. When the entity was seen before its rename, `previous.index` is exact.
+            const originalIndex = previous?.index ?? CountEntitiesWithName(scene, targetType, oldName);
+            original = { name: oldName, index: originalIndex };
+            state.originalIdentity.set(entityObject, original);
+        }
+        if (original.name !== newValue) {
+            AddOverride(scene, { targetType, targetName: original.name, targetIndex: original.index, propertyPath: "name", value: newValue }, { originalValue: original.name });
+        }
+        else {
+            // Renamed back to the original name — the name override is now a no-op.
+            RemoveOverride(scene, targetType, original.name, original.index, "name");
+        }
+    }
+    state.previousIdentity.set(entityObject, { name: newValue, index: ComputeTargetIndex(scene, targetType, entity, newValue) });
+}
+/**
+ * Seeds both identity maps for an entity on first contact.
+ * @param state - The capture state.
+ * @param entity - The entity to seed.
+ * @param name - The entity's current name.
+ * @param index - The entity's index among same-named siblings.
+ */
+function SeedIdentity(state, entity, name, index) {
+    if (!state.previousIdentity.has(entity)) {
+        state.previousIdentity.set(entity, { name, index });
+    }
+    if (!state.originalIdentity.has(entity)) {
+        state.originalIdentity.set(entity, { name, index });
+    }
+}
+/**
+ * Classifies an entity into an OverrideTargetType by membership in the
+ * scene's standard collections (or by being the scene itself).
+ * @param entity - The entity to classify.
+ * @param scene - The scene to check collections against.
+ * @returns The target type, or null if unrecognized.
+ */
+function ClassifyEntity(entity, scene) {
+    if (entity === scene) {
+        return "scene";
+    }
+    const obj = entity;
+    if (!obj || typeof obj !== "object") {
+        return null;
+    }
+    if (scene.materials.includes(obj)) {
+        return "materials";
+    }
+    if (scene.meshes.includes(obj)) {
+        return "meshes";
+    }
+    // Pure TransformNodes (not meshes) are a separate scene collection and are common in glTF
+    // imports (pivots, empties, armature roots). Meshes are never added to scene.transformNodes,
+    // so this check is disjoint from the meshes check above.
+    if (scene.transformNodes.includes(obj)) {
+        return "transformNodes";
+    }
+    if (scene.lights.includes(obj)) {
+        return "lights";
+    }
+    if (scene.cameras.includes(obj)) {
+        return "cameras";
+    }
+    if (scene.textures.includes(obj)) {
+        return "textures";
+    }
+    if (scene.animationGroups.includes(obj)) {
+        return "animationGroups";
+    }
+    return null;
+}
+/**
+ * Gets the name of a scene entity.
+ * @param entity - The entity to get the name from.
+ * @returns The entity name, or an empty string if unavailable.
+ */
+function GetEntityName(entity) {
+    const obj = entity;
+    return obj?.name ?? "";
+}
+/**
+ * Returns the position of `entity` among scene[targetType] objects with the
+ * same name. Used so overrides can disambiguate same-named siblings.
+ * @param scene - The scene to inspect.
+ * @param targetType - The target type / collection name.
+ * @param entity - The entity to locate.
+ * @param name - The name to filter by.
+ * @returns The index within the same-name filter, or 0 if not found.
+ */
+function ComputeTargetIndex(scene, targetType, entity, name) {
+    const collection = GetCollection(scene, targetType);
+    if (!collection) {
+        return 0;
+    }
+    const sameName = collection.filter((obj) => obj.name === name);
+    const idx = sameName.indexOf(entity);
+    return idx >= 0 ? idx : 0;
+}
+/**
+ * Counts how many entities in scene[targetType] currently have the given name.
+ * Used as a best-effort original index when an entity's first observed edit is
+ * a rename (its pre-rename position can no longer be read directly).
+ * @param scene - The scene to inspect.
+ * @param targetType - The target type / collection name.
+ * @param name - The name to count.
+ * @returns The number of same-named entities, or 0 if the collection is unknown.
+ */
+function CountEntitiesWithName(scene, targetType, name) {
+    const collection = GetCollection(scene, targetType);
+    if (!collection) {
+        return 0;
+    }
+    return collection.filter((obj) => obj.name === name).length;
+}
+/**
+ * Returns the scene collection matching a target type.
+ * @param scene - The scene to inspect.
+ * @param targetType - The target type.
+ * @returns The collection, or null if `targetType` doesn't map to one.
+ */
+function GetCollection(scene, targetType) {
+    switch (targetType) {
+        case "meshes":
+            return scene.meshes;
+        case "transformNodes":
+            return scene.transformNodes;
+        case "materials":
+            return scene.materials;
+        case "textures":
+            return scene.textures;
+        case "lights":
+            return scene.lights;
+        case "cameras":
+            return scene.cameras;
+        case "animationGroups":
+            return scene.animationGroups;
+        default:
+            return null;
+    }
+}
+/**
+ * Serializes a property value into an OverrideValue.
+ * Returns undefined for unsupported types.
+ * @param value - The value to serialize.
+ * @param scene - Optional scene for resolving object references.
+ * @returns The serialized value, or undefined if unsupported.
+ */
+function SerializeOverrideValueForCapture(value, scene) {
+    // null is a legitimate override value (e.g. clearing a material slot or a
+    // parent) and must round-trip as null — substituting "" here would silently
+    // corrupt object-typed slots with an empty string on reload.
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+        return value;
+    }
+    // Node reference (parent, etc.) → "ref:nodeName". Checked before the math
+    // heuristics below because a Node is an object without top-level x/y/z.
+    if (value instanceof Node$1) {
+        return `ref:${value.name}`;
+    }
+    // Material reference → "ref:materialName"
+    if (value && typeof value === "object" && "getClassName" in value && typeof value.getClassName === "function") {
+        const className = value.getClassName();
+        if (className.includes("Material") || className.includes("material")) {
+            return `ref:${value.name}`;
+        }
+    }
+    // Texture reference → "samTexture:<key>" if SmartAsset-tracked, else "texture:<name>".
+    // The SAM key is stable across save/load; `texture.name` for a SAM-tracked
+    // texture is the blob URL, which dies on page reload — using it as the
+    // override identifier would break the override after every reload.
+    if (value && typeof value === "object" && "getClassName" in value && scene) {
+        const className = value.getClassName();
+        if (className.includes("Texture") || className.includes("texture")) {
+            const samKey = FindSmartAssetKeyForObject(scene, value);
+            if (samKey !== undefined) {
+                return `samTexture:${samKey}`;
+            }
+            return `texture:${value.name}`;
         }
-        const sectionRegistration = sceneExplorerService.addSection({
-            displayName: "Particle Systems",
-            order: 800 /* DefaultSectionsOrder.ParticleSystems */,
-            getRootEntities: () => scene.particleSystems,
-            getEntityDisplayInfo: (particleSystem) => {
-                const onChangeObservable = new Observable();
-                const nameHookToken = watcherService.watchProperty(particleSystem, "name", () => onChangeObservable.notifyObservers());
-                return {
-                    get name() {
-                        return particleSystem.name || `Unnamed ${particleSystem.getClassName()}`;
-                    },
-                    onChange: onChangeObservable,
-                    dispose: () => {
-                        nameHookToken.dispose();
-                        onChangeObservable.clear();
-                    },
-                };
-            },
-            entityIcon: () => jsx(DropRegular, { color: tokens.colorPaletteCranberryForeground2 }),
-            getEntityAddedObservables: () => [scene.onNewParticleSystemAddedObservable],
-            getEntityRemovedObservables: () => [scene.onParticleSystemRemovedObservable],
-        });
-        const editParticleSystemCommandRegistration = sceneExplorerService.addEntityCommand({
-            predicate: (entity) => entity instanceof ParticleSystem && entity.isNodeGenerated,
-            order: 1100 /* DefaultCommandsOrder.EditParticleSystem */,
-            getCommand: (particleSystem) => {
-                return {
-                    type: "action",
-                    displayName: "Edit in Node Particle System Editor",
-                    icon: () => jsx(EditRegular, {}),
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    execute: async () => await EditParticleSystem(particleSystem),
-                };
-            },
-        });
-        return {
-            dispose: () => {
-                sectionRegistration.dispose();
-                editParticleSystemCommandRegistration.dispose();
-            },
-        };
-    },
-};
-
-const PostProcessExplorerServiceDefinition = {
-    friendlyName: "Post Process Explorer",
-    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
-    factory: (sceneExplorerService, sceneContext, watcherService) => {
-        const scene = sceneContext.currentScene;
-        if (!scene) {
-            return undefined;
+    }
+    // Color3 / Color4
+    if (value && typeof value === "object" && "r" in value && "g" in value && "b" in value) {
+        const color = value;
+        if ("a" in color && color.a !== undefined) {
+            return [color.r, color.g, color.b, color.a];
         }
-        const sectionRegistration = sceneExplorerService.addSection({
-            displayName: "Post Processes",
-            order: 500 /* DefaultSectionsOrder.PostProcesses */,
-            getRootEntities: () => scene.postProcesses,
-            getEntityDisplayInfo: (postProcess) => {
-                const onChangeObservable = new Observable();
-                const nameHookToken = watcherService.watchProperty(postProcess, "name", () => onChangeObservable.notifyObservers());
-                return {
-                    get name() {
-                        return postProcess.name || `Unnamed ${postProcess.getClassName()}`;
-                    },
-                    onChange: onChangeObservable,
-                    dispose: () => {
-                        nameHookToken.dispose();
-                        onChangeObservable.clear();
-                    },
-                };
-            },
-            entityIcon: () => jsx(BlurRegular, { color: tokens.colorPaletteRedForeground2 }),
-            getEntityAddedObservables: () => [scene.onNewPostProcessAddedObservable],
-            getEntityRemovedObservables: () => [scene.onPostProcessRemovedObservable],
-        });
-        return {
-            dispose: () => {
-                sectionRegistration.dispose();
-            },
-        };
-    },
-};
-
-const RenderingPipelineExplorerServiceDefinition = {
-    friendlyName: "Rendering Pipeline Explorer",
-    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity],
-    factory: (sceneExplorerService, sceneContext) => {
-        const scene = sceneContext.currentScene;
-        if (!scene) {
-            return undefined;
+        return [color.r, color.g, color.b];
+    }
+    // Vector3 / Vector4 / Quaternion
+    if (value && typeof value === "object" && "x" in value && "y" in value && "z" in value) {
+        const vec = value;
+        if ("w" in vec && vec.w !== undefined) {
+            return [vec.x, vec.y, vec.z, vec.w];
         }
-        const sectionRegistration = sceneExplorerService.addSection({
-            displayName: "Rendering Pipelines",
-            order: 600 /* DefaultSectionsOrder.RenderingPipelines */,
-            getRootEntities: () => scene.postProcessRenderPipelineManager.supportedPipelines ?? [],
-            getEntityDisplayInfo: (pipeline) => {
-                return {
-                    get name() {
-                        return `${pipeline.name || "Unnamed"} [${pipeline.getClassName()}]`;
-                    },
-                };
-            },
-            entityIcon: () => jsx(PipelineRegular, { color: tokens.colorPaletteRedForeground2 }),
-            getEntityAddedObservables: () => [scene.postProcessRenderPipelineManager.onNewPipelineAddedObservable],
-            getEntityRemovedObservables: () => [scene.postProcessRenderPipelineManager.onPipelineRemovedObservable],
-        });
-        return {
-            dispose: () => {
-                sectionRegistration.dispose();
-            },
-        };
-    },
-};
+        return [vec.x, vec.y, vec.z];
+    }
+    // Vector2
+    if (value && typeof value === "object" && "x" in value && "y" in value && !("z" in value)) {
+        const vec2 = value;
+        return [vec2.x, vec2.y];
+    }
+    return undefined;
+}
+/**
+ * Checks if an entity is a sub-object of a known scene entity by scanning
+ * well-known sub-object properties on the scene and its collections.
+ * Returns the parent entity info with the property path prefix.
+ * @param entity - The entity to search for.
+ * @param scene - The scene to search in.
+ * @returns The parent entity info, or null if not found.
+ */
+function FindParentEntity(entity, scene) {
+    // Check scene sub-objects (imageProcessingConfiguration, fogSettings, etc.)
+    const sceneSubProps = ["imageProcessingConfiguration", "postProcessRenderPipelineManager", "ambientColor", "gravity"];
+    for (const prop of sceneSubProps) {
+        if (scene[prop] === entity) {
+            return { targetType: "scene", targetName: "", targetIndex: 0, parentProperty: prop };
+        }
+    }
+    const collections = [
+        { type: "materials", items: scene.materials },
+        { type: "cameras", items: scene.cameras },
+        { type: "meshes", items: scene.meshes },
+        { type: "lights", items: scene.lights },
+    ];
+    for (const { type, items } of collections) {
+        for (const parent of items) {
+            for (const prop of Object.keys(parent)) {
+                if (prop.startsWith("_")) {
+                    continue;
+                }
+                try {
+                    if (parent[prop] === entity) {
+                        const targetIndex = items.filter((p) => p.name === parent.name).indexOf(parent);
+                        return { targetType: type, targetName: parent.name, targetIndex: Math.max(targetIndex, 0), parentProperty: prop };
+                    }
+                }
+                catch {
+                    // Skip properties that throw on access
+                }
+            }
+        }
+    }
+    return null;
+}
 
-const SkeletonExplorerServiceDefinition = {
-    friendlyName: "Skeleton Explorer",
-    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
-    factory: (sceneExplorerService, sceneContext, watcherService) => {
+function IsCameraFrameGraphTask(task) {
+    return task.camera instanceof Camera;
+}
+function IsNodesSectionType(node) {
+    return node instanceof TransformNode || node instanceof Camera || node instanceof Light;
+}
+const NodeExplorerServiceDefinition = {
+    friendlyName: "Node Explorer",
+    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, GizmoServiceIdentity, WatcherServiceIdentity],
+    factory: (sceneExplorerService, sceneContext, gizmoService, watcherService) => {
         const scene = sceneContext.currentScene;
         if (!scene) {
             return undefined;
         }
-        const boneMovedObservable = new Observable();
+        const nodeMovedObservable = new Observable();
+        // Set of all nodes known to be in the scene, rebuilt each time getRootEntities
+        // is called. Used by getEntityDisplayInfo to detect orphaned ancestor nodes.
+        const knownSceneNodes = new Set();
         const sectionRegistration = sceneExplorerService.addSection({
-            displayName: "Skeletons",
-            order: 200 /* DefaultSectionsOrder.Skeletons */,
-            getRootEntities: () => scene.skeletons,
-            getEntityChildren: (skeletonOrBone) => skeletonOrBone.getChildren(),
-            getEntityDisplayInfo: (skeletonOrBone) => {
+            displayName: "Nodes",
+            order: 100 /* DefaultSectionsOrder.Nodes */,
+            getRootEntities: () => {
+                const rootNodes = new Set(scene.rootNodes);
+                knownSceneNodes.clear();
+                // Ensure all nodes in the scene are reachable in the explorer, even if their
+                // parent was removed from the scene or is not a type shown in the Nodes section.
+                for (const node of [...scene.meshes, ...scene.transformNodes, ...scene.cameras, ...scene.lights]) {
+                    knownSceneNodes.add(node);
+                    if (!node.parent) {
+                        continue;
+                    }
+                    if (!IsNodesSectionType(node.parent)) {
+                        // Parent is not a type shown in the Nodes section (e.g. a Bone).
+                        // Treat this node as a root so it still appears in the explorer.
+                        rootNodes.add(node);
+                    }
+                    else {
+                        // Walk up through Nodes-section-type parents to find the topmost ancestor.
+                        // If that ancestor was removed from the scene (not in rootNodes), add it
+                        // so the entire subtree remains visible in the explorer.
+                        let ancestor = node.parent;
+                        while (ancestor.parent && IsNodesSectionType(ancestor.parent)) {
+                            ancestor = ancestor.parent;
+                        }
+                        rootNodes.add(ancestor);
+                    }
+                }
+                // Lights within a clustered light container are not included in Scene.lights or Scene.rootNodes.
+                // If they also have no parent, then they won't show up anywhere, so show them as root nodes.
+                for (const light of scene.lights) {
+                    if (light instanceof ClusteredLightContainer) {
+                        for (const childLight of light.lights) {
+                            knownSceneNodes.add(childLight);
+                            if (!childLight.parent) {
+                                rootNodes.add(childLight);
+                            }
+                        }
+                    }
+                }
+                return [...rootNodes];
+            },
+            getEntityChildren: (node) => node.getChildren(),
+            getEntityDisplayInfo: (node) => {
                 const onChangeObservable = new Observable();
-                const nameHookToken = watcherService.watchProperty(skeletonOrBone, "name", () => onChangeObservable.notifyObservers());
-                const parentHookToken = skeletonOrBone instanceof Skeleton ? null : watcherService.watchProperty(skeletonOrBone, "parent", () => boneMovedObservable.notifyObservers(skeletonOrBone));
+                const nameHookToken = watcherService.watchProperty(node, "name", () => onChangeObservable.notifyObservers());
+                const parentHookToken = watcherService.watchProperty(node, "parent", () => nodeMovedObservable.notifyObservers(node));
+                // A node is "not in the scene" if it is a Nodes-section type but is not
+                // a known scene node. This handles nodes that were removed from the scene
+                // but still appear because a descendant is in the scene. Nodes from the
+                // !IsNodesSectionType(parent) branch are unaffected because they always
+                // come from the scene's tracking lists. Clustered light children are also
+                // unaffected because they are added to knownSceneNodes explicitly.
+                const validationError = IsNodesSectionType(node) && !knownSceneNodes.has(node) ? "This entity is not in the scene but is shown because a descendant is still in the scene." : undefined;
                 return {
                     get name() {
-                        return skeletonOrBone.name || `Unnamed ${skeletonOrBone.getClassName()}`;
+                        return node.name || `Unnamed ${node.getClassName()}`;
                     },
+                    validationError,
                     onChange: onChangeObservable,
                     dispose: () => {
                         nameHookToken.dispose();
-                        parentHookToken?.dispose();
+                        parentHookToken.dispose();
                         onChangeObservable.clear();
                     },
                 };
             },
-            entityIcon: ({ entity: skeletonOrBone }) => skeletonOrBone instanceof Skeleton ? (jsx(PersonWalkingRegular, { color: tokens.colorPaletteAnchorForeground2 })) : (jsx(DataLineRegular, { color: tokens.colorPaletteBeigeForeground2 })),
-            getEntityAddedObservables: () => [scene.onNewSkeletonAddedObservable],
-            getEntityRemovedObservables: () => [scene.onSkeletonRemovedObservable],
-            getEntityMovedObservables: () => [boneMovedObservable],
-        });
-        return {
-            dispose: () => {
-                sectionRegistration.dispose();
+            entityIcon: ({ entity: node }) => node instanceof AbstractMesh ? (jsx(MeshIcon, { color: tokens.colorPaletteBlueForeground2 })) : node instanceof TransformNode ? (jsx(MyLocationRegular, { color: tokens.colorPaletteBlueForeground2 })) : node instanceof Camera ? (jsx(CameraRegular, { color: tokens.colorPaletteGreenForeground2 })) : node instanceof ClusteredLightContainer ? (jsx(BubbleMultipleRegular, { color: tokens.colorPaletteYellowForeground2 })) : node instanceof Light ? (jsx(LightbulbRegular, { color: tokens.colorPaletteYellowForeground2 })) : (jsx(Fragment, {})),
+            getEntityAddedObservables: () => [
+                scene.onNewMeshAddedObservable,
+                scene.onNewTransformNodeAddedObservable,
+                scene.onNewCameraAddedObservable,
+                scene.onNewLightAddedObservable,
+            ],
+            getEntityRemovedObservables: () => [
+                scene.onMeshRemovedObservable,
+                scene.onTransformNodeRemovedObservable,
+                scene.onCameraRemovedObservable,
+                scene.onLightRemovedObservable,
+            ],
+            getEntityMovedObservables: () => [nodeMovedObservable],
+            dragDropConfig: {
+                canDrag: (node) => node instanceof Node$1,
+                canDrop: (draggedNode, targetNode) => {
+                    // Can't drop on self
+                    if (targetNode === draggedNode) {
+                        return false;
+                    }
+                    // Can't drop on a descendant
+                    if (targetNode !== null && targetNode.isDescendantOf(draggedNode)) {
+                        return false;
+                    }
+                    // Can drop onto section root (null) only if node has a parent
+                    if (targetNode === null) {
+                        return draggedNode.parent !== null;
+                    }
+                    return true;
+                },
+                onDrop: (draggedNode, targetNode) => {
+                    if (draggedNode.parent === targetNode) {
+                        return;
+                    }
+                    const nodeScene = draggedNode.getScene();
+                    const oldParent = draggedNode.parent;
+                    // Use setParent for TransformNodes to preserve world transform
+                    if (draggedNode instanceof TransformNode) {
+                        // setParent recomputes local position/rotation/scaling to
+                        // preserve the world transform, so capture those alongside
+                        // the parent change to round-trip the reparent on reload.
+                        const oldPosition = draggedNode.position.clone();
+                        const oldRotation = draggedNode.rotation.clone();
+                        const oldRotationQuaternion = draggedNode.rotationQuaternion ? draggedNode.rotationQuaternion.clone() : null;
+                        const oldScaling = draggedNode.scaling.clone();
+                        draggedNode.setParent(targetNode);
+                        RecordEntityPropertyOverride(nodeScene, draggedNode, "parent", targetNode, oldParent);
+                        RecordEntityPropertyOverride(nodeScene, draggedNode, "position", draggedNode.position, oldPosition);
+                        if (draggedNode.rotationQuaternion) {
+                            RecordEntityPropertyOverride(nodeScene, draggedNode, "rotationQuaternion", draggedNode.rotationQuaternion, oldRotationQuaternion);
+                        }
+                        else {
+                            RecordEntityPropertyOverride(nodeScene, draggedNode, "rotation", draggedNode.rotation, oldRotation);
+                        }
+                        RecordEntityPropertyOverride(nodeScene, draggedNode, "scaling", draggedNode.scaling, oldScaling);
+                    }
+                    else {
+                        draggedNode.parent = targetNode;
+                        RecordEntityPropertyOverride(nodeScene, draggedNode, "parent", targetNode, oldParent);
+                    }
+                },
             },
-        };
-    },
-};
-
-const SoundExplorerServiceDefinition = {
-    friendlyName: "Sound Explorer",
-    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
-    factory: (sceneExplorerService, sceneContext, watcherService) => {
-        const scene = sceneContext.currentScene;
-        if (!scene) {
-            return undefined;
-        }
-        const soundAddedObservable = new Observable();
-        const soundRemovedObservable = new Observable();
-        let addSoundHook;
-        let removeSoundHook;
-        const hookMainSoundTrack = (mainSoundTrack) => {
-            addSoundHook?.dispose();
-            addSoundHook = undefined;
-            removeSoundHook?.dispose();
-            removeSoundHook = undefined;
-            if (mainSoundTrack) {
-                addSoundHook = InterceptFunction(mainSoundTrack, "addSound", {
-                    afterCall: (sound) => soundAddedObservable.notifyObservers(sound),
-                });
-                removeSoundHook = InterceptFunction(mainSoundTrack, "removeSound", {
-                    afterCall: (sound) => soundRemovedObservable.notifyObservers(sound),
-                });
-            }
-        };
-        // If _mainSoundTrack is already defined, set up hooks immediately.
-        hookMainSoundTrack(scene.mainSoundTrack);
-        // Watch for _mainSoundTrack being set (it is lazily created by the mainSoundTrack getter in audioSceneComponent.ts).
-        const mainSoundTrackHook = watcherService.watchProperty(scene, "_mainSoundTrack", () => hookMainSoundTrack(scene._mainSoundTrack));
-        const sectionRegistration = sceneExplorerService.addSection({
-            displayName: "Sounds",
-            order: 1400 /* DefaultSectionsOrder.Sounds */,
-            getRootEntities: () => scene.mainSoundTrack?.soundCollection ?? [],
-            getEntityDisplayInfo: (sound) => {
+        });
+        const abstractMeshBoundingBoxCommandRegistration = sceneExplorerService.addEntityCommand({
+            predicate: (entity) => entity instanceof AbstractMesh && entity.getTotalVertices() > 0,
+            order: 1000 /* DefaultCommandsOrder.MeshBoundingBox */,
+            getCommand: (mesh) => {
                 const onChangeObservable = new Observable();
-                const nameHookToken = watcherService.watchProperty(sound, "name", () => onChangeObservable.notifyObservers());
+                const showBoundingBoxHook = watcherService.watchProperty(mesh, "showBoundingBox", () => onChangeObservable.notifyObservers());
                 return {
-                    get name() {
-                        return sound.name || `Unnamed ${sound.getClassName()}`;
+                    type: "toggle",
+                    get displayName() {
+                        return `${mesh.showBoundingBox ? "Hide" : "Show"} Bounding Box`;
+                    },
+                    icon: () => (mesh.showBoundingBox ? jsx(BorderOutsideRegular, {}) : jsx(BorderNoneRegular, {})),
+                    get isEnabled() {
+                        return mesh.showBoundingBox;
+                    },
+                    set isEnabled(enabled) {
+                        mesh.showBoundingBox = enabled;
                     },
                     onChange: onChangeObservable,
                     dispose: () => {
-                        nameHookToken.dispose();
+                        showBoundingBoxHook.dispose();
                         onChangeObservable.clear();
                     },
                 };
             },
-            entityIcon: () => jsx(SoundWaveCircleRegular, { color: tokens.colorPaletteForestForeground2 }),
-            getEntityAddedObservables: () => [soundAddedObservable],
-            getEntityRemovedObservables: () => [soundRemovedObservable],
         });
-        return {
-            dispose: () => {
-                mainSoundTrackHook.dispose();
-                addSoundHook?.dispose();
-                removeSoundHook?.dispose();
-                soundAddedObservable.clear();
-                soundRemovedObservable.clear();
-                sectionRegistration.dispose();
-            },
-        };
-    },
-};
-
-const SpriteManagerExplorerServiceDefinition = {
-    friendlyName: "Sprite Manager Explorer",
-    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
-    factory: (sceneExplorerService, sceneContext, watcherService) => {
-        const scene = sceneContext.currentScene;
-        if (!scene) {
-            return undefined;
-        }
-        const sectionRegistration = sceneExplorerService.addSection({
-            displayName: "Sprite Managers",
-            order: 900 /* DefaultSectionsOrder.SpriteManagers */,
-            getRootEntities: () => scene.spriteManagers ?? [],
-            getEntityChildren: (spriteEntity) => (spriteEntity instanceof Sprite ? [] : spriteEntity.sprites),
-            getEntityDisplayInfo: (spriteEntity) => {
+        const abstractMeshVisibilityCommandRegistration = sceneExplorerService.addEntityCommand({
+            predicate: (entity) => entity instanceof AbstractMesh && entity.getTotalVertices() > 0,
+            order: 1100 /* DefaultCommandsOrder.MeshVisibility */,
+            getCommand: (mesh) => {
                 const onChangeObservable = new Observable();
-                const nameHookToken = watcherService.watchProperty(spriteEntity, "name", () => onChangeObservable.notifyObservers());
+                const isVisibleHook = watcherService.watchProperty(mesh, "isVisible", () => onChangeObservable.notifyObservers());
                 return {
-                    get name() {
-                        return spriteEntity.name || `Unnamed ${spriteEntity instanceof Sprite ? spriteEntity.getClassName() : "SpriteManager"}`;
+                    type: "toggle",
+                    get displayName() {
+                        return `${mesh.isVisible ? "Hide" : "Show"} Mesh`;
+                    },
+                    icon: () => (mesh.isVisible ? jsx(EyeRegular, {}) : jsx(EyeOffRegular, {})),
+                    hotKey: {
+                        keyCode: "Space",
+                        control: true,
+                    },
+                    get isEnabled() {
+                        return !mesh.isVisible;
+                    },
+                    set isEnabled(enabled) {
+                        const oldValue = mesh.isVisible;
+                        mesh.isVisible = !enabled;
+                        RecordEntityPropertyOverride(mesh.getScene(), mesh, "isVisible", mesh.isVisible, oldValue);
                     },
                     onChange: onChangeObservable,
                     dispose: () => {
-                        nameHookToken.dispose();
+                        isVisibleHook.dispose();
                         onChangeObservable.clear();
                     },
                 };
             },
-            entityIcon: ({ entity: spriteEntity }) => spriteEntity instanceof Sprite ? (jsx(PersonSquareRegular, { color: tokens.colorPalettePeachForeground2 })) : (jsx(LayerDiagonalPersonRegular, { color: tokens.colorPalettePeachForeground2 })),
-            getEntityAddedObservables: () => [scene.onNewSpriteManagerAddedObservable],
-            getEntityRemovedObservables: () => [scene.onSpriteManagerRemovedObservable],
         });
-        const spritePlayStopCommandRegistration = sceneExplorerService.addEntityCommand({
-            predicate: (entity) => entity instanceof Sprite,
-            order: 600 /* DefaultCommandsOrder.SpritePlay */,
-            getCommand: (sprite) => {
+        const getActiveCamera = () => (scene.frameGraph ? FindMainCamera(scene.frameGraph) : scene.activeCamera);
+        const activeCameraCommandRegistration = sceneExplorerService.addEntityCommand({
+            predicate: (entity) => entity instanceof Camera,
+            order: 700 /* DefaultCommandsOrder.CameraActive */,
+            getCommand: (camera) => {
+                const scene = camera.getScene();
                 const onChangeObservable = new Observable();
-                const playHook = InterceptFunction(sprite, "playAnimation", {
-                    afterCall: () => onChangeObservable.notifyObservers(),
-                });
-                const stopHook = InterceptFunction(sprite, "stopAnimation", {
-                    afterCall: () => onChangeObservable.notifyObservers(),
-                });
-                const animateHook = InterceptFunction(sprite, "_animate", {
-                    afterCall: () => onChangeObservable.notifyObservers(),
+                const activeCameraChangedObserver = scene.onActiveCameraChanged.add(() => {
+                    onChangeObservable.notifyObservers();
                 });
                 return {
-                    type: "action",
+                    type: "toggle",
+                    displayName: "Activate and Attach Controls",
+                    icon: () => {
+                        return getActiveCamera() === camera ? jsx(VideoFilled, {}) : jsx(VideoRegular, {});
+                    },
+                    get isEnabled() {
+                        return getActiveCamera() === camera;
+                    },
+                    set isEnabled(enabled) {
+                        const activeCamera = getActiveCamera();
+                        if (enabled && activeCamera !== camera) {
+                            if (scene.frameGraph) {
+                                void (async (frameGraph) => {
+                                    let updated = false;
+                                    const nrg = frameGraph.getLinkedNodeRenderGraph();
+                                    if (nrg) {
+                                        updated = await nrg.replaceCameraAsync(activeCamera, camera);
+                                    }
+                                    else {
+                                        for (const task of frameGraph.tasks) {
+                                            if (IsCameraFrameGraphTask(task)) {
+                                                task.camera = camera;
+                                                updated = true;
+                                            }
+                                        }
+                                    }
+                                    if (updated) {
+                                        activeCamera?.detachControl();
+                                        camera.attachControl(true);
+                                        onChangeObservable.notifyObservers();
+                                    }
+                                })(scene.frameGraph);
+                            }
+                            else {
+                                activeCamera?.detachControl();
+                                scene.activeCamera = camera;
+                                camera.attachControl(true);
+                            }
+                        }
+                    },
+                    onChange: onChangeObservable,
+                    dispose: () => {
+                        activeCameraChangedObserver.remove();
+                        onChangeObservable.clear();
+                    },
+                };
+            },
+        });
+        function addGizmoCommand(nodeClass, getGizmoRef) {
+            return sceneExplorerService.addEntityCommand({
+                predicate: (entity) => entity instanceof nodeClass,
+                order: 800 /* DefaultCommandsOrder.GizmoActive */,
+                getCommand: (node) => {
+                    const onChangeObservable = new Observable();
+                    let gizmoRef = null;
+                    return {
+                        type: "toggle",
+                        get displayName() {
+                            return `Turn ${gizmoRef ? "Off" : "On"} Gizmo`;
+                        },
+                        icon: () => (gizmoRef ? jsx(EyeRegular, {}) : jsx(EyeOffRegular, {})),
+                        get isEnabled() {
+                            return !!gizmoRef;
+                        },
+                        set isEnabled(enabled) {
+                            if (enabled) {
+                                if (!gizmoRef) {
+                                    gizmoRef = getGizmoRef(node);
+                                    onChangeObservable.notifyObservers();
+                                }
+                            }
+                            else {
+                                if (gizmoRef) {
+                                    gizmoRef.dispose();
+                                    gizmoRef = null;
+                                    onChangeObservable.notifyObservers();
+                                }
+                            }
+                        },
+                        onChange: onChangeObservable,
+                        dispose: () => {
+                            onChangeObservable.clear();
+                        },
+                    };
+                },
+            });
+        }
+        const cameraGizmoCommandRegistration = addGizmoCommand(Camera, gizmoService.getCameraGizmo.bind(gizmoService));
+        const lightEnabledCommandRegistration = sceneExplorerService.addEntityCommand({
+            predicate: (entity) => entity instanceof Light,
+            order: 700 /* DefaultCommandsOrder.LightActive */,
+            getCommand: (light) => {
+                return {
+                    type: "toggle",
                     get displayName() {
-                        return `${sprite.animationStarted ? "Stop" : "Play"} Animation`;
+                        return `Turn Light ${light.isEnabled() ? "Off" : "On"}`;
                     },
-                    icon: () => (sprite.animationStarted ? jsx(StopFilled, {}) : jsx(PlayFilled, {})),
-                    execute: () => (sprite.animationStarted ? sprite.stopAnimation() : sprite.playAnimation(sprite.fromIndex, sprite.toIndex, sprite.loopAnimation, sprite.delay)),
-                    onChange: onChangeObservable,
-                    dispose: () => {
-                        playHook.dispose();
-                        stopHook.dispose();
-                        animateHook.dispose();
-                        onChangeObservable.clear();
+                    icon: () => (light.isEnabled() ? jsx(FlashlightRegular, {}) : jsx(FlashlightOffRegular, {})),
+                    get isEnabled() {
+                        return !light.isEnabled();
+                    },
+                    set isEnabled(enabled) {
+                        light.setEnabled(!enabled);
                     },
+                    onChange: light.onEnabledStateChangedObservable,
                 };
             },
         });
-        return {
-            dispose: () => {
-                sectionRegistration.dispose();
-                spritePlayStopCommandRegistration.dispose();
-            },
-        };
-    },
-};
-
-const TextureExplorerServiceDefinition = {
-    friendlyName: "Texture Explorer",
-    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
-    factory: (sceneExplorerService, sceneContext, watcherService) => {
-        const scene = sceneContext.currentScene;
-        if (!scene) {
-            return undefined;
-        }
-        const sectionRegistration = sceneExplorerService.addSection({
-            displayName: "Textures",
-            order: 400 /* DefaultSectionsOrder.Textures */,
-            getRootEntities: () => scene.textures.filter((texture) => texture.getClassName() !== "AdvancedDynamicTexture"),
-            getEntityDisplayInfo: (texture) => {
-                const onChangeObservable = new Observable();
-                const displayNameHookToken = watcherService.watchProperty(texture, "displayName", () => onChangeObservable.notifyObservers());
-                const nameHookToken = watcherService.watchProperty(texture, "name", () => onChangeObservable.notifyObservers());
+        const lightGizmoCommandRegistration = addGizmoCommand(Light, gizmoService.getLightGizmo.bind(gizmoService));
+        const editNodeGeometryCommandRegistration = sceneExplorerService.addEntityCommand({
+            predicate: (entity) => entity instanceof Mesh && !!GetNodeGeometry(entity),
+            order: 1100 /* DefaultCommandsOrder.EditNodeGeometry */,
+            getCommand: (mesh) => {
                 return {
-                    get name() {
-                        return texture.displayName || texture.name || `${texture.getClassName() || "Unnamed Texture"} (${texture.uniqueId})`;
-                    },
-                    onChange: onChangeObservable,
-                    dispose: () => {
-                        nameHookToken.dispose();
-                        displayNameHookToken.dispose();
-                        onChangeObservable.clear();
+                    type: "action",
+                    displayName: "Edit in Node Geometry Editor",
+                    icon: () => jsx(EditRegular, {}),
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    execute: async () => {
+                        const nodeGeometry = GetNodeGeometry(mesh);
+                        if (nodeGeometry) {
+                            await EditNodeGeometry(nodeGeometry, mesh.getScene());
+                        }
                     },
                 };
             },
-            entityIcon: ({ entity: texture }) => texture instanceof DynamicTexture ? jsx(ImageEditRegular, { color: tokens.colorPaletteGrapeForeground2 }) : jsx(ImageRegular, { color: tokens.colorPaletteGrapeForeground2 }),
-            getEntityAddedObservables: () => [scene.onNewTextureAddedObservable],
-            getEntityRemovedObservables: () => [scene.onTextureRemovedObservable],
         });
         return {
             dispose: () => {
                 sectionRegistration.dispose();
+                abstractMeshBoundingBoxCommandRegistration.dispose();
+                abstractMeshVisibilityCommandRegistration.dispose();
+                activeCameraCommandRegistration.dispose();
+                cameraGizmoCommandRegistration.dispose();
+                lightEnabledCommandRegistration.dispose();
+                lightGizmoCommandRegistration.dispose();
+                editNodeGeometryCommandRegistration.dispose();
             },
-        };
-    },
-};
-
-const EquirectangularCaptureTool = ({ scene }) => {
-    const captureEquirectangularAsync = useCallback(async () => {
-        const currentActiveCamera = scene.activeCamera;
-        if (!currentActiveCamera && scene.frameGraph) {
-            scene.activeCamera = FrameGraphUtils.FindMainCamera(scene.frameGraph);
-        }
-        if (scene.activeCamera) {
-            await captureEquirectangularFromScene(scene, { size: 1024, filename: "equirectangular_capture.png" });
-        }
-        // eslint-disable-next-line require-atomic-updates
-        scene.activeCamera = currentActiveCamera;
-    }, [scene]);
-    return jsx(ButtonLine, { label: "Capture Equirectangular", icon: CameraRegular, onClick: captureEquirectangularAsync });
-};
-
-const GIFCaptureTool = MakeLazyComponent(async () => {
-    const gif = (await import('./gif-CdXfT-By.js').then(function (n) { return n.g; })).default;
-    // TODO: Figure out how to grab this from NPM package instead of CDN
-    const workerContent = await Tools.LoadFileAsync("https://cdn.jsdelivr.net/gh//terikon/gif.js.optimized@0.1.6/dist/gif.worker.js");
-    const workerBlob = new Blob([workerContent], { type: "application/javascript" });
-    const workerUrl = URL.createObjectURL(workerBlob);
-    return ({ scene }) => {
-        const [recordingSession, setRecordingSession] = useState({ state: "Idle" });
-        const [targetWidth, setTargetWidth] = useState(512);
-        const [frequency, setFrequency] = useState(200);
-        useEffect(() => {
-            return () => {
-                if (recordingSession.state === "Recording") {
-                    // Reset session resources if component is unmounted
-                    scene.onAfterRenderObservable.remove(recordingSession.captureObserver);
-                    scene.getEngine().setHardwareScalingLevel(recordingSession.previousHardwareScaling);
-                }
-            };
-        }, [recordingSession, scene]);
-        // Use functional setState to guard against multiple rapid clicks
-        const startRecording = useCallback(() => {
-            setRecordingSession((currentSession) => {
-                // If already recording/rendering, don't start a new session
-                if (currentSession.state !== "Idle") {
-                    return currentSession;
-                }
-                const engine = scene.getEngine();
-                const canvas = engine.getRenderingCanvas();
-                if (!canvas) {
-                    return currentSession;
-                }
-                const gifInstance = new gif({
-                    workers: 2,
-                    quality: 10,
-                    workerScript: workerUrl,
-                });
-                // Adjust hardware scaling to match desired width
-                const previousHardwareScaling = engine.getHardwareScalingLevel();
-                engine.setHardwareScalingLevel(engine.getRenderWidth() / (targetWidth * globalThis.devicePixelRatio) || 1);
-                // Capture frames after each render
-                let lastCaptureTime = 0;
-                const captureObserver = scene.onAfterRenderObservable.add(() => {
-                    const now = Date.now();
-                    if (now - lastCaptureTime >= frequency && gifInstance) {
-                        lastCaptureTime = now;
-                        gifInstance.addFrame(canvas, { delay: 1, copy: true });
-                    }
-                });
-                return {
-                    state: "Recording",
-                    gif: gifInstance,
-                    captureObserver: captureObserver,
-                    previousHardwareScaling: previousHardwareScaling,
-                };
-            });
-        }, [scene, targetWidth, frequency]);
-        const stopRecording = useCallback(() => {
-            setRecordingSession((currentSession) => {
-                if (currentSession.state !== "Recording") {
-                    return currentSession;
-                }
-                // Remove the frame capture observer
-                scene.onAfterRenderObservable.remove(currentSession.captureObserver);
-                // Restore previous hardware scaling
-                scene.getEngine().setHardwareScalingLevel(currentSession.previousHardwareScaling);
-                currentSession.gif.on("finished", (blob) => {
-                    // Download the rendered GIF
-                    Tools.Download(blob, "recording.gif");
-                    // Reset state
-                    setRecordingSession({ state: "Idle" });
-                });
-                // Start rendering the GIF
-                currentSession.gif.render();
-                return { state: "Rendering", gif: currentSession.gif };
-            });
-        }, [scene]);
-        return (jsxs(Fragment, { children: [recordingSession.state === "Idle" && jsx(ButtonLine, { label: "Record GIF", icon: RecordRegular, onClick: startRecording }), recordingSession.state === "Recording" && jsx(ButtonLine, { label: "Stop", icon: RecordStopRegular, onClick: stopRecording }), recordingSession.state === "Rendering" && jsx(Label, { children: "Creating the GIF file..." }), jsxs(Collapse, { visible: recordingSession.state === "Idle", children: [jsx(SyncedSliderPropertyLine, { label: "Resolution", description: "The pixel width of the output. The height will be adjusted accordingly to maintain the aspect ratio.", value: targetWidth, onChange: (value) => setTargetWidth(Math.floor(value)), min: 128, max: 2048, step: 128 }), jsx(SyncedSliderPropertyLine, { label: "Frequency (ms)", description: "The time interval in milliseconds between each capture of the scene.", value: frequency, onChange: (value) => setFrequency(Math.floor(value)), min: 50, max: 1000, step: 50 })] })] }));
-    };
-}, { spinnerSize: "extra-tiny", spinnerLabel: "Loading..." });
-
-const SceneReplayTool = ({ scene }) => {
-    const [isRecording, setIsRecording] = useState(false);
-    const sceneRecorder = useResource(() => new SceneRecorder());
-    const startRecording = useCallback(() => {
-        sceneRecorder.track(scene);
-        setIsRecording(true);
-    }, [scene]);
-    const exportReplay = useCallback(() => {
-        const content = JSON.stringify(sceneRecorder.getDelta());
-        const blob = new Blob([content], { type: "application/json" });
-        Tools.Download(blob, "replay_delta.json");
-        setIsRecording(false);
-    }, []);
-    const applyDelta = useCallback((files) => {
-        const file = files[0];
-        if (!file) {
-            return;
-        }
-        Tools.ReadFile(file, (data) => {
-            try {
-                const json = JSON.parse(data);
-                SceneRecorder.ApplyDelta(json, scene);
-            }
-            catch (error) {
-                Logger.Error("Failed to apply replay delta:" + error);
-            }
-        }, undefined, false);
-    }, [scene]);
-    return (jsxs(Fragment, { children: [!isRecording && jsx(ButtonLine, { label: "Start Recording", icon: RecordRegular, onClick: startRecording }), isRecording && (jsxs(Fragment, { children: [jsx(Label, { children: "Recording in progress..." }), jsx(ButtonLine, { label: "Generate Delta File", icon: SaveRegular, onClick: exportReplay })] })), jsx(FileUploadLine, { label: "Apply Delta File", icon: ArrowDownloadRegular, onClick: applyDelta, accept: ".json" })] }));
-};
-
-const ScreenshotTool = ({ scene }) => {
-    const [precision, setPrecision] = useState(1);
-    const [useCustomSize, setUseCustomSize] = useState(false);
-    const [width, setWidth] = useState(512);
-    const [height, setHeight] = useState(512);
-    const captureScreenshot = useCallback(async () => {
-        const engine = scene.getEngine();
-        const camera = scene.frameGraph ? FrameGraphUtils.FindMainCamera(scene.frameGraph) : scene.activeCamera;
-        const screenshotSize = useCustomSize ? { width, height, precision } : { precision };
-        if (camera) {
-            await CreateScreenshotUsingRenderTargetAsync(engine, camera, screenshotSize, "image/png", undefined, undefined, "screenshot.png");
-        }
-    }, [useCustomSize, precision, width, height, scene]);
-    return (jsxs(Fragment, { children: [jsx(ButtonLine, { label: "Capture Screenshot", icon: CameraRegular, onClick: captureScreenshot }), jsx(SyncedSliderPropertyLine, { label: "Precision", description: "A multiplier allowing capture at a higher or lower resolution.", value: precision, onChange: setPrecision, min: 0.1, max: 10, step: 0.1 }), jsx(SwitchPropertyLine, { label: "Use Custom Size", value: useCustomSize, onChange: setUseCustomSize }), jsxs(Collapse, { visible: useCustomSize, children: [jsx(SyncedSliderPropertyLine, { label: "Width", description: "The width of the screenshot in pixels. ", value: width, onChange: setWidth, min: 1, step: 1 }), jsx(SyncedSliderPropertyLine, { label: "Height", description: "The height of the screenshot in pixels.", value: height, onChange: setHeight, min: 1, step: 1 })] })] }));
+        };
+    },
 };
 
-const VideoCaptureTool = ({ scene }) => {
-    const [isRecording, setIsRecording] = useState(false);
-    const videoRecorder = useResource(useCallback(() => {
-        return new VideoRecorder(scene.getEngine());
-    }, [scene.getEngine()]));
-    const recordVideoAsync = useCallback(async () => {
-        if (videoRecorder && videoRecorder.isRecording) {
-            videoRecorder.stopRecording();
-            setIsRecording(false);
-            return;
+const ParticleSystemExplorerServiceDefinition = {
+    friendlyName: "Particle System Explorer",
+    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
+    factory: (sceneExplorerService, sceneContext, watcherService) => {
+        const scene = sceneContext.currentScene;
+        if (!scene) {
+            return undefined;
         }
-        void videoRecorder.startRecording(undefined, 0); // Use 0 to prevent automatic stop; let the user stop it
-        setIsRecording(true);
-    }, [scene]);
-    return (jsx(Fragment, { children: jsx(ButtonLine, { uniqueId: "Start/Stop", label: isRecording ? "Stop Recording" : "Record Video", icon: isRecording ? RecordStopRegular : RecordRegular, onClick: recordVideoAsync }) }));
-};
-
-const CaptureToolsDefinition = {
-    friendlyName: "Capture Tools",
-    consumes: [ToolsServiceIdentity],
-    factory: (toolsService) => {
-        const contentRegistrations = [];
-        // Screenshot
-        contentRegistrations.push(toolsService.addSectionContent({
-            key: "Screenshot",
-            section: "Screenshot",
-            order: 10,
-            component: ({ context }) => jsx(ScreenshotTool, { scene: context }),
-        }));
-        // Equirectangular capture
-        contentRegistrations.push(toolsService.addSectionContent({
-            key: "Equirectangular",
-            section: "Equirectangular",
-            order: 15,
-            component: ({ context }) => jsx(EquirectangularCaptureTool, { scene: context }),
-        }));
-        // Video recorder
-        contentRegistrations.push(toolsService.addSectionContent({
-            key: "Video",
-            section: "Video",
-            order: 20,
-            component: ({ context }) => jsx(VideoCaptureTool, { scene: context }),
-        }));
-        // GIF recorder
-        contentRegistrations.push(toolsService.addSectionContent({
-            key: "GIF",
-            section: "GIF",
-            order: 25,
-            component: ({ context }) => jsx(GIFCaptureTool, { scene: context }),
-        }));
-        // Scene replay
-        contentRegistrations.push(toolsService.addSectionContent({
-            key: "Scene Replay",
-            section: "Scene Replay",
-            order: 30,
-            component: ({ context }) => jsx(SceneReplayTool, { scene: context }),
-        }));
+        const sectionRegistration = sceneExplorerService.addSection({
+            displayName: "Particle Systems",
+            order: 800 /* DefaultSectionsOrder.ParticleSystems */,
+            getRootEntities: () => scene.particleSystems,
+            getEntityDisplayInfo: (particleSystem) => {
+                const onChangeObservable = new Observable();
+                const nameHookToken = watcherService.watchProperty(particleSystem, "name", () => onChangeObservable.notifyObservers());
+                return {
+                    get name() {
+                        return particleSystem.name || `Unnamed ${particleSystem.getClassName()}`;
+                    },
+                    onChange: onChangeObservable,
+                    dispose: () => {
+                        nameHookToken.dispose();
+                        onChangeObservable.clear();
+                    },
+                };
+            },
+            entityIcon: () => jsx(DropRegular, { color: tokens.colorPaletteCranberryForeground2 }),
+            getEntityAddedObservables: () => [scene.onNewParticleSystemAddedObservable],
+            getEntityRemovedObservables: () => [scene.onParticleSystemRemovedObservable],
+        });
+        const editParticleSystemCommandRegistration = sceneExplorerService.addEntityCommand({
+            predicate: (entity) => entity instanceof ParticleSystem && entity.isNodeGenerated,
+            order: 1100 /* DefaultCommandsOrder.EditParticleSystem */,
+            getCommand: (particleSystem) => {
+                return {
+                    type: "action",
+                    displayName: "Edit in Node Particle System Editor",
+                    icon: () => jsx(EditRegular, {}),
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    execute: async () => await EditParticleSystem(particleSystem),
+                };
+            },
+        });
         return {
             dispose: () => {
-                contentRegistrations.forEach((registration) => registration.dispose());
+                sectionRegistration.dispose();
+                editParticleSystemCommandRegistration.dispose();
             },
         };
     },
 };
 
-const EnvExportImageTypes = [
-    { label: "PNG", value: 0, imageType: "image/png" },
-    { label: "WebP", value: 1, imageType: "image/webp" },
-];
-const ExportBabylonTools = ({ scene }) => {
-    // Track environment texture changes to re-render when it's updated (e.g., when a new HDRI is loaded)
-    const environmentTexture = useProperty(scene, "environmentTexture");
-    const [babylonExportOptions, setBabylonExportOptions] = useState({
-        imageTypeIndex: 0,
-        imageQuality: 0.8,
-        iblDiffuse: false,
-    });
-    const exportBabylon = useCallback(async () => {
-        const strScene = JSON.stringify(SceneSerializer.Serialize(scene));
-        const blob = new Blob([strScene], { type: "octet/stream" });
-        Tools.Download(blob, "scene.babylon");
-    }, [scene]);
-    const createEnvTexture = useCallback(async () => {
-        if (!environmentTexture) {
-            return;
-        }
-        try {
-            const buffer = await EnvironmentTextureTools.CreateEnvTextureAsync(environmentTexture, {
-                imageType: EnvExportImageTypes[babylonExportOptions.imageTypeIndex].imageType,
-                imageQuality: babylonExportOptions.imageQuality,
-                disableIrradianceTexture: !babylonExportOptions.iblDiffuse,
-            });
-            const blob = new Blob([buffer], { type: "octet/stream" });
-            Tools.Download(blob, "environment.env");
-        }
-        catch (error) {
-            Logger.Error(error);
-            alert(error);
+const PostProcessExplorerServiceDefinition = {
+    friendlyName: "Post Process Explorer",
+    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
+    factory: (sceneExplorerService, sceneContext, watcherService) => {
+        const scene = sceneContext.currentScene;
+        if (!scene) {
+            return undefined;
         }
-    }, [scene, environmentTexture, babylonExportOptions]);
-    return (jsxs(Fragment, { children: [jsx(ButtonLine, { label: "Export to Babylon", icon: ArrowDownloadRegular, onClick: exportBabylon }), !scene.getEngine().premultipliedAlpha && environmentTexture && environmentTexture._prefiltered && scene.activeCamera && (jsxs(Fragment, { children: [jsx(ButtonLine, { label: "Generate .env Texture", icon: ArrowDownloadRegular, onClick: createEnvTexture }), environmentTexture.irradianceTexture && (jsx(SwitchPropertyLine, { label: "Diffuse Texture", description: "Export diffuse texture for IBL", value: babylonExportOptions.iblDiffuse, onChange: (value) => {
-                            setBabylonExportOptions((prev) => ({ ...prev, iblDiffuse: value }));
-                        } }, "iblDiffuse")), jsx(NumberDropdownPropertyLine, { label: "Image type", options: EnvExportImageTypes, value: babylonExportOptions.imageTypeIndex, onChange: (val) => {
-                            setBabylonExportOptions((prev) => ({ ...prev, imageTypeIndex: val }));
-                        } }), jsx(Collapse, { visible: babylonExportOptions.imageTypeIndex > 0, children: jsx(SyncedSliderPropertyLine, { label: "Quality", value: babylonExportOptions.imageQuality, onChange: (value) => setBabylonExportOptions((prev) => ({ ...prev, imageQuality: value })), min: 0, max: 1 }) })] }))] }));
-};
-const ExportGltfTools = MakeLazyComponent(async () => {
-    // Defer importing anything from the serializers package until this component is actually mounted.
-    const { GLTF2Export } = await import('@babylonjs/serializers/glTF/2.0/glTFSerializer.js');
-    return (props) => {
-        const [isExportingGltf, setIsExportingGltf] = useState(false);
-        const [gltfExportOptions, setGltfExportOptions] = useState({
-            exportDisabledNodes: false,
-            exportSkyboxes: false,
-            exportCameras: false,
-            exportLights: false,
-            dracoCompression: false,
+        const sectionRegistration = sceneExplorerService.addSection({
+            displayName: "Post Processes",
+            order: 500 /* DefaultSectionsOrder.PostProcesses */,
+            getRootEntities: () => scene.postProcesses,
+            getEntityDisplayInfo: (postProcess) => {
+                const onChangeObservable = new Observable();
+                const nameHookToken = watcherService.watchProperty(postProcess, "name", () => onChangeObservable.notifyObservers());
+                return {
+                    get name() {
+                        return postProcess.name || `Unnamed ${postProcess.getClassName()}`;
+                    },
+                    onChange: onChangeObservable,
+                    dispose: () => {
+                        nameHookToken.dispose();
+                        onChangeObservable.clear();
+                    },
+                };
+            },
+            entityIcon: () => jsx(BlurRegular, { color: tokens.colorPaletteRedForeground2 }),
+            getEntityAddedObservables: () => [scene.onNewPostProcessAddedObservable],
+            getEntityRemovedObservables: () => [scene.onPostProcessRemovedObservable],
         });
-        const exportGLTF = useCallback(async () => {
-            setIsExportingGltf(true);
-            const shouldExport = (node) => {
-                if (!gltfExportOptions.exportDisabledNodes) {
-                    if (!node.isEnabled()) {
-                        return false;
-                    }
-                }
-                if (!gltfExportOptions.exportSkyboxes) {
-                    if (node instanceof Mesh) {
-                        if (node.material) {
-                            const material = node.material;
-                            const reflectionTexture = material.reflectionTexture;
-                            if (reflectionTexture && reflectionTexture.coordinatesMode === Texture.SKYBOX_MODE) {
-                                return false;
-                            }
-                        }
-                    }
-                }
-                if (!gltfExportOptions.exportCameras) {
-                    if (node instanceof Camera) {
-                        return false;
-                    }
-                }
-                if (!gltfExportOptions.exportLights) {
-                    if (node instanceof Light) {
-                        return false;
-                    }
-                }
-                return true;
-            };
-            try {
-                const glb = await GLTF2Export.GLBAsync(props.scene, "scene", {
-                    meshCompressionMethod: gltfExportOptions.dracoCompression ? "Draco" : undefined,
-                    shouldExportNode: (node) => shouldExport(node),
-                });
-                glb.downloadFiles();
-            }
-            catch (reason) {
-                Logger.Error(`Failed to export GLB: ${reason}`);
-            }
-            finally {
-                setIsExportingGltf(false);
-            }
-        }, [gltfExportOptions, props.scene]);
-        return (jsxs(Fragment, { children: [jsx(ButtonLine, { label: "Export to GLB", icon: ArrowDownloadRegular, onClick: exportGLTF, disabled: isExportingGltf }), jsx(SwitchPropertyLine, { label: "Export Disabled Nodes", description: "Whether to export nodes that are disabled in the scene.", value: gltfExportOptions.exportDisabledNodes, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, exportDisabledNodes: checked }) }, "GLTFExportDisabledNodes"), jsx(SwitchPropertyLine, { label: "Export Skyboxes", description: "Whether to export skybox nodes in the scene.", value: gltfExportOptions.exportSkyboxes, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, exportSkyboxes: checked }) }, "GLTFExportSkyboxes"), jsx(SwitchPropertyLine, { label: "Export Cameras", description: "Whether to export cameras in the scene.", value: gltfExportOptions.exportCameras, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, exportCameras: checked }) }, "GLTFExportCameras"), jsx(SwitchPropertyLine, { label: "Export Lights", description: "Whether to export lights in the scene.", value: gltfExportOptions.exportLights, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, exportLights: checked }) }, "GLTFExportLights"), jsx(SwitchPropertyLine, { label: "Draco Compression", description: "Whether to apply Draco compression to geometry.", value: gltfExportOptions.dracoCompression, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, dracoCompression: checked }) }, "GLTFDracoCompression")] }));
-    };
-});
+        return {
+            dispose: () => {
+                sectionRegistration.dispose();
+            },
+        };
+    },
+};
 
-const ExportServiceDefinition = {
-    friendlyName: "Export Tools",
-    consumes: [ToolsServiceIdentity],
-    factory: (toolsService) => {
-        const contentRegistrations = [];
-        // glTF export content
-        contentRegistrations.push(toolsService.addSectionContent({
-            key: "GLTF Export",
-            section: "GLTF Export",
-            component: ({ context }) => jsx(ExportGltfTools, { scene: context }),
-        }));
-        // Babylon export content
-        contentRegistrations.push(toolsService.addSectionContent({
-            key: "Babylon Export",
-            section: "Babylon Export",
-            component: ({ context }) => jsx(ExportBabylonTools, { scene: context }),
-        }));
+const RenderingPipelineExplorerServiceDefinition = {
+    friendlyName: "Rendering Pipeline Explorer",
+    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity],
+    factory: (sceneExplorerService, sceneContext) => {
+        const scene = sceneContext.currentScene;
+        if (!scene) {
+            return undefined;
+        }
+        const sectionRegistration = sceneExplorerService.addSection({
+            displayName: "Rendering Pipelines",
+            order: 600 /* DefaultSectionsOrder.RenderingPipelines */,
+            getRootEntities: () => scene.postProcessRenderPipelineManager.supportedPipelines ?? [],
+            getEntityDisplayInfo: (pipeline) => {
+                return {
+                    get name() {
+                        return `${pipeline.name || "Unnamed"} [${pipeline.getClassName()}]`;
+                    },
+                };
+            },
+            entityIcon: () => jsx(PipelineRegular, { color: tokens.colorPaletteRedForeground2 }),
+            getEntityAddedObservables: () => [scene.postProcessRenderPipelineManager.onNewPipelineAddedObservable],
+            getEntityRemovedObservables: () => [scene.postProcessRenderPipelineManager.onPipelineRemovedObservable],
+        });
         return {
             dispose: () => {
-                contentRegistrations.forEach((registration) => registration.dispose());
+                sectionRegistration.dispose();
             },
         };
     },
 };
 
-const OverrideManagerKey = Symbol("babylonjs:overrideManager");
-const OverrideManagerInternals = new WeakMap();
-const OnOverrideManagerCreatedObservable = new Observable();
-/**
- * Creates a new OverrideManager state object and attaches it to the scene.
- *
- * Internal: callers should use {@link GetOverrideManager} which returns the
- * existing manager when one is already attached.
- * @param scene - The scene this manager operates on.
- * @returns The created override manager state.
- */
-function CreateOverrideManager(scene) {
-    const manager = {
-        scene,
-        onChangedObservable: new Observable(),
-    };
-    const internal = {
-        overrides: [],
-        originalValues: new Map(),
-        sceneDisposeObserver: null,
-    };
-    OverrideManagerInternals.set(manager, internal);
-    if (!scene.metadata) {
-        scene.metadata = {};
-    }
-    scene.metadata[OverrideManagerKey] = manager;
-    // Auto-dispose when the scene is disposed so the manager doesn't outlive it.
-    internal.sceneDisposeObserver = scene.onDisposeObservable.add(() => DisposeOverrideManager(manager));
-    OnOverrideManagerCreatedObservable.notifyObservers(manager);
-    return manager;
-}
-/**
- * Returns the OverrideManager attached to the given scene, creating and
- * attaching one if none exists.
- * @param scene - The scene to look up or attach a manager to.
- * @returns The existing or newly created OverrideManager.
- */
-function GetOverrideManager(scene) {
-    const existing = scene.metadata?.[OverrideManagerKey];
-    if (existing) {
-        return existing;
-    }
-    return CreateOverrideManager(scene);
-}
-/**
- * Adds an override entry and immediately applies it.
- * If an override with the same target coordinates already exists, it is replaced.
- *
- * When the caller has already mutated the target (e.g. an Inspector edit),
- * pass `{ originalValue }` containing the property's prior value — this seeds
- * the original-value map (so {@link RemoveOverride} can restore it) and skips
- * the redundant apply step.
- * @param scene - The scene whose override registry to update.
- * @param entry - The override to add.
- * @param options - Optional behavior modifiers; see {@link AddOverrideOptions}.
- */
-function AddOverride(scene, entry, options) {
-    const manager = GetOverrideManager(scene);
-    const internal = GetOverrideInternals(manager);
-    RemoveMatchingOverride(internal, entry.targetType, entry.targetName, entry.targetIndex, entry.propertyPath);
-    internal.overrides.push(entry);
-    if (options && "originalValue" in options) {
-        // Caller already applied the new value. Seed the captured original from
-        // their pre-edit snapshot — otherwise ApplyOverrideEntry would capture
-        // the post-edit value and RemoveOverride would have nothing to restore.
-        const origKey = MakeOriginalValueKey(entry.targetType, entry.targetName, entry.targetIndex, entry.propertyPath);
-        if (!internal.originalValues.has(origKey)) {
-            internal.originalValues.set(origKey, CloneValue(options.originalValue));
-        }
-    }
-    else {
-        ApplyOverrideEntry(manager, internal, entry);
-    }
-    manager.onChangedObservable.notifyObservers();
-}
-/**
- * Returns all overrides currently registered with the scene.
- * @param scene - The scene whose override registry to read.
- * @returns A read-only array of override entries.
- */
-function GetOverrides(scene) {
-    return GetOverrideInternals(GetOverrideManager(scene)).overrides;
-}
-/**
- * Removes all overrides, optionally restoring original values.
- * @param scene - The scene whose override registry to clear.
- * @param restoreOriginals - If true, restores all captured original values.
- */
-function ClearOverrides(scene, restoreOriginals = false) {
-    const manager = GetOverrideManager(scene);
-    const internal = GetOverrideInternals(manager);
-    if (restoreOriginals) {
-        // Snapshot the entries so we can restore each original without firing
-        // an onChangedObservable notification per entry; consumers only need
-        // one signal that the registry was emptied.
-        const entries = [...internal.overrides];
-        internal.overrides.length = 0;
-        for (const entry of entries) {
-            const origKey = MakeOriginalValueKey(entry.targetType, entry.targetName, entry.targetIndex, entry.propertyPath);
-            const original = internal.originalValues.get(origKey);
-            if (original !== undefined) {
-                const target = ResolveTarget(manager.scene, entry.targetType, entry.targetName, entry.targetIndex);
-                if (target) {
-                    SetNestedProperty(target, entry.propertyPath, original);
-                }
-            }
-        }
-        internal.originalValues.clear();
-        manager.onChangedObservable.notifyObservers();
-        return;
-    }
-    internal.overrides.length = 0;
-    internal.originalValues.clear();
-    manager.onChangedObservable.notifyObservers();
-}
-/**
- * Updates the target coordinates on the override matching a specific (type,
- * old-name, old-index) so it follows an entity rename. Used by capture services
- * to keep overrides attached to a specific object after the user renames it.
- *
- * Only the override at the exact `(targetType, oldName, oldIndex)` slot is
- * updated, so other same-named siblings keep their own overrides untouched.
- *
- * @param scene - The scene whose override registry to update.
- * @param targetType - The target type.
- * @param oldName - The previous name of the renamed entity.
- * @param oldIndex - The previous index of the renamed entity among same-named siblings.
- * @param newName - The new name of the renamed entity.
- * @param newIndex - The new index of the renamed entity among same-named siblings.
- */
-function RenameOverrideTarget(scene, targetType, oldName, oldIndex, newName, newIndex) {
-    const manager = GetOverrideManager(scene);
-    const internal = GetOverrideInternals(manager);
-    let changed = false;
-    for (let i = 0; i < internal.overrides.length; i++) {
-        const entry = internal.overrides[i];
-        if (entry.targetType === targetType && entry.targetName === oldName && entry.targetIndex === oldIndex) {
-            internal.overrides[i] = { ...entry, targetName: newName, targetIndex: newIndex };
-            changed = true;
-        }
-    }
-    // Update original-value keys to match the new identity
-    const oldPrefix = `${targetType}::${oldName}::${oldIndex}::`;
-    const newPrefix = `${targetType}::${newName}::${newIndex}::`;
-    for (const [origKey, value] of Array.from(internal.originalValues.entries())) {
-        if (origKey.startsWith(oldPrefix)) {
-            const propertyPath = origKey.substring(oldPrefix.length);
-            internal.originalValues.set(newPrefix + propertyPath, value);
-            internal.originalValues.delete(origKey);
-        }
-    }
-    if (changed) {
-        manager.onChangedObservable.notifyObservers();
-    }
-}
-/**
- * Rewrites override *values* that reference an entity by name when that entity
- * has been renamed. Mirrors {@link RenameOverrideTarget} but operates on the
- * `value` field rather than the `targetName` field, so overrides whose value
- * is `"ref:oldName"` (material/light/camera references) or `"texture:oldName"`
- * (non-SmartAsset texture references) follow the rename instead of silently
- * pointing at a non-existent entity.
- *
- * SmartAsset texture references (`"samTexture:<key>"`) are unaffected because
- * the SmartAsset key is decoupled from the texture's runtime `name` field.
- *
- * @param scene - The scene whose override registry to update.
- * @param valueScheme - Which encoded-reference prefix to rewrite: `"ref"` for
- * material/light/camera references, `"texture"` for non-SAM textures.
- * @param oldName - The previous name embedded in the reference.
- * @param newName - The new name embedded in the reference.
- */
-function RenameOverrideValueReferences(scene, valueScheme, oldName, newName) {
-    if (oldName === newName) {
-        return;
-    }
-    const manager = GetOverrideManager(scene);
-    const internal = GetOverrideInternals(manager);
-    const oldValue = `${valueScheme}:${oldName}`;
-    const newValue = `${valueScheme}:${newName}`;
-    let changed = false;
-    for (let i = 0; i < internal.overrides.length; i++) {
-        const entry = internal.overrides[i];
-        if (entry.value === oldValue) {
-            internal.overrides[i] = { ...entry, value: newValue };
-            changed = true;
-        }
-    }
-    if (changed) {
-        manager.onChangedObservable.notifyObservers();
-    }
-}
-// ── Application ──
-/**
- * Applies all overrides to their current targets in the scene.
- *
- * Call this after any scene mutation that might have invalidated previously
- * applied state (asset reload, object recreation, project load). The override
- * manager does not auto-subscribe to other scene subsystems — coordination is
- * the caller's responsibility, which keeps the override system independent.
- * @param scene - The scene whose overrides to apply.
- */
-function ApplyAllOverrides(scene) {
-    const manager = GetOverrideManager(scene);
-    const internal = GetOverrideInternals(manager);
-    for (const entry of internal.overrides) {
-        ApplyOverrideEntry(manager, internal, entry);
-    }
-}
-// ── Serialization ──
-/**
- * Serializes all overrides to a JSON-compatible array.
- * The on-disk shape is identical to the in-memory `IOverrideEntry`.
- * @param scene - The scene whose overrides to serialize.
- * @returns An array of override entries (shallow copies).
- */
-function SerializeOverrides(scene) {
-    const internal = GetOverrideInternals(GetOverrideManager(scene));
-    return internal.overrides.map((o) => ({ ...o }));
-}
-/**
- * Loads overrides from a serialized array and applies them.
- * @param scene - The scene whose override registry to populate.
- * @param data - Array of override entries.
- */
-function DeserializeAndApplyOverrides(scene, data) {
-    if (!Array.isArray(data)) {
-        throw new Error("OverrideManager: Expected an array of override entries.");
-    }
-    for (const entry of data) {
-        if (!entry.targetType || entry.targetName === undefined || typeof entry.targetIndex !== "number" || !entry.propertyPath || entry.value === undefined) {
-            Logger.Warn("OverrideManager: Skipping invalid override entry.");
-            continue;
+const SkeletonExplorerServiceDefinition = {
+    friendlyName: "Skeleton Explorer",
+    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
+    factory: (sceneExplorerService, sceneContext, watcherService) => {
+        const scene = sceneContext.currentScene;
+        if (!scene) {
+            return undefined;
         }
-        AddOverride(scene, entry);
-    }
-}
-// ── Lifecycle ──
-/**
- * Disposes the manager, clearing all overrides and detaching it from its scene.
- * Safe to call multiple times; subsequent calls are no-ops. Automatically invoked when the
- * owning scene is disposed.
- * @param manager - The override manager state.
- */
-function DisposeOverrideManager(manager) {
-    const internal = OverrideManagerInternals.get(manager);
-    if (!internal) {
-        return;
-    }
-    OverrideManagerInternals.delete(manager);
-    if (internal.sceneDisposeObserver) {
-        manager.scene.onDisposeObservable.remove(internal.sceneDisposeObserver);
-        internal.sceneDisposeObserver = null;
-    }
-    internal.overrides.length = 0;
-    internal.originalValues.clear();
-    manager.onChangedObservable.clear();
-    if (manager.scene.metadata) {
-        delete manager.scene.metadata[OverrideManagerKey];
-    }
-}
-// ── Private ──
-function GetOverrideInternals(manager) {
-    const internal = OverrideManagerInternals.get(manager);
-    if (!internal) {
-        throw new Error("OverrideManager: Unknown manager state.");
-    }
-    return internal;
-}
-/**
- * Applies a single override entry to its target, capturing the original value
- * on the first application so {@link RemoveOverride} can restore it later.
- * @param manager - The override manager owning the entry.
- * @param internal - The manager's internal state.
- * @param entry - The override to apply.
- */
-function ApplyOverrideEntry(manager, internal, entry) {
-    const target = ResolveTarget(manager.scene, entry.targetType, entry.targetName, entry.targetIndex);
-    if (!target) {
-        Logger.Warn(`OverrideManager: target not found for type="${entry.targetType}" name="${entry.targetName}" index=${entry.targetIndex} prop="${entry.propertyPath}"`);
-        return; // Target not loaded yet — override will be applied on next ApplyAllOverrides
-    }
-    // Capture original value before first override
-    const origKey = MakeOriginalValueKey(entry.targetType, entry.targetName, entry.targetIndex, entry.propertyPath);
-    if (!internal.originalValues.has(origKey)) {
-        const currentValue = GetNestedProperty(target, entry.propertyPath);
-        if (currentValue !== undefined) {
-            internal.originalValues.set(origKey, CloneValue(currentValue));
+        const boneMovedObservable = new Observable();
+        const sectionRegistration = sceneExplorerService.addSection({
+            displayName: "Skeletons",
+            order: 200 /* DefaultSectionsOrder.Skeletons */,
+            getRootEntities: () => scene.skeletons,
+            getEntityChildren: (skeletonOrBone) => skeletonOrBone.getChildren(),
+            getEntityDisplayInfo: (skeletonOrBone) => {
+                const onChangeObservable = new Observable();
+                const nameHookToken = watcherService.watchProperty(skeletonOrBone, "name", () => onChangeObservable.notifyObservers());
+                const parentHookToken = skeletonOrBone instanceof Skeleton ? null : watcherService.watchProperty(skeletonOrBone, "parent", () => boneMovedObservable.notifyObservers(skeletonOrBone));
+                return {
+                    get name() {
+                        return skeletonOrBone.name || `Unnamed ${skeletonOrBone.getClassName()}`;
+                    },
+                    onChange: onChangeObservable,
+                    dispose: () => {
+                        nameHookToken.dispose();
+                        parentHookToken?.dispose();
+                        onChangeObservable.clear();
+                    },
+                };
+            },
+            entityIcon: ({ entity: skeletonOrBone }) => skeletonOrBone instanceof Skeleton ? (jsx(PersonWalkingRegular, { color: tokens.colorPaletteAnchorForeground2 })) : (jsx(DataLineRegular, { color: tokens.colorPaletteBeigeForeground2 })),
+            getEntityAddedObservables: () => [scene.onNewSkeletonAddedObservable],
+            getEntityRemovedObservables: () => [scene.onSkeletonRemovedObservable],
+            getEntityMovedObservables: () => [boneMovedObservable],
+        });
+        return {
+            dispose: () => {
+                sectionRegistration.dispose();
+            },
+        };
+    },
+};
+
+const SoundExplorerServiceDefinition = {
+    friendlyName: "Sound Explorer",
+    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
+    factory: (sceneExplorerService, sceneContext, watcherService) => {
+        const scene = sceneContext.currentScene;
+        if (!scene) {
+            return undefined;
         }
-    }
-    const resolvedValue = ResolveOverrideValue(manager.scene, entry.value);
-    SetNestedProperty(target, entry.propertyPath, resolvedValue);
-}
-/**
- * Locates a scene object by (targetType, targetName, targetIndex). The scene
- * collection is filtered to objects matching `targetName`; the N-th survivor
- * (per `targetIndex`) is returned. Falls back to the first match if the index
- * is out of range — useful when the scene shape has changed since capture.
- * @param scene - The scene to search.
- * @param targetType - The override target type.
- * @param targetName - The target object name (or "" for scene-level).
- * @param targetIndex - The target's position among same-named siblings.
- * @returns The matching scene object, or null if not found.
- */
-function ResolveTarget(scene, targetType, targetName, targetIndex) {
-    // Scene-level overrides target the scene itself
-    if (targetType === "scene") {
-        return scene;
-    }
-    const collection = GetCollection$1(scene, targetType);
-    if (!collection) {
-        return null;
-    }
-    const matches = collection.filter((obj) => obj.name === targetName);
-    if (matches.length === 0) {
-        return null;
-    }
-    return (matches[targetIndex] ?? matches[0]);
-}
-/**
- * Returns the scene collection corresponding to an override target type.
- * @param scene - The scene to inspect.
- * @param targetType - The target type.
- * @returns The collection, or null if the type has no collection.
- */
-function GetCollection$1(scene, targetType) {
-    switch (targetType) {
-        case "meshes":
-            return scene.meshes;
-        case "materials":
-            return scene.materials;
-        case "textures":
-            return scene.textures;
-        case "lights":
-            return scene.lights;
-        case "cameras":
-            return scene.cameras;
-        case "animationGroups":
-            return scene.animationGroups;
-        default:
-            return null;
-    }
-}
-/**
- * Resolves an override value, expanding string references like "ref:name",
- * "samTexture:key", or "texture:name" into the actual scene object they refer to.
- * @param scene - The scene used to look up references.
- * @param value - The serialized override value.
- * @returns The runtime value to assign to the target property.
- */
-function ResolveOverrideValue(scene, value) {
-    if (typeof value === "string") {
-        if (value.startsWith("ref:")) {
-            return ResolveObjectReference(scene, value.substring(4));
+        const soundAddedObservable = new Observable();
+        const soundRemovedObservable = new Observable();
+        let addSoundHook;
+        let removeSoundHook;
+        const hookMainSoundTrack = (mainSoundTrack) => {
+            addSoundHook?.dispose();
+            addSoundHook = undefined;
+            removeSoundHook?.dispose();
+            removeSoundHook = undefined;
+            if (mainSoundTrack) {
+                addSoundHook = InterceptFunction(mainSoundTrack, "addSound", {
+                    afterCall: (sound) => soundAddedObservable.notifyObservers(sound),
+                });
+                removeSoundHook = InterceptFunction(mainSoundTrack, "removeSound", {
+                    afterCall: (sound) => soundRemovedObservable.notifyObservers(sound),
+                });
+            }
+        };
+        // If _mainSoundTrack is already defined, set up hooks immediately.
+        hookMainSoundTrack(scene.mainSoundTrack);
+        // Watch for _mainSoundTrack being set (it is lazily created by the mainSoundTrack getter in audioSceneComponent.ts).
+        const mainSoundTrackHook = watcherService.watchProperty(scene, "_mainSoundTrack", () => hookMainSoundTrack(scene._mainSoundTrack));
+        const sectionRegistration = sceneExplorerService.addSection({
+            displayName: "Sounds",
+            order: 1400 /* DefaultSectionsOrder.Sounds */,
+            getRootEntities: () => scene.mainSoundTrack?.soundCollection ?? [],
+            getEntityDisplayInfo: (sound) => {
+                const onChangeObservable = new Observable();
+                const nameHookToken = watcherService.watchProperty(sound, "name", () => onChangeObservable.notifyObservers());
+                return {
+                    get name() {
+                        return sound.name || `Unnamed ${sound.getClassName()}`;
+                    },
+                    onChange: onChangeObservable,
+                    dispose: () => {
+                        nameHookToken.dispose();
+                        onChangeObservable.clear();
+                    },
+                };
+            },
+            entityIcon: () => jsx(SoundWaveCircleRegular, { color: tokens.colorPaletteForestForeground2 }),
+            getEntityAddedObservables: () => [soundAddedObservable],
+            getEntityRemovedObservables: () => [soundRemovedObservable],
+        });
+        return {
+            dispose: () => {
+                mainSoundTrackHook.dispose();
+                addSoundHook?.dispose();
+                removeSoundHook?.dispose();
+                soundAddedObservable.clear();
+                soundRemovedObservable.clear();
+                sectionRegistration.dispose();
+            },
+        };
+    },
+};
+
+const SpriteManagerExplorerServiceDefinition = {
+    friendlyName: "Sprite Manager Explorer",
+    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
+    factory: (sceneExplorerService, sceneContext, watcherService) => {
+        const scene = sceneContext.currentScene;
+        if (!scene) {
+            return undefined;
+        }
+        const sectionRegistration = sceneExplorerService.addSection({
+            displayName: "Sprite Managers",
+            order: 900 /* DefaultSectionsOrder.SpriteManagers */,
+            getRootEntities: () => scene.spriteManagers ?? [],
+            getEntityChildren: (spriteEntity) => (spriteEntity instanceof Sprite ? [] : spriteEntity.sprites),
+            getEntityDisplayInfo: (spriteEntity) => {
+                const onChangeObservable = new Observable();
+                const nameHookToken = watcherService.watchProperty(spriteEntity, "name", () => onChangeObservable.notifyObservers());
+                return {
+                    get name() {
+                        return spriteEntity.name || `Unnamed ${spriteEntity instanceof Sprite ? spriteEntity.getClassName() : "SpriteManager"}`;
+                    },
+                    onChange: onChangeObservable,
+                    dispose: () => {
+                        nameHookToken.dispose();
+                        onChangeObservable.clear();
+                    },
+                };
+            },
+            entityIcon: ({ entity: spriteEntity }) => spriteEntity instanceof Sprite ? (jsx(PersonSquareRegular, { color: tokens.colorPalettePeachForeground2 })) : (jsx(LayerDiagonalPersonRegular, { color: tokens.colorPalettePeachForeground2 })),
+            getEntityAddedObservables: () => [scene.onNewSpriteManagerAddedObservable],
+            getEntityRemovedObservables: () => [scene.onSpriteManagerRemovedObservable],
+        });
+        const spritePlayStopCommandRegistration = sceneExplorerService.addEntityCommand({
+            predicate: (entity) => entity instanceof Sprite,
+            order: 600 /* DefaultCommandsOrder.SpritePlay */,
+            getCommand: (sprite) => {
+                const onChangeObservable = new Observable();
+                const playHook = InterceptFunction(sprite, "playAnimation", {
+                    afterCall: () => onChangeObservable.notifyObservers(),
+                });
+                const stopHook = InterceptFunction(sprite, "stopAnimation", {
+                    afterCall: () => onChangeObservable.notifyObservers(),
+                });
+                const animateHook = InterceptFunction(sprite, "_animate", {
+                    afterCall: () => onChangeObservable.notifyObservers(),
+                });
+                return {
+                    type: "action",
+                    get displayName() {
+                        return `${sprite.animationStarted ? "Stop" : "Play"} Animation`;
+                    },
+                    icon: () => (sprite.animationStarted ? jsx(StopFilled, {}) : jsx(PlayFilled, {})),
+                    execute: () => (sprite.animationStarted ? sprite.stopAnimation() : sprite.playAnimation(sprite.fromIndex, sprite.toIndex, sprite.loopAnimation, sprite.delay)),
+                    onChange: onChangeObservable,
+                    dispose: () => {
+                        playHook.dispose();
+                        stopHook.dispose();
+                        animateHook.dispose();
+                        onChangeObservable.clear();
+                    },
+                };
+            },
+        });
+        return {
+            dispose: () => {
+                sectionRegistration.dispose();
+                spritePlayStopCommandRegistration.dispose();
+            },
+        };
+    },
+};
+
+const TextureExplorerServiceDefinition = {
+    friendlyName: "Texture Explorer",
+    consumes: [SceneExplorerServiceIdentity, SceneContextIdentity, WatcherServiceIdentity],
+    factory: (sceneExplorerService, sceneContext, watcherService) => {
+        const scene = sceneContext.currentScene;
+        if (!scene) {
+            return undefined;
         }
-        if (value.startsWith("samTexture:")) {
-            return ResolveSamTextureReference(scene, value.substring(11));
+        const sectionRegistration = sceneExplorerService.addSection({
+            displayName: "Textures",
+            order: 400 /* DefaultSectionsOrder.Textures */,
+            getRootEntities: () => scene.textures.filter((texture) => texture.getClassName() !== "AdvancedDynamicTexture"),
+            getEntityDisplayInfo: (texture) => {
+                const onChangeObservable = new Observable();
+                const displayNameHookToken = watcherService.watchProperty(texture, "displayName", () => onChangeObservable.notifyObservers());
+                const nameHookToken = watcherService.watchProperty(texture, "name", () => onChangeObservable.notifyObservers());
+                return {
+                    get name() {
+                        return texture.displayName || texture.name || `${texture.getClassName() || "Unnamed Texture"} (${texture.uniqueId})`;
+                    },
+                    onChange: onChangeObservable,
+                    dispose: () => {
+                        nameHookToken.dispose();
+                        displayNameHookToken.dispose();
+                        onChangeObservable.clear();
+                    },
+                };
+            },
+            entityIcon: ({ entity: texture }) => texture instanceof DynamicTexture ? jsx(ImageEditRegular, { color: tokens.colorPaletteGrapeForeground2 }) : jsx(ImageRegular, { color: tokens.colorPaletteGrapeForeground2 }),
+            getEntityAddedObservables: () => [scene.onNewTextureAddedObservable],
+            getEntityRemovedObservables: () => [scene.onTextureRemovedObservable],
+        });
+        return {
+            dispose: () => {
+                sectionRegistration.dispose();
+            },
+        };
+    },
+};
+
+const EquirectangularCaptureTool = ({ scene }) => {
+    const captureEquirectangularAsync = useCallback(async () => {
+        const currentActiveCamera = scene.activeCamera;
+        if (!currentActiveCamera && scene.frameGraph) {
+            scene.activeCamera = FrameGraphUtils.FindMainCamera(scene.frameGraph);
         }
-        if (value.startsWith("texture:")) {
-            return ResolveTextureReference(scene, value.substring(8));
+        if (scene.activeCamera) {
+            await captureEquirectangularFromScene(scene, { size: 1024, filename: "equirectangular_capture.png" });
         }
-    }
-    // Number arrays are passed through as-is. SetNestedProperty will use
-    // the live target's `fromArray` method (Vector3, Color3, etc.) to push
-    // values in-place, preserving the math instance identity.
-    return value;
-}
-/**
- * Resolves a "ref:name" value by looking up a material, light, or camera
- * in the scene by name.
- * @param scene - The scene to search.
- * @param name - The object name to resolve.
- * @returns The matching material, light, or camera, or undefined if not found.
- */
-function ResolveObjectReference(scene, name) {
-    const mat = scene.materials.find((m) => m.name === name);
-    if (mat) {
-        return mat;
-    }
-    const light = scene.lights.find((l) => l.name === name);
-    if (light) {
-        return light;
-    }
-    const camera = scene.cameras.find((c) => c.name === name);
-    if (camera) {
-        return camera;
-    }
-    Logger.Warn(`OverrideManager: Object reference "${name}" not found in scene.`);
-    return undefined;
-}
-/**
- * Resolves a "texture:name" value by looking up a texture in the scene by name.
- * @param scene - The scene to search.
- * @param name - The texture name to resolve.
- * @returns The matching texture, or undefined if not found.
- */
-function ResolveTextureReference(scene, name) {
-    const tex = scene.textures.find((t) => t.name === name);
-    if (tex) {
-        return tex;
-    }
-    Logger.Warn(`OverrideManager: Texture reference "${name}" not found.`);
-    return undefined;
-}
-/**
- * Resolves a "samTexture:key" value by looking up a SmartAsset-tracked texture
- * by its registry key. The SAM key is stable across save/load whereas the
- * texture's `name` (for SAM textures, the blob URL) changes on every reload,
- * so this is the only reliable way to round-trip texture references on
- * user-uploaded SmartAsset textures.
- * @param scene - The scene to search.
- * @param key - The SmartAsset key to resolve.
- * @returns The matching texture, or undefined if not found.
- */
-function ResolveSamTextureReference(scene, key) {
-    const tex = scene.textures.find((t) => FindSmartAssetKeyForObject(scene, t) === key);
-    if (tex) {
-        return tex;
-    }
-    Logger.Warn(`OverrideManager: SmartAsset texture "${key}" not found.`);
-    return undefined;
-}
-/**
- * Finds the index of an override matching the given coordinates.
- * @param internal - The manager's internal state.
- * @param targetType - The target type.
- * @param targetName - The target object name.
- * @param targetIndex - The target index among same-named siblings.
- * @param propertyPath - The property path.
- * @returns The matching index, or -1 if none found.
- */
-function FindOverrideIndex(internal, targetType, targetName, targetIndex, propertyPath) {
-    return internal.overrides.findIndex((o) => o.targetType === targetType && o.targetName === targetName && o.targetIndex === targetIndex && o.propertyPath === propertyPath);
-}
-/**
- * Removes any existing override that matches the given coordinates. Used by
- * {@link AddOverride} to enforce one entry per (type, name, index, property).
- * @param internal - The manager's internal state.
- * @param targetType - The target type.
- * @param targetName - The target object name.
- * @param targetIndex - The target index among same-named siblings.
- * @param propertyPath - The property path.
- */
-function RemoveMatchingOverride(internal, targetType, targetName, targetIndex, propertyPath) {
-    const idx = FindOverrideIndex(internal, targetType, targetName, targetIndex, propertyPath);
-    if (idx >= 0) {
-        internal.overrides.splice(idx, 1);
-    }
-}
-/**
- * Creates a unique key for storing original values.
- * @param targetType - The override target type.
- * @param targetName - The target object name.
- * @param targetIndex - The target index among same-named siblings.
- * @param propertyPath - The property path.
- * @returns A composite string key uniquely identifying the original value slot.
- */
-function MakeOriginalValueKey(targetType, targetName, targetIndex, propertyPath) {
-    return `${targetType}::${targetName}::${targetIndex}::${propertyPath}`;
-}
-/**
- * Gets a nested property from an object using a dot-separated path.
- * @param obj - The root object to traverse.
- * @param path - The dot-separated property path.
- * @returns The value at the path, or undefined if any segment is missing.
- */
-function GetNestedProperty(obj, path) {
-    const parts = path.split(".");
-    let current = obj;
-    for (const part of parts) {
-        if (current === null || current === undefined || typeof current !== "object") {
-            return undefined;
+        // eslint-disable-next-line require-atomic-updates
+        scene.activeCamera = currentActiveCamera;
+    }, [scene]);
+    return jsx(ButtonLine, { label: "Capture Equirectangular", icon: CameraRegular, onClick: captureEquirectangularAsync });
+};
+
+const GIFCaptureTool = MakeLazyComponent(async () => {
+    const gif = (await import('./gif-CdXfT-By.js').then(function (n) { return n.g; })).default;
+    // TODO: Figure out how to grab this from NPM package instead of CDN
+    const workerContent = await Tools.LoadFileAsync("https://cdn.jsdelivr.net/gh//terikon/gif.js.optimized@0.1.6/dist/gif.worker.js");
+    const workerBlob = new Blob([workerContent], { type: "application/javascript" });
+    const workerUrl = URL.createObjectURL(workerBlob);
+    return ({ scene }) => {
+        const [recordingSession, setRecordingSession] = useState({ state: "Idle" });
+        const [targetWidth, setTargetWidth] = useState(512);
+        const [frequency, setFrequency] = useState(200);
+        useEffect(() => {
+            return () => {
+                if (recordingSession.state === "Recording") {
+                    // Reset session resources if component is unmounted
+                    scene.onAfterRenderObservable.remove(recordingSession.captureObserver);
+                    scene.getEngine().setHardwareScalingLevel(recordingSession.previousHardwareScaling);
+                }
+            };
+        }, [recordingSession, scene]);
+        // Use functional setState to guard against multiple rapid clicks
+        const startRecording = useCallback(() => {
+            setRecordingSession((currentSession) => {
+                // If already recording/rendering, don't start a new session
+                if (currentSession.state !== "Idle") {
+                    return currentSession;
+                }
+                const engine = scene.getEngine();
+                const canvas = engine.getRenderingCanvas();
+                if (!canvas) {
+                    return currentSession;
+                }
+                const gifInstance = new gif({
+                    workers: 2,
+                    quality: 10,
+                    workerScript: workerUrl,
+                });
+                // Adjust hardware scaling to match desired width
+                const previousHardwareScaling = engine.getHardwareScalingLevel();
+                engine.setHardwareScalingLevel(engine.getRenderWidth() / (targetWidth * globalThis.devicePixelRatio) || 1);
+                // Capture frames after each render
+                let lastCaptureTime = 0;
+                const captureObserver = scene.onAfterRenderObservable.add(() => {
+                    const now = Date.now();
+                    if (now - lastCaptureTime >= frequency && gifInstance) {
+                        lastCaptureTime = now;
+                        gifInstance.addFrame(canvas, { delay: 1, copy: true });
+                    }
+                });
+                return {
+                    state: "Recording",
+                    gif: gifInstance,
+                    captureObserver: captureObserver,
+                    previousHardwareScaling: previousHardwareScaling,
+                };
+            });
+        }, [scene, targetWidth, frequency]);
+        const stopRecording = useCallback(() => {
+            setRecordingSession((currentSession) => {
+                if (currentSession.state !== "Recording") {
+                    return currentSession;
+                }
+                // Remove the frame capture observer
+                scene.onAfterRenderObservable.remove(currentSession.captureObserver);
+                // Restore previous hardware scaling
+                scene.getEngine().setHardwareScalingLevel(currentSession.previousHardwareScaling);
+                currentSession.gif.on("finished", (blob) => {
+                    // Download the rendered GIF
+                    Tools.Download(blob, "recording.gif");
+                    // Reset state
+                    setRecordingSession({ state: "Idle" });
+                });
+                // Start rendering the GIF
+                currentSession.gif.render();
+                return { state: "Rendering", gif: currentSession.gif };
+            });
+        }, [scene]);
+        return (jsxs(Fragment, { children: [recordingSession.state === "Idle" && jsx(ButtonLine, { label: "Record GIF", icon: RecordRegular, onClick: startRecording }), recordingSession.state === "Recording" && jsx(ButtonLine, { label: "Stop", icon: RecordStopRegular, onClick: stopRecording }), recordingSession.state === "Rendering" && jsx(Label, { children: "Creating the GIF file..." }), jsxs(Collapse, { visible: recordingSession.state === "Idle", children: [jsx(SyncedSliderPropertyLine, { label: "Resolution", description: "The pixel width of the output. The height will be adjusted accordingly to maintain the aspect ratio.", value: targetWidth, onChange: (value) => setTargetWidth(Math.floor(value)), min: 128, max: 2048, step: 128 }), jsx(SyncedSliderPropertyLine, { label: "Frequency (ms)", description: "The time interval in milliseconds between each capture of the scene.", value: frequency, onChange: (value) => setFrequency(Math.floor(value)), min: 50, max: 1000, step: 50 })] })] }));
+    };
+}, { spinnerSize: "extra-tiny", spinnerLabel: "Loading..." });
+
+const SceneReplayTool = ({ scene }) => {
+    const [isRecording, setIsRecording] = useState(false);
+    const sceneRecorder = useResource(() => new SceneRecorder());
+    const startRecording = useCallback(() => {
+        sceneRecorder.track(scene);
+        setIsRecording(true);
+    }, [scene]);
+    const exportReplay = useCallback(() => {
+        const content = JSON.stringify(sceneRecorder.getDelta());
+        const blob = new Blob([content], { type: "application/json" });
+        Tools.Download(blob, "replay_delta.json");
+        setIsRecording(false);
+    }, []);
+    const applyDelta = useCallback((files) => {
+        const file = files[0];
+        if (!file) {
+            return;
         }
-        current = current[part];
-    }
-    return current;
-}
-/**
- * Sets a nested property on an object using a dot-separated path.
- *
- * When the value is a number array and the existing property is a Babylon
- * math type (Vector*, Quaternion, Color3/4, Matrix), uses the math type's
- * `fromArray` method to mutate it in place — preserving the live instance
- * identity that consumers may already hold references to. Otherwise falls
- * back to direct property replacement.
- * @param obj - The root object to mutate.
- * @param path - The dot-separated property path.
- * @param value - The new value to assign.
- */
-function SetNestedProperty(obj, path, value) {
-    const parts = path.split(".");
-    let current = obj;
-    for (let i = 0; i < parts.length - 1; i++) {
-        if (current === null || current === undefined || typeof current !== "object") {
+        Tools.ReadFile(file, (data) => {
+            try {
+                const json = JSON.parse(data);
+                SceneRecorder.ApplyDelta(json, scene);
+            }
+            catch (error) {
+                Logger.Error("Failed to apply replay delta:" + error);
+            }
+        }, undefined, false);
+    }, [scene]);
+    return (jsxs(Fragment, { children: [!isRecording && jsx(ButtonLine, { label: "Start Recording", icon: RecordRegular, onClick: startRecording }), isRecording && (jsxs(Fragment, { children: [jsx(Label, { children: "Recording in progress..." }), jsx(ButtonLine, { label: "Generate Delta File", icon: SaveRegular, onClick: exportReplay })] })), jsx(FileUploadLine, { label: "Apply Delta File", icon: ArrowDownloadRegular, onClick: applyDelta, accept: ".json" })] }));
+};
+
+const ScreenshotTool = ({ scene }) => {
+    const [precision, setPrecision] = useState(1);
+    const [useCustomSize, setUseCustomSize] = useState(false);
+    const [width, setWidth] = useState(512);
+    const [height, setHeight] = useState(512);
+    const captureScreenshot = useCallback(async () => {
+        const engine = scene.getEngine();
+        const camera = scene.frameGraph ? FrameGraphUtils.FindMainCamera(scene.frameGraph) : scene.activeCamera;
+        const screenshotSize = useCustomSize ? { width, height, precision } : { precision };
+        if (camera) {
+            await CreateScreenshotUsingRenderTargetAsync(engine, camera, screenshotSize, "image/png", undefined, undefined, "screenshot.png");
+        }
+    }, [useCustomSize, precision, width, height, scene]);
+    return (jsxs(Fragment, { children: [jsx(ButtonLine, { label: "Capture Screenshot", icon: CameraRegular, onClick: captureScreenshot }), jsx(SyncedSliderPropertyLine, { label: "Precision", description: "A multiplier allowing capture at a higher or lower resolution.", value: precision, onChange: setPrecision, min: 0.1, max: 10, step: 0.1 }), jsx(SwitchPropertyLine, { label: "Use Custom Size", value: useCustomSize, onChange: setUseCustomSize }), jsxs(Collapse, { visible: useCustomSize, children: [jsx(SyncedSliderPropertyLine, { label: "Width", description: "The width of the screenshot in pixels. ", value: width, onChange: setWidth, min: 1, step: 1 }), jsx(SyncedSliderPropertyLine, { label: "Height", description: "The height of the screenshot in pixels.", value: height, onChange: setHeight, min: 1, step: 1 })] })] }));
+};
+
+const VideoCaptureTool = ({ scene }) => {
+    const [isRecording, setIsRecording] = useState(false);
+    const videoRecorder = useResource(useCallback(() => {
+        return new VideoRecorder(scene.getEngine());
+    }, [scene.getEngine()]));
+    const recordVideoAsync = useCallback(async () => {
+        if (videoRecorder && videoRecorder.isRecording) {
+            videoRecorder.stopRecording();
+            setIsRecording(false);
             return;
         }
-        current = current[parts[i]];
-    }
-    if (current === null || current === undefined || typeof current !== "object") {
-        return;
-    }
-    const lastPart = parts[parts.length - 1];
-    const existing = current[lastPart];
-    if (Array.isArray(value) && existing && typeof existing === "object" && typeof existing.fromArray === "function") {
-        existing.fromArray(value);
-        return;
-    }
-    current[lastPart] = value;
-}
-/**
- * Snapshots a value for original-value tracking.
- *
- * Scene entities (textures, materials, meshes, etc.) are stored by reference
- * because cloning them would register unwanted duplicates in the scene.
- * Plain math types (Vector3, Color3, etc.) are cloned so mutations to the
- * live object don't corrupt the saved original.
- * @param value - The value to snapshot.
- * @returns The snapshot value (cloned for plain math types, by reference for entities).
- */
-function CloneValue(value) {
-    if (value === null || value === undefined) {
-        return value;
-    }
-    if (typeof value !== "object") {
-        return value;
-    }
-    if (typeof value.getScene === "function") {
-        return value;
-    }
-    if ("clone" in value && typeof value.clone === "function") {
-        return value.clone();
-    }
-    return { ...value };
-}
+        void videoRecorder.startRecording(undefined, 0); // Use 0 to prevent automatic stop; let the user stop it
+        setIsRecording(true);
+    }, [scene]);
+    return (jsx(Fragment, { children: jsx(ButtonLine, { uniqueId: "Start/Stop", label: isRecording ? "Stop Recording" : "Record Video", icon: isRecording ? RecordStopRegular : RecordRegular, onClick: recordVideoAsync }) }));
+};
+
+const CaptureToolsDefinition = {
+    friendlyName: "Capture Tools",
+    consumes: [ToolsServiceIdentity],
+    factory: (toolsService) => {
+        const contentRegistrations = [];
+        // Screenshot
+        contentRegistrations.push(toolsService.addSectionContent({
+            key: "Screenshot",
+            section: "Screenshot",
+            order: 10,
+            component: ({ context }) => jsx(ScreenshotTool, { scene: context }),
+        }));
+        // Equirectangular capture
+        contentRegistrations.push(toolsService.addSectionContent({
+            key: "Equirectangular",
+            section: "Equirectangular",
+            order: 15,
+            component: ({ context }) => jsx(EquirectangularCaptureTool, { scene: context }),
+        }));
+        // Video recorder
+        contentRegistrations.push(toolsService.addSectionContent({
+            key: "Video",
+            section: "Video",
+            order: 20,
+            component: ({ context }) => jsx(VideoCaptureTool, { scene: context }),
+        }));
+        // GIF recorder
+        contentRegistrations.push(toolsService.addSectionContent({
+            key: "GIF",
+            section: "GIF",
+            order: 25,
+            component: ({ context }) => jsx(GIFCaptureTool, { scene: context }),
+        }));
+        // Scene replay
+        contentRegistrations.push(toolsService.addSectionContent({
+            key: "Scene Replay",
+            section: "Scene Replay",
+            order: 30,
+            component: ({ context }) => jsx(SceneReplayTool, { scene: context }),
+        }));
+        return {
+            dispose: () => {
+                contentRegistrations.forEach((registration) => registration.dispose());
+            },
+        };
+    },
+};
+
+const EnvExportImageTypes = [
+    { label: "PNG", value: 0, imageType: "image/png" },
+    { label: "WebP", value: 1, imageType: "image/webp" },
+];
+const ExportBabylonTools = ({ scene }) => {
+    // Track environment texture changes to re-render when it's updated (e.g., when a new HDRI is loaded)
+    const environmentTexture = useProperty(scene, "environmentTexture");
+    const [babylonExportOptions, setBabylonExportOptions] = useState({
+        imageTypeIndex: 0,
+        imageQuality: 0.8,
+        iblDiffuse: false,
+    });
+    const exportBabylon = useCallback(async () => {
+        const strScene = JSON.stringify(SceneSerializer.Serialize(scene));
+        const blob = new Blob([strScene], { type: "octet/stream" });
+        Tools.Download(blob, "scene.babylon");
+    }, [scene]);
+    const createEnvTexture = useCallback(async () => {
+        if (!environmentTexture) {
+            return;
+        }
+        try {
+            const buffer = await EnvironmentTextureTools.CreateEnvTextureAsync(environmentTexture, {
+                imageType: EnvExportImageTypes[babylonExportOptions.imageTypeIndex].imageType,
+                imageQuality: babylonExportOptions.imageQuality,
+                disableIrradianceTexture: !babylonExportOptions.iblDiffuse,
+            });
+            const blob = new Blob([buffer], { type: "octet/stream" });
+            Tools.Download(blob, "environment.env");
+        }
+        catch (error) {
+            Logger.Error(error);
+            alert(error);
+        }
+    }, [scene, environmentTexture, babylonExportOptions]);
+    return (jsxs(Fragment, { children: [jsx(ButtonLine, { label: "Export to Babylon", icon: ArrowDownloadRegular, onClick: exportBabylon }), !scene.getEngine().premultipliedAlpha && environmentTexture && environmentTexture._prefiltered && scene.activeCamera && (jsxs(Fragment, { children: [jsx(ButtonLine, { label: "Generate .env Texture", icon: ArrowDownloadRegular, onClick: createEnvTexture }), environmentTexture.irradianceTexture && (jsx(SwitchPropertyLine, { label: "Diffuse Texture", description: "Export diffuse texture for IBL", value: babylonExportOptions.iblDiffuse, onChange: (value) => {
+                            setBabylonExportOptions((prev) => ({ ...prev, iblDiffuse: value }));
+                        } }, "iblDiffuse")), jsx(NumberDropdownPropertyLine, { label: "Image type", options: EnvExportImageTypes, value: babylonExportOptions.imageTypeIndex, onChange: (val) => {
+                            setBabylonExportOptions((prev) => ({ ...prev, imageTypeIndex: val }));
+                        } }), jsx(Collapse, { visible: babylonExportOptions.imageTypeIndex > 0, children: jsx(SyncedSliderPropertyLine, { label: "Quality", value: babylonExportOptions.imageQuality, onChange: (value) => setBabylonExportOptions((prev) => ({ ...prev, imageQuality: value })), min: 0, max: 1 }) })] }))] }));
+};
+const ExportGltfTools = MakeLazyComponent(async () => {
+    // Defer importing anything from the serializers package until this component is actually mounted.
+    const { GLTF2Export } = await import('@babylonjs/serializers/glTF/2.0/glTFSerializer.js');
+    return (props) => {
+        const [isExportingGltf, setIsExportingGltf] = useState(false);
+        const [gltfExportOptions, setGltfExportOptions] = useState({
+            exportDisabledNodes: false,
+            exportSkyboxes: false,
+            exportCameras: false,
+            exportLights: false,
+            dracoCompression: false,
+        });
+        const exportGLTF = useCallback(async () => {
+            setIsExportingGltf(true);
+            const shouldExport = (node) => {
+                if (!gltfExportOptions.exportDisabledNodes) {
+                    if (!node.isEnabled()) {
+                        return false;
+                    }
+                }
+                if (!gltfExportOptions.exportSkyboxes) {
+                    if (node instanceof Mesh) {
+                        if (node.material) {
+                            const material = node.material;
+                            const reflectionTexture = material.reflectionTexture;
+                            if (reflectionTexture && reflectionTexture.coordinatesMode === Texture.SKYBOX_MODE) {
+                                return false;
+                            }
+                        }
+                    }
+                }
+                if (!gltfExportOptions.exportCameras) {
+                    if (node instanceof Camera) {
+                        return false;
+                    }
+                }
+                if (!gltfExportOptions.exportLights) {
+                    if (node instanceof Light) {
+                        return false;
+                    }
+                }
+                return true;
+            };
+            try {
+                const glb = await GLTF2Export.GLBAsync(props.scene, "scene", {
+                    meshCompressionMethod: gltfExportOptions.dracoCompression ? "Draco" : undefined,
+                    shouldExportNode: (node) => shouldExport(node),
+                });
+                glb.downloadFiles();
+            }
+            catch (reason) {
+                Logger.Error(`Failed to export GLB: ${reason}`);
+            }
+            finally {
+                setIsExportingGltf(false);
+            }
+        }, [gltfExportOptions, props.scene]);
+        return (jsxs(Fragment, { children: [jsx(ButtonLine, { label: "Export to GLB", icon: ArrowDownloadRegular, onClick: exportGLTF, disabled: isExportingGltf }), jsx(SwitchPropertyLine, { label: "Export Disabled Nodes", description: "Whether to export nodes that are disabled in the scene.", value: gltfExportOptions.exportDisabledNodes, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, exportDisabledNodes: checked }) }, "GLTFExportDisabledNodes"), jsx(SwitchPropertyLine, { label: "Export Skyboxes", description: "Whether to export skybox nodes in the scene.", value: gltfExportOptions.exportSkyboxes, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, exportSkyboxes: checked }) }, "GLTFExportSkyboxes"), jsx(SwitchPropertyLine, { label: "Export Cameras", description: "Whether to export cameras in the scene.", value: gltfExportOptions.exportCameras, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, exportCameras: checked }) }, "GLTFExportCameras"), jsx(SwitchPropertyLine, { label: "Export Lights", description: "Whether to export lights in the scene.", value: gltfExportOptions.exportLights, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, exportLights: checked }) }, "GLTFExportLights"), jsx(SwitchPropertyLine, { label: "Draco Compression", description: "Whether to apply Draco compression to geometry.", value: gltfExportOptions.dracoCompression, onChange: (checked) => setGltfExportOptions({ ...gltfExportOptions, dracoCompression: checked }) }, "GLTFDracoCompression")] }));
+    };
+});
+
+const ExportServiceDefinition = {
+    friendlyName: "Export Tools",
+    consumes: [ToolsServiceIdentity],
+    factory: (toolsService) => {
+        const contentRegistrations = [];
+        // glTF export content
+        contentRegistrations.push(toolsService.addSectionContent({
+            key: "GLTF Export",
+            section: "GLTF Export",
+            component: ({ context }) => jsx(ExportGltfTools, { scene: context }),
+        }));
+        // Babylon export content
+        contentRegistrations.push(toolsService.addSectionContent({
+            key: "Babylon Export",
+            section: "Babylon Export",
+            component: ({ context }) => jsx(ExportBabylonTools, { scene: context }),
+        }));
+        return {
+            dispose: () => {
+                contentRegistrations.forEach((registration) => registration.dispose());
+            },
+        };
+    },
+};
 
 /**
  * Inspector service that captures property edits made through Inspector and
@@ -24387,100 +24915,30 @@ function CloneValue(value) {
  *
  * The service re-attaches to the current scene whenever it changes, so
  * overrides are captured against the active scene even after loads/swaps.
+ *
+ * The capture logic itself lives in the React-free `overrideCapture`
+ * module so it can be reused by non-Inspector edit paths (e.g. scene-explorer
+ * commands) and unit-tested without a DOM.
  */
 const OverrideCaptureServiceDefinition = {
     friendlyName: "Override Capture",
     consumes: [SceneContextIdentity, PropertiesServiceIdentity],
     factory: (sceneContext, propertiesService) => {
-        // Track each entity's name + index at first contact so we can update
-        // existing overrides when the user renames the entity in Inspector.
-        // Re-created on each scene attach so identities don't leak across scenes.
-        let previousIdentity = new WeakMap();
+        // Per-scene identity tracking, re-created on each scene attach so
+        // identities don't leak across scenes.
+        let captureState = CreateCaptureState();
         let changeObserver = null;
         function attachToScene(scene) {
             if (changeObserver) {
                 changeObserver.remove();
                 changeObserver = null;
             }
-            previousIdentity = new WeakMap();
+            captureState = CreateCaptureState();
             if (!scene) {
                 return;
             }
             changeObserver = propertiesService.onPropertyChanged.add((changeInfo) => {
-                const { entity, propertyKey, oldValue, newValue } = changeInfo;
-                // When "name" changes, update the matching override so it follows the rename
-                // instead of creating a new (orphaned) one. Also rewrite any overrides
-                // whose *value* referenced this entity by name so cross-references
-                // (e.g. `mesh.material = ref:redMat`) survive the rename too.
-                if (propertyKey === "name" && typeof newValue === "string") {
-                    const targetType = ClassifyEntity(entity, scene);
-                    if (targetType !== null && targetType !== "scene") {
-                        const previous = previousIdentity.get(entity);
-                        if (previous && previous.name !== newValue) {
-                            // The entity already has the new name at this point, so compute its new index among same-named siblings.
-                            const newIndex = ComputeTargetIndex(scene, targetType, entity, newValue);
-                            RenameOverrideTarget(scene, targetType, previous.name, previous.index, newValue, newIndex);
-                            // Mirror the rename into override values that reference
-                            // this entity by name. SmartAsset textures use the
-                            // `samTexture:<key>` form and stay decoupled from the
-                            // texture's runtime name, so they don't need rewriting.
-                            const valueScheme = targetType === "textures" ? "texture" : "ref";
-                            RenameOverrideValueReferences(scene, valueScheme, previous.name, newValue);
-                        }
-                        previousIdentity.set(entity, { name: newValue, index: ComputeTargetIndex(scene, targetType, entity, newValue) });
-                    }
-                    return;
-                }
-                if (propertyKey === "id") {
-                    return;
-                }
-                let targetType = ClassifyEntity(entity, scene);
-                let targetName;
-                let targetIndex;
-                let propertyPath = String(propertyKey);
-                let targetEntity;
-                if (targetType !== null) {
-                    if (targetType === "scene") {
-                        targetName = "";
-                        targetIndex = 0;
-                        targetEntity = scene;
-                    }
-                    else {
-                        targetName = GetEntityName(entity);
-                        targetIndex = ComputeTargetIndex(scene, targetType, entity, targetName);
-                        targetEntity = entity;
-                    }
-                    // Seed identity on first contact so rename tracking works
-                    if (!previousIdentity.has(targetEntity) && targetName) {
-                        previousIdentity.set(targetEntity, { name: targetName, index: targetIndex });
-                    }
-                }
-                else {
-                    // Sub-object: check if this is a property of a known parent
-                    const parentInfo = FindParentEntity(entity, scene);
-                    if (!parentInfo) {
-                        return;
-                    }
-                    targetType = parentInfo.targetType;
-                    targetName = parentInfo.targetName;
-                    targetIndex = parentInfo.targetIndex;
-                    propertyPath = `${parentInfo.parentProperty}.${propertyPath}`;
-                }
-                const serializedValue = SerializeOverrideValueForCapture(newValue, scene);
-                if (serializedValue === undefined) {
-                    return;
-                }
-                // The Inspector binding has already written `newValue` to the
-                // entity, so pass `oldValue` so the manager can record the
-                // true pre-edit value (without this, RemoveOverride would have
-                // no record of the original and could not restore it).
-                AddOverride(scene, {
-                    targetType,
-                    targetName,
-                    targetIndex,
-                    propertyPath,
-                    value: serializedValue,
-                }, { originalValue: oldValue });
+                HandleCapturedPropertyChange(scene, captureState, changeInfo);
             });
         }
         attachToScene(sceneContext.currentScene);
@@ -24496,195 +24954,6 @@ const OverrideCaptureServiceDefinition = {
         };
     },
 };
-/**
- * Classifies an entity into an OverrideTargetType by membership in the
- * scene's standard collections (or by being the scene itself).
- * @param entity - The entity to classify.
- * @param scene - The scene to check collections against.
- * @returns The target type, or null if unrecognized.
- */
-function ClassifyEntity(entity, scene) {
-    if (entity === scene) {
-        return "scene";
-    }
-    const obj = entity;
-    if (!obj || typeof obj !== "object") {
-        return null;
-    }
-    if (scene.materials.includes(obj)) {
-        return "materials";
-    }
-    if (scene.meshes.includes(obj)) {
-        return "meshes";
-    }
-    if (scene.lights.includes(obj)) {
-        return "lights";
-    }
-    if (scene.cameras.includes(obj)) {
-        return "cameras";
-    }
-    if (scene.textures.includes(obj)) {
-        return "textures";
-    }
-    if (scene.animationGroups.includes(obj)) {
-        return "animationGroups";
-    }
-    return null;
-}
-/**
- * Gets the name of a scene entity.
- * @param entity - The entity to get the name from.
- * @returns The entity name, or an empty string if unavailable.
- */
-function GetEntityName(entity) {
-    const obj = entity;
-    return obj?.name ?? "";
-}
-/**
- * Returns the position of `entity` among scene[targetType] objects with the
- * same name. Used so overrides can disambiguate same-named siblings.
- * @param scene - The scene to inspect.
- * @param targetType - The target type / collection name.
- * @param entity - The entity to locate.
- * @param name - The name to filter by.
- * @returns The index within the same-name filter, or 0 if not found.
- */
-function ComputeTargetIndex(scene, targetType, entity, name) {
-    const collection = GetCollection(scene, targetType);
-    if (!collection) {
-        return 0;
-    }
-    const sameName = collection.filter((obj) => obj.name === name);
-    const idx = sameName.indexOf(entity);
-    return idx >= 0 ? idx : 0;
-}
-/**
- * Returns the scene collection matching a target type.
- * @param scene - The scene to inspect.
- * @param targetType - The target type.
- * @returns The collection, or null if `targetType` doesn't map to one.
- */
-function GetCollection(scene, targetType) {
-    switch (targetType) {
-        case "meshes":
-            return scene.meshes;
-        case "materials":
-            return scene.materials;
-        case "textures":
-            return scene.textures;
-        case "lights":
-            return scene.lights;
-        case "cameras":
-            return scene.cameras;
-        case "animationGroups":
-            return scene.animationGroups;
-        default:
-            return null;
-    }
-}
-/**
- * Serializes a property value into an OverrideValue.
- * Returns undefined for unsupported types.
- * @param value - The value to serialize.
- * @param scene - Optional scene for resolving object references.
- * @returns The serialized value, or undefined if unsupported.
- */
-function SerializeOverrideValueForCapture(value, scene) {
-    // null is a legitimate override value (e.g. clearing a material slot) and
-    // must round-trip as null — substituting "" here would silently corrupt
-    // object-typed slots with an empty string on reload.
-    if (value === null) {
-        return null;
-    }
-    if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
-        return value;
-    }
-    // Material reference → "ref:materialName"
-    if (value && typeof value === "object" && "getClassName" in value && typeof value.getClassName === "function") {
-        const className = value.getClassName();
-        if (className.includes("Material") || className.includes("material")) {
-            return `ref:${value.name}`;
-        }
-    }
-    // Texture reference → "samTexture:<key>" if SmartAsset-tracked, else "texture:<name>".
-    // The SAM key is stable across save/load; `texture.name` for a SAM-tracked
-    // texture is the blob URL, which dies on page reload — using it as the
-    // override identifier would break the override after every reload.
-    if (value && typeof value === "object" && "getClassName" in value && scene) {
-        const className = value.getClassName();
-        if (className.includes("Texture") || className.includes("texture")) {
-            const samKey = FindSmartAssetKeyForObject(scene, value);
-            if (samKey !== undefined) {
-                return `samTexture:${samKey}`;
-            }
-            return `texture:${value.name}`;
-        }
-    }
-    // Color3 / Color4
-    if (value && typeof value === "object" && "r" in value && "g" in value && "b" in value) {
-        const color = value;
-        if ("a" in color && color.a !== undefined) {
-            return [color.r, color.g, color.b, color.a];
-        }
-        return [color.r, color.g, color.b];
-    }
-    // Vector3 / Vector4
-    if (value && typeof value === "object" && "x" in value && "y" in value && "z" in value) {
-        const vec = value;
-        if ("w" in vec && vec.w !== undefined) {
-            return [vec.x, vec.y, vec.z, vec.w];
-        }
-        return [vec.x, vec.y, vec.z];
-    }
-    // Vector2
-    if (value && typeof value === "object" && "x" in value && "y" in value && !("z" in value)) {
-        const vec2 = value;
-        return [vec2.x, vec2.y];
-    }
-    return undefined;
-}
-/**
- * Checks if an entity is a sub-object of a known scene entity by scanning
- * well-known sub-object properties on the scene and its collections.
- * Returns the parent entity info with the property path prefix.
- * @param entity - The entity to search for.
- * @param scene - The scene to search in.
- * @returns The parent entity info, or null if not found.
- */
-function FindParentEntity(entity, scene) {
-    // Check scene sub-objects (imageProcessingConfiguration, fogSettings, etc.)
-    const sceneSubProps = ["imageProcessingConfiguration", "postProcessRenderPipelineManager", "ambientColor", "gravity"];
-    for (const prop of sceneSubProps) {
-        if (scene[prop] === entity) {
-            return { targetType: "scene", targetName: "", targetIndex: 0, parentProperty: prop };
-        }
-    }
-    const collections = [
-        { type: "materials", items: scene.materials },
-        { type: "cameras", items: scene.cameras },
-        { type: "meshes", items: scene.meshes },
-        { type: "lights", items: scene.lights },
-    ];
-    for (const { type, items } of collections) {
-        for (const parent of items) {
-            for (const prop of Object.keys(parent)) {
-                if (prop.startsWith("_")) {
-                    continue;
-                }
-                try {
-                    if (parent[prop] === entity) {
-                        const targetIndex = items.filter((p) => p.name === parent.name).indexOf(parent);
-                        return { targetType: type, targetName: parent.name, targetIndex: Math.max(targetIndex, 0), parentProperty: prop };
-                    }
-                }
-                catch {
-                    // Skip properties that throw on access
-                }
-            }
-        }
-    }
-    return null;
-}
 
 // Side-effect import: registers the `.babylon` SceneLoader plugin so the
 // companion `.babylon` file produced by SerializeProject can be loaded back.
@@ -27381,4 +27650,4 @@ const TextAreaPropertyLine = (props) => {
 AttachDebugLayer();
 
 export { GetPropertyDescriptor as $, Accordion as A, Button as B, CheckboxPropertyLine as C, Color4PropertyLine as D, ColorPickerPopup as E, ColorStepGradientComponent as F, ComboBox as G, ComboBoxPropertyLine as H, ConstructorFactory as I, ConvertOptions as J, DebugServiceIdentity as K, Link as L, MessageBar as M, NumberInputPropertyLine as N, DetachDebugLayer as O, Popover as P, DraggableLine as Q, Dropdown as R, ShellServiceIdentity as S, TextInputPropertyLine as T, EntitySelector as U, Vector3PropertyLine as V, ErrorBoundary as W, ExtensibleAccordion as X, FactorGradientComponent as Y, FactorGradientList as Z, FileUploadLine as _, useToast as a, ThemeServiceIdentity as a$, GizmoServiceIdentity as a0, HexPropertyLine as a1, InfoLabel as a2, InputHexField as a3, InputHsvField as a4, Inspector as a5, InterceptFunction as a6, InterceptProperty as a7, IsPropertyReadonly as a8, LineContainer as a9, SearchBox as aA, SelectionServiceDefinition as aB, SettingsServiceIdentity as aC, SettingsStore as aD, SettingsStoreIdentity as aE, ShowInspector as aF, SidePaneContainer as aG, SkeletonSelector as aH, Slider as aI, SpinButton as aJ, StartInspectable as aK, StatsServiceIdentity as aL, StringDropdown as aM, StringDropdownPropertyLine as aN, StringifiedPropertyLine as aO, Switch as aP, SwitchPropertyLine as aQ, SyncedSliderInput as aR, SyncedSliderPropertyLine as aS, TeachingMoment as aT, TextAreaPropertyLine as aU, TextInput as aV, TextPropertyLine as aW, Textarea as aX, TextureSelector as aY, TextureUpload as aZ, Theme as a_, LinkPropertyLine as aa, LinkToEntityPropertyLine as ab, List as ac, MakeDialogTeachingMoment as ad, MakeLazyComponent as ae, MakeModularBridge as af, MakeModularTool as ag, MakePopoverTeachingMoment as ah, MakePropertyHook as ai, MakeTeachingMoment as aj, MaterialSelector as ak, NodeSelector as al, NumberDropdown as am, NumberDropdownPropertyLine as an, ObservableCollection as ao, Pane as ap, PlaceholderPropertyLine as aq, PositionedPopover as ar, PropertiesServiceIdentity as as, Property as at, PropertyContext as au, PropertyLine as av, QuaternionPropertyLine as aw, RotationVectorPropertyLine as ax, SceneExplorerServiceIdentity as ay, SearchBar as az, useInterceptObservable as b, ToastProvider as b0, ToggleButton as b1, Tooltip as b2, UploadButton as b3, Vector2PropertyLine as b4, Vector4PropertyLine as b5, WatcherServiceIdentity as b6, inspectorAssetNotFoundHandler as b7, useAngleConverters as b8, useAsyncResource as b9, useColor3Property as ba, useColor4Property as bb, useEventListener as bc, useEventfulState as bd, useKeyListener as be, useKeyState as bf, useObservableCollection as bg, useOrderedObservableCollection as bh, usePollingObservable as bi, usePropertyChangedNotifier as bj, useQuaternionProperty as bk, useResource as bl, useTheme as bm, useThemeMode as bn, useVector3Property as bo, LinkToEntity as c, SpinButtonPropertyLine as d, useProperty as e, SceneContextIdentity as f, SelectionServiceIdentity as g, useObservableState as h, AccordionSection as i, ButtonLine as j, ToolsServiceIdentity as k, AccordionSectionItem as l, AttachDebugLayer as m, BooleanBadgePropertyLine as n, BoundProperty as o, BridgeCommandRegistryIdentity as p, BuiltInsExtensionFeed as q, Checkbox as r, ChildWindow as s, Collapse as t, useExtensionManager as u, Color3GradientComponent as v, Color3GradientList as w, Color3PropertyLine as x, Color4GradientComponent as y, Color4GradientList as z };
-//# sourceMappingURL=index-DG9gOJk5.js.map
+//# sourceMappingURL=index-DhgT03HX.js.map