@babylonjs/inspector 9.25.0 → 9.26.0

package/bin/inspector-bridge.mjs

@@ -687,7 +687,9 @@ let PerMessageDeflate$4 = class PerMessageDeflate {
             (typeof opts.serverMaxWindowBits === 'number' &&
               opts.serverMaxWindowBits > params.server_max_window_bits))) ||
         (typeof opts.clientMaxWindowBits === 'number' &&
-          !params.client_max_window_bits)
+          (typeof params.client_max_window_bits === 'number'
+            ? opts.clientMaxWindowBits > params.client_max_window_bits
+            : !params.client_max_window_bits))
       ) {
         return false;
       }

package/bin/inspector-cli.mjs

@@ -690,7 +690,9 @@ let PerMessageDeflate$3 = class PerMessageDeflate {
             (typeof opts.serverMaxWindowBits === 'number' &&
               opts.serverMaxWindowBits > params.server_max_window_bits))) ||
         (typeof opts.clientMaxWindowBits === 'number' &&
-          !params.client_max_window_bits)
+          (typeof params.client_max_window_bits === 'number'
+            ? opts.clientMaxWindowBits > params.client_max_window_bits
+            : !params.client_max_window_bits))
       ) {
         return false;
       }

package/lib/components/explorer/explorer.d.ts

@@ -0,0 +1,40 @@
+import { type FunctionComponent } from "react";
+import { type Nullable } from "@babylonjs/core/index.js";
+import { type ExplorerCommandProvider, type ExplorerNodeDescription } from "./explorerModel";
+/**
+ * A generic, recursive tree explorer.
+ *
+ * The Explorer is intentionally product agnostic: it renders whatever hierarchy is described by the
+ * {@link ExplorerNodeDescription}s returned from `getNodes`, which means nodes of different kinds backed by
+ * completely unrelated entity types can be arbitrarily nested within each other.
+ * @param props The props describing the hierarchy to render, the available commands, and the selection state.
+ * @returns The explorer tree component.
+ */
+export declare const Explorer: FunctionComponent<{
+    /**
+     * Enumerates the top level nodes of the tree. This is re-invoked whenever the tree needs to be rebuilt
+     * (e.g. when one of the change observables of the described nodes fires), so it should always reflect
+     * the current state of the hierarchy. It must be referentially stable (e.g. wrapped in `useCallback`).
+     */
+    getNodes: () => readonly ExplorerNodeDescription[];
+    /**
+     * Command providers for nodes that represent an entity.
+     */
+    itemCommandProviders: readonly ExplorerCommandProvider<object>[];
+    /**
+     * Command providers for group nodes. The provider context is the group's display name.
+     */
+    groupCommandProviders: readonly ExplorerCommandProvider<string, "contextMenu">[];
+    /**
+     * The currently selected entity.
+     */
+    selectedEntity?: Nullable<object>;
+    /**
+     * Called when the selected entity changes.
+     */
+    setSelectedEntity?: (entity: Nullable<object>) => void;
+    /**
+     * The accessible label of the tree.
+     */
+    ariaLabel?: string;
+}>;

package/lib/components/{scene/sceneExplorerDragDrop.d.ts → explorer/explorerDragDrop.d.ts}

@@ -1,7 +1,7 @@
 import { type DragEvent } from "react";
-import { type SceneExplorerDragDropConfig } from "./sceneExplorer";
+import { type ExplorerDragDropConfig } from "./explorerModel";
 /**
- * Props for drop-only event handlers on a section header.
+ * Props for drop-only event handlers on a group node.
  */
 export type DropProps = {
     onDragOver: (e: DragEvent) => void;
@@ -19,20 +19,20 @@ export type DragDropProps = {
 /**
  * Options for the drag-drop hook.
  */
-export type SceneExplorerDragDropOptions = {
-    /** Called after a successful drop with the dragged entity and target (entity or null for section root). */
+export type ExplorerDragDropOptions = {
+    /** Called after a successful drop with the dragged entity and target (entity or null for the branch root). */
     onDrop?: (draggedEntity: object, targetEntity: object | null) => void;
 };
 /**
- * Hook that provides drag-drop functionality for the scene explorer.
+ * Hook that provides drag-drop functionality for the explorer.
  * Uses vanilla HTML5 drag and drop APIs.
  * @param options Optional callbacks for drag-drop events.
  * @returns State and props factory for drag-drop functionality.
  */
-export declare function useSceneExplorerDragDrop(options?: SceneExplorerDragDropOptions): {
+export declare function useExplorerDragDrop(options?: ExplorerDragDropOptions): {
     draggedEntity: object | undefined;
     dropTarget: object | undefined;
     dropTargetIsRoot: boolean;
-    createDragProps: (entity: object, getName: () => string, dragDropConfig?: SceneExplorerDragDropConfig<object>) => DragDropProps;
-    createSectionDropProps: (dragDropConfig: SceneExplorerDragDropConfig<object> | undefined) => DropProps;
+    createDragProps: (entity: object, getName: () => string, dragDropConfig?: ExplorerDragDropConfig<object>) => DragDropProps;
+    createGroupDropProps: (dragDropConfig: ExplorerDragDropConfig<object> | undefined) => DropProps;
 };

package/lib/components/explorer/explorerModel.d.ts

@@ -0,0 +1,359 @@
+import { type ComponentType } from "react";
+import { type IDisposable, type IReadonlyObservable } from "@babylonjs/core/index.js";
+/**
+ * The value used to uniquely identify a node within the Explorer tree (e.g. for expansion state).
+ * This matches the Fluent `TreeItemValue` type.
+ * @experimental
+ */
+export type ExplorerNodeValue = string | number;
+/**
+ * Information about how to display a node in the Explorer tree.
+ * @experimental
+ */
+export type ExplorerDisplayInfo = Partial<IDisposable> & Readonly<{
+    /**
+     * The name of the node to display in the Explorer tree.
+     */
+    name: string;
+    /**
+     * An observable that notifies when the display info (such as the name) changes.
+     */
+    onChange?: IReadonlyObservable<void>;
+    /**
+     * An optional validation error message for this node. When present, the node's
+     * icon is replaced with a warning icon whose tooltip displays this message.
+     */
+    validationError?: string;
+}>;
+/**
+ * Configuration for drag-and-drop behavior within a branch of the Explorer tree.
+ * The configuration applies to the node it is specified on as well as all of its descendants.
+ * @experimental
+ */
+export type ExplorerDragDropConfig<T> = Readonly<{
+    /**
+     * Determines whether an entity can be dragged.
+     * @param entity The entity to check.
+     * @returns True if the entity can be dragged, false otherwise.
+     */
+    canDrag: (entity: T) => boolean;
+    /**
+     * Determines whether an entity can be dropped onto a target.
+     * @param draggedEntity The entity being dragged.
+     * @param targetEntity The potential drop target entity, or null if dropping onto the branch root.
+     * @returns True if the drop is allowed, false otherwise.
+     */
+    canDrop: (draggedEntity: T, targetEntity: T | null) => boolean;
+    /**
+     * Called when a drag-and-drop operation completes.
+     * @param draggedEntity The entity that was dragged.
+     * @param targetEntity The entity it was dropped onto, or null if dropped onto the branch root.
+     */
+    onDrop: (draggedEntity: T, targetEntity: T | null) => void;
+}>;
+type InlineCommand = {
+    /**
+     * An icon component to render for the command. Required for inline commands.
+     */
+    icon: ComponentType;
+    /**
+     * The mode of the command. Inline commands are shown directly in the tree item layout. Inline by default.
+     */
+    mode?: "inline";
+};
+type ContextMenuCommand = {
+    /**
+     * An icon component to render for the command. Optional for context menu commands.
+     */
+    icon?: ComponentType;
+    /**
+     * The mode of the command. Context menu commands are shown in the context menu for the tree item.
+     */
+    mode: "contextMenu";
+};
+/**
+ * The supported command modes (inline or context menu).
+ * @experimental
+ */
+export type ExplorerCommandMode = NonNullable<(InlineCommand | ContextMenuCommand)["mode"]>;
+type ActionCommand = {
+    readonly type: "action";
+    /**
+     * The function that executes the command.
+     */
+    execute(): unknown | Promise<unknown>;
+};
+type ToggleCommand = {
+    readonly type: "toggle";
+    /**
+     * A boolean indicating if the command is enabled.
+     */
+    isEnabled: boolean;
+};
+/**
+ * The supported command types (action or toggle).
+ * @experimental
+ */
+export type ExplorerCommandType = (ActionCommand | ToggleCommand)["type"];
+/**
+ * Describes a command that can be executed on a node in the Explorer.
+ * @experimental
+ */
+export type ExplorerCommand<ModeT extends ExplorerCommandMode = ExplorerCommandMode, TypeT extends ExplorerCommandType = ExplorerCommandType> = Partial<IDisposable> & Readonly<{
+    /**
+     * The display name of the command (e.g. "Delete", "Rename", etc.).
+     */
+    displayName: string;
+    /**
+     * An optional array of hotkeys that trigger the command.
+     */
+    hotKey?: {
+        keyCode: string;
+        control?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+        meta?: boolean;
+    };
+    /**
+     * An observable that notifies when the command state changes.
+     */
+    onChange?: IReadonlyObservable<unknown>;
+}> & (ModeT extends "inline" ? InlineCommand : ContextMenuCommand) & (TypeT extends "action" ? ActionCommand : ToggleCommand);
+/**
+ * Provides a command for a specific context (an entity or a group name) in the Explorer.
+ * @experimental
+ */
+export type ExplorerCommandProvider<ContextT, ModeT extends ExplorerCommandMode = ExplorerCommandMode, TypeT extends ExplorerCommandType = ExplorerCommandType> = Readonly<{
+    /**
+     * An optional order for the command, relative to other commands.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * A predicate function that determines if the command is applicable to the given context.
+     */
+    predicate: (context: unknown) => context is ContextT;
+    /**
+     * Gets the command information for the given context.
+     */
+    getCommand: (context: ContextT) => ExplorerCommand<ModeT, TypeT>;
+}>;
+/**
+ * The visual treatment used for a node in the Explorer tree.
+ * - "root": The single top level node representing the object being inspected (e.g. a Scene or an Engine).
+ * - "group": A heading style node (e.g. "Nodes", "Materials", "Auxiliary Surfaces").
+ * - "item": A standard node representing an entity within the tree (e.g. a mesh or a material).
+ * @experimental
+ */
+export type ExplorerNodeKind = "root" | "group" | "item";
+/**
+ * Describes a single node of the Explorer tree.
+ *
+ * This is the generic (product agnostic) model the Explorer renders. Each node describes its own
+ * presentation and enumerates its own children, which means an Explorer hierarchy can be arbitrarily
+ * deep and fully heterogeneous (nodes of different kinds, backed by unrelated entity types, can be
+ * freely nested within each other).
+ * @experimental
+ */
+export type ExplorerNodeDescription = Readonly<{
+    /**
+     * An identifier for the node that is stable across rebuilds and unique among its siblings.
+     */
+    id: string;
+    /**
+     * The visual treatment used for this node. Defaults to "item".
+     */
+    kind?: ExplorerNodeKind;
+    /**
+     * The entity represented by this node, if any.
+     * Nodes with an entity are selectable and are always displayed.
+     * Nodes without an entity are purely structural, are not selectable, and are only displayed when they have visible children.
+     */
+    entity?: object;
+    /**
+     * Gets the display information for this node.
+     * This is ideally "live" display info (e.g. updates to the display info are taken into account and communicated via the observable).
+     * This means in many cases the display info will need to be disposed when it is no longer needed so observable registrations can be removed.
+     */
+    getDisplayInfo: () => ExplorerDisplayInfo;
+    /**
+     * An optional icon component to render for the node.
+     */
+    icon?: ComponentType<{
+        entity: object;
+    }>;
+    /**
+     * Enumerates the children of this node. Children may be of any kind and may describe entirely different entity types.
+     */
+    getChildren?: () => readonly ExplorerNodeDescription[];
+    /**
+     * Optional configuration for drag-and-drop behavior within this node.
+     * Descendants inherit this configuration unless they specify their own.
+     * If not provided (and not inherited), drag-and-drop is disabled for the node.
+     */
+    dragDropConfig?: ExplorerDragDropConfig<object>;
+    /**
+     * A function that returns observables that notify when descendants of this node are added.
+     */
+    getAddedObservables?: () => readonly IReadonlyObservable<unknown>[];
+    /**
+     * A function that returns observables that notify when descendants of this node are removed.
+     */
+    getRemovedObservables?: () => readonly IReadonlyObservable<object>[];
+    /**
+     * A function that returns observables that notify when descendants of this node are moved (e.g. re-parented).
+     */
+    getMovedObservables?: () => readonly IReadonlyObservable<unknown>[];
+}>;
+/**
+ * A materialized node of the Explorer tree, produced by {@link BuildExplorerTree}.
+ */
+export type ExplorerNode = {
+    /**
+     * The visual treatment used for this node.
+     */
+    readonly kind: ExplorerNodeKind;
+    /**
+     * The value that uniquely identifies this node within the tree (e.g. for expansion state).
+     */
+    readonly value: ExplorerNodeValue;
+    /**
+     * The one based depth of this node within the tree (used for indentation and accessibility).
+     */
+    readonly depth: number;
+    /**
+     * The parent of this node, or undefined for top level nodes.
+     */
+    readonly parent?: ExplorerNode;
+    /**
+     * The visible children of this node.
+     */
+    readonly children: ExplorerNode[];
+    /**
+     * The entity represented by this node, or undefined if this node is purely structural.
+     */
+    readonly entity?: object;
+    /**
+     * An optional icon component to render for the node.
+     */
+    readonly icon?: ComponentType<{
+        entity: object;
+    }>;
+    /**
+     * Gets the (possibly live) display info for this node.
+     */
+    readonly getDisplayInfo: () => ExplorerDisplayInfo;
+    /**
+     * The drag-and-drop configuration that applies to this node (either its own or inherited from an ancestor).
+     */
+    readonly dragDropConfig?: ExplorerDragDropConfig<object>;
+};
+/**
+ * The result of materializing a set of {@link ExplorerNodeDescription}s into a tree.
+ */
+export type ExplorerTree = {
+    /**
+     * The visible top level nodes, in the order they were described.
+     */
+    readonly nodes: readonly ExplorerNode[];
+    /**
+     * All visible nodes, keyed by their tree value.
+     */
+    readonly nodesByValue: ReadonlyMap<ExplorerNodeValue, ExplorerNode>;
+    /**
+     * All visible nodes that represent an entity, keyed by that entity. An entity can occur in
+     * multiple branches, so each value contains every occurrence in tree order.
+     */
+    readonly nodesByEntity: ReadonlyMap<object, readonly ExplorerNode[]>;
+    /**
+     * The observables (gathered from every described node, including nodes that are not currently visible)
+     * that notify when the topology of the tree changes.
+     */
+    readonly changeObservables: {
+        readonly added: readonly IReadonlyObservable<unknown>[];
+        readonly removed: readonly IReadonlyObservable<object>[];
+        readonly moved: readonly IReadonlyObservable<unknown>[];
+    };
+};
+/**
+ * Gets a stable identifier for an entity. If the entity has a numeric `uniqueId` property it is used,
+ * otherwise a synthetic id is generated and cached for the lifetime of the entity.
+ * @param entity The entity to get an identifier for.
+ * @returns A stable numeric identifier for the entity.
+ */
+export declare function GetEntityId(entity: object): number;
+/**
+ * Determines whether a node should be displayed in the Explorer tree.
+ * Nodes that represent an entity are always displayed (they are selectable and meaningful on their own),
+ * while purely structural nodes are only displayed when they have at least one visible child.
+ * @param node A node with an optional entity and a set of already filtered (visible) children.
+ * @returns True if the node should be displayed, false otherwise.
+ */
+export declare function ShouldDisplayNode(node: {
+    readonly entity?: object;
+    readonly children: readonly unknown[];
+}): boolean;
+/**
+ * Gets the children of a node in display order. The declared order is preserved unless alphabetical
+ * sorting is enabled, in which case item nodes are sorted without moving structural nodes.
+ * @param node The node whose children should be ordered.
+ * @param sortItems Whether item nodes should be sorted alphabetically by display name.
+ * @returns The ordered children of the node.
+ */
+export declare function GetOrderedChildren(node: ExplorerNode, sortItems: boolean): readonly ExplorerNode[];
+/**
+ * Materializes a set of node descriptions into an Explorer tree.
+ *
+ * Nodes are visited recursively so that arbitrarily nested, heterogeneous hierarchies are supported.
+ * Structural nodes (nodes without an entity) that end up with no visible children are omitted from the
+ * resulting tree, but their change observables are still gathered so the tree can be rebuilt when they
+ * gain children.
+ * @param descriptions The top level node descriptions.
+ * @returns The materialized tree, along with lookup maps and the gathered change observables.
+ */
+export declare function BuildExplorerTree(descriptions: readonly ExplorerNodeDescription[]): ExplorerTree;
+/**
+ * Options that control which nodes of an Explorer tree are visible.
+ */
+export type ExplorerVisibilityOptions = Readonly<{
+    /**
+     * The values of the nodes that are currently expanded.
+     */
+    openItems: ReadonlySet<ExplorerNodeValue>;
+    /**
+     * A lower case filter string. When non-empty, the expansion state is ignored and only matching
+     * nodes (and their ancestors) are visible.
+     */
+    filter: string;
+    /**
+     * Whether item nodes should be sorted alphabetically by display name.
+     */
+    sortItems: boolean;
+}>;
+/**
+ * Computes the flattened, ordered list of nodes that should currently be rendered.
+ *
+ * Only nodes that represent an entity participate in filter matching. Purely structural nodes
+ * (e.g. the "Nodes" or "Materials" sections) become visible when one of their descendants matches.
+ * The root node is always visible.
+ * @param nodes The top level nodes of the tree.
+ * @param options Options controlling expansion, filtering, and sorting.
+ * @returns The nodes to render, in tree order.
+ */
+export declare function GetVisibleExplorerNodes(nodes: readonly ExplorerNode[], options: ExplorerVisibilityOptions): readonly ExplorerNode[];
+/**
+ * Expands or collapses a node and all of its descendants.
+ * @param node The node to expand or collapse.
+ * @param open True to expand, false to collapse.
+ * @param openItems The mutable set of expanded node values to update.
+ */
+export declare function ExpandOrCollapseAll(node: ExplorerNode, open: boolean, openItems: Set<ExplorerNodeValue>): void;
+/**
+ * Gets the values of all ancestors of the node representing the specified entity, which is what must be
+ * expanded for that entity to be revealed.
+ * @param tree The tree to search.
+ * @param entity The entity to reveal.
+ * @returns The values of the ancestor nodes, or an empty array if the entity is not present in the tree.
+ */
+export declare function GetAncestorValues(tree: ExplorerTree, entity: object): readonly ExplorerNodeValue[];
+export {};

package/lib/components/properties/boundProperty.d.ts

@@ -49,6 +49,21 @@ declare function BoundPropertyImpl<TargetT extends object, PropertyKeyT extends
  * @returns JSX element
  */
 export declare const BoundProperty: typeof BoundPropertyImpl;
+type ComponentValue<ComponentT extends ComponentType<any>> = ComponentProps<ComponentT> extends {
+    value: infer ValueT;
+} ? ValueT : never;
+export type ComputedPropertyProps<TargetT extends object, ComponentT extends ComponentType<any>> = Omit<ComponentProps<ComponentT>, "value" | "onChange"> & {
+    component: ComponentT;
+    target: TargetT;
+    getValue: (target: TargetT) => ComponentValue<ComponentT>;
+};
+/**
+ * Renders a read-only property-line component with a computed value that follows the Preferred
+ * Watch Mode. Use {@link BoundProperty} instead for an editable `target[propertyKey]`.
+ * @param props The target, computed getter, and property-line component props.
+ * @returns The property-line component with its current computed value.
+ */
+export declare function ComputedProperty<TargetT extends object, ComponentT extends ComponentType<any>>(props: ComputedPropertyProps<TargetT, ComponentT>): import("react/jsx-runtime").JSX.Element;
 /**
  * Mutually exclusive propertyPath or functionPath - one required
  */

package/lib/components/scene/sceneExplorer.d.ts

@@ -1,49 +1,16 @@
-import { type ComponentType, type FunctionComponent } from "react";
-import { type IDisposable, type IReadonlyObservable, type Nullable, type Scene } from "@babylonjs/core/index.js";
+import { type ComponentType } from "react";
+import { type IReadonlyObservable } from "@babylonjs/core/index.js";
+import { type ExplorerCommand, type ExplorerCommandMode, type ExplorerCommandProvider, type ExplorerCommandType, type ExplorerDisplayInfo, type ExplorerDragDropConfig } from "../explorer/explorerModel";
 /**
  * Information about how to display an entity in the Scene Explorer tree.
  */
-export type EntityDisplayInfo = Partial<IDisposable> & Readonly<{
-    /**
-     * The name of the entity to display in the Scene Explorer tree.
-     */
-    name: string;
-    /**
-     * An observable that notifies when the display info (such as the name) changes.
-     */
-    onChange?: IReadonlyObservable<void>;
-    /**
-     * An optional validation error message for this entity. When present, the entity's
-     * icon is replaced with a warning icon whose tooltip displays this message.
-     */
-    validationError?: string;
-}>;
+export type EntityDisplayInfo = ExplorerDisplayInfo;
 /**
  * Configuration for drag-and-drop behavior within a section.
  */
-export type SceneExplorerDragDropConfig<T> = Readonly<{
-    /**
-     * Determines whether an entity can be dragged.
-     * @param entity The entity to check.
-     * @returns True if the entity can be dragged, false otherwise.
-     */
-    canDrag: (entity: T) => boolean;
-    /**
-     * Determines whether an entity can be dropped onto a target.
-     * @param draggedEntity The entity being dragged.
-     * @param targetEntity The potential drop target entity, or null if dropping onto the section root.
-     * @returns True if the drop is allowed, false otherwise.
-     */
-    canDrop: (draggedEntity: T, targetEntity: T | null) => boolean;
-    /**
-     * Called when a drag-and-drop operation completes.
-     * @param draggedEntity The entity that was dragged.
-     * @param targetEntity The entity it was dropped onto, or null if dropped onto the section root.
-     */
-    onDrop: (draggedEntity: T, targetEntity: T | null) => void;
-}>;
+export type SceneExplorerDragDropConfig<T> = ExplorerDragDropConfig<T>;
 /**
- * Describes a section in the Scene Explorer (e.g. "Nodes", "Materials", etc.).
+ * Describes a section containing entities in the Scene Explorer.
  */
 export type SceneExplorerSection<T extends object> = Readonly<{
     /**
@@ -93,95 +60,14 @@ export type SceneExplorerSection<T extends object> = Readonly<{
      */
     dragDropConfig?: SceneExplorerDragDropConfig<T>;
 }>;
-type InlineCommand = {
-    /**
-     * An icon component to render for the command. Required for inline commands.
-     */
-    icon: ComponentType;
-    /**
-     * The mode of the command. Inline commands are shown directly in the tree item layout. Inline by default.
-     */
-    mode?: "inline";
-};
-type ContextMenuCommand = {
-    /**
-     * An icon component to render for the command. Optional for context menu commands.
-     */
-    icon?: ComponentType;
-    /**
-     * The mode of the command. Context menu commands are shown in the context menu for the tree item.
-     */
-    mode: "contextMenu";
-};
-type CommandMode = NonNullable<(InlineCommand | ContextMenuCommand)["mode"]>;
-type ActionCommand = {
-    readonly type: "action";
-    /**
-     * The function that executes the command.
-     */
-    execute(): unknown | Promise<unknown>;
-};
-type ToggleCommand = {
-    readonly type: "toggle";
-    /**
-     * A boolean indicating if the command is enabled.
-     */
-    isEnabled: boolean;
-};
-type CommandType = (ActionCommand | ToggleCommand)["type"];
+type CommandMode = ExplorerCommandMode;
+type CommandType = ExplorerCommandType;
 /**
  * Describes a command that can be executed on entities or sections in the Scene Explorer.
  */
-export type SceneExplorerCommand<ModeT extends CommandMode = CommandMode, TypeT extends CommandType = CommandType> = Partial<IDisposable> & Readonly<{
-    /**
-     * The display name of the command (e.g. "Delete", "Rename", etc.).
-     */
-    displayName: string;
-    /**
-     * An optional array of hotkeys that trigger the command.
-     */
-    hotKey?: {
-        keyCode: string;
-        control?: boolean;
-        alt?: boolean;
-        shift?: boolean;
-        meta?: boolean;
-    };
-    /**
-     * An observable that notifies when the command state changes.
-     */
-    onChange?: IReadonlyObservable<unknown>;
-}> & (ModeT extends "inline" ? InlineCommand : ContextMenuCommand) & (TypeT extends "action" ? ActionCommand : ToggleCommand);
+export type SceneExplorerCommand<ModeT extends CommandMode = CommandMode, TypeT extends CommandType = CommandType> = ExplorerCommand<ModeT, TypeT>;
 /**
  * Provides a command for a specific entity or section context in the Scene Explorer.
  */
-export type SceneExplorerCommandProvider<ContextT, ModeT extends CommandMode = CommandMode, TypeT extends CommandType = CommandType> = Readonly<{
-    /**
-     * An optional order for the section, relative to other commands.
-     * Defaults to 0.
-     */
-    order?: number;
-    /**
-     * A predicate function that determines if the command is applicable to the given context.
-     */
-    predicate: (context: unknown) => context is ContextT;
-    /**
-     * Gets the command information for the given context.
-     */
-    getCommand: (context: ContextT) => SceneExplorerCommand<ModeT, TypeT>;
-}>;
-declare const ActionCommand: FunctionComponent<{
-    command: SceneExplorerCommand<"inline", "action">;
-}>;
-declare const ToggleCommand: FunctionComponent<{
-    command: SceneExplorerCommand<"inline", "toggle">;
-}>;
-export declare const SceneExplorer: FunctionComponent<{
-    sections: readonly SceneExplorerSection<object>[];
-    entityCommandProviders: readonly SceneExplorerCommandProvider<object>[];
-    sectionCommandProviders: readonly SceneExplorerCommandProvider<string, "contextMenu">[];
-    scene: Scene;
-    selectedEntity?: Nullable<object>;
-    setSelectedEntity?: (entity: Nullable<object>) => void;
-}>;
+export type SceneExplorerCommandProvider<ContextT, ModeT extends CommandMode = CommandMode, TypeT extends CommandType = CommandType> = ExplorerCommandProvider<ContextT, ModeT, TypeT>;
 export {};

package/lib/contexts/watcherContext.d.ts

@@ -1,3 +1,14 @@
 import { type IWatcherService } from "../services/watcherService";
 export declare const WatcherContext: import("react").Context<IWatcherService>;
 export declare function useWatcher(): IWatcherService;
+/**
+ * Reads a computed value and keeps it synchronized with Watcher refreshes.
+ * @param target The object from which the value is computed.
+ * @param getValue A stable function that computes the value from the target.
+ * @returns The latest computed value.
+ * @remarks Use this for inspected values that should honor the Preferred Watch Mode. Use
+ * `useObservableState` directly when the source exposes a precise change observable, or combine
+ * `usePollingObservable` with `useObservableState` for telemetry that intentionally uses a fixed
+ * cadence independent of Watch Mode.
+ */
+export declare function useWatchedValue<Target, Value>(target: Target, getValue: (target: Target) => Value): Value;