vim-web 0.4.1 → 0.5.0-dev.1

package/dist/vim-web.js

@@ -45272,7 +45272,7 @@ class InsertableSubmesh {
    * Returns vim object for this submesh.
    */
   get object() {
-    return this.mesh.vim.getElementFromInstanceIndex(this.instance);
+    return this.mesh.vim.getElement(this.instance);
   }
   saveColors(colors) {
     if (this._colors) return;
@@ -46853,7 +46853,7 @@ let Vim$1 = class Vim {
    * @param {number} instance - The instance number of the object.
    * @returns {THREE.Object3D | undefined} The object corresponding to the instance, or undefined if not found.
    */
-  getElementFromInstanceIndex(instance) {
+  getElement(instance) {
     const element = this.map.getElementFromInstance(instance);
     if (element === void 0) return;
     return this.getElementFromIndex(element);
@@ -46906,7 +46906,7 @@ let Vim$1 = class Vim {
     const count = subset.getInstanceCount();
     for (let i = 0; i < count; i++) {
       const instance = subset.getVimInstance(i);
-      const obj = this.getElementFromInstanceIndex(instance);
+      const obj = this.getElement(instance);
       if (!set3.has(obj)) {
         result.push(obj);
         set3.add(obj);
@@ -47267,7 +47267,7 @@ class Scene2 {
     this._instanceToMeshes.set(submesh.instance, meshes);
     this.setDirty();
     if (this.vim) {
-      const obj = this.vim.getElementFromInstanceIndex(submesh.instance);
+      const obj = this.vim.getElement(submesh.instance);
       obj._addMesh(submesh);
     }
   }
@@ -48898,7 +48898,7 @@ class InstancedSubmesh {
    * Returns vim object for this submesh.
    */
   get object() {
-    return this.mesh.vim.getElementFromInstanceIndex(this.instance);
+    return this.mesh.vim.getElement(this.instance);
   }
 }
 class InstancedMesh2 {
@@ -57483,14 +57483,14 @@ class Camera3 {
    * @param segment - Optional segment to save as the camera position
    */
   async save(segment) {
-    this._savedPosition = segment ?? await this._rpc.RPCGetCameraPosition();
+    this._savedPosition = segment ?? await this._rpc.RPCGetCameraView();
   }
   /**
    * Resets the camera to the last saved position
    */
   restoreSavedPosition(blendTime = this._defaultBlendTime) {
     if (!this._savedPosition) return;
-    this._rpc.RPCSetCameraPosition(this._savedPosition, blendTime);
+    this._rpc.RPCSetCameraView(this._savedPosition, blendTime);
   }
   /**
    * Restores the camera to its last tracked position
@@ -57500,7 +57500,7 @@ class Camera3 {
     var _a3;
     if ((_a3 = this._lastPosition) == null ? void 0 : _a3.isValid()) {
       console.log("Restoring camera position: ", this._lastPosition);
-      this._rpc.RPCSetCameraPosition(this._lastPosition, blendTime);
+      this._rpc.RPCSetCameraView(this._lastPosition, blendTime);
     }
   }
   /**
@@ -57514,7 +57514,7 @@ class Camera3 {
     this._lastPosition = pose;
   }
   set(position, target, blendTime = this._defaultBlendTime) {
-    this._rpc.RPCSetCameraPosition(new Segment(position, target), blendTime);
+    this._rpc.RPCSetCameraView(new Segment(position, target), blendTime);
   }
   /**
    * Pauses or resumes rendering
@@ -57539,7 +57539,7 @@ class Camera3 {
    * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
    */
   async frameBox(box, blendTime = this._defaultBlendTime) {
-    const segment = await this._rpc.RPCFrameBox(box, blendTime);
+    const segment = await this._rpc.RPCFrameAABB(box, blendTime);
     this._savedPosition = this._savedPosition ?? segment;
     return segment;
   }
@@ -57555,13 +57555,13 @@ class Camera3 {
     if (nodes === "all") {
       segment = await this._rpc.RPCFrameVim(vim.handle, blendTime);
     } else {
-      segment = await this._rpc.RPCFrameInstances(vim.handle, nodes, blendTime);
+      segment = await this._rpc.RPCFrameElements(vim.handle, nodes, blendTime);
     }
     this._savedPosition = this._savedPosition ?? segment;
     return segment;
   }
   async frameObject(object, blendTime = this._defaultBlendTime) {
-    const segment = await this._rpc.RPCFrameInstances(object.vim.handle, [object.instance], blendTime);
+    const segment = await this._rpc.RPCFrameElements(object.vim.handle, [object.element], blendTime);
     this._savedPosition = this._savedPosition ?? segment;
     return segment;
   }
@@ -57637,9 +57637,10 @@ class Marshal {
   }
   // -------------------- HitCheckResult -------------------
   writeHitCheckResult(data2) {
-    this.ensureCapacity(4 + 4 + 4 * 3 + 4 * 3);
+    this.ensureCapacity(4 + 4 + 4 + 4 * 3 + 4 * 3);
     this.writeUInt(data2.vimHandle);
     this.writeUInt(data2.nodeIndex);
+    this.writeUInt(data2.elementIndex);
     this.writeVector3(data2.worldPosition);
     this.writeVector3(data2.worldNormal);
   }
@@ -57763,6 +57764,12 @@ class ReadMarshal {
     this._offset += 4;
     return value;
   }
+  //TODO: Maybe wrong
+  readUInt64() {
+    const low = this.readUInt();
+    const high = this.readUInt();
+    return BigInt(high) << 32n | BigInt(low);
+  }
   readFloat() {
     const value = this._dataView.getFloat32(this._offset, true);
     this._offset += 4;
@@ -57783,11 +57790,13 @@ class ReadMarshal {
   readHitCheckResult() {
     const vimHandle = this.readUInt();
     const nodeIndex = this.readUInt();
+    const mElementIndex = this.readUInt();
     const worldPosition = this.readVector3();
     const worldNormal = this.readVector3();
     return {
       vimHandle,
       nodeIndex,
+      elementIndex: mElementIndex,
       worldPosition,
       worldNormal
     };
@@ -57856,6 +57865,14 @@ class ReadMarshal {
   readArrayOfUInt() {
     return this.readArray(() => this.readUInt());
   }
+  readArrayOfUInt64() {
+    const length = this.readUInt();
+    const array = [];
+    for (let i = 0; i < length; i++) {
+      array.push(this.readUInt64());
+    }
+    return array;
+  }
   readArrayOfFloat() {
     return this.readArray(() => this.readFloat());
   }
@@ -57902,7 +57919,7 @@ class RpcClient {
   constructor(_socket) {
     __publicField(this, "_socket");
     // RPC Generated Code
-    __publicField(this, "API_VERSION", "5.1.0");
+    __publicField(this, "API_VERSION", "6.0.0");
     this._socket = _socket;
   }
   get connected() {
@@ -57911,25 +57928,12 @@ class RpcClient {
   get url() {
     return this._socket.url;
   }
-  RPCAddNodeFlags(componentHandle, nodes, flags) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCAddNodeFlags");
-    marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
-    marshal.writeUInt(flags);
-    this._socket.sendRPC(marshal);
-  }
   RPCClearMaterialOverrides(componentHandle) {
     const marshal = new Marshal();
     marshal.writeString("RPCClearMaterialOverrides");
     marshal.writeUInt(componentHandle);
     this._socket.sendRPC(marshal);
   }
-  RPCClearScene() {
-    const marshal = new Marshal();
-    marshal.writeString("RPCClearScene");
-    this._socket.sendRPC(marshal);
-  }
   async RPCCreateMaterialInstances(materialHandle, smoothness, colors) {
     const marshal = new Marshal();
     marshal.writeString("RPCCreateMaterialInstances");
@@ -57968,28 +57972,28 @@ class RpcClient {
     marshal.writeBoolean(value);
     this._socket.sendRPC(marshal);
   }
-  async RPCFrameAll(blendTime) {
+  async RPCFrameAABB(box, blendTime) {
     const marshal = new Marshal();
-    marshal.writeString("RPCFrameAll");
+    marshal.writeString("RPCFrameAABB");
+    marshal.writeBox3(box);
     marshal.writeFloat(blendTime);
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
     const ret = returnMarshal.readSegment();
     return ret;
   }
-  async RPCFrameBox(box, blendTime) {
+  async RPCFrameAll(blendTime) {
     const marshal = new Marshal();
-    marshal.writeString("RPCFrameBox");
-    marshal.writeBox3(box);
+    marshal.writeString("RPCFrameAll");
     marshal.writeFloat(blendTime);
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
     const ret = returnMarshal.readSegment();
     return ret;
   }
-  async RPCFrameInstances(componentHandle, nodes, blendTime) {
+  async RPCFrameElements(componentHandle, elementIndices, blendTime) {
     const marshal = new Marshal();
-    marshal.writeString("RPCFrameInstances");
+    marshal.writeString("RPCFrameElements");
     marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
+    marshal.writeArrayOfUInt(elementIndices);
     marshal.writeFloat(blendTime);
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
     const ret = returnMarshal.readSegment();
@@ -58004,42 +58008,58 @@ class RpcClient {
     const ret = returnMarshal.readSegment();
     return ret;
   }
-  async RPCGetAPIVersion() {
+  async RPCGetAABBForAll() {
     const marshal = new Marshal();
-    marshal.writeString("RPCGetAPIVersion");
+    marshal.writeString("RPCGetAABBForAll");
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
-    const ret = returnMarshal.readString();
+    const ret = returnMarshal.readBox3();
     return ret;
   }
-  async RPCGetBoundingBox(componentHandle, nodes) {
+  async RPCGetAABBForElements(componentHandle, elementIndices) {
     const marshal = new Marshal();
-    marshal.writeString("RPCGetBoundingBox");
+    marshal.writeString("RPCGetAABBForElements");
     marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
+    marshal.writeArrayOfUInt(elementIndices);
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
     const ret = returnMarshal.readBox3();
     return ret;
   }
-  async RPCGetBoundingBoxAll(componentHandle) {
+  async RPCGetAABBForVim(componentHandle) {
     const marshal = new Marshal();
-    marshal.writeString("RPCGetBoundingBoxAll");
+    marshal.writeString("RPCGetAABBForVim");
     marshal.writeUInt(componentHandle);
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
     const ret = returnMarshal.readBox3();
     return ret;
   }
-  async RPCGetCameraPosition() {
+  async RPCGetAPIVersion() {
+    const marshal = new Marshal();
+    marshal.writeString("RPCGetAPIVersion");
+    const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
+    const ret = returnMarshal.readString();
+    return ret;
+  }
+  async RPCGetCameraView() {
     const marshal = new Marshal();
-    marshal.writeString("RPCGetCameraPosition");
+    marshal.writeString("RPCGetCameraView");
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
     const ret = returnMarshal.readSegment();
     return ret;
   }
-  async RPCGetIblRotation() {
+  async RPCGetElementCount(componentHandle) {
+    const marshal = new Marshal();
+    marshal.writeString("RPCGetElementCount");
+    marshal.writeUInt(componentHandle);
+    const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
+    const ret = returnMarshal.readUInt();
+    return ret;
+  }
+  async RPCGetElementIds(componentHandle) {
     const marshal = new Marshal();
-    marshal.writeString("RPCGetIblRotation");
+    marshal.writeString("RPCGetElementIds");
+    marshal.writeUInt(componentHandle);
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
-    const ret = returnMarshal.readMatrix44();
+    const ret = returnMarshal.readArrayOfUInt64();
     return ret;
   }
   async RPCGetLastError() {
@@ -58049,11 +58069,12 @@ class RpcClient {
     const ret = returnMarshal.readString();
     return ret;
   }
-  async RPCGetSceneAABB() {
+  async RPCGetRoomElements(componentHandle) {
     const marshal = new Marshal();
-    marshal.writeString("RPCGetSceneAABB");
+    marshal.writeString("RPCGetRoomElements");
+    marshal.writeUInt(componentHandle);
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
-    const ret = returnMarshal.readBox3();
+    const ret = returnMarshal.readArrayOfUInt();
     return ret;
   }
   async RPCGetSectionBox() {
@@ -58071,58 +58092,6 @@ class RpcClient {
     const ret = returnMarshal.readVimStatus();
     return ret;
   }
-  RPCGhost(componentHandle, nodes) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCGhost");
-    marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
-    this._socket.sendRPC(marshal);
-  }
-  RPCGhostAll(componentHandle) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCGhostAll");
-    marshal.writeUInt(componentHandle);
-    this._socket.sendRPC(marshal);
-  }
-  RPCHide(componentHandle, nodes) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCHide");
-    marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
-    this._socket.sendRPC(marshal);
-  }
-  RPCHideAABBs(componentHandle, nodes) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCHideAABBs");
-    marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
-    this._socket.sendRPC(marshal);
-  }
-  RPCHideAll(componentHandle) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCHideAll");
-    marshal.writeUInt(componentHandle);
-    this._socket.sendRPC(marshal);
-  }
-  RPCHideAllAABBs(componentHandle) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCHideAllAABBs");
-    marshal.writeUInt(componentHandle);
-    this._socket.sendRPC(marshal);
-  }
-  RPCHighlight(componentHandle, nodes) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCHighlight");
-    marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
-    this._socket.sendRPC(marshal);
-  }
-  RPCHighlightAll(componentHandle) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCHighlightAll");
-    marshal.writeUInt(componentHandle);
-    this._socket.sendRPC(marshal);
-  }
   RPCKeyEvent(keyCode, down) {
     const marshal = new Marshal();
     marshal.writeString("RPCKeyEvent");
@@ -58147,12 +58116,6 @@ class RpcClient {
     const ret = returnMarshal.readUInt();
     return ret;
   }
-  RPCLockIblRotation(lock) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCLockIblRotation");
-    marshal.writeBoolean(lock);
-    this._socket.sendRPC(marshal);
-  }
   RPCMouseButtonEvent(mousePos, mouseButton, down) {
     const marshal = new Marshal();
     marshal.writeString("RPCMouseButtonEvent");
@@ -58187,16 +58150,6 @@ class RpcClient {
     marshal.writeInt(mouseButton);
     this._socket.sendRPC(marshal);
   }
-  RPCMoveCameraTo(usePosition, useTarget, position, target, blendTime) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCMoveCameraTo");
-    marshal.writeBoolean(usePosition);
-    marshal.writeBoolean(useTarget);
-    marshal.writeVector3(position);
-    marshal.writeVector3(target);
-    marshal.writeFloat(blendTime);
-    this._socket.sendRPC(marshal);
-  }
   RPCPauseRendering(pause) {
     const marshal = new Marshal();
     marshal.writeString("RPCPauseRendering");
@@ -58211,17 +58164,9 @@ class RpcClient {
     const ret = returnMarshal.readHitCheckResult();
     return ret;
   }
-  RPCRemoveNodeFlags(componentHandle, nodes, flags) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCRemoveNodeFlags");
-    marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
-    marshal.writeUInt(flags);
-    this._socket.sendRPC(marshal);
-  }
-  RPCSetAspectRatio(width, height) {
+  RPCSetCameraAspectRatio(width, height) {
     const marshal = new Marshal();
-    marshal.writeString("RPCSetAspectRatio");
+    marshal.writeString("RPCSetCameraAspectRatio");
     marshal.writeUInt(width);
     marshal.writeUInt(height);
     this._socket.sendRPC(marshal);
@@ -58232,29 +58177,37 @@ class RpcClient {
     marshal.writeBoolean(orbit2);
     this._socket.sendRPC(marshal);
   }
-  RPCSetCameraPosition(state, blendTime) {
+  RPCSetCameraPosition(position, blendTime) {
     const marshal = new Marshal();
     marshal.writeString("RPCSetCameraPosition");
-    marshal.writeSegment(state);
+    marshal.writeVector3(position);
     marshal.writeFloat(blendTime);
     this._socket.sendRPC(marshal);
   }
-  RPCSetGhostColor(ghostColor) {
+  RPCSetCameraSpeed(speed) {
     const marshal = new Marshal();
-    marshal.writeString("RPCSetGhostColor");
-    marshal.writeRGBA(ghostColor);
+    marshal.writeString("RPCSetCameraSpeed");
+    marshal.writeFloat(speed);
     this._socket.sendRPC(marshal);
   }
-  RPCSetGhostColor2(ghostColor) {
+  RPCSetCameraTarget(target, blendTime) {
     const marshal = new Marshal();
-    marshal.writeString("RPCSetGhostColor2");
-    marshal.writeRGBA(ghostColor);
+    marshal.writeString("RPCSetCameraTarget");
+    marshal.writeVector3(target);
+    marshal.writeFloat(blendTime);
+    this._socket.sendRPC(marshal);
+  }
+  RPCSetCameraView(state, blendTime) {
+    const marshal = new Marshal();
+    marshal.writeString("RPCSetCameraView");
+    marshal.writeSegment(state);
+    marshal.writeFloat(blendTime);
     this._socket.sendRPC(marshal);
   }
-  RPCSetIblRotation(transform) {
+  RPCSetGhostColor(ghostColor) {
     const marshal = new Marshal();
-    marshal.writeString("RPCSetIblRotation");
-    marshal.writeMatrix44(transform);
+    marshal.writeString("RPCSetGhostColor");
+    marshal.writeRGBA(ghostColor);
     this._socket.sendRPC(marshal);
   }
   RPCSetLighting(toneMappingWhitePoint, hdrScale, hdrBackgroundScale, hdrBackgroundSaturation, backgroundBlur, backgroundColor) {
@@ -58268,45 +58221,41 @@ class RpcClient {
     marshal.writeRGBA(backgroundColor);
     this._socket.sendRPC(marshal);
   }
-  RPCSetMaterialOverrides(componentHandle, nodes, materialInstanceHandles) {
+  RPCSetMaterialOverrides(componentHandle, elementIndices, materialInstanceHandles) {
     const marshal = new Marshal();
     marshal.writeString("RPCSetMaterialOverrides");
     marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
+    marshal.writeArrayOfUInt(elementIndices);
     marshal.writeArrayOfUInt(materialInstanceHandles);
     this._socket.sendRPC(marshal);
   }
-  RPCSetMoveSpeed(speed) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCSetMoveSpeed");
-    marshal.writeFloat(speed);
-    this._socket.sendRPC(marshal);
-  }
   RPCSetSectionBox(state) {
     const marshal = new Marshal();
     marshal.writeString("RPCSetSectionBox");
     marshal.writeSectionBoxState(state);
     this._socket.sendRPC(marshal);
   }
-  RPCShow(componentHandle, nodes) {
+  RPCSetStateVim(componentHandle, state) {
     const marshal = new Marshal();
-    marshal.writeString("RPCShow");
+    marshal.writeString("RPCSetStateVim");
     marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
+    marshal.writeUInt(state);
     this._socket.sendRPC(marshal);
   }
-  RPCShowAABBs(componentHandle, nodes, colors) {
+  RPCSetStateElements(componentHandle, elementIndices, state) {
     const marshal = new Marshal();
-    marshal.writeString("RPCShowAABBs");
+    marshal.writeString("RPCSetStateElements");
     marshal.writeUInt(componentHandle);
-    marshal.writeArrayOfUInt(nodes);
-    marshal.writeArrayOfRGBA32(colors);
+    marshal.writeArrayOfUInt(elementIndices);
+    marshal.writeUInt(state);
     this._socket.sendRPC(marshal);
   }
-  RPCShowAll(componentHandle) {
+  RPCSetStatesElements(componentHandle, elementIndices, states) {
     const marshal = new Marshal();
-    marshal.writeString("RPCShowAll");
+    marshal.writeString("RPCSetStatesElements");
     marshal.writeUInt(componentHandle);
+    marshal.writeArrayOfUInt(elementIndices);
+    marshal.writeArrayOfUInt(states);
     this._socket.sendRPC(marshal);
   }
   async RPCStartScene(toneMappingWhitePoint, hdrScale, hdrBackgroundScale, hdrBackgroundSaturation, backgroundBlur, backgroundColor) {
@@ -58327,6 +58276,11 @@ class RpcClient {
     marshal.writeString("RPCTriggerRenderDocCapture");
     this._socket.sendRPC(marshal);
   }
+  RPCUnloadAll() {
+    const marshal = new Marshal();
+    marshal.writeString("RPCUnloadAll");
+    this._socket.sendRPC(marshal);
+  }
   RPCUnloadVim(componentHandle) {
     const marshal = new Marshal();
     marshal.writeString("RPCUnloadVim");
@@ -58878,7 +58832,7 @@ function ultraInputAdapter(viewer) {
 function createAdapter$1(viewer) {
   return {
     init: () => {
-      viewer.rpc.RPCSetMoveSpeed(10);
+      viewer.rpc.RPCSetCameraSpeed(10);
     },
     orbitCamera: (value) => {
     },
@@ -59085,7 +59039,7 @@ class Raycaster3 {
     if (!test2) return void 0;
     const vim = this._vims.getFromHandle(test2.vimHandle);
     if (!vim) return void 0;
-    const object = vim.getElementFromInstanceIndex(test2.nodeIndex);
+    const object = vim.getElement(test2.elementIndex);
     if (!object) return void 0;
     return new UltraRaycastResult(
       object,
@@ -59178,118 +59132,39 @@ class RpcSafeClient {
       Validation.clampRGBA01(s.backgroundColor)
     );
   }
-  RPCLockIblRotation(lock) {
-    this.rpc.RPCLockIblRotation(lock);
-  }
-  RPCGetSceneAABB() {
-    return this.safeCall(
-      () => this.rpc.RPCGetSceneAABB(),
-      void 0
-    );
-  }
   /*******************************************************************************
    * 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) {
-    if (!Validation.isComponentHandle(componentHandle)) return;
-    this.rpc.RPCHideAll(componentHandle);
-  }
-  /**
-   * 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) {
-    if (!Validation.isComponentHandle(componentHandle)) return;
-    this.rpc.RPCShowAll(componentHandle);
-  }
-  /**
-   * 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) {
-    if (!Validation.isComponentHandle(componentHandle)) return;
-    this.rpc.RPCGhostAll(componentHandle);
-  }
-  /**
-   * Highlights all nodes in a component.
-   * @param componentHandle - The component to highlight entirely
-   * @throws {Error} If the component handle is invalid
-   */
-  RPCHighlightAll(componentHandle) {
-    if (!Validation.isComponentHandle(componentHandle)) return;
-    this.rpc.RPCHighlightAll(componentHandle);
-  }
-  /**
-   * 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, nodes) {
-    if (!Validation.isComponentHandle(componentHandle)) return;
-    if (!Validation.areComponentHandles(nodes)) return;
-    const batches = batchArray(nodes, this.batchSize);
-    for (const batch of batches) {
-      this.rpc.RPCHide(componentHandle, batch);
-    }
-  }
-  /**
-   * Shows specified nodes in a component, making them visible.
+   * 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 show
+   * @param nodes - Array of node indices to highlight
    * @throws {Error} If the component handle is invalid or nodes array is invalid
    */
-  RPCShow(componentHandle, nodes) {
-    if (nodes.length === 0) return;
+  RPCSetStateElements(componentHandle, elements, state) {
+    if (elements.length === 0) return;
     if (!Validation.isComponentHandle(componentHandle)) return;
-    if (!Validation.areComponentHandles(nodes)) return;
-    const batches = batchArray(nodes, this.batchSize);
+    if (!Validation.areComponentHandles(elements)) return;
+    const batches = batchArray(elements, this.batchSize);
     for (const batch of batches) {
-      this.rpc.RPCShow(componentHandle, batch);
+      this.rpc.RPCSetStateElements(componentHandle, batch, state);
     }
   }
-  /**
-   * 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, nodes) {
-    if (nodes.length === 0) return;
+  RPCSetStatesElements(componentHandle, elements, states) {
     if (!Validation.isComponentHandle(componentHandle)) return;
-    if (!Validation.areComponentHandles(nodes)) return;
-    const batches = batchArray(nodes, this.batchSize);
-    for (const batch of batches) {
-      this.rpc.RPCGhost(componentHandle, batch);
+    if (!Validation.areComponentHandles(elements)) return;
+    if (!Validation.areSameLength(elements, states)) return;
+    const batches = batchArrays(elements, states, this.batchSize);
+    for (const [batchedElements, batchedStates] of batches) {
+      this.rpc.RPCSetStatesElements(componentHandle, batchedElements, batchedStates);
     }
   }
-  /**
-   * 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
-   */
-  RPCHighlight(componentHandle, nodes) {
-    if (nodes.length === 0) return;
+  RPCSetStateVim(componentHandle, state) {
     if (!Validation.isComponentHandle(componentHandle)) return;
-    if (!Validation.areComponentHandles(nodes)) return;
-    const batches = batchArray(nodes, this.batchSize);
-    for (const batch of batches) {
-      this.rpc.RPCHighlight(componentHandle, batch);
-    }
+    this.rpc.RPCSetStateVim(componentHandle, state);
   }
   /*******************************************************************************
    * TEXT AND UI METHODS
@@ -59349,9 +59224,9 @@ class RpcSafeClient {
    * Retrieves the current camera position and orientation.
    * @returns Promise resolving to a segment representing the camera's current position and target
    */
-  async RPCGetCameraPosition() {
+  async RPCGetCameraView() {
     return await this.safeCall(
-      () => this.rpc.RPCGetCameraPosition(),
+      () => this.rpc.RPCGetCameraView(),
       void 0
     );
   }
@@ -59359,16 +59234,58 @@ class RpcSafeClient {
    * 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, blendTime) {
+  RPCSetCameraView(segment, blendTime) {
     if (!Validation.isValidSegment(segment)) return;
     blendTime = Validation.clamp01(blendTime);
-    this.rpc.RPCSetCameraPosition(segment, blendTime);
+    this.rpc.RPCSetCameraView(segment, blendTime);
+  }
+  /**
+   * 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, blendTime) {
+    if (!Validation.isValidVector3(position)) return;
+    blendTime = Validation.clamp01(blendTime);
+    this.rpc.RPCSetCameraPosition(position, blendTime);
+  }
+  /**
+   * 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, blendTime) {
+    if (!Validation.isValidVector3(target)) return;
+    blendTime = Validation.clamp01(blendTime);
+    this.rpc.RPCSetCameraTarget(target, blendTime);
+  }
+  /**
+   * 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() {
+    return this.safeCall(
+      () => this.rpc.RPCGetAABBForAll(),
+      void 0
+    );
   }
-  async RPCGetBoundingBoxAll(componentHandle) {
+  /**
+   * 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
+   */
+  async RPCGetAABBForVim(componentHandle) {
     return await this.safeCall(
-      () => this.rpc.RPCGetBoundingBoxAll(componentHandle),
+      () => this.rpc.RPCGetAABBForVim(componentHandle),
       void 0
     );
   }
@@ -59376,25 +59293,25 @@ class RpcSafeClient {
    * 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
    */
-  async RPCGetBoundingBox(componentHandle, nodes) {
+  async RPCGetAABBForElements(componentHandle, elements) {
     if (!Validation.isComponentHandle(componentHandle)) return;
-    if (!Validation.areComponentHandles(nodes)) return;
+    if (!Validation.areComponentHandles(elements)) return;
     return await this.safeCall(
-      () => this.getBoundingBoxBatched(componentHandle, nodes),
+      () => this.RPCGetAABBForElementsBatched(componentHandle, elements),
       void 0
     );
   }
-  async getBoundingBoxBatched(componentHandle, nodes) {
-    if (nodes.length === 0) {
+  async RPCGetAABBForElementsBatched(componentHandle, elements) {
+    if (elements.length === 0) {
       return new Box3();
     }
-    const batches = batchArray(nodes, this.batchSize);
+    const batches = batchArray(elements, this.batchSize);
     const promises = batches.map(async (batch) => {
-      const aabb = await this.rpc.RPCGetBoundingBox(componentHandle, batch);
+      const aabb = await this.rpc.RPCGetAABBForElements(componentHandle, batch);
       const v1 = new Vector3(aabb.min.x, aabb.min.y, aabb.min.z);
       const v2 = new Vector3(aabb.max.x, aabb.max.y, aabb.max.z);
       return new Box3(v1, v2);
@@ -59435,28 +59352,28 @@ 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
    */
-  async RPCFrameInstances(componentHandle, nodes, blendTime) {
+  async RPCFrameElements(componentHandle, elements, blendTime) {
     if (!Validation.isComponentHandle(componentHandle)) return;
-    if (!Validation.areComponentHandles(nodes)) return;
+    if (!Validation.areComponentHandles(elements)) return;
     blendTime = Validation.clamp01(blendTime);
-    if (nodes.length < this.batchSize) {
+    if (elements.length < this.batchSize) {
       return await this.safeCall(
-        () => this.rpc.RPCFrameInstances(componentHandle, nodes, blendTime),
+        () => this.rpc.RPCFrameElements(componentHandle, elements, blendTime),
         void 0
       );
     } else {
       const box = await this.safeCall(
-        () => this.getBoundingBoxBatched(componentHandle, nodes),
+        () => this.RPCGetAABBForElementsBatched(componentHandle, elements),
         void 0
       );
       if (!box) return void 0;
       return await this.safeCall(
-        () => this.rpc.RPCFrameBox(box, blendTime),
+        () => this.rpc.RPCFrameAABB(box, blendTime),
         void 0
       );
     }
@@ -59467,11 +59384,11 @@ class RpcSafeClient {
    * @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)
    */
-  async RPCFrameBox(box, blendTime) {
+  async RPCFrameAABB(box, blendTime) {
     if (!Validation.isValidBox(box)) return;
     blendTime = Validation.clamp01(blendTime);
     return await this.safeCall(
-      () => this.rpc.RPCFrameBox(box, blendTime),
+      () => this.rpc.RPCFrameAABB(box, blendTime),
       void 0
     );
   }
@@ -59484,9 +59401,9 @@ class RpcSafeClient {
    * @param speed - The desired movement speed (must be positive)
    * @throws {Error} If speed is not positive
    */
-  RPCSetMoveSpeed(speed) {
+  RPCSetCameraSpeed(speed) {
     speed = Validation.min0(speed);
-    this.rpc.RPCSetMoveSpeed(speed);
+    this.rpc.RPCSetCameraSpeed(speed);
   }
   RPCSetCameraMode(mode) {
     this.rpc.RPCSetCameraMode(
@@ -59500,10 +59417,10 @@ class RpcSafeClient {
    * @param height - The height component of the aspect ratio
    * @throws {Error} If width or height are not positive integers
    */
-  RPCSetAspectRatio(width, height) {
+  RPCSetCameraAspectRatio(width, height) {
     if (!Validation.isPositiveInteger(width)) return;
     if (!Validation.isPositiveInteger(height)) return;
-    this.rpc.RPCSetAspectRatio(width, height);
+    this.rpc.RPCSetCameraAspectRatio(width, height);
   }
   /*******************************************************************************
    * VIM FILE MANAGEMENT METHODS
@@ -59567,8 +59484,8 @@ class RpcSafeClient {
   /**
    * Clears the entire scene, removing all components and resetting to initial state.
    */
-  RPCClearScene() {
-    this.rpc.RPCClearScene();
+  RPCUnloadAll() {
+    this.rpc.RPCUnloadAll();
   }
   /**
    * Sets the color used for ghosted geometry.
@@ -59576,7 +59493,7 @@ class RpcSafeClient {
    */
   RPCSetGhostColor(ghostColor) {
     const color = Validation.clampRGBA01(ghostColor);
-    this.rpc.RPCSetGhostColor2(color);
+    this.rpc.RPCSetGhostColor(color);
   }
   /**
    * Performs hit testing at a specified screen position.
@@ -59772,46 +59689,6 @@ class RpcSafeClient {
   RPCTriggerRenderDocCapture() {
     this.rpc.RPCTriggerRenderDocCapture();
   }
-  /**
-   * 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, nodes, colors) {
-    if (!Validation.isComponentHandle(componentHandle)) return;
-    if (!Validation.areComponentHandles(nodes)) return;
-    const batches = batchArrays(nodes, colors, this.batchSize);
-    for (const [batchedNodes, batchedColors] of batches) {
-      this.rpc.RPCShowAABBs(componentHandle, batchedNodes, batchedColors);
-    }
-  }
-  /**
-   * 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, nodes) {
-    if (!Validation.isComponentHandle(componentHandle)) return;
-    if (!Validation.areComponentHandles(nodes)) return;
-    const batches = batchArray(nodes, this.batchSize);
-    for (const batch of batches) {
-      this.rpc.RPCHideAABBs(componentHandle, batch);
-    }
-  }
-  /**
-   * 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) {
-    if (!Validation.isComponentHandle(componentHandle)) return;
-    this.rpc.RPCHideAllAABBs(componentHandle);
-  }
   async safeCall(func, defaultValue) {
     try {
       return await func();
@@ -59823,7 +59700,6 @@ class RpcSafeClient {
 }
 const defaultRenderSettings = {
   ...defaultSceneSettings,
-  lockIblRotation: true,
   ghostColor: new RGBA(14 / 255, 14 / 255, 14 / 255, 64 / 255)
 };
 class Renderer2 {
@@ -59839,7 +59715,6 @@ class Renderer2 {
     __publicField(this, "_animationFrame");
     __publicField(this, "_updateLighting", false);
     __publicField(this, "_updateGhostColor", false);
-    __publicField(this, "_updateIblRotation", false);
     __publicField(this, "_onSceneUpdated", new distExports$1.SignalDispatcher());
     this._rpc = rpc;
     this._logger = logger;
@@ -59873,7 +59748,6 @@ class Renderer2 {
    */
   onConnect() {
     this._rpc.RPCSetGhostColor(this._settings.ghostColor);
-    this._rpc.RPCLockIblRotation(this._settings.lockIblRotation);
   }
   notifySceneUpdated() {
     this._onSceneUpdated.dispatch();
@@ -59886,13 +59760,6 @@ class Renderer2 {
   get ghostColor() {
     return this._settings.ghostColor;
   }
-  /**
-   * Gets the IBL rotation lock setting
-   * @returns Whether IBL rotation is locked
-   */
-  get lockIblRotation() {
-    return this._settings.lockIblRotation;
-  }
   /**
    * Gets the tone mapping white point value
    * @returns Current tone mapping white point
@@ -59947,16 +59814,6 @@ class Renderer2 {
     this._updateGhostColor = true;
     this.requestSettingsUpdate();
   }
-  /**
-   * Updates the IBL rotation lock setting
-   * @param value - Whether to lock IBL rotation
-   */
-  set lockIblRotation(value) {
-    if (this._settings.lockIblRotation === value) return;
-    this._settings.lockIblRotation = value;
-    this._updateIblRotation = true;
-    this.requestSettingsUpdate();
-  }
   /**
    * Sets the tone mapping white point value
    * @param value - New tone mapping white point value
@@ -60024,7 +59881,7 @@ class Renderer2 {
     this.requestSettingsUpdate();
   }
   getBoundingBox() {
-    return this._rpc.RPCGetSceneAABB();
+    return this._rpc.RPCGetAABBForAll();
   }
   /**
    * Requests an update to be performed on the next animation frame.
@@ -60040,10 +59897,8 @@ class Renderer2 {
   async applySettings() {
     if (this._updateLighting) await this._rpc.RPCSetLighting(this._settings);
     if (this._updateGhostColor) await this._rpc.RPCSetGhostColor(this._settings.ghostColor);
-    if (this._updateIblRotation) await this._rpc.RPCLockIblRotation(this._settings.lockIblRotation);
     this._updateLighting = false;
     this._updateGhostColor = false;
-    this._updateIblRotation = false;
     this._animationFrame = void 0;
   }
   /**
@@ -60156,13 +60011,15 @@ class SectionBox2 {
     this._onUpdate.clear();
   }
 }
-var NodeState$1 = /* @__PURE__ */ ((NodeState2) => {
-  NodeState2["VISIBLE"] = "visible";
-  NodeState2["HIDDEN"] = "hidden";
-  NodeState2["GHOSTED"] = "ghosted";
-  NodeState2["HIGHLIGHTED"] = "highlighted";
-  return NodeState2;
-})(NodeState$1 || {});
+var VisibilityState$1 = /* @__PURE__ */ ((VisibilityState2) => {
+  VisibilityState2[VisibilityState2["VISIBLE"] = 0] = "VISIBLE";
+  VisibilityState2[VisibilityState2["HIDDEN"] = 1] = "HIDDEN";
+  VisibilityState2[VisibilityState2["GHOSTED"] = 2] = "GHOSTED";
+  VisibilityState2[VisibilityState2["HIGHLIGHTED"] = 16] = "HIGHLIGHTED";
+  VisibilityState2[VisibilityState2["HIDDEN_HIGHLIGHTED"] = 17] = "HIDDEN_HIGHLIGHTED";
+  VisibilityState2[VisibilityState2["GHOSTED_HIGHLIGHTED"] = 18] = "GHOSTED_HIGHLIGHTED";
+  return VisibilityState2;
+})(VisibilityState$1 || {});
 class StateSynchronizer {
   /**
    * Creates a new StateSynchronizer instance.
@@ -60171,9 +60028,10 @@ class StateSynchronizer {
    * @param getHandle - Function that returns the current handle identifier
    * @param isConnected - Function that returns whether the connection to the remote system is active
    * @param onUpdate - Callback function invoked when updates are sent to the remote system
-   * @param defaultState - The default state for nodes when not explicitly set (defaults to VISIBLE)
+   * @param defaultState - The default state for elements when not explicitly set (defaults to VISIBLE)
    */
-  constructor(rpc, getHandle, isConnected, onUpdate, defaultState = "visible") {
+  constructor(rpc, getHandle, isConnected, onUpdate, defaultState = 0) {
+    //TODO: Take advantage of the new rpcs that can take multiple states at once
     __publicField(this, "_tracker");
     __publicField(this, "_rpc");
     __publicField(this, "_getHandle");
@@ -60188,34 +60046,34 @@ class StateSynchronizer {
   }
   // --- Getters ---
   /**
-   * Checks if all nodes are in the specified state(s).
+   * Checks if all elements are in the specified state(s).
    * 
    * @param state - A single state or array of states to check against
-   * @returns True if all nodes are in the specified state(s), false otherwise
+   * @returns True if all elements are in the specified state(s), false otherwise
    */
   areAllInState(state) {
     return this._tracker.areAll(state);
   }
   /**
-   * Gets the current state of a specific node.
+   * Gets the current state of a specific element.
    * 
-   * @param node - The node identifier
-   * @returns The current state of the node
+   * @param elementIndex - The element index
+   * @returns The current state of the element
    */
-  getNodeState(node) {
-    return this._tracker.getState(node);
+  getElementState(elementIndex) {
+    return this._tracker.getState(elementIndex);
   }
   /**
-   * Gets all nodes that are currently in the specified state.
+   * Gets all elements that are currently in the specified state.
    * 
    * @param state - The state to query
-   * @returns Either 'all' if all nodes are in this state, or an array of node IDs
+   * @returns Either 'all' if all elements are in this state, or an array of element indices
    */
-  getNodesInState(state) {
+  getElementsInState(state) {
     return this._tracker.getAll(state);
   }
   /**
-   * Gets the default state used for nodes without explicit state settings.
+   * Gets the default state used for elements without explicit state settings.
    * 
    * @returns The current default state
    */
@@ -60224,27 +60082,27 @@ class StateSynchronizer {
   }
   // --- Setters ---
   /**
-   * Sets the state of a specific node.
+   * Sets the state of a specific elements.
    * 
-   * @param nodeId - The identifier of the node
+   * @param elementIndex - The element index to update
    * @param state - The new state to apply
    */
-  setNodeState(nodeId, state) {
-    this._tracker.setState(nodeId, state);
+  setElementState(elementIndex, state) {
+    this._tracker.setState(elementIndex, state);
     this.scheduleUpdate();
   }
   /**
-   * Sets the state of all nodes to the specified value.
+   * Sets the state of all elements to the specified value.
    * 
-   * @param state - The state to apply to all nodes
-   * @param clear - If true, clears all node-specific overrides
+   * @param state - The state to apply to all elements
+   * @param clear - If true, clears all elements-specific overrides
    */
-  setAllNodesState(state) {
+  setStateForAll(state) {
     this._tracker.setAll(state);
     this.scheduleUpdate();
   }
   /**
-   * Replaces all nodes in one state (or states) with another state.
+   * Replaces all elements in one state (or states) with another state.
    * 
    * @param fromState - The state(s) to replace
    * @param toState - The new state to apply
@@ -60281,76 +60139,25 @@ class StateSynchronizer {
    * @private
    */
   remoteUpdate() {
-    const [defaultUpdate, nodeUpdates] = this._tracker.getUpdates();
+    const [defaultUpdate, elementUpdates] = this._tracker.getUpdates();
     this._tracker.reset();
-    if (defaultUpdate) {
-      this.callRPCForStateAll(defaultUpdate);
+    if (defaultUpdate !== void 0) {
+      this._rpc.RPCSetStateVim(this._getHandle(), defaultUpdate);
     }
-    for (const [state, nodes] of nodeUpdates.entries()) {
-      if (nodes.length === 0) continue;
-      this.callRPCForStateNodes(state, nodes);
+    for (const [state, elements] of elementUpdates.entries()) {
+      if (elements.length === 0) continue;
+      this._rpc.RPCSetStateElements(this._getHandle(), elements, state);
     }
     this._onUpdate();
   }
-  /**
-   * Calls the appropriate RPC method to update the state of all nodes.
-   * 
-   * @param state - The state to apply to all nodes
-   * @private
-   */
-  callRPCForStateAll(state) {
-    if (!this._isConnected()) {
-      return;
-    }
-    switch (state) {
-      case "visible":
-        this._rpc.RPCShowAll(this._getHandle());
-        break;
-      case "hidden":
-        this._rpc.RPCHideAll(this._getHandle());
-        break;
-      case "ghosted":
-        this._rpc.RPCGhostAll(this._getHandle());
-        break;
-      case "highlighted":
-        this._rpc.RPCHighlightAll(this._getHandle());
-        break;
-    }
-  }
-  /**
-   * Calls the appropriate RPC method to update the state of specific nodes.
-   * 
-   * @param state - The state to apply
-   * @param nodes - Array of node IDs to update
-   * @private
-   */
-  callRPCForStateNodes(state, nodes) {
-    if (!this._isConnected()) {
-      return;
-    }
-    switch (state) {
-      case "visible":
-        this._rpc.RPCShow(this._getHandle(), nodes);
-        break;
-      case "hidden":
-        this._rpc.RPCHide(this._getHandle(), nodes);
-        break;
-      case "ghosted":
-        this._rpc.RPCGhost(this._getHandle(), nodes);
-        break;
-      case "highlighted":
-        this._rpc.RPCHighlight(this._getHandle(), nodes);
-        break;
-    }
-  }
 }
 class StateTracker {
   /**
    * Creates a new StateTracker instance.
    * 
-   * @param defaultState - The default state for nodes when not explicitly set
+   * @param defaultState - The default state for elements when not explicitly set
    */
-  constructor(defaultState = "visible") {
+  constructor(defaultState = 0) {
     __publicField(this, "_state", /* @__PURE__ */ new Map());
     __publicField(this, "_updates", /* @__PURE__ */ new Set());
     __publicField(this, "_default");
@@ -60358,10 +60165,9 @@ class StateTracker {
     this._default = defaultState;
   }
   /**
-   * Sets the default state for all nodes and optionally clears node-specific overrides.
+   * Sets the default state for all elements and optionally clears element-specific overrides.
    * 
    * @param state - The new default state
-   * @param clearNodes - If true, clears all node-specific overrides
    */
   setAll(state) {
     this._default = state;
@@ -60376,30 +60182,30 @@ class StateTracker {
   reapply() {
     this._updates.clear();
     const toRemove = /* @__PURE__ */ new Set();
-    for (const [nodeId, state] of this._state.entries()) {
+    for (const [elementIndex, state] of this._state.entries()) {
       if (state === this._default) {
-        toRemove.add(nodeId);
+        toRemove.add(elementIndex);
       } else {
-        this._updates.add(nodeId);
+        this._updates.add(elementIndex);
       }
     }
-    toRemove.forEach((nodeId) => this._state.delete(nodeId));
+    toRemove.forEach((elementIndex) => this._state.delete(elementIndex));
   }
   /**
-   * Sets the state of a specific node.
+   * Sets the state of a specific element.
    * 
-   * @param nodeId - The node identifier
+   * @param elementIndex - The element index to update
    * @param state - The new state to apply
    */
-  setState(nodeId, state) {
+  setState(elementIndex, state) {
     if (this._default === state) {
-      this._state.delete(nodeId);
+      this._state.delete(elementIndex);
       if (!this._updatedDefault) {
-        this._updates.add(nodeId);
+        this._updates.add(elementIndex);
       }
     } else {
-      this._state.set(nodeId, state);
-      this._updates.add(nodeId);
+      this._state.set(elementIndex, state);
+      this._updates.add(elementIndex);
     }
   }
   /**
@@ -60411,66 +60217,65 @@ class StateTracker {
     return this._default;
   }
   /**
-   * Returns whether every node (override or not) is in the given state(s).
+   * Returns whether every element (override or not) is in the given state(s).
    * 
    * @param state - A single state or array of states to check against
-   * @returns True if all nodes are in the specified state(s), false otherwise
+   * @returns True if all element are in the specified state(s), false otherwise
    */
   areAll(state) {
     if (!matchesState(this._default, state)) {
       return false;
     }
-    for (const nodeState of this._state.values()) {
-      if (!matchesState(nodeState, state)) {
+    for (const currentState of this._state.values()) {
+      if (!matchesState(currentState, state)) {
         return false;
       }
     }
     return true;
   }
   /**
-   * Returns a node's effective state.
+   * Returns an element effective state.
    * 
-   * @param node - The node identifier
-   * @returns The current state of the node (override or default)
+   * @param elementIndex - The element index
+   * @returns The current state of the element (override or default)
    */
-  getState(node) {
-    return this._state.get(node) ?? this._default;
+  getState(elementIndex) {
+    return this._state.get(elementIndex) ?? this._default;
   }
   /**
-   * Returns either 'all' if every node is in the given state, or an array
-   * of node IDs (from the overrides) whose state equals the provided state.
+   * Returns either 'all' if every element is in the given state, or an array
+   * of element index (from the overrides) whose state equals the provided state.
    * 
    * @param state - The state to query
-   * @returns Either 'all' if all nodes are in this state, or an array of node IDs
+   * @returns Either 'all' if all elements are in this state, or an array of element indices
    */
   getAll(state) {
     if (this.areAll(state)) return "all";
-    const nodes = [];
-    for (const [nodeId, nodeState] of this._state.entries()) {
-      if (nodeState === state) {
-        nodes.push(nodeId);
+    const elements = [];
+    for (const [elementIndex, currentState] of this._state.entries()) {
+      if (matchesState(currentState, state)) {
+        elements.push(elementIndex);
       }
     }
-    return nodes;
+    return elements;
   }
   /**
-   * Returns a mapping from state to an array of updated node IDs.
-   * 
-   * @returns A tuple with the updated default state (if any) and a map of states to node IDs
+   * Returns a mapping from state to an array of updated elementIndices.
+   * @returns A tuple with the updated default state (if any) and a map of states to element Indices
    */
   getUpdates() {
-    const nodesByState = /* @__PURE__ */ new Map();
-    Object.values(NodeState$1).forEach((state) => {
-      nodesByState.set(state, []);
+    const elementsByState = /* @__PURE__ */ new Map();
+    Object.values(VisibilityState$1).filter((v) => typeof v === "number").forEach((state) => {
+      elementsByState.set(state, []);
     });
-    for (const nodeId of this._updates) {
-      const state = this._state.get(nodeId) ?? this._default;
-      const nodesArray = nodesByState.get(state);
-      if (nodesArray) {
-        nodesArray.push(nodeId);
+    for (const elementIndex of this._updates) {
+      const state = this._state.get(elementIndex) ?? this._default;
+      const elementArray = elementsByState.get(state);
+      if (elementArray) {
+        elementArray.push(elementIndex);
       }
     }
-    return [this._updatedDefault ? this._default : void 0, nodesByState];
+    return [this._updatedDefault ? this._default : void 0, elementsByState];
   }
   /**
    * Checks if the default state has been updated.
@@ -60481,23 +60286,23 @@ class StateTracker {
     return this._updatedDefault;
   }
   /**
-   * Resets the update tracking, clearing the list of nodes that need updates.
+   * Resets the update tracking, clearing the list of elements that need updates.
    */
   reset() {
     this._updates.clear();
     this._updatedDefault = false;
   }
   /**
-   * Returns an iterator over all node overrides.
+   * Returns an iterator over all elements overrides.
    * 
-   * @returns An iterator of [nodeId, state] pairs
+   * @returns An iterator of [elementIndex, state] pairs
    */
   entries() {
     return this._state.entries();
   }
   /**
-   * Replaces all nodes that match the provided state(s) with a new state.
-   * If all nodes are in the given state(s), the default is updated.
+   * Replaces all elements that match the provided state(s) with a new state.
+   * If all elements are in the given state(s), the default is updated.
    * 
    * @param fromState - The state(s) to replace
    * @param toState - The new state to apply
@@ -60510,36 +60315,40 @@ class StateTracker {
       this.reapply();
       return;
     }
-    for (const [nodeId, state] of this._state.entries()) {
+    for (const [elementIndex, state] of this._state.entries()) {
       if (matchesState(state, fromState)) {
-        this._state.set(nodeId, toState);
-        this._updates.add(nodeId);
+        this._state.set(elementIndex, toState);
+        this._updates.add(elementIndex);
       }
     }
   }
   // Clean up redundant overrides
   purge() {
     const toRemove = [];
-    for (const [nodeId, state] of this._state.entries()) {
+    for (const [elementIndex, state] of this._state.entries()) {
       if (state === this._default) {
-        toRemove.push(nodeId);
+        toRemove.push(elementIndex);
       }
     }
-    toRemove.forEach((nodeId) => this._state.delete(nodeId));
+    toRemove.forEach((elementIndex) => this._state.delete(elementIndex));
   }
 }
-function matchesState(nodeState, state) {
-  if (Array.isArray(state)) {
-    return state.includes(nodeState);
+function matchesState(state, targetState) {
+  if (Array.isArray(targetState)) {
+    return targetState.includes(state);
   }
-  return nodeState === state;
+  return state === targetState;
 }
 function createSelection() {
   return new Selection(new SelectionAdapter2());
 }
 class SelectionAdapter2 {
   outline(object, state) {
-    object.state = state ? NodeState$1.HIGHLIGHTED : NodeState$1.VISIBLE;
+    if (state) {
+      object.state = object.state === VisibilityState$1.VISIBLE ? VisibilityState$1.HIGHLIGHTED : object.state === VisibilityState$1.HIDDEN ? VisibilityState$1.HIDDEN_HIGHLIGHTED : object.state === VisibilityState$1.GHOSTED ? VisibilityState$1.GHOSTED_HIGHLIGHTED : VisibilityState$1.HIGHLIGHTED;
+    } else {
+      object.state = object.state === VisibilityState$1.HIGHLIGHTED ? VisibilityState$1.VISIBLE : object.state === VisibilityState$1.HIDDEN_HIGHLIGHTED ? VisibilityState$1.HIDDEN : object.state === VisibilityState$1.GHOSTED_HIGHLIGHTED ? VisibilityState$1.GHOSTED : VisibilityState$1.VISIBLE;
+    }
   }
 }
 const HEADER_SIZE = 16;
@@ -60935,7 +60744,7 @@ class Viewport2 {
    */
   update() {
     if (this._rpc.connected) {
-      this._rpc.RPCSetAspectRatio(this.canvas.offsetWidth, this.canvas.offsetHeight);
+      this._rpc.RPCSetCameraAspectRatio(this.canvas.offsetWidth, this.canvas.offsetHeight);
     }
   }
   /**
@@ -60950,9 +60759,9 @@ class Element3D2 {
   /**
    * 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, instance) {
+  constructor(vim, element) {
     /**
      * The parent `Vim` instance this element belongs to.
      */
@@ -60962,9 +60771,9 @@ class Element3D2 {
     /**
      * The internal instance index within the `Vim` model.
      */
-    __publicField(this, "instance");
+    __publicField(this, "element");
     this.vim = vim;
-    this.instance = instance;
+    this.element = element;
   }
   /**
    * The unique handle of the parent `Vim` model.
@@ -60976,19 +60785,19 @@ class Element3D2 {
    * Gets or sets the display state of the element (e.g., visible, hidden).
    */
   get state() {
-    return this.vim.nodeState.getNodeState(this.instance);
+    return this.vim.visibility.getElementState(this.element);
   }
   set state(state) {
-    this.vim.nodeState.setNodeState(this.instance, state);
+    this.vim.visibility.setElementState(this.element, state);
   }
   /**
    * Gets or sets the color override of the element.
    */
   get color() {
-    return this.vim.getColor(this.instance);
+    return this.vim.getColor(this.element);
   }
   set color(color) {
-    this.vim.setColor([this.instance], color);
+    this.vim.setColor([this.element], color);
   }
   /**
    * Computes and returns the bounding box of the element.
@@ -60996,7 +60805,7 @@ class Element3D2 {
    * @returns A promise resolving to the element's bounding box.
    */
   async getBoundingBox() {
-    return this.vim.getBoundingBoxNodes([this.instance]);
+    return this.vim.getBoundingBoxNodes([this.element]);
   }
 }
 class Vim2 {
@@ -61009,7 +60818,7 @@ class Vim2 {
     __publicField(this, "_renderer");
     __publicField(this, "_logger");
     // The StateSynchronizer wraps a StateTracker and handles RPC synchronization.
-    __publicField(this, "nodeState");
+    __publicField(this, "visibility");
     // Color tracking remains unchanged.
     __publicField(this, "_nodeColors", /* @__PURE__ */ new Map());
     __publicField(this, "_updatedColors", /* @__PURE__ */ new Set());
@@ -61021,21 +60830,21 @@ class Vim2 {
     this._colors = color;
     this._renderer = renderer;
     this._logger = logger;
-    this.nodeState = new StateSynchronizer(
+    this.visibility = new StateSynchronizer(
       this._rpc,
       () => this._handle,
       () => this.connected,
       () => this._renderer.notifySceneUpdated(),
-      NodeState$1.VISIBLE
+      VisibilityState$1.VISIBLE
       // default state
     );
   }
-  getElementFromInstanceIndex(instance) {
-    if (this._objects.has(instance)) {
-      return this._objects.get(instance);
+  getElement(elementIndex) {
+    if (this._objects.has(elementIndex)) {
+      return this._objects.get(elementIndex);
     }
-    const object = new Element3D2(this, instance);
-    this._objects.set(instance, object);
+    const object = new Element3D2(this, elementIndex);
+    this._objects.set(elementIndex, object);
     return object;
   }
   getElementsFromId(id2) {
@@ -61066,7 +60875,7 @@ class Vim2 {
       const result = await request.getResult();
       if (result.isSuccess) {
         this._logger.log("Successfully loaded vim: ", this.source);
-        this.nodeState.reapplyStates();
+        this.visibility.reapplyStates();
         this.reapplyColors();
       } else {
         this._logger.log("Failed to load vim: ", this.source);
@@ -61151,15 +60960,15 @@ class Vim2 {
       return Promise.resolve(void 0);
     }
     if (nodes === "all") {
-      return await this._rpc.RPCGetBoundingBoxAll(this._handle);
+      return await this._rpc.RPCGetAABBForVim(this._handle);
     }
-    return await this._rpc.RPCGetBoundingBox(this._handle, nodes);
+    return await this._rpc.RPCGetAABBForElements(this._handle, nodes);
   }
   async getBoundingBox() {
     if (!this.connected) {
       return Promise.resolve(void 0);
     }
-    return await this._rpc.RPCGetBoundingBoxAll(this._handle);
+    return await this._rpc.RPCGetAABBForVim(this._handle);
   }
   getColor(node) {
     return this._nodeColors.get(node);
@@ -61545,13 +61354,13 @@ const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   INVALID_HANDLE,
   InputMode,
   MaterialHandles,
-  NodeState: NodeState$1,
   RGB,
   RGBA,
   RGBA32,
   Segment,
   Viewer: Viewer$2,
   VimLoadingStatus,
+  VisibilityState: VisibilityState$1,
   materialHandles
 }, Symbol.toStringTag, { value: "Module" }));
 const index$6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -76039,7 +75848,7 @@ function createWebglIsolationAdapter(viewer) {
     show: (instances) => {
       for (let i of instances) {
         for (let v of viewer.vims) {
-          const o = v.getElementFromInstanceIndex(i);
+          const o = v.getElement(i);
           o.visible = true;
         }
       }
@@ -76047,7 +75856,7 @@ function createWebglIsolationAdapter(viewer) {
     hide: (instances) => {
       for (let i of instances) {
         for (let v of viewer.vims) {
-          const o = v.getElementFromInstanceIndex(i);
+          const o = v.getElement(i);
           o.visible = false;
         }
       }
@@ -76362,7 +76171,7 @@ function useUltraCamera(viewer, section) {
     getSceneBox: () => viewer.renderer.getBoundingBox()
   }, section);
 }
-const NodeState = NodeState$1;
+const VisibilityState = VisibilityState$1;
 function useUltraIsolation(viewer) {
   const adapter = createAdapter(viewer);
   return useSharedIsolation(adapter);
@@ -76370,29 +76179,33 @@ function useUltraIsolation(viewer) {
 function createAdapter(viewer) {
   const ghost2 = useStateRef(false);
   const hide = (objects) => {
-    const state = ghost2.get() ? NodeState.GHOSTED : NodeState.HIDDEN;
+    const state = ghost2.get() ? VisibilityState.GHOSTED : VisibilityState.HIDDEN;
     if (objects === "all") {
       viewer.vims.getAll().forEach((vim) => {
-        vim.nodeState.setAllNodesState(state);
+        vim.visibility.setStateForAll(state);
       });
       return;
     }
-    objects.forEach((obj) => {
-      obj.state = state;
-    });
+    for (const obj of objects) {
+      if (viewer.selection.has(obj)) {
+        obj.state = state == VisibilityState.GHOSTED ? VisibilityState.GHOSTED_HIGHLIGHTED : VisibilityState.HIDDEN_HIGHLIGHTED;
+      } else {
+        obj.state = state;
+      }
+    }
   };
   return {
     onVisibilityChange: viewer.renderer.onSceneUpdated,
     onSelectionChanged: viewer.selection.onSelectionChanged,
     computeVisibility: () => getVisibilityState(viewer),
     hasSelection: () => viewer.selection.any(),
-    hasVisibleSelection: () => checkSelectionState(viewer, (s) => s === "visible" || s === "highlighted"),
-    hasHiddenSelection: () => checkSelectionState(viewer, (s) => s === "hidden" || s === "ghosted"),
+    hasVisibleSelection: () => checkSelectionState(viewer, (s) => s === VisibilityState.VISIBLE || s === VisibilityState.HIGHLIGHTED),
+    hasHiddenSelection: () => checkSelectionState(viewer, (s) => s === VisibilityState.HIDDEN || s === VisibilityState.GHOSTED),
     clearSelection: () => viewer.selection.clear(),
     isolateSelection: () => {
       hide("all");
       for (const obj of viewer.selection.getAll()) {
-        obj.state = NodeState.HIGHLIGHTED;
+        obj.state = VisibilityState.HIGHLIGHTED;
       }
     },
     hideSelection: () => {
@@ -76401,7 +76214,7 @@ function createAdapter(viewer) {
     },
     showSelection: () => {
       viewer.selection.getAll().forEach((obj) => {
-        obj.state = NodeState.VISIBLE;
+        obj.state = VisibilityState.VISIBLE;
       });
     },
     hideAll: () => {
@@ -76409,29 +76222,29 @@ function createAdapter(viewer) {
     },
     showAll: () => {
       for (const vim of viewer.vims.getAll()) {
-        vim.nodeState.setAllNodesState(NodeState.VISIBLE);
+        vim.visibility.setStateForAll(VisibilityState.VISIBLE);
       }
       viewer.selection.getAll().forEach((obj) => {
-        obj.state = NodeState.HIGHLIGHTED;
+        obj.state = VisibilityState.HIGHLIGHTED;
       });
     },
     isolate: (instances) => {
       hide("all");
       viewer.selection.getAll().forEach((obj) => {
-        obj.state = NodeState.HIGHLIGHTED;
+        obj.state = VisibilityState.HIGHLIGHTED;
       });
     },
     show: (instances) => {
       for (const vim of viewer.vims.getAll()) {
         for (const i of instances) {
-          vim.getElementFromInstanceIndex(i).state = NodeState.VISIBLE;
+          vim.getElement(i).state = VisibilityState.VISIBLE;
         }
       }
     },
     hide: (instances) => {
       for (const vim of viewer.vims.getAll()) {
         for (const i of instances) {
-          const obj = vim.getElementFromInstanceIndex(i);
+          const obj = vim.getElement(i);
           hide([obj]);
         }
       }
@@ -76442,9 +76255,9 @@ function createAdapter(viewer) {
       ghost2.set(show);
       for (const vim of viewer.vims.getAll()) {
         if (show) {
-          vim.nodeState.replaceState(NodeState.HIDDEN, NodeState.GHOSTED);
+          vim.visibility.replaceState(VisibilityState.HIDDEN, VisibilityState.GHOSTED);
         } else {
-          vim.nodeState.replaceState(NodeState.GHOSTED, NodeState.HIDDEN);
+          vim.visibility.replaceState(VisibilityState.GHOSTED, VisibilityState.HIDDEN);
         }
       }
     },
@@ -76472,8 +76285,8 @@ function getVisibilityState(viewer) {
   let allButSelectionFlag = true;
   let onlySelectionFlag = true;
   for (let v of viewer.vims.getAll()) {
-    const allVisible = v.nodeState.areAllInState([NodeState.VISIBLE, NodeState.HIGHLIGHTED]);
-    const allHidden = v.nodeState.areAllInState([NodeState.HIDDEN, NodeState.GHOSTED]);
+    const allVisible = v.visibility.areAllInState([VisibilityState.VISIBLE, VisibilityState.HIGHLIGHTED]);
+    const allHidden = v.visibility.areAllInState([VisibilityState.HIDDEN, VisibilityState.GHOSTED]);
     all = all && allVisible;
     none = none && allHidden;
     onlySelectionFlag = onlySelection();