vim-web 0.5.0-dev.2 → 0.5.0-dev.4

package/dist/types/core-viewers/ultra/camera.d.ts

@@ -107,10 +107,10 @@ export declare class Camera implements ICamera {
     /**
      * Frames specific nodes of a Vim model in the camera view
      * @param vim - The Vim model containing the nodes to frame
-     * @param nodes - Array of node indices to frame, or 'all' to frame the entire model
+     * @param elements - Array of element indices to frame, or 'all' to frame the entire model
      * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
      * @returns Promise that resolves when the framing animation is complete
      */
-    frameVim(vim: Vim, nodes: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
+    frameVim(vim: Vim, elements: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
     frameObject(object: Element3D, blendTime?: number): Promise<Segment | undefined>;
 }

package/dist/types/core-viewers/ultra/rpcClient.d.ts

@@ -32,27 +32,28 @@ export declare class RpcClient {
     get url(): string;
     constructor(_socket: SocketClient);
     readonly API_VERSION = "6.0.0";
-    RPCClearMaterialOverrides(componentHandle: number): void;
+    RPCClearMaterialOverrides(): void;
     RPCCreateMaterialInstances(materialHandle: number, smoothness: number, colors: RpcTypes.RGBA32[]): Promise<number>;
     RPCCreateText(position: RpcTypes.Vector3, color: RpcTypes.RGBA32, text: string): Promise<number>;
-    RPCDestroyMaterialInstances(materialInstanceHandle: number[]): void;
+    RPCDestroyMaterialInstances(materialInstanceHandles: number[]): void;
     RPCDestroyText(componentHandle: number): void;
     RPCEnableSectionBox(value: boolean): void;
     RPCFrameAABB(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment>;
-    RPCFrameAll(blendTime: number): Promise<RpcTypes.Segment>;
-    RPCFrameElements(componentHandle: number, elementIndices: number[], blendTime: number): Promise<RpcTypes.Segment>;
-    RPCFrameVim(componentHandle: number, blendTime: number): Promise<RpcTypes.Segment>;
-    RPCGetAABBForAll(): Promise<RpcTypes.Box3>;
-    RPCGetAABBForElements(componentHandle: number, elementIndices: number[]): Promise<RpcTypes.Box3>;
-    RPCGetAABBForVim(componentHandle: number): Promise<RpcTypes.Box3>;
+    RPCFrameElements(vimIndex: number, elementIndices: number[], blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameScene(blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameVim(vimIndex: number, blendTime: number): Promise<RpcTypes.Segment>;
+    RPCGetAABBForElements(vimIndex: number, elementIndices: number[]): Promise<RpcTypes.Box3>;
+    RPCGetAABBForScene(): Promise<RpcTypes.Box3>;
+    RPCGetAABBForVim(vimIndex: number): Promise<RpcTypes.Box3>;
     RPCGetAPIVersion(): Promise<string>;
     RPCGetCameraView(): Promise<RpcTypes.Segment>;
-    RPCGetElementCount(componentHandle: number): Promise<number>;
-    RPCGetElementIds(componentHandle: number): Promise<bigint[]>;
+    RPCGetElementCountForScene(): Promise<number>;
+    RPCGetElementCountForVim(vimIndex: number): Promise<number>;
+    RPCGetElementIds(vimIndex: number): Promise<bigint[]>;
     RPCGetLastError(): Promise<string>;
-    RPCGetRoomElements(componentHandle: number): Promise<number[]>;
+    RPCGetRoomElements(vimIndex: number): Promise<number[]>;
     RPCGetSectionBox(): Promise<RpcTypes.SectionBoxState>;
-    RPCGetVimLoadingState(componentHandle: number): Promise<RpcTypes.VimStatus>;
+    RPCGetVimLoadingState(vimIndex: number): Promise<RpcTypes.VimStatus>;
     RPCKeyEvent(keyCode: number, down: boolean): void;
     RPCLoadVim(fileName: string): Promise<number>;
     RPCLoadVimURL(url: string, authToken: string): Promise<number>;
@@ -71,13 +72,13 @@ export declare class RpcClient {
     RPCSetCameraView(state: RpcTypes.Segment, blendTime: number): void;
     RPCSetGhostColor(ghostColor: RpcTypes.RGBA): void;
     RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): void;
-    RPCSetMaterialOverrides(componentHandle: number, elementIndices: number[], materialInstanceHandles: number[]): void;
+    RPCSetMaterialOverridesForElements(vimIndex: number, elementIndices: number[], materialInstanceHandles: number[]): void;
     RPCSetSectionBox(state: RpcTypes.SectionBoxState): void;
-    RPCSetStateVim(componentHandle: number, state: number): void;
-    RPCSetStateElements(componentHandle: number, elementIndices: number[], state: number): void;
-    RPCSetStatesElements(componentHandle: number, elementIndices: number[], states: number[]): void;
+    RPCSetStateElements(vimIndex: number, elementIndices: number[], state: number): void;
+    RPCSetStateScene(state: number): void;
+    RPCSetStateVim(vimIndex: number, state: number): void;
+    RPCSetStatesElements(vimIndex: number, elementIndices: number[], states: number[]): void;
     RPCStartScene(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): Promise<boolean>;
     RPCTriggerRenderDocCapture(): void;
     RPCUnloadAll(): void;
-    RPCUnloadVim(componentHandle: number): void;
 }

package/dist/types/core-viewers/ultra/rpcSafeClient.d.ts

@@ -1,44 +1,129 @@
 import * as RpcTypes from "./rpcTypes";
 import { MaterialHandle, RpcClient } from "./rpcClient";
 import { VisibilityState } from "./visibility";
+/**
+ * Describes the source location and optional authentication for loading a VIM file.
+ */
 export type VimSource = {
+    /**
+     * URL to the VIM file.
+     * Can be a local path (file://) or remote URL (http:// or https://).
+     */
     url: string;
+    /**
+     * Optional authentication token for accessing protected resources.
+     */
     authToken?: string;
 };
+/**
+ * Represents the loading state and progress for a single vim.
+ */
 export type VimLoadingState = {
+    /**
+     * Current loading status.
+     */
     status: VimLoadingStatus;
+    /**
+     * Loading progress as a percentage from 0 to 100.
+     */
     progress: number;
 };
+/**
+ * Defines supported input modes for camera control in the viewer.
+ */
 export declare enum InputMode {
+    /**
+     * Orbit mode — rotates around a fixed point.
+     */
     Orbit = "orbit",
+    /**
+     * Free mode — allows unrestricted movement.
+     */
     Free = "free"
 }
+/**
+ * Scene-wide rendering and lighting configuration options.
+ */
 export type SceneSettings = {
+    /**
+     * White point for tone mapping (clamped between 0 and 1).
+     */
     toneMappingWhitePoint: number;
+    /**
+     * Global HDR intensity multiplier (floored to 0).
+     */
     hdrScale: number;
+    /**
+     * HDR scale for the background (clamped between 0 and 1).
+     */
     hdrBackgroundScale: number;
+    /**
+     * Background saturation (clamped between 0 and 1).
+     */
     hdrBackgroundSaturation: number;
-    backGroundBlur: number;
+    /**
+     * Background blur strength (clamped between 0 and 1).
+     */
+    backgroundBlur: number;
+    /**
+     * Background color in linear RGBA format.
+     */
     backgroundColor: RpcTypes.RGBA;
 };
+/**
+ * Default scene settings used when none are explicitly provided.
+ */
 export declare const defaultSceneSettings: SceneSettings;
+/**
+ * Enumerates the possible states of VIM file loading.
+ */
 export declare enum VimLoadingStatus {
+    /**
+     * No known loading activity.
+     */
     Unknown = 0,
+    /**
+     * Actively loading VIM data.
+     */
     Loading = 1,
+    /**
+     * Downloading VIM file from a remote source.
+     */
     Downloading = 2,
+    /**
+     * Load completed successfully.
+     */
     Done = 3,
+    /**
+     * Download failed (e.g., due to network or permission issues).
+     */
     FailedToDownload = 4,
+    /**
+     * VIM file could not be parsed or initialized correctly.
+     */
     FailedToLoad = 5
 }
 /**
  * Provides safe, validated methods to interact with the RpcClient.
- * This class wraps the raw RPC methods with input validation and batching support for large operations.
+ * This class wraps low-level RPC calls with input validation, error handling,
+ * and batching support to ensure robustness and performance when dealing with large data.
  */
 export declare class RpcSafeClient {
     private readonly rpc;
     private readonly batchSize;
+    /**
+     * The URL used by the underlying RPC connection.
+     */
     get url(): string;
+    /**
+     * Indicates whether the RPC client is currently connected.
+     */
     get connected(): boolean;
+    /**
+     * Creates a new RpcSafeClient instance.
+     * @param rpc - The underlying RpcClient used for communication
+     * @param batchSize - Maximum size of batched data for operations (default: 10000)
+     */
     constructor(rpc: RpcClient, batchSize?: number);
     /*******************************************************************************
      * SCENE MANAGEMENT METHODS
@@ -46,31 +131,59 @@ export declare class RpcSafeClient {
      * and scene-wide settings.
      ******************************************************************************/
     /**
-     * Initializes and starts the scene with specified settings.
+     * Initializes and starts the scene with the given settings.
      * @param settings - Optional partial scene settings to override defaults
-     * @remarks If no settings are provided, default values will be used
+     * @returns Promise resolving to true if the scene started successfully, false otherwise
+     * @remarks Missing values will be filled from {@link defaultSceneSettings}
      */
     RPCStartScene(settings?: Partial<SceneSettings>): Promise<boolean>;
     /**
-     * Sets the lighting settings for the scene.
-     * @param settings - The lighting settings to apply
+     * Updates the scene’s lighting configuration.
+     * @param settings - The complete lighting and background settings to apply
      */
     RPCSetLighting(settings: SceneSettings): void;
+    /**
+     * Retrieves the total number of elements across the entire scene.
+     * @returns Promise resolving to the total number of elements (0 on failure).
+     */
+    RPCGetElementCountForScene(): Promise<number>;
+    /**
+     * Retrieves the number of elements within a specific loaded vim.
+     * @param vimIndex - Index of the loaded vim to query
+     * @returns Promise resolving to the element count (0 on failure)
+     */
+    RPCGetElementCountForVim(vimIndex: number): Promise<number>;
     /*******************************************************************************
-     * NODE VISIBILITY METHODS
-     * Methods for controlling node visibility, including show/hide, ghosting,
+     * ELEMENTS VISIBILITY METHODS
+     * Methods for controlling element visibility, including show/hide, ghosting,
      * and highlighting functionality.
      ******************************************************************************/
     /**
-     * Highlights specified nodes in a component.
-     * Large node arrays are automatically processed in batches.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices to highlight
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     * Sets a single visibility state for given elements within a loaded vim.
+     * The operation is automatically split into batches if the array is large.
+     *
+     * @param vimIndex - The index of the loaded vim containing the elements
+     * @param vimElementIndices - Array of vim-based element indices to apply the state to
+     * @param state - The visibility state to apply (e.g., VISIBLE, HIDDEN)
+     */
+    RPCSetStateElements(vimIndex: number, vimElementIndices: number[], state: VisibilityState): void;
+    /**
+     * Sets individual visibility states for multiple elements in a vim.
+     * Each element receives a corresponding visibility state from the input array.
+     * The operation is automatically split into batches if the array is large.
+     *
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices
+     * @param states - Array of visibility states to apply, one per element
      */
-    RPCSetStateElements(componentHandle: number, elements: number[], state: VisibilityState): void;
-    RPCSetStatesElements(componentHandle: number, elements: number[], states: VisibilityState[]): void;
-    RPCSetStateVim(componentHandle: number, state: VisibilityState): void;
+    RPCSetStatesElements(vimIndex: number, vimElementIndices: number[], states: VisibilityState[]): void;
+    /**
+     * Applies a single visibility state to all elements of a loaded vim.
+     *
+     * @param vimIndex - The index of the loaded vim
+     * @param state - The visibility state to apply (e.g., VISIBLE, HIDDEN)
+     */
+    RPCSetStateVim(vimIndex: number, state: VisibilityState): void;
     /*******************************************************************************
      * TEXT AND UI METHODS
      * Methods for creating and managing 3D text elements in the scene.
@@ -81,21 +194,31 @@ export declare class RpcSafeClient {
      * @param color - The color of the text
      * @param text - The content to display
      * @returns Promise resolving to the handle of the created text component
-     * @throws {Error} If the text is empty
      */
     RPCCreateText(position: RpcTypes.Vector3, color: RpcTypes.RGBA32, text: string): Promise<number>;
     /**
      * Destroys a text component, removing it from the scene.
      * @param componentHandle - The handle of the text component to destroy
-     * @throws {Error} If the component handle is invalid
      */
     RPCDestroyText(componentHandle: number): void;
     /*******************************************************************************
      * SECTION BOX METHODS
      * Methods for controlling section box visibility and position.
      ******************************************************************************/
+    /**
+     * Enables or disables the section box.
+     * @param enable - True to enable the section box, false to disable it
+     */
     RPCEnableSectionBox(enable: boolean): void;
+    /**
+     * Sets the parameters of the section box.
+     * @param state - The new section box state, including visibility and bounding box
+     */
     RPCSetSectionBox(state: RpcTypes.SectionBoxState): void;
+    /**
+     * Retrieves the current section box state.
+     * @returns Promise resolving to the section box state or undefined on failure
+     */
     RPCGetSectionBox(): Promise<RpcTypes.SectionBoxState | undefined>;
     /*******************************************************************************
      * CAMERA AND VIEW METHODS
@@ -130,58 +253,54 @@ export declare class RpcSafeClient {
     RPCSetCameraTarget(target: RpcTypes.Vector3, blendTime: number): void;
     /**
      * Retrieves the axis-aligned bounding box (AABB) that encompasses the entire scene.
-     * This includes all loaded geometry across all VIM components.
+     * This includes all loaded geometry across all loaded vims.
      *
      * @returns Promise resolving to the global AABB of the scene, or undefined on failure
      */
-    RPCGetAABBForAll(): Promise<RpcTypes.Box3 | undefined>;
+    RPCGetAABBForScene(): Promise<RpcTypes.Box3 | undefined>;
     /**
-     * Retrieves the axis-aligned bounding box (AABB) for a specific VIM component.
-     * This bounding box represents the spatial bounds of all geometry within the given component.
+     * Retrieves the axis-aligned bounding box (AABB) for a specific loaded vim.
+     * This bounding box represents the spatial bounds of all geometry within the given loaded vim.
      *
-     * @param componentHandle - The handle of the VIM component to query
-     * @returns Promise resolving to the component’s bounding box, or undefined on failure
+     * @param vimIndex - The index of the loaded vim to query
+     * @returns Promise resolving to the vim bounding box, or undefined on failure
      */
-    RPCGetAABBForVim(componentHandle: number): Promise<RpcTypes.Box3 | undefined>;
+    RPCGetAABBForVim(vimIndex: number): Promise<RpcTypes.Box3 | undefined>;
     /**
-     * Calculates the bounding box for specified nodes in a component.
-     * Large node arrays are automatically processed in batches for better performance.
-     * @param componentHandle - The component containing the nodes
-     * @param elements - Array of node indices to calculate bounds for
-     * @returns Promise resolving to the combined bounding box
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     * Calculates the bounding box for specified elements of a loaded vim.
+     * Large element arrays are automatically processed in batches.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to calculate bounds for
+     * @returns Promise resolving to the combined bounding box or undefined on failure
      */
-    RPCGetAABBForElements(componentHandle: number, elements: number[]): Promise<RpcTypes.Box3 | undefined>;
+    RPCGetAABBForElements(vimIndex: number, vimElementIndices: number[]): Promise<RpcTypes.Box3 | undefined>;
     private RPCGetAABBForElementsBatched;
     /**
-     * Frames the camera to show all components in the scene.
+     * Frames the camera to show all elements in the scene.
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
      */
-    RPCFrameAll(blendTime: number): Promise<RpcTypes.Segment | undefined>;
+    RPCFrameScene(blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /**
-     * Frames a specific VIM component in the scene.
-     * @param componentHandle - The handle of the VIM component to frame
+     * Frames a specific vim in the scene.
+     * @param vimIndex - The index of the loaded vim to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
-     * @throws {Error} If the component handle is invalid
      */
-    RPCFrameVim(componentHandle: number, blendTime: number): Promise<RpcTypes.Segment | undefined>;
+    RPCFrameVim(vimIndex: number, blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /**
-     * Frames specific instances within a component. For large numbers of instances,
-     * automatically switches to bounding box framing for better performance.
-     * @param componentHandle - The component containing the instances
-     * @param elements - Array of node indices to frame
+     * Frames specific elements of a loaded vim.
+     * Automatically batches large arrays of elements.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
-     * @throws {Error} If the component handle is invalid or nodes array is empty
      */
-    RPCFrameElements(componentHandle: number, elements: number[], blendTime: number): Promise<RpcTypes.Segment | undefined>;
+    RPCFrameElements(vimIndex: number, vimElementIndices: number[], blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /**
      * Frames the camera to show a specific bounding box.
      * @param box - The bounding box to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
-     * @throws {Error} If the box is invalid (min values must be less than max values)
      */
     RPCFrameAABB(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /*******************************************************************************
@@ -191,50 +310,43 @@ export declare class RpcSafeClient {
     /**
      * Sets the camera movement speed.
      * @param speed - The desired movement speed (must be positive)
-     * @throws {Error} If speed is not positive
      */
     RPCSetCameraSpeed(speed: number): void;
+    /**
+     * Sets the camera control mode.
+     * @param mode - The desired input mode (e.g., {@link InputMode.Orbit} or {@link InputMode.Free})
+     */
     RPCSetCameraMode(mode: InputMode): void;
     /**
      * Sets the viewer's aspect ratio.
-     * @param width - The width component of the aspect ratio
-     * @param height - The height component of the aspect ratio
-     * @throws {Error} If width or height are not positive integers
+     * @param width - The width of the desired aspect ratio
+     * @param height - The height of the desired aspect ratio
      */
     RPCSetCameraAspectRatio(width: number, height: number): void;
     /*******************************************************************************
      * VIM FILE MANAGEMENT METHODS
-     * Methods for loading, unloading, and managing VIM files and components.
+     * Methods for loading, unloading, and managing VIM files.
      ******************************************************************************/
     /**
      * Loads a VIM file from the local filesystem.
      * @param source - The path to the VIM file (supports file:// protocol)
-     * @returns Promise resolving to the handle of the loaded VIM component
-     * @throws {Error} If the filename is invalid or empty
+     * @returns Promise resolving to the index of the loaded vim
      */
     RPCLoadVim(source: VimSource): Promise<number>;
     /**
      * Loads a VIM file from a remote URL.
-     * @param url - The URL of the VIM file to load
-     * @returns Promise resolving to the handle of the loaded VIM component
-     * @throws {Error} If the URL is invalid
+     * @param source - The URL or file path of the VIM file to load
+     * @returns Promise resolving to the index of the loaded vim
      */
     RPCLoadVimURL(source: VimSource): Promise<number>;
     /**
-     * Retrieves the current loading state and progress of a VIM component.
-     * @param componentHandle - The handle of the VIM component
+     * Retrieves the current loading state and progress of a vim.
+     * @param vimIndex - The index of the vim being loaded
      * @returns Promise resolving to the current loading state and progress
-     * @throws {Error} If the component handle is invalid
-     */
-    RPCGetVimLoadingState(componentHandle: number): Promise<VimLoadingState>;
-    /**
-     * Unloads a VIM component and frees associated resources.
-     * @param componentHandle - The handle of the component to unload
-     * @throws {Error} If the component handle is invalid
      */
-    RPCUnloadVim(componentHandle: number): void;
+    RPCGetVimLoadingState(vimIndex: number): Promise<VimLoadingState>;
     /**
-     * Clears the entire scene, removing all components and resetting to initial state.
+     * Clears the entire scene, unloading all vims and resetting to initial state.
      */
     RPCUnloadAll(): void;
     /**
@@ -245,7 +357,7 @@ export declare class RpcSafeClient {
     /**
      * Performs hit testing at a specified screen position.
      * @param pos - Normalized screen coordinates (0-1, 0-1)
-     * @returns Promise resolving to hit test result if something was hit, undefined otherwise
+     * @returns Promise resolving to hit test result if a valid hit was detected, undefined otherwise
      */
     RPCPerformHitTest(pos: RpcTypes.Vector2): Promise<RpcTypes.HitCheckResult | undefined>;
     /**
@@ -253,14 +365,12 @@ export declare class RpcSafeClient {
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
      * @param down - True if button is pressed down, false if released
-     * @throws {Error} If mouseButton is not a valid positive integer
      */
     RPCMouseButtonEvent(position: RpcTypes.Vector2, mouseButton: number, down: boolean): void;
     /**
      * Sends a mouse double-click event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
-     * @throws {Error} If mouseButton is not a valid positive integer
      */
     RPCMouseDoubleClickEvent(position: RpcTypes.Vector2, mouseButton: number): void;
     /**
@@ -277,7 +387,6 @@ export declare class RpcSafeClient {
      * Sends a mouse selection event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
-     * @throws {Error} If mouseButton is not a valid positive integer
      */
     RPCMouseSelectEvent(position: RpcTypes.Vector2, mouseButton: number): void;
     /**
@@ -297,32 +406,27 @@ export declare class RpcSafeClient {
      * @param smoothness - The smoothness value to apply (clamped between 0 and 1)
      * @param colors - Array of colors for each material instance
      * @returns Array of handles for the created material instances
-     * @throws {Error} If the material handle is invalid or smoothness is out of range
      */
     RPCCreateMaterialInstances(materialHandle: MaterialHandle, smoothness: number, colors: RpcTypes.RGBA32[]): Promise<number[] | undefined>;
     private createMaterialInstancesBatched;
     /**
      * Destroys multiple material instances, freeing associated resources.
-     * @param materialInstanceHandle - Array of handles for material instances to destroy
-     * @throws {Error} If any handle in the array is invalid
+     * @param materialInstanceHandles - Array of handles for material instances to destroy
      */
-    RPCDestroyMaterialInstances(materialInstanceHandle: number[]): void;
+    RPCDestroyMaterialInstances(materialInstanceHandles: number[]): void;
     /**
-     * Sets material overrides for specific nodes in a component.
-     * Large arrays are automatically processed in batches for better performance.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices to override
-     * @param materialInstanceHandles - Array of material instance handles to apply (must match nodes length)
-     * @throws {Error} If arrays have different lengths or any handle is invalid
+     * Sets material overrides for specific elements in a loaded vim.
+     * Large arrays are automatically processed in batches.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to override
+     * @param materialInstanceHandles - Array of material instance handles to apply (must match element length)
      */
-    RPCSetMaterialOverrides(componentHandle: number, nodes: number[], materialInstanceHandles: number[]): void;
+    RPCSetMaterialOverridesForElements(vimIndex: number, vimElementIndices: number[], materialInstanceHandles: number[]): void;
     private setMaterialOverridesBatched;
     /**
-     * Clears all material overrides for the specified component, restoring default materials.
-     * @param componentHandle - The unique identifier of the component
-     * @throws {Error} If the component handle is invalid or INVALID_HANDLE
+     * Clears all material overrides for the entire scene.
      */
-    RPCClearMaterialOverrides(componentHandle: number): void;
+    RPCClearMaterialOverrides(): void;
     /*******************************************************************************
      * DEBUG AND UTILITY METHODS
      * Utility methods for debugging, error handling, and misc functionality.

package/dist/types/core-viewers/ultra/rpcTypes.d.ts

@@ -50,9 +50,9 @@ export declare class RGBA32 {
     get a(): number;
 }
 export type HitCheckResult = {
-    vimHandle: number;
-    nodeIndex: number;
-    elementIndex: number;
+    vimIndex: number;
+    vimElementIndex: number;
+    sceneElementIndex: number;
     worldPosition: THREE.Vector3;
     worldNormal: THREE.Vector3;
 };

package/dist/types/core-viewers/ultra/viewer.d.ts

@@ -126,6 +126,7 @@ export declare class Viewer {
      * Clears all loaded VIMs from the viewer.
      */
     clearVims(): void;
+    getElement3Ds(): Promise<number>;
     /**
      * Disposes all resources used by the viewer and disconnects from the server.
      */

package/dist/types/core-viewers/ultra/vim.d.ts

@@ -3,7 +3,7 @@ import type { ILogger } from './logger';
 import { ColorManager } from './colorManager';
 import { Element3D } from './element3d';
 import { LoadRequest } from './loadRequest';
-import { StateSynchronizer } from './visibility';
+import { VisibilitySynchronizer } from './visibility';
 import { Renderer } from './renderer';
 import { RpcSafeClient, VimSource } from './rpcSafeClient';
 import * as THREE from 'three';
@@ -16,10 +16,11 @@ export declare class Vim implements IVim<Element3D> {
     private _colors;
     private _renderer;
     private _logger;
-    readonly visibility: StateSynchronizer;
+    readonly visibility: VisibilitySynchronizer;
     private _nodeColors;
     private _updatedColors;
     private _updateScheduled;
+    private _elementCount;
     private _objects;
     constructor(rpc: RpcSafeClient, color: ColorManager, renderer: Renderer, source: VimSource, logger: ILogger);
     getElement(elementIndex: number): Element3D;
@@ -40,7 +41,7 @@ export declare class Vim implements IVim<Element3D> {
     setColor(nodes: number[], color: RGBA32 | undefined): Promise<void>;
     setColors(nodes: number[], color: (RGBA32 | undefined)[]): Promise<void>;
     private applyColor;
-    clearColor(nodes: number[] | 'all'): void;
+    clearColor(elements: number[] | 'all'): void;
     reapplyColors(): void;
     private scheduleColorUpdate;
     private updateRemote;

package/dist/types/core-viewers/ultra/visibility.d.ts

@@ -14,7 +14,7 @@ export declare enum VisibilityState {
  * A class that wraps a StateTracker and is responsible for synchronizing its state updates with the remote RPCs.
  * It batches updates to optimize performance and handles the communication with the remote system.
  */
-export declare class StateSynchronizer {
+export declare class VisibilitySynchronizer {
     private _tracker;
     private _rpc;
     private _getHandle;
@@ -64,7 +64,7 @@ export declare class StateSynchronizer {
      * @param elementIndex - The element index to update
      * @param state - The new state to apply
      */
-    setElementState(elementIndex: number, state: VisibilityState): void;
+    setStateForElement(elementIndex: number, state: VisibilityState): void;
     /**
      * Sets the state of all elements to the specified value.
      *

package/dist/types/utils/validation.d.ts

@@ -7,8 +7,8 @@ export declare class Validation {
     static isPositiveInteger(value: number): boolean;
     static isInRange01(value: number): boolean;
     static areIntegers(values: number[]): boolean;
-    static isComponentHandle(handle: number): boolean;
-    static areComponentHandles(handles: number[]): boolean;
+    static isIndex(index: number): boolean;
+    static areIndices(indices: number[]): boolean;
     static isMaterialHandle(handle: number): boolean;
     static isValidVector2(value: THREE.Vector2): boolean;
     static isRelativeVector2(value: THREE.Vector2): boolean;