vim-web 0.4.1 → 0.5.0-dev.1

package/README.md

@@ -1,41 +1,35 @@
-# VIM WebGL Component
+# VIM Web
+
+## Live Demo
+
+Visit our [Demo page](https://vimaec.github.io/vim-web-demo)
 
 ### Documentation
 
-Explore the full [API Documentation](https://vimaec.github.io/vim-web/api/).
+Explore the full [API Documentation](https://vimaec.github.io/vim-web).
 
 ### Package
 https://www.npmjs.com/package/vim-web
 
-## Live Demo
-
-### WebGL Viewer
-- **[Small - Residence](https://vimaec.github.io/vim-web/webgl)**
-- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/webgl?vim=https://storage.cdn.vimaec.com/samples/Medical_Tower.vim)**
-
-### Ultra Viewer
-- **[Small - Residence](https://vimaec.github.io/vim-web/ultra)**
-- **[Medium - Medical Tower](https://vimaec.github.io/vim-web/ultra?vim=https://storage.cdn.vimaec.com/samples/Medical_Tower.vim)**
-
-Find detailed camera controls here: [Camera Controls](https://docs.vimaec.com/docs/vim-cloud/webgl-navigation-and-controls-guide).
 
 ## Overview
 
 The **VIM-Web** repository consists of four primary components, divided into two layers:
 
 ### Core Viewers
-- **WebGL Viewer:** A WebGL-based viewer for the VIM format. Includes features like outlines, ghosting, and sectioning, but without UI components.
-- **Ultra Viewer:** A high-performance viewer for the VIM Ultra Render Server, optimized for scale and speed.
+- **WebGL Core Viewer:** A WebGL-based viewer for the VIM format. Includes features like outlines, ghosting, and sectioning, but without UI components.
+- **Ultra Core Viewer:** A high-performance viewer for the VIM Ultra Render Server, optimized for scale and speed.
 
 ### React Viewers
-- **WebGL Component:** A React-based wrapper for the WebGL viewer, providing interactive UI elements and a BIM explorer.
-- **Ultra Component:** A React-based wrapper for the Ultra viewer, featuring a UI for real-time interactions.
+- **WebGL Viewer:** A React-based wrapper for the WebGL viewer, providing interactive UI elements and a BIM explorer.
+- **Ultra Viewer:** A React-based wrapper for the Ultra viewer, featuring a UI for real-time interactions.
 
 ## VIM Format
 
 The **VIM** file format is a high-performance 3D scene format that supports rich BIM data. It can also be extended to accommodate other relational and non-relational datasets. Unlike **IFC**, the VIM format is pre-tessellated, allowing for rapid loading and rendering.
 
-Learn more about the VIM format here: [VIM GitHub Repository](https://github.com/vimaec/vim).
+Learn more about the VIM format here: [VIM Format Repository](https://github.com/vimaec/vim-format)
+).
 
 ### Built With
 - [VIM WebGL Viewer](https://github.com/vimaec/vim-webgl-viewer)

package/dist/style.css

@@ -709,9 +709,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-left-0 {
   left: 0px;
 }
-.vc-left-1\/2 {
-  left: 50%;
-}
 .vc-left-4 {
   left: 1rem;
 }
@@ -733,9 +730,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-top-1 {
   top: 0.25rem;
 }
-.vc-top-10 {
-  top: 2.5rem;
-}
 .vc-top-4 {
   top: 1rem;
 }
@@ -745,9 +739,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-top-\[10\%\] {
   top: 10%;
 }
-.vc-top-\[150px\] {
-  top: 150px;
-}
 .vc-top-\[20px\] {
   top: 20px;
 }
@@ -855,9 +846,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-hidden {
   display: none;
 }
-.vc-h-1\/2 {
-  height: 50%;
-}
 .vc-h-2 {
   height: 0.5rem;
 }
@@ -945,10 +933,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-shrink-0 {
   flex-shrink: 0;
 }
-.vc--translate-x-1\/2 {
-  --tw-translate-x: -50%;
-  transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
-}
 .vc-rotate-0 {
   --tw-rotate: 0deg;
   transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
@@ -992,9 +976,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-justify-evenly {
   justify-content: space-evenly;
 }
-.vc-gap-1 {
-  gap: 0.25rem;
-}
 .vc-gap-2 {
   gap: 0.5rem;
 }
@@ -1139,9 +1120,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-p-1 {
   padding: 0.25rem;
 }
-.vc-p-4 {
-  padding: 1rem;
-}
 .vc-p-5 {
   padding: 1.25rem;
 }
@@ -1215,9 +1193,6 @@ video:where(.vim-component,.vim-component *) {
 .vc-font-bold {
   font-weight: 700;
 }
-.vc-font-medium {
-  font-weight: 500;
-}
 .vc-font-normal {
   font-weight: 400;
 }

package/dist/types/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/{core-viewers → vim-web/core-viewers}/shared/vim.d.ts

@@ -22,7 +22,7 @@ export interface IVim<T extends IVimElement> {
      * @param instance - The instance index of the of one of the instance included in the element.
      * @returns The object corresponding to the instance, or undefined if not found.
      */
-    getElementFromInstanceIndex(instance: number): T | undefined;
+    getElement(instance: number): T | undefined;
     /**
      * Retrieves the element associated with the specified id.
      * @param id - The element ID to retrieve objects for.

package/dist/types/{core-viewers → vim-web/core-viewers}/ultra/element3d.d.ts

@@ -1,5 +1,5 @@
 import { IVimElement } from "../shared/vim";
-import { NodeState } from "./nodeState";
+import { VisibilityState } from "./visibility";
 import { Box3, RGBA32 } from "./rpcTypes";
 import { Vim } from "./vim";
 /**
@@ -14,7 +14,7 @@ export declare class Element3D implements IVimElement {
     /**
      * The internal instance index within the `Vim` model.
      */
-    readonly instance: number;
+    readonly element: number;
     /**
      * The unique handle of the parent `Vim` model.
      */
@@ -22,14 +22,14 @@ export declare class Element3D implements IVimElement {
     /**
      * Creates a new `Element3D` instance.
      * @param vim - The parent `Vim` model.
-     * @param instance - The internal instance index.
+     * @param element - The internal instance index.
      */
-    constructor(vim: Vim, instance: number);
+    constructor(vim: Vim, element: number);
     /**
      * Gets or sets the display state of the element (e.g., visible, hidden).
      */
-    get state(): NodeState;
-    set state(state: NodeState);
+    get state(): VisibilityState;
+    set state(state: VisibilityState);
     /**
      * Gets or sets the color override of the element.
      */

package/dist/types/{core-viewers → vim-web/core-viewers}/ultra/index.d.ts

@@ -2,12 +2,12 @@ import "./style.css";
 export * from './viewer';
 export { RGB, RGBA, RGBA32, Segment, type SectionBoxState, type HitCheckResult, type VimStatus } from './rpcTypes';
 export { materialHandles, MaterialHandles, type MaterialHandle, } from './rpcClient';
-export { NodeState } from './nodeState';
 export { InputMode, VimLoadingStatus } from './rpcSafeClient';
+export { VisibilityState } from './visibility';
 export type * from './camera';
 export type * from './colorManager';
 export type * from './decoder';
-export type * from './nodeState';
+export type * from './visibility';
 export type * from './element3d';
 export type * from './inputAdapter';
 export type * from './loadRequest';

package/dist/types/{core-viewers → vim-web/core-viewers}/ultra/renderer.d.ts

@@ -8,8 +8,6 @@ import { ClientStreamError } from "./socketClient";
  * Render settings that extend SceneSettings with additional rendering-specific properties
  */
 export type RenderSettings = SceneSettings & {
-    /** Whether to lock the Image-Based Lighting rotation */
-    lockIblRotation: boolean;
     /** Color used for ghost/transparent rendering */
     ghostColor: RGBA;
 };
@@ -23,7 +21,6 @@ export declare const defaultRenderSettings: RenderSettings;
 export interface IRenderer {
     onSceneUpdated: ISignal;
     ghostColor: RGBA;
-    lockIblRotation: boolean;
     hdrScale: number;
     toneMappingWhitePoint: number;
     hdrBackgroundScale: number;
@@ -42,7 +39,6 @@ export declare class Renderer implements IRenderer {
     private _animationFrame;
     private _updateLighting;
     private _updateGhostColor;
-    private _updateIblRotation;
     private readonly _onSceneUpdated;
     get onSceneUpdated(): ISignal;
     /**
@@ -67,11 +63,6 @@ export declare class Renderer implements IRenderer {
      * @returns Current ghost color as RGBA
      */
     get ghostColor(): RGBA;
-    /**
-     * Gets the IBL rotation lock setting
-     * @returns Whether IBL rotation is locked
-     */
-    get lockIblRotation(): boolean;
     /**
      * Gets the tone mapping white point value
      * @returns Current tone mapping white point
@@ -107,11 +98,6 @@ export declare class Renderer implements IRenderer {
      * @param value - New ghost color as RGBA
      */
     set ghostColor(value: RGBA);
-    /**
-     * Updates the IBL rotation lock setting
-     * @param value - Whether to lock IBL rotation
-     */
-    set lockIblRotation(value: boolean);
     /**
      * Sets the tone mapping white point value
      * @param value - New tone mapping white point value

package/dist/types/{core-viewers → vim-web/core-viewers}/ultra/rpcClient.d.ts

@@ -13,69 +13,71 @@ export declare class MaterialHandles {
     static readonly Highlight: MaterialHandle;
     static readonly Invisible: MaterialHandle;
 }
+export type VisibilityState = 0 | 1 | 2 | 3 | 16;
+export declare class VisibilityStates {
+    static readonly Visible: VisibilityState;
+    static readonly Hidden: VisibilityState;
+    static readonly Ghosted: VisibilityState;
+    static readonly Highlighted: VisibilityState;
+}
+export type RenderingMode = 0 | 1;
+export declare class RenderingModes {
+    static readonly Standard: RenderingMode;
+    static readonly FlatShaded: RenderingMode;
+}
 export declare const materialHandles: MaterialHandle[];
 export declare class RpcClient {
     private readonly _socket;
     get connected(): boolean;
     get url(): string;
     constructor(_socket: SocketClient);
-    readonly API_VERSION = "5.1.0";
-    RPCAddNodeFlags(componentHandle: number, nodes: number[], flags: number): void;
+    readonly API_VERSION = "6.0.0";
     RPCClearMaterialOverrides(componentHandle: number): void;
-    RPCClearScene(): 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;
     RPCDestroyText(componentHandle: number): void;
     RPCEnableSectionBox(value: boolean): void;
+    RPCFrameAABB(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment>;
     RPCFrameAll(blendTime: number): Promise<RpcTypes.Segment>;
-    RPCFrameBox(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment>;
-    RPCFrameInstances(componentHandle: number, nodes: number[], 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>;
     RPCGetAPIVersion(): Promise<string>;
-    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<RpcTypes.Box3>;
-    RPCGetBoundingBoxAll(componentHandle: number): Promise<RpcTypes.Box3>;
-    RPCGetCameraPosition(): Promise<RpcTypes.Segment>;
-    RPCGetIblRotation(): Promise<RpcTypes.Matrix44>;
+    RPCGetCameraView(): Promise<RpcTypes.Segment>;
+    RPCGetElementCount(componentHandle: number): Promise<number>;
+    RPCGetElementIds(componentHandle: number): Promise<bigint[]>;
     RPCGetLastError(): Promise<string>;
-    RPCGetSceneAABB(): Promise<RpcTypes.Box3>;
+    RPCGetRoomElements(componentHandle: number): Promise<number[]>;
     RPCGetSectionBox(): Promise<RpcTypes.SectionBoxState>;
     RPCGetVimLoadingState(componentHandle: number): Promise<RpcTypes.VimStatus>;
-    RPCGhost(componentHandle: number, nodes: number[]): void;
-    RPCGhostAll(componentHandle: number): void;
-    RPCHide(componentHandle: number, nodes: number[]): void;
-    RPCHideAABBs(componentHandle: number, nodes: number[]): void;
-    RPCHideAll(componentHandle: number): void;
-    RPCHideAllAABBs(componentHandle: number): void;
-    RPCHighlight(componentHandle: number, nodes: number[]): void;
-    RPCHighlightAll(componentHandle: number): void;
     RPCKeyEvent(keyCode: number, down: boolean): void;
     RPCLoadVim(fileName: string): Promise<number>;
     RPCLoadVimURL(url: string, authToken: string): Promise<number>;
-    RPCLockIblRotation(lock: boolean): void;
     RPCMouseButtonEvent(mousePos: RpcTypes.Vector2, mouseButton: number, down: boolean): void;
     RPCMouseDoubleClickEvent(mousePos: RpcTypes.Vector2, mouseButton: number): void;
     RPCMouseMoveEvent(mousePos: RpcTypes.Vector2): void;
     RPCMouseScrollEvent(scrollValue: number): void;
     RPCMouseSelectEvent(mousePos: RpcTypes.Vector2, mouseButton: number): void;
-    RPCMoveCameraTo(usePosition: boolean, useTarget: boolean, position: RpcTypes.Vector3, target: RpcTypes.Vector3, blendTime: number): void;
     RPCPauseRendering(pause: boolean): void;
     RPCPerformHitTest(pos: RpcTypes.Vector2): Promise<RpcTypes.HitCheckResult>;
-    RPCRemoveNodeFlags(componentHandle: number, nodes: number[], flags: number): void;
-    RPCSetAspectRatio(width: number, height: number): void;
+    RPCSetCameraAspectRatio(width: number, height: number): void;
     RPCSetCameraMode(orbit: boolean): void;
-    RPCSetCameraPosition(state: RpcTypes.Segment, blendTime: number): void;
+    RPCSetCameraPosition(position: RpcTypes.Vector3, blendTime: number): void;
+    RPCSetCameraSpeed(speed: number): void;
+    RPCSetCameraTarget(target: RpcTypes.Vector3, blendTime: number): void;
+    RPCSetCameraView(state: RpcTypes.Segment, blendTime: number): void;
     RPCSetGhostColor(ghostColor: RpcTypes.RGBA): void;
-    RPCSetGhostColor2(ghostColor: RpcTypes.RGBA): void;
-    RPCSetIblRotation(transform: RpcTypes.Matrix44): void;
     RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): void;
-    RPCSetMaterialOverrides(componentHandle: number, nodes: number[], materialInstanceHandles: number[]): void;
-    RPCSetMoveSpeed(speed: number): void;
+    RPCSetMaterialOverrides(componentHandle: number, elementIndices: number[], materialInstanceHandles: number[]): void;
     RPCSetSectionBox(state: RpcTypes.SectionBoxState): void;
-    RPCShow(componentHandle: number, nodes: number[]): void;
-    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RpcTypes.RGBA32[]): void;
-    RPCShowAll(componentHandle: number): void;
+    RPCSetStateVim(componentHandle: number, state: number): void;
+    RPCSetStateElements(componentHandle: number, elementIndices: number[], state: number): void;
+    RPCSetStatesElements(componentHandle: 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 → vim-web/core-viewers}/ultra/rpcMarshal.d.ts

@@ -40,6 +40,7 @@ export declare class ReadMarshal {
     readMatrix44(): RpcTypes.Matrix44;
     readInt(): number;
     readUInt(): number;
+    readUInt64(): bigint;
     readFloat(): number;
     readBoolean(): boolean;
     readString(): string;
@@ -55,6 +56,7 @@ export declare class ReadMarshal {
     readSectionBoxState(): RpcTypes.SectionBoxState;
     readArrayOfInt(): number[];
     readArrayOfUInt(): number[];
+    readArrayOfUInt64(): bigint[];
     readArrayOfFloat(): number[];
     readArrayOfBool(): boolean[];
     readArrayOfRGBA32(): RpcTypes.RGBA32[];

package/dist/types/{core-viewers → vim-web/core-viewers}/ultra/rpcSafeClient.d.ts

@@ -1,5 +1,6 @@
 import * as RpcTypes from "./rpcTypes";
 import { MaterialHandle, RpcClient } from "./rpcClient";
+import { VisibilityState } from "./visibility";
 export type VimSource = {
     url: string;
     authToken?: string;
@@ -55,61 +56,11 @@ export declare class RpcSafeClient {
      * @param settings - The lighting settings to apply
      */
     RPCSetLighting(settings: SceneSettings): void;
-    RPCLockIblRotation(lock: boolean): void;
-    RPCGetSceneAABB(): Promise<RpcTypes.Box3 | undefined>;
     /*******************************************************************************
      * NODE VISIBILITY METHODS
      * Methods for controlling node visibility, including show/hide, ghosting,
      * and highlighting functionality.
      ******************************************************************************/
-    /**
-     * Hides all nodes in a component, making the entire component invisible.
-     * @param componentHandle - The component to hide entirely
-     * @throws {Error} If the component handle is invalid
-     */
-    RPCHideAll(componentHandle: number): void;
-    /**
-     * Shows all nodes in a component, making the entire component visible.
-     * @param componentHandle - The component to show entirely
-     * @throws {Error} If the component handle is invalid
-     */
-    RPCShowAll(componentHandle: number): void;
-    /**
-     * Makes all nodes in a component semi-transparent (ghosted).
-     * @param componentHandle - The component to ghost entirely
-     * @throws {Error} If the component handle is invalid
-     */
-    RPCGhostAll(componentHandle: number): void;
-    /**
-     * Highlights all nodes in a component.
-     * @param componentHandle - The component to highlight entirely
-     * @throws {Error} If the component handle is invalid
-     */
-    RPCHighlightAll(componentHandle: number): void;
-    /**
-     * Hides specified nodes in a component, making them invisible.
-     * Large node arrays are automatically processed in batches.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices to hide
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
-     */
-    RPCHide(componentHandle: number, nodes: number[]): void;
-    /**
-     * Shows specified nodes in a component, making them visible.
-     * Large node arrays are automatically processed in batches.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices to show
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
-     */
-    RPCShow(componentHandle: number, nodes: number[]): void;
-    /**
-     * Makes specified nodes semi-transparent (ghosted) 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 ghost
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
-     */
-    RPCGhost(componentHandle: number, nodes: number[]): void;
     /**
      * Highlights specified nodes in a component.
      * Large node arrays are automatically processed in batches.
@@ -117,7 +68,9 @@ export declare class RpcSafeClient {
      * @param nodes - Array of node indices to highlight
      * @throws {Error} If the component handle is invalid or nodes array is invalid
      */
-    RPCHighlight(componentHandle: number, nodes: number[]): void;
+    RPCSetStateElements(componentHandle: number, elements: number[], state: VisibilityState): void;
+    RPCSetStatesElements(componentHandle: number, elements: number[], states: VisibilityState[]): void;
+    RPCSetStateVim(componentHandle: number, state: VisibilityState): void;
     /*******************************************************************************
      * TEXT AND UI METHODS
      * Methods for creating and managing 3D text elements in the scene.
@@ -152,25 +105,54 @@ export declare class RpcSafeClient {
      * Retrieves the current camera position and orientation.
      * @returns Promise resolving to a segment representing the camera's current position and target
      */
-    RPCGetCameraPosition(): Promise<RpcTypes.Segment | undefined>;
+    RPCGetCameraView(): Promise<RpcTypes.Segment | undefined>;
     /**
      * Sets the camera position and orientation.
      * @param segment - The desired camera position and target
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
-     * @throws {Error} If segment is invalid or blendTime is negative
      */
-    RPCSetCameraPosition(segment: RpcTypes.Segment, blendTime: number): void;
-    RPCGetBoundingBoxAll(componentHandle: number): Promise<RpcTypes.Box3 | undefined>;
+    RPCSetCameraView(segment: RpcTypes.Segment, blendTime: number): void;
+    /**
+     * Sets the camera's position without changing its target.
+     * The camera will move to the specified position while maintaining its current look-at direction.
+     *
+     * @param position - The new position of the camera in world space
+     * @param blendTime - Duration of the camera transition in seconds (non-negative)
+     */
+    RPCSetCameraPosition(position: RpcTypes.Vector3, blendTime: number): void;
+    /**
+     * Sets the camera's look-at target without changing its position.
+     * The camera will rotate to face the specified target while remaining at its current position.
+     *
+     * @param target - The new look-at target of the camera in world space
+     * @param blendTime - Duration of the camera transition in seconds (non-negative)
+     */
+    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.
+     *
+     * @returns Promise resolving to the global AABB of the scene, or undefined on failure
+     */
+    RPCGetAABBForAll(): 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.
+     *
+     * @param componentHandle - The handle of the VIM component to query
+     * @returns Promise resolving to the component’s bounding box, or undefined on failure
+     */
+    RPCGetAABBForVim(componentHandle: 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 nodes - Array of node indices to calculate bounds for
+     * @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
      */
-    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<RpcTypes.Box3 | undefined>;
-    private getBoundingBoxBatched;
+    RPCGetAABBForElements(componentHandle: number, elements: number[]): Promise<RpcTypes.Box3 | undefined>;
+    private RPCGetAABBForElementsBatched;
     /**
      * Frames the camera to show all components in the scene.
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
@@ -189,19 +171,19 @@ export declare class RpcSafeClient {
      * 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 nodes - Array of node indices to frame
+     * @param elements - Array of node 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
      */
-    RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<RpcTypes.Segment | undefined>;
+    RPCFrameElements(componentHandle: number, elements: 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)
      */
-    RPCFrameBox(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment | undefined>;
+    RPCFrameAABB(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /*******************************************************************************
      * INPUT HANDLING METHODS
      * Methods for handling user input including mouse, keyboard, and camera controls.
@@ -211,7 +193,7 @@ export declare class RpcSafeClient {
      * @param speed - The desired movement speed (must be positive)
      * @throws {Error} If speed is not positive
      */
-    RPCSetMoveSpeed(speed: number): void;
+    RPCSetCameraSpeed(speed: number): void;
     RPCSetCameraMode(mode: InputMode): void;
     /**
      * Sets the viewer's aspect ratio.
@@ -219,7 +201,7 @@ export declare class RpcSafeClient {
      * @param height - The height component of the aspect ratio
      * @throws {Error} If width or height are not positive integers
      */
-    RPCSetAspectRatio(width: number, height: number): void;
+    RPCSetCameraAspectRatio(width: number, height: number): void;
     /*******************************************************************************
      * VIM FILE MANAGEMENT METHODS
      * Methods for loading, unloading, and managing VIM files and components.
@@ -254,7 +236,7 @@ export declare class RpcSafeClient {
     /**
      * Clears the entire scene, removing all components and resetting to initial state.
      */
-    RPCClearScene(): void;
+    RPCUnloadAll(): void;
     /**
      * Sets the color used for ghosted geometry.
      * @param ghostColor - The RGBA color to use for ghosted elements
@@ -369,28 +351,5 @@ export declare class RpcSafeClient {
      * Triggers a RenderDoc frame capture if RenderDoc is attached.
      */
     RPCTriggerRenderDocCapture(): void;
-    /**
-     * Shows axis-aligned bounding boxes (AABBs) for specified nodes with custom colors.
-     * Large arrays are automatically processed in batches for better performance.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices to show AABBs for
-     * @param colors - Array of colors for each AABB (must match nodes length)
-     * @throws {Error} If arrays have different lengths or component handle is invalid
-     */
-    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RpcTypes.RGBA32[]): void;
-    /**
-     * Hides the axis-aligned bounding boxes (AABBs) for specified nodes.
-     * Large node arrays are automatically processed in batches.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices whose AABBs should be hidden
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
-     */
-    RPCHideAABBs(componentHandle: number, nodes: number[]): void;
-    /**
-     * Hides all axis-aligned bounding boxes (AABBs) in a component.
-     * @param componentHandle - The component whose AABBs should be hidden
-     * @throws {Error} If the component handle is invalid
-     */
-    RPCHideAllAABBs(componentHandle: number): void;
     private safeCall;
 }

package/dist/types/{core-viewers → vim-web/core-viewers}/ultra/rpcTypes.d.ts

@@ -52,6 +52,7 @@ export declare class RGBA32 {
 export type HitCheckResult = {
     vimHandle: number;
     nodeIndex: number;
+    elementIndex: number;
     worldPosition: THREE.Vector3;
     worldNormal: THREE.Vector3;
 };

package/dist/types/{core-viewers → vim-web/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 './nodeState';
+import { StateSynchronizer } from './visibility';
 import { Renderer } from './renderer';
 import { RpcSafeClient, VimSource } from './rpcSafeClient';
 import * as THREE from 'three';
@@ -16,13 +16,13 @@ export declare class Vim implements IVim<Element3D> {
     private _colors;
     private _renderer;
     private _logger;
-    readonly nodeState: StateSynchronizer;
+    readonly visibility: StateSynchronizer;
     private _nodeColors;
     private _updatedColors;
     private _updateScheduled;
     private _objects;
     constructor(rpc: RpcSafeClient, color: ColorManager, renderer: Renderer, source: VimSource, logger: ILogger);
-    getElementFromInstanceIndex(instance: number): Element3D;
+    getElement(elementIndex: number): Element3D;
     getElementsFromId(id: number): Element3D[];
     getElementFromIndex(element: number): Element3D;
     getObjectsInBox(box: THREE.Box3): Element3D[];