vim-web 0.4.1 → 0.5.0-dev.1

package/dist/vim-web.iife.js

@@ -45288,7 +45288,7 @@ void main() {
      * 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;
@@ -46869,7 +46869,7 @@ void main() {
      * @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);
@@ -46922,7 +46922,7 @@ void main() {
       const count = subset.getInstanceCount();
       for (let i2 = 0; i2 < count; i2++) {
         const instance = subset.getVimInstance(i2);
-        const obj = this.getElementFromInstanceIndex(instance);
+        const obj = this.getElement(instance);
         if (!set2.has(obj)) {
           result.push(obj);
           set2.add(obj);
@@ -47283,7 +47283,7 @@ void main() {
       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);
       }
     }
@@ -48914,7 +48914,7 @@ void main() {
      * Returns vim object for this submesh.
      */
     get object() {
-      return this.mesh.vim.getElementFromInstanceIndex(this.instance);
+      return this.mesh.vim.getElement(this.instance);
     }
   }
   class InstancedMesh {
@@ -57499,14 +57499,14 @@ void main() {
      * @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
@@ -57516,7 +57516,7 @@ void main() {
       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);
       }
     }
     /**
@@ -57530,7 +57530,7 @@ void main() {
       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
@@ -57555,7 +57555,7 @@ void main() {
      * @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;
     }
@@ -57571,13 +57571,13 @@ void main() {
       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;
     }
@@ -57653,9 +57653,10 @@ void main() {
     }
     // -------------------- 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);
     }
@@ -57779,6 +57780,12 @@ void main() {
       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;
@@ -57799,11 +57806,13 @@ void main() {
     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
       };
@@ -57872,6 +57881,14 @@ void main() {
     readArrayOfUInt() {
       return this.readArray(() => this.readUInt());
     }
+    readArrayOfUInt64() {
+      const length = this.readUInt();
+      const array = [];
+      for (let i2 = 0; i2 < length; i2++) {
+        array.push(this.readUInt64());
+      }
+      return array;
+    }
     readArrayOfFloat() {
       return this.readArray(() => this.readFloat());
     }
@@ -57918,7 +57935,7 @@ void main() {
     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() {
@@ -57927,25 +57944,12 @@ void main() {
     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");
@@ -57984,28 +57988,28 @@ void main() {
       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();
@@ -58020,42 +58024,58 @@ void main() {
       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() {
@@ -58065,11 +58085,12 @@ void main() {
       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() {
@@ -58087,58 +58108,6 @@ void main() {
       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");
@@ -58163,12 +58132,6 @@ void main() {
       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");
@@ -58203,16 +58166,6 @@ void main() {
       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");
@@ -58227,17 +58180,9 @@ void main() {
       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);
@@ -58248,29 +58193,37 @@ void main() {
       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) {
@@ -58284,45 +58237,41 @@ void main() {
       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) {
@@ -58343,6 +58292,11 @@ void main() {
       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");
@@ -58894,7 +58848,7 @@ void main() {
   function createAdapter$1(viewer) {
     return {
       init: () => {
-        viewer.rpc.RPCSetMoveSpeed(10);
+        viewer.rpc.RPCSetCameraSpeed(10);
       },
       orbitCamera: (value) => {
       },
@@ -59101,7 +59055,7 @@ void main() {
       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,
@@ -59194,118 +59148,39 @@ void main() {
         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
@@ -59365,9 +59240,9 @@ void main() {
      * 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
       );
     }
@@ -59375,16 +59250,58 @@ void main() {
      * 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
       );
     }
@@ -59392,25 +59309,25 @@ void main() {
      * 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);
@@ -59451,28 +59368,28 @@ void main() {
      * 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
         );
       }
@@ -59483,11 +59400,11 @@ void main() {
      * @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
       );
     }
@@ -59500,9 +59417,9 @@ void main() {
      * @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(
@@ -59516,10 +59433,10 @@ void main() {
      * @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
@@ -59583,8 +59500,8 @@ void main() {
     /**
      * 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.
@@ -59592,7 +59509,7 @@ void main() {
      */
     RPCSetGhostColor(ghostColor) {
       const color = Validation.clampRGBA01(ghostColor);
-      this.rpc.RPCSetGhostColor2(color);
+      this.rpc.RPCSetGhostColor(color);
     }
     /**
      * Performs hit testing at a specified screen position.
@@ -59788,46 +59705,6 @@ void main() {
     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();
@@ -59839,7 +59716,6 @@ void main() {
   }
   const defaultRenderSettings = {
     ...defaultSceneSettings,
-    lockIblRotation: true,
     ghostColor: new RGBA(14 / 255, 14 / 255, 14 / 255, 64 / 255)
   };
   class Renderer {
@@ -59855,7 +59731,6 @@ void main() {
       __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;
@@ -59889,7 +59764,6 @@ void main() {
      */
     onConnect() {
       this._rpc.RPCSetGhostColor(this._settings.ghostColor);
-      this._rpc.RPCLockIblRotation(this._settings.lockIblRotation);
     }
     notifySceneUpdated() {
       this._onSceneUpdated.dispatch();
@@ -59902,13 +59776,6 @@ void main() {
     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
@@ -59963,16 +59830,6 @@ void main() {
       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
@@ -60040,7 +59897,7 @@ void main() {
       this.requestSettingsUpdate();
     }
     getBoundingBox() {
-      return this._rpc.RPCGetSceneAABB();
+      return this._rpc.RPCGetAABBForAll();
     }
     /**
      * Requests an update to be performed on the next animation frame.
@@ -60056,10 +59913,8 @@ void main() {
     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;
     }
     /**
@@ -60172,13 +60027,15 @@ void main() {
       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.
@@ -60187,9 +60044,10 @@ void main() {
      * @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");
@@ -60204,34 +60062,34 @@ void main() {
     }
     // --- 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
      */
@@ -60240,27 +60098,27 @@ void main() {
     }
     // --- 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
@@ -60297,76 +60155,25 @@ void main() {
      * @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");
@@ -60374,10 +60181,9 @@ void main() {
       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;
@@ -60392,30 +60198,30 @@ void main() {
     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);
       }
     }
     /**
@@ -60427,66 +60233,65 @@ void main() {
       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.
@@ -60497,23 +60302,23 @@ void main() {
       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
@@ -60526,36 +60331,40 @@ void main() {
         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 SelectionAdapter());
   }
   class SelectionAdapter {
     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;
@@ -60951,7 +60760,7 @@ Averrage Date/Second ${avgDataRatePS} kb
      */
     update() {
       if (this._rpc.connected) {
-        this._rpc.RPCSetAspectRatio(this.canvas.offsetWidth, this.canvas.offsetHeight);
+        this._rpc.RPCSetCameraAspectRatio(this.canvas.offsetWidth, this.canvas.offsetHeight);
       }
     }
     /**
@@ -60966,9 +60775,9 @@ Averrage Date/Second ${avgDataRatePS} kb
     /**
      * 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.
        */
@@ -60978,9 +60787,9 @@ Averrage Date/Second ${avgDataRatePS} kb
       /**
        * 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.
@@ -60992,19 +60801,19 @@ Averrage Date/Second ${avgDataRatePS} kb
      * 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.
@@ -61012,7 +60821,7 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @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 Vim {
@@ -61025,7 +60834,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       __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());
@@ -61037,21 +60846,21 @@ Averrage Date/Second ${avgDataRatePS} kb
       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 Element3D(this, instance);
-      this._objects.set(instance, object);
+      const object = new Element3D(this, elementIndex);
+      this._objects.set(elementIndex, object);
       return object;
     }
     getElementsFromId(id2) {
@@ -61082,7 +60891,7 @@ Averrage Date/Second ${avgDataRatePS} kb
         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);
@@ -61167,15 +60976,15 @@ Averrage Date/Second ${avgDataRatePS} kb
         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);
@@ -61561,13 +61370,13 @@ Averrage Date/Second ${avgDataRatePS} kb
     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({
@@ -76055,7 +75864,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       show: (instances) => {
         for (let i2 of instances) {
           for (let v of viewer.vims) {
-            const o = v.getElementFromInstanceIndex(i2);
+            const o = v.getElement(i2);
             o.visible = true;
           }
         }
@@ -76063,7 +75872,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       hide: (instances) => {
         for (let i2 of instances) {
           for (let v of viewer.vims) {
-            const o = v.getElementFromInstanceIndex(i2);
+            const o = v.getElement(i2);
             o.visible = false;
           }
         }
@@ -76378,7 +76187,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       getSceneBox: () => viewer.renderer.getBoundingBox()
     }, section);
   }
-  const NodeState = NodeState$1;
+  const VisibilityState = VisibilityState$1;
   function useUltraIsolation(viewer) {
     const adapter = createAdapter(viewer);
     return useSharedIsolation(adapter);
@@ -76386,29 +76195,33 @@ Averrage Date/Second ${avgDataRatePS} kb
   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: () => {
@@ -76417,7 +76230,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       },
       showSelection: () => {
         viewer.selection.getAll().forEach((obj) => {
-          obj.state = NodeState.VISIBLE;
+          obj.state = VisibilityState.VISIBLE;
         });
       },
       hideAll: () => {
@@ -76425,29 +76238,29 @@ Averrage Date/Second ${avgDataRatePS} kb
       },
       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 i2 of instances) {
-            vim.getElementFromInstanceIndex(i2).state = NodeState.VISIBLE;
+            vim.getElement(i2).state = VisibilityState.VISIBLE;
           }
         }
       },
       hide: (instances) => {
         for (const vim of viewer.vims.getAll()) {
           for (const i2 of instances) {
-            const obj = vim.getElementFromInstanceIndex(i2);
+            const obj = vim.getElement(i2);
             hide([obj]);
           }
         }
@@ -76458,9 +76271,9 @@ Averrage Date/Second ${avgDataRatePS} kb
         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);
           }
         }
       },
@@ -76488,8 +76301,8 @@ Averrage Date/Second ${avgDataRatePS} kb
     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();