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

package/dist/vim-web.iife.js

@@ -50892,16 +50892,16 @@ void main() {
     //= ===========================================================================
     // HANDLE VALIDATIONS
     //= ===========================================================================
-    static isComponentHandle(handle) {
-      if (!this.isPositiveInteger(handle)) return false;
-      if (handle === INVALID_HANDLE) {
-        console.warn(`Invalid handle ${handle}. Aborting operation.`);
+    static isIndex(index2) {
+      if (!this.isPositiveInteger(index2)) return false;
+      if (index2 === INVALID_HANDLE) {
+        console.warn(`Invalid index ${index2}. Aborting operation.`);
         return false;
       }
       return true;
     }
-    static areComponentHandles(handles) {
-      return handles.every((h) => this.isComponentHandle(h));
+    static areIndices(indices) {
+      return indices.every((h) => this.isIndex(h));
     }
     static isMaterialHandle(handle) {
       if (!materialHandles.includes(handle)) {
@@ -57545,7 +57545,7 @@ void main() {
      * @returns Promise that resolves when the framing animation is complete
      */
     async frameAll(blendTime = this._defaultBlendTime) {
-      const segment = await this._rpc.RPCFrameAll(blendTime);
+      const segment = await this._rpc.RPCFrameScene(blendTime);
       this._savedPosition = this._savedPosition ?? segment;
       return segment;
     }
@@ -57562,16 +57562,16 @@ void main() {
     /**
      * Frames specific nodes of a Vim model in the camera view
      * @param vim - The Vim model containing the nodes to frame
-     * @param nodes - Array of node indices to frame, or 'all' to frame the entire model
+     * @param elements - Array of element indices to frame, or 'all' to frame the entire model
      * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
      * @returns Promise that resolves when the framing animation is complete
      */
-    async frameVim(vim, nodes, blendTime = this._defaultBlendTime) {
+    async frameVim(vim, elements, blendTime = this._defaultBlendTime) {
       let segment;
-      if (nodes === "all") {
+      if (elements === "all") {
         segment = await this._rpc.RPCFrameVim(vim.handle, blendTime);
       } else {
-        segment = await this._rpc.RPCFrameElements(vim.handle, nodes, blendTime);
+        segment = await this._rpc.RPCFrameElements(vim.handle, elements, blendTime);
       }
       this._savedPosition = this._savedPosition ?? segment;
       return segment;
@@ -57654,9 +57654,9 @@ void main() {
     // -------------------- HitCheckResult -------------------
     writeHitCheckResult(data2) {
       this.ensureCapacity(4 + 4 + 4 + 4 * 3 + 4 * 3);
-      this.writeUInt(data2.vimHandle);
-      this.writeUInt(data2.nodeIndex);
-      this.writeUInt(data2.elementIndex);
+      this.writeUInt(data2.vimIndex);
+      this.writeUInt(data2.vimElementIndex);
+      this.writeUInt(data2.sceneElementIndex);
       this.writeVector3(data2.worldPosition);
       this.writeVector3(data2.worldNormal);
     }
@@ -57804,15 +57804,15 @@ void main() {
       return textDecoder.decode(stringData);
     }
     readHitCheckResult() {
-      const vimHandle = this.readUInt();
-      const nodeIndex = this.readUInt();
-      const mElementIndex = this.readUInt();
+      const vimIndex = this.readUInt();
+      const vimElementIndex = this.readUInt();
+      const sceneElementIndex = this.readUInt();
       const worldPosition = this.readVector3();
       const worldNormal = this.readVector3();
       return {
-        vimHandle,
-        nodeIndex,
-        elementIndex: mElementIndex,
+        vimIndex,
+        vimElementIndex,
+        sceneElementIndex,
         worldPosition,
         worldNormal
       };
@@ -57944,10 +57944,9 @@ void main() {
     get url() {
       return this._socket.url;
     }
-    RPCClearMaterialOverrides(componentHandle) {
+    RPCClearMaterialOverrides() {
       const marshal = new Marshal();
       marshal.writeString("RPCClearMaterialOverrides");
-      marshal.writeUInt(componentHandle);
       this._socket.sendRPC(marshal);
     }
     async RPCCreateMaterialInstances(materialHandle, smoothness, colors) {
@@ -57970,10 +57969,10 @@ void main() {
       const ret = returnMarshal.readUInt();
       return ret;
     }
-    RPCDestroyMaterialInstances(materialInstanceHandle) {
+    RPCDestroyMaterialInstances(materialInstanceHandles) {
       const marshal = new Marshal();
       marshal.writeString("RPCDestroyMaterialInstances");
-      marshal.writeArrayOfUInt(materialInstanceHandle);
+      marshal.writeArrayOfUInt(materialInstanceHandles);
       this._socket.sendRPC(marshal);
     }
     RPCDestroyText(componentHandle) {
@@ -57997,53 +57996,53 @@ void main() {
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCFrameAll(blendTime) {
+    async RPCFrameElements(vimIndex, elementIndices, blendTime) {
       const marshal = new Marshal();
-      marshal.writeString("RPCFrameAll");
+      marshal.writeString("RPCFrameElements");
+      marshal.writeUInt(vimIndex);
+      marshal.writeArrayOfUInt(elementIndices);
       marshal.writeFloat(blendTime);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCFrameElements(componentHandle, elementIndices, blendTime) {
+    async RPCFrameScene(blendTime) {
       const marshal = new Marshal();
-      marshal.writeString("RPCFrameElements");
-      marshal.writeUInt(componentHandle);
-      marshal.writeArrayOfUInt(elementIndices);
+      marshal.writeString("RPCFrameScene");
       marshal.writeFloat(blendTime);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCFrameVim(componentHandle, blendTime) {
+    async RPCFrameVim(vimIndex, blendTime) {
       const marshal = new Marshal();
       marshal.writeString("RPCFrameVim");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       marshal.writeFloat(blendTime);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCGetAABBForAll() {
+    async RPCGetAABBForElements(vimIndex, elementIndices) {
       const marshal = new Marshal();
-      marshal.writeString("RPCGetAABBForAll");
+      marshal.writeString("RPCGetAABBForElements");
+      marshal.writeUInt(vimIndex);
+      marshal.writeArrayOfUInt(elementIndices);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readBox3();
       return ret;
     }
-    async RPCGetAABBForElements(componentHandle, elementIndices) {
+    async RPCGetAABBForScene() {
       const marshal = new Marshal();
-      marshal.writeString("RPCGetAABBForElements");
-      marshal.writeUInt(componentHandle);
-      marshal.writeArrayOfUInt(elementIndices);
+      marshal.writeString("RPCGetAABBForScene");
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readBox3();
       return ret;
     }
-    async RPCGetAABBForVim(componentHandle) {
+    async RPCGetAABBForVim(vimIndex) {
       const marshal = new Marshal();
       marshal.writeString("RPCGetAABBForVim");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readBox3();
       return ret;
@@ -58062,18 +58061,25 @@ void main() {
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCGetElementCount(componentHandle) {
+    async RPCGetElementCountForScene() {
       const marshal = new Marshal();
-      marshal.writeString("RPCGetElementCount");
-      marshal.writeUInt(componentHandle);
+      marshal.writeString("RPCGetElementCountForScene");
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
+      const ret = returnMarshal.readUInt();
+      return ret;
+    }
+    async RPCGetElementCountForVim(vimIndex) {
+      const marshal = new Marshal();
+      marshal.writeString("RPCGetElementCountForVim");
+      marshal.writeUInt(vimIndex);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readUInt();
       return ret;
     }
-    async RPCGetElementIds(componentHandle) {
+    async RPCGetElementIds(vimIndex) {
       const marshal = new Marshal();
       marshal.writeString("RPCGetElementIds");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readArrayOfUInt64();
       return ret;
@@ -58085,10 +58091,10 @@ void main() {
       const ret = returnMarshal.readString();
       return ret;
     }
-    async RPCGetRoomElements(componentHandle) {
+    async RPCGetRoomElements(vimIndex) {
       const marshal = new Marshal();
       marshal.writeString("RPCGetRoomElements");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readArrayOfUInt();
       return ret;
@@ -58100,10 +58106,10 @@ void main() {
       const ret = returnMarshal.readSectionBoxState();
       return ret;
     }
-    async RPCGetVimLoadingState(componentHandle) {
+    async RPCGetVimLoadingState(vimIndex) {
       const marshal = new Marshal();
       marshal.writeString("RPCGetVimLoadingState");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readVimStatus();
       return ret;
@@ -58237,10 +58243,10 @@ void main() {
       marshal.writeRGBA(backgroundColor);
       this._socket.sendRPC(marshal);
     }
-    RPCSetMaterialOverrides(componentHandle, elementIndices, materialInstanceHandles) {
+    RPCSetMaterialOverridesForElements(vimIndex, elementIndices, materialInstanceHandles) {
       const marshal = new Marshal();
-      marshal.writeString("RPCSetMaterialOverrides");
-      marshal.writeUInt(componentHandle);
+      marshal.writeString("RPCSetMaterialOverridesForElements");
+      marshal.writeUInt(vimIndex);
       marshal.writeArrayOfUInt(elementIndices);
       marshal.writeArrayOfUInt(materialInstanceHandles);
       this._socket.sendRPC(marshal);
@@ -58251,25 +58257,31 @@ void main() {
       marshal.writeSectionBoxState(state);
       this._socket.sendRPC(marshal);
     }
-    RPCSetStateVim(componentHandle, state) {
+    RPCSetStateElements(vimIndex, elementIndices, state) {
       const marshal = new Marshal();
-      marshal.writeString("RPCSetStateVim");
-      marshal.writeUInt(componentHandle);
+      marshal.writeString("RPCSetStateElements");
+      marshal.writeUInt(vimIndex);
+      marshal.writeArrayOfUInt(elementIndices);
       marshal.writeUInt(state);
       this._socket.sendRPC(marshal);
     }
-    RPCSetStateElements(componentHandle, elementIndices, state) {
+    RPCSetStateScene(state) {
       const marshal = new Marshal();
-      marshal.writeString("RPCSetStateElements");
-      marshal.writeUInt(componentHandle);
-      marshal.writeArrayOfUInt(elementIndices);
+      marshal.writeString("RPCSetStateScene");
+      marshal.writeUInt(state);
+      this._socket.sendRPC(marshal);
+    }
+    RPCSetStateVim(vimIndex, state) {
+      const marshal = new Marshal();
+      marshal.writeString("RPCSetStateVim");
+      marshal.writeUInt(vimIndex);
       marshal.writeUInt(state);
       this._socket.sendRPC(marshal);
     }
-    RPCSetStatesElements(componentHandle, elementIndices, states) {
+    RPCSetStatesElements(vimIndex, elementIndices, states) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetStatesElements");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       marshal.writeArrayOfUInt(elementIndices);
       marshal.writeArrayOfUInt(states);
       this._socket.sendRPC(marshal);
@@ -58297,12 +58309,6 @@ void main() {
       marshal.writeString("RPCUnloadAll");
       this._socket.sendRPC(marshal);
     }
-    RPCUnloadVim(componentHandle) {
-      const marshal = new Marshal();
-      marshal.writeString("RPCUnloadVim");
-      marshal.writeUInt(componentHandle);
-      this._socket.sendRPC(marshal);
-    }
   }
   class RemoteColor {
     /**
@@ -59053,9 +59059,9 @@ void main() {
       if (!Validation.isRelativeVector2(position)) return void 0;
       const test2 = await this._rpc.RPCPerformHitTest(position);
       if (!test2) return void 0;
-      const vim = this._vims.getFromHandle(test2.vimHandle);
+      const vim = this._vims.getFromHandle(test2.vimIndex);
       if (!vim) return void 0;
-      const object = vim.getElement(test2.elementIndex);
+      const object = vim.getElement(test2.vimElementIndex);
       if (!object) return void 0;
       return new UltraRaycastResult(
         object,
@@ -59084,7 +59090,7 @@ void main() {
     hdrScale: 1.37,
     hdrBackgroundScale: 1,
     hdrBackgroundSaturation: 1,
-    backGroundBlur: 1,
+    backgroundBlur: 1,
     backgroundColor: new RGBA(0.9, 0.9, 0.9, 1)
   };
   var VimLoadingStatus = /* @__PURE__ */ ((VimLoadingStatus2) => {
@@ -59097,15 +59103,26 @@ void main() {
     return VimLoadingStatus2;
   })(VimLoadingStatus || {});
   class RpcSafeClient {
+    /**
+     * Creates a new RpcSafeClient instance.
+     * @param rpc - The underlying RpcClient used for communication
+     * @param batchSize - Maximum size of batched data for operations (default: 10000)
+     */
     constructor(rpc, batchSize = defaultBatchSize) {
       __publicField(this, "rpc");
       __publicField(this, "batchSize");
       this.rpc = rpc;
       this.batchSize = batchSize;
     }
+    /**
+     * The URL used by the underlying RPC connection.
+     */
     get url() {
       return this.rpc.url;
     }
+    /**
+     * Indicates whether the RPC client is currently connected.
+     */
     get connected() {
       return this.rpc.connected;
     }
@@ -59115,9 +59132,10 @@ void main() {
      * and scene-wide settings.
      ******************************************************************************/
     /**
-     * Initializes and starts the scene with specified settings.
+     * Initializes and starts the scene with the given settings.
      * @param settings - Optional partial scene settings to override defaults
-     * @remarks If no settings are provided, default values will be used
+     * @returns Promise resolving to true if the scene started successfully, false otherwise
+     * @remarks Missing values will be filled from {@link defaultSceneSettings}
      */
     async RPCStartScene(settings2) {
       const s = { ...defaultSceneSettings, ...settings2 ?? {} };
@@ -59127,15 +59145,15 @@ void main() {
           Validation.min0(s.hdrScale),
           Validation.clamp01(s.hdrBackgroundScale),
           Validation.clamp01(s.hdrBackgroundSaturation),
-          Validation.clamp01(s.backGroundBlur),
+          Validation.clamp01(s.backgroundBlur),
           Validation.clampRGBA01(s.backgroundColor)
         ),
         false
       );
     }
     /**
-     * Sets the lighting settings for the scene.
-     * @param settings - The lighting settings to apply
+     * Updates the scene’s lighting configuration.
+     * @param settings - The complete lighting and background settings to apply
      */
     RPCSetLighting(settings2) {
       const s = settings2;
@@ -59144,43 +59162,80 @@ void main() {
         Validation.min0(s.hdrScale),
         Validation.clamp01(s.hdrBackgroundScale),
         Validation.clamp01(s.hdrBackgroundSaturation),
-        Validation.clamp01(s.backGroundBlur),
+        Validation.clamp01(s.backgroundBlur),
         Validation.clampRGBA01(s.backgroundColor)
       );
     }
+    /**
+     * Retrieves the total number of elements across the entire scene.
+     * @returns Promise resolving to the total number of elements (0 on failure).
+     */
+    RPCGetElementCountForScene() {
+      return this.safeCall(
+        () => this.rpc.RPCGetElementCountForScene(),
+        0
+      );
+    }
+    /**
+     * Retrieves the number of elements within a specific loaded vim.
+     * @param vimIndex - Index of the loaded vim to query
+     * @returns Promise resolving to the element count (0 on failure)
+     */
+    RPCGetElementCountForVim(vimIndex) {
+      return this.safeCall(
+        () => this.rpc.RPCGetElementCountForVim(vimIndex),
+        0
+      );
+    }
     /*******************************************************************************
-     * NODE VISIBILITY METHODS
-     * Methods for controlling node visibility, including show/hide, ghosting,
+     * ELEMENTS VISIBILITY METHODS
+     * Methods for controlling element visibility, including show/hide, ghosting,
      * and highlighting functionality.
      ******************************************************************************/
     /**
-     * Highlights specified nodes in a component.
-     * Large node arrays are automatically processed in batches.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices to highlight
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
-     */
-    RPCSetStateElements(componentHandle, elements, state) {
-      if (elements.length === 0) return;
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(elements)) return;
-      const batches = batchArray(elements, this.batchSize);
+     * Sets a single visibility state for given elements within a loaded vim.
+     * The operation is automatically split into batches if the array is large.
+     *
+     * @param vimIndex - The index of the loaded vim containing the elements
+     * @param vimElementIndices - Array of vim-based element indices to apply the state to
+     * @param state - The visibility state to apply (e.g., VISIBLE, HIDDEN)
+     */
+    RPCSetStateElements(vimIndex, vimElementIndices, state) {
+      if (vimElementIndices.length === 0) return;
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
+      const batches = batchArray(vimElementIndices, this.batchSize);
       for (const batch of batches) {
-        this.rpc.RPCSetStateElements(componentHandle, batch, state);
+        this.rpc.RPCSetStateElements(vimIndex, batch, state);
       }
     }
-    RPCSetStatesElements(componentHandle, elements, states) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(elements)) return;
-      if (!Validation.areSameLength(elements, states)) return;
-      const batches = batchArrays(elements, states, this.batchSize);
+    /**
+     * Sets individual visibility states for multiple elements in a vim.
+     * Each element receives a corresponding visibility state from the input array.
+     * The operation is automatically split into batches if the array is large.
+     *
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices
+     * @param states - Array of visibility states to apply, one per element
+     */
+    RPCSetStatesElements(vimIndex, vimElementIndices, states) {
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
+      if (!Validation.areSameLength(vimElementIndices, states)) return;
+      const batches = batchArrays(vimElementIndices, states, this.batchSize);
       for (const [batchedElements, batchedStates] of batches) {
-        this.rpc.RPCSetStatesElements(componentHandle, batchedElements, batchedStates);
+        this.rpc.RPCSetStatesElements(vimIndex, batchedElements, batchedStates);
       }
     }
-    RPCSetStateVim(componentHandle, state) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      this.rpc.RPCSetStateVim(componentHandle, state);
+    /**
+     * Applies a single visibility state to all elements of a loaded vim.
+     *
+     * @param vimIndex - The index of the loaded vim
+     * @param state - The visibility state to apply (e.g., VISIBLE, HIDDEN)
+     */
+    RPCSetStateVim(vimIndex, state) {
+      if (!Validation.isIndex(vimIndex)) return;
+      this.rpc.RPCSetStateVim(vimIndex, state);
     }
     /*******************************************************************************
      * TEXT AND UI METHODS
@@ -59192,7 +59247,6 @@ void main() {
      * @param color - The color of the text
      * @param text - The content to display
      * @returns Promise resolving to the handle of the created text component
-     * @throws {Error} If the text is empty
      */
     async RPCCreateText(position, color, text) {
       if (!Validation.isNonEmptyString(text)) return INVALID_HANDLE;
@@ -59205,19 +59259,26 @@ void main() {
     /**
      * Destroys a text component, removing it from the scene.
      * @param componentHandle - The handle of the text component to destroy
-     * @throws {Error} If the component handle is invalid
      */
     RPCDestroyText(componentHandle) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
+      if (!Validation.isIndex(componentHandle)) return;
       this.rpc.RPCDestroyText(componentHandle);
     }
     /*******************************************************************************
      * SECTION BOX METHODS
      * Methods for controlling section box visibility and position.
      ******************************************************************************/
+    /**
+     * Enables or disables the section box.
+     * @param enable - True to enable the section box, false to disable it
+     */
     RPCEnableSectionBox(enable) {
       this.rpc.RPCEnableSectionBox(enable);
     }
+    /**
+     * Sets the parameters of the section box.
+     * @param state - The new section box state, including visibility and bounding box
+     */
     RPCSetSectionBox(state) {
       this.rpc.RPCSetSectionBox(
         {
@@ -59226,6 +59287,10 @@ void main() {
         }
       );
     }
+    /**
+     * Retrieves the current section box state.
+     * @returns Promise resolving to the section box state or undefined on failure
+     */
     async RPCGetSectionBox() {
       return await this.safeCall(
         () => this.rpc.RPCGetSectionBox(),
@@ -59282,52 +59347,52 @@ void main() {
     }
     /**
      * Retrieves the axis-aligned bounding box (AABB) that encompasses the entire scene.
-     * This includes all loaded geometry across all VIM components.
+     * This includes all loaded geometry across all loaded vims.
      *
      * @returns Promise resolving to the global AABB of the scene, or undefined on failure
      */
-    RPCGetAABBForAll() {
+    RPCGetAABBForScene() {
       return this.safeCall(
-        () => this.rpc.RPCGetAABBForAll(),
+        () => this.rpc.RPCGetAABBForScene(),
         void 0
       );
     }
     /**
-     * Retrieves the axis-aligned bounding box (AABB) for a specific VIM component.
-     * This bounding box represents the spatial bounds of all geometry within the given component.
+     * Retrieves the axis-aligned bounding box (AABB) for a specific loaded vim.
+     * This bounding box represents the spatial bounds of all geometry within the given loaded vim.
      *
-     * @param componentHandle - The handle of the VIM component to query
-     * @returns Promise resolving to the component’s bounding box, or undefined on failure
+     * @param vimIndex - The index of the loaded vim to query
+     * @returns Promise resolving to the vim bounding box, or undefined on failure
      */
-    async RPCGetAABBForVim(componentHandle) {
+    async RPCGetAABBForVim(vimIndex) {
+      if (!Validation.isIndex(vimIndex)) return void 0;
       return await this.safeCall(
-        () => this.rpc.RPCGetAABBForVim(componentHandle),
+        () => this.rpc.RPCGetAABBForVim(vimIndex),
         void 0
       );
     }
     /**
-     * Calculates the bounding box for specified nodes in a component.
-     * Large node arrays are automatically processed in batches for better performance.
-     * @param componentHandle - The component containing the nodes
-     * @param elements - Array of node indices to calculate bounds for
-     * @returns Promise resolving to the combined bounding box
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     * Calculates the bounding box for specified elements of a loaded vim.
+     * Large element arrays are automatically processed in batches.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to calculate bounds for
+     * @returns Promise resolving to the combined bounding box or undefined on failure
      */
-    async RPCGetAABBForElements(componentHandle, elements) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(elements)) return;
+    async RPCGetAABBForElements(vimIndex, vimElementIndices) {
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
       return await this.safeCall(
-        () => this.RPCGetAABBForElementsBatched(componentHandle, elements),
+        () => this.RPCGetAABBForElementsBatched(vimIndex, vimElementIndices),
         void 0
       );
     }
-    async RPCGetAABBForElementsBatched(componentHandle, elements) {
-      if (elements.length === 0) {
+    async RPCGetAABBForElementsBatched(vimIndex, vimElementIndices) {
+      if (vimElementIndices.length === 0) {
         return new Box3();
       }
-      const batches = batchArray(elements, this.batchSize);
+      const batches = batchArray(vimElementIndices, this.batchSize);
       const promises = batches.map(async (batch) => {
-        const aabb = await this.rpc.RPCGetAABBForElements(componentHandle, batch);
+        const aabb = await this.rpc.RPCGetAABBForElements(vimIndex, 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);
@@ -59338,53 +59403,51 @@ void main() {
       return box;
     }
     /**
-     * Frames the camera to show all components in the scene.
+     * Frames the camera to show all elements in the scene.
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
      */
-    async RPCFrameAll(blendTime) {
+    async RPCFrameScene(blendTime) {
       blendTime = Validation.clamp01(blendTime);
       return await this.safeCall(
-        () => this.rpc.RPCFrameAll(blendTime),
+        () => this.rpc.RPCFrameScene(blendTime),
         void 0
       );
     }
     /**
-     * Frames a specific VIM component in the scene.
-     * @param componentHandle - The handle of the VIM component to frame
+     * Frames a specific vim in the scene.
+     * @param vimIndex - The index of the loaded vim to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
-     * @throws {Error} If the component handle is invalid
      */
-    async RPCFrameVim(componentHandle, blendTime) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
+    async RPCFrameVim(vimIndex, blendTime) {
+      if (!Validation.isIndex(vimIndex)) return;
       blendTime = Validation.clamp01(blendTime);
       return await this.safeCall(
-        () => this.rpc.RPCFrameVim(componentHandle, blendTime),
+        () => this.rpc.RPCFrameVim(vimIndex, blendTime),
         void 0
       );
     }
     /**
-     * Frames specific instances within a component. For large numbers of instances,
-     * automatically switches to bounding box framing for better performance.
-     * @param componentHandle - The component containing the instances
-     * @param elements - Array of node indices to frame
+     * Frames specific elements of a loaded vim.
+     * Automatically batches large arrays of elements.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
-     * @throws {Error} If the component handle is invalid or nodes array is empty
      */
-    async RPCFrameElements(componentHandle, elements, blendTime) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(elements)) return;
+    async RPCFrameElements(vimIndex, vimElementIndices, blendTime) {
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
       blendTime = Validation.clamp01(blendTime);
-      if (elements.length < this.batchSize) {
+      if (vimElementIndices.length < this.batchSize) {
         return await this.safeCall(
-          () => this.rpc.RPCFrameElements(componentHandle, elements, blendTime),
+          () => this.rpc.RPCFrameElements(vimIndex, vimElementIndices, blendTime),
           void 0
         );
       } else {
         const box = await this.safeCall(
-          () => this.RPCGetAABBForElementsBatched(componentHandle, elements),
+          () => this.RPCGetAABBForElementsBatched(vimIndex, vimElementIndices),
           void 0
         );
         if (!box) return void 0;
@@ -59398,7 +59461,6 @@ void main() {
      * Frames the camera to show a specific bounding box.
      * @param box - The bounding box to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
-     * @throws {Error} If the box is invalid (min values must be less than max values)
      */
     async RPCFrameAABB(box, blendTime) {
       if (!Validation.isValidBox(box)) return;
@@ -59415,12 +59477,15 @@ void main() {
     /**
      * Sets the camera movement speed.
      * @param speed - The desired movement speed (must be positive)
-     * @throws {Error} If speed is not positive
      */
     RPCSetCameraSpeed(speed) {
       speed = Validation.min0(speed);
       this.rpc.RPCSetCameraSpeed(speed);
     }
+    /**
+     * Sets the camera control mode.
+     * @param mode - The desired input mode (e.g., {@link InputMode.Orbit} or {@link InputMode.Free})
+     */
     RPCSetCameraMode(mode) {
       this.rpc.RPCSetCameraMode(
         mode === "orbit"
@@ -59429,9 +59494,8 @@ void main() {
     }
     /**
      * Sets the viewer's aspect ratio.
-     * @param width - The width component of the aspect ratio
-     * @param height - The height component of the aspect ratio
-     * @throws {Error} If width or height are not positive integers
+     * @param width - The width of the desired aspect ratio
+     * @param height - The height of the desired aspect ratio
      */
     RPCSetCameraAspectRatio(width, height) {
       if (!Validation.isPositiveInteger(width)) return;
@@ -59440,13 +59504,12 @@ void main() {
     }
     /*******************************************************************************
      * VIM FILE MANAGEMENT METHODS
-     * Methods for loading, unloading, and managing VIM files and components.
+     * Methods for loading, unloading, and managing VIM files.
      ******************************************************************************/
     /**
      * Loads a VIM file from the local filesystem.
      * @param source - The path to the VIM file (supports file:// protocol)
-     * @returns Promise resolving to the handle of the loaded VIM component
-     * @throws {Error} If the filename is invalid or empty
+     * @returns Promise resolving to the index of the loaded vim
      */
     async RPCLoadVim(source) {
       if (!Validation.isNonEmptyString(source.url)) return INVALID_HANDLE;
@@ -59458,9 +59521,8 @@ void main() {
     }
     /**
      * Loads a VIM file from a remote URL.
-     * @param url - The URL of the VIM file to load
-     * @returns Promise resolving to the handle of the loaded VIM component
-     * @throws {Error} If the URL is invalid
+     * @param source - The URL or file path of the VIM file to load
+     * @returns Promise resolving to the index of the loaded vim
      */
     async RPCLoadVimURL(source) {
       if (!Validation.isURL(source.url)) return INVALID_HANDLE;
@@ -59470,17 +59532,16 @@ void main() {
       );
     }
     /**
-     * Retrieves the current loading state and progress of a VIM component.
-     * @param componentHandle - The handle of the VIM component
+     * Retrieves the current loading state and progress of a vim.
+     * @param vimIndex - The index of the vim being loaded
      * @returns Promise resolving to the current loading state and progress
-     * @throws {Error} If the component handle is invalid
      */
-    async RPCGetVimLoadingState(componentHandle) {
-      if (!Validation.isComponentHandle(componentHandle)) {
+    async RPCGetVimLoadingState(vimIndex) {
+      if (!Validation.isIndex(vimIndex)) {
         return { status: 0, progress: 0 };
       }
       const result = await this.safeCall(
-        () => this.rpc.RPCGetVimLoadingState(componentHandle),
+        () => this.rpc.RPCGetVimLoadingState(vimIndex),
         { status: 0, progress: 0 }
       );
       if (!(result.status in VimLoadingStatus)) {
@@ -59489,16 +59550,7 @@ void main() {
       return result;
     }
     /**
-     * Unloads a VIM component and frees associated resources.
-     * @param componentHandle - The handle of the component to unload
-     * @throws {Error} If the component handle is invalid
-     */
-    RPCUnloadVim(componentHandle) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      this.rpc.RPCUnloadVim(componentHandle);
-    }
-    /**
-     * Clears the entire scene, removing all components and resetting to initial state.
+     * Clears the entire scene, unloading all vims and resetting to initial state.
      */
     RPCUnloadAll() {
       this.rpc.RPCUnloadAll();
@@ -59514,7 +59566,7 @@ void main() {
     /**
      * Performs hit testing at a specified screen position.
      * @param pos - Normalized screen coordinates (0-1, 0-1)
-     * @returns Promise resolving to hit test result if something was hit, undefined otherwise
+     * @returns Promise resolving to hit test result if a valid hit was detected, undefined otherwise
      */
     async RPCPerformHitTest(pos) {
       if (!Validation.isRelativeVector2(pos)) return;
@@ -59522,7 +59574,7 @@ void main() {
         () => this.rpc.RPCPerformHitTest(pos),
         void 0
       );
-      if (!result || result.nodeIndex < 0) {
+      if (!result || result.vimIndex === INVALID_HANDLE) {
         return void 0;
       }
       return result;
@@ -59532,7 +59584,6 @@ void main() {
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
      * @param down - True if button is pressed down, false if released
-     * @throws {Error} If mouseButton is not a valid positive integer
      */
     RPCMouseButtonEvent(position, mouseButton, down) {
       if (!Validation.isPositiveInteger(mouseButton)) return;
@@ -59543,7 +59594,6 @@ void main() {
      * Sends a mouse double-click event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
-     * @throws {Error} If mouseButton is not a valid positive integer
      */
     RPCMouseDoubleClickEvent(position, mouseButton) {
       if (!Validation.isPositiveInteger(mouseButton)) return;
@@ -59570,7 +59620,6 @@ void main() {
      * Sends a mouse selection event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
-     * @throws {Error} If mouseButton is not a valid positive integer
      */
     RPCMouseSelectEvent(position, mouseButton) {
       if (!Validation.isPositiveInteger(mouseButton)) return;
@@ -59597,7 +59646,6 @@ void main() {
      * @param smoothness - The smoothness value to apply (clamped between 0 and 1)
      * @param colors - Array of colors for each material instance
      * @returns Array of handles for the created material instances
-     * @throws {Error} If the material handle is invalid or smoothness is out of range
      */
     async RPCCreateMaterialInstances(materialHandle, smoothness, colors) {
       if (!Validation.isMaterialHandle(materialHandle)) return;
@@ -59620,46 +59668,41 @@ void main() {
     }
     /**
      * Destroys multiple material instances, freeing associated resources.
-     * @param materialInstanceHandle - Array of handles for material instances to destroy
-     * @throws {Error} If any handle in the array is invalid
+     * @param materialInstanceHandles - Array of handles for material instances to destroy
      */
-    RPCDestroyMaterialInstances(materialInstanceHandle) {
-      if (!Validation.areComponentHandles(materialInstanceHandle)) return;
-      this.rpc.RPCDestroyMaterialInstances(materialInstanceHandle);
+    RPCDestroyMaterialInstances(materialInstanceHandles) {
+      if (!Validation.areIndices(materialInstanceHandles)) return;
+      this.rpc.RPCDestroyMaterialInstances(materialInstanceHandles);
     }
     /**
-     * Sets material overrides for specific nodes in a component.
-     * Large arrays are automatically processed in batches for better performance.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices to override
-     * @param materialInstanceHandles - Array of material instance handles to apply (must match nodes length)
-     * @throws {Error} If arrays have different lengths or any handle is invalid
+     * Sets material overrides for specific elements in a loaded vim.
+     * Large arrays are automatically processed in batches.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to override
+     * @param materialInstanceHandles - Array of material instance handles to apply (must match element length)
      */
-    RPCSetMaterialOverrides(componentHandle, nodes, materialInstanceHandles) {
-      if (!Validation.areSameLength(nodes, materialInstanceHandles)) return;
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(nodes)) return;
+    RPCSetMaterialOverridesForElements(vimIndex, vimElementIndices, materialInstanceHandles) {
+      if (!Validation.areSameLength(vimElementIndices, materialInstanceHandles)) return;
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
       if (!Validation.areIntegers(materialInstanceHandles)) return;
       this.setMaterialOverridesBatched(
-        componentHandle,
-        nodes,
+        vimIndex,
+        vimElementIndices,
         materialInstanceHandles
       );
     }
-    setMaterialOverridesBatched(componentHandle, nodes, materialInstanceHandles) {
-      const batches = batchArrays(nodes, materialInstanceHandles, this.batchSize);
-      for (const [batchedNodes, batchedMaterials] of batches) {
-        this.rpc.RPCSetMaterialOverrides(componentHandle, batchedNodes, batchedMaterials);
+    setMaterialOverridesBatched(vimIndex, vimElementIndices, materialInstanceHandles) {
+      const batches = batchArrays(vimElementIndices, materialInstanceHandles, this.batchSize);
+      for (const [batchedElements, batchedMaterials] of batches) {
+        this.rpc.RPCSetMaterialOverridesForElements(vimIndex, batchedElements, batchedMaterials);
       }
     }
     /**
-     * Clears all material overrides for the specified component, restoring default materials.
-     * @param componentHandle - The unique identifier of the component
-     * @throws {Error} If the component handle is invalid or INVALID_HANDLE
+     * Clears all material overrides for the entire scene.
      */
-    RPCClearMaterialOverrides(componentHandle) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      this.rpc.RPCClearMaterialOverrides(componentHandle);
+    RPCClearMaterialOverrides() {
+      this.rpc.RPCClearMaterialOverrides();
     }
     /*******************************************************************************
      * DEBUG AND UTILITY METHODS
@@ -59809,7 +59852,7 @@ void main() {
      * @returns Current background blur
      */
     get backgroundBlur() {
-      return this._settings.backGroundBlur;
+      return this._settings.backgroundBlur;
     }
     /**
      * Gets the background color
@@ -59880,8 +59923,8 @@ void main() {
      */
     set backgroundBlur(value) {
       value = Validation.clamp01(value);
-      if (this._settings.backGroundBlur === value) return;
-      this._settings.backGroundBlur = value;
+      if (this._settings.backgroundBlur === value) return;
+      this._settings.backgroundBlur = value;
       this._updateLighting = true;
       this.requestSettingsUpdate();
     }
@@ -59897,7 +59940,7 @@ void main() {
       this.requestSettingsUpdate();
     }
     getBoundingBox() {
-      return this._rpc.RPCGetAABBForAll();
+      return this._rpc.RPCGetAABBForScene();
     }
     /**
      * Requests an update to be performed on the next animation frame.
@@ -60036,7 +60079,7 @@ void main() {
     VisibilityState2[VisibilityState2["GHOSTED_HIGHLIGHTED"] = 18] = "GHOSTED_HIGHLIGHTED";
     return VisibilityState2;
   })(VisibilityState$1 || {});
-  class StateSynchronizer {
+  class VisibilitySynchronizer {
     /**
      * Creates a new StateSynchronizer instance.
      * 
@@ -60054,7 +60097,7 @@ void main() {
       __publicField(this, "_onUpdate");
       __publicField(this, "_isConnected");
       __publicField(this, "_animationFrame");
-      this._tracker = new StateTracker(defaultState);
+      this._tracker = new VisibilityTracker(defaultState);
       this._rpc = rpc;
       this._onUpdate = onUpdate;
       this._getHandle = getHandle;
@@ -60103,7 +60146,7 @@ void main() {
      * @param elementIndex - The element index to update
      * @param state - The new state to apply
      */
-    setElementState(elementIndex, state) {
+    setStateForElement(elementIndex, state) {
       this._tracker.setState(elementIndex, state);
       this.scheduleUpdate();
     }
@@ -60167,7 +60210,7 @@ void main() {
       this._onUpdate();
     }
   }
-  class StateTracker {
+  class VisibilityTracker {
     /**
      * Creates a new StateTracker instance.
      * 
@@ -60804,7 +60847,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       return this.vim.visibility.getElementState(this.element);
     }
     set state(state) {
-      this.vim.visibility.setElementState(this.element, state);
+      this.vim.visibility.setStateForElement(this.element, state);
     }
     /**
      * Gets or sets the color override of the element.
@@ -60834,19 +60877,21 @@ Averrage Date/Second ${avgDataRatePS} kb
       __publicField(this, "_renderer");
       __publicField(this, "_logger");
       // The StateSynchronizer wraps a StateTracker and handles RPC synchronization.
+      // Should be private
       __publicField(this, "visibility");
       // Color tracking remains unchanged.
       __publicField(this, "_nodeColors", /* @__PURE__ */ new Map());
       __publicField(this, "_updatedColors", /* @__PURE__ */ new Set());
       // Delayed update flag.
       __publicField(this, "_updateScheduled", false);
+      __publicField(this, "_elementCount", 0);
       __publicField(this, "_objects", /* @__PURE__ */ new Map());
       this._rpc = rpc;
       this.source = source;
       this._colors = color;
       this._renderer = renderer;
       this._logger = logger;
-      this.visibility = new StateSynchronizer(
+      this.visibility = new VisibilitySynchronizer(
         this._rpc,
         () => this._handle,
         () => this.connected,
@@ -60873,7 +60918,10 @@ Averrage Date/Second ${avgDataRatePS} kb
       throw new Error("Method not implemented.");
     }
     getAllElements() {
-      throw new Error("Method not implemented.");
+      for (var i2 = 0; i2 < this._elementCount; i2++) {
+        this.getElement(i2);
+      }
+      return Array.from(this._objects.values());
     }
     get handle() {
       return this._handle;
@@ -60904,7 +60952,6 @@ Averrage Date/Second ${avgDataRatePS} kb
       (_a3 = this._request) == null ? void 0 : _a3.error("cancelled", "The request was cancelled");
       this._request = void 0;
       if (this.connected) {
-        this._rpc.RPCUnloadVim(this._handle);
         this._handle = -1;
       }
     }
@@ -60926,12 +60973,12 @@ Averrage Date/Second ${avgDataRatePS} kb
             case VimLoadingStatus.FailedToDownload:
             case VimLoadingStatus.FailedToLoad:
             case VimLoadingStatus.Unknown:
-              this._rpc.RPCUnloadVim(handle);
               const details = await this._rpc.RPCGetLastError();
               const error = this.getErrorType(state.status);
               return result.error(error, details);
             case VimLoadingStatus.Done:
               this._handle = handle;
+              this._elementCount = await this._rpc.RPCGetElementCountForVim(handle);
               return result.success(this);
           }
         } catch (e) {
@@ -61012,18 +61059,18 @@ Averrage Date/Second ${avgDataRatePS} kb
       }
       this.scheduleColorUpdate();
     }
-    clearColor(nodes) {
-      if (nodes === "all") {
+    clearColor(elements) {
+      if (elements === "all") {
         this._nodeColors.clear();
       } else {
-        nodes.forEach((n) => this._nodeColors.delete(n));
+        elements.forEach((n) => this._nodeColors.delete(n));
       }
       if (!this.connected) return;
-      if (nodes === "all") {
-        this._rpc.RPCClearMaterialOverrides(this._handle);
+      if (elements === "all") {
+        this._rpc.RPCClearMaterialOverrides();
       } else {
-        const ids = new Array(nodes.length).fill(MaterialHandles.Invalid);
-        this._rpc.RPCSetMaterialOverrides(this._handle, nodes, ids);
+        const ids = new Array(elements.length).fill(MaterialHandles.Invalid);
+        this._rpc.RPCSetMaterialOverridesForElements(this._handle, elements, ids);
       }
     }
     reapplyColors() {
@@ -61048,7 +61095,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       const colors = nodes.map((n) => this._nodeColors.get(n));
       const remoteColors = await this._colors.getColors(colors);
       const colorIds = remoteColors.map((c) => (c == null ? void 0 : c.id) ?? -1);
-      this._rpc.RPCSetMaterialOverrides(this._handle, nodes, colorIds);
+      this._rpc.RPCSetMaterialOverridesForElements(this._handle, nodes, colorIds);
       this._updatedColors.clear();
     }
   }
@@ -61349,6 +61396,9 @@ Averrage Date/Second ${avgDataRatePS} kb
       this._vims.getAll().forEach((vim) => vim.disconnect());
       this._vims.clear();
     }
+    getElement3Ds() {
+      return this.rpc.RPCGetElementCountForScene();
+    }
     /**
      * Disposes all resources used by the viewer and disconnects from the server.
      */