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

package/dist/vim-web.js

@@ -50876,16 +50876,16 @@ class Validation {
   //= ===========================================================================
   // 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)) {
@@ -57529,7 +57529,7 @@ class Camera3 {
    * @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;
   }
@@ -57546,16 +57546,16 @@ class Camera3 {
   /**
    * 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;
@@ -57638,9 +57638,9 @@ class Marshal {
   // -------------------- 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);
   }
@@ -57788,15 +57788,15 @@ class ReadMarshal {
     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
     };
@@ -57928,10 +57928,9 @@ class RpcClient {
   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) {
@@ -57954,10 +57953,10 @@ class RpcClient {
     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) {
@@ -57981,53 +57980,53 @@ class RpcClient {
     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;
@@ -58046,18 +58045,25 @@ class RpcClient {
     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;
@@ -58069,10 +58075,10 @@ class RpcClient {
     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;
@@ -58084,10 +58090,10 @@ class RpcClient {
     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;
@@ -58221,10 +58227,10 @@ class RpcClient {
     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);
@@ -58235,25 +58241,31 @@ class RpcClient {
     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);
@@ -58281,12 +58293,6 @@ class RpcClient {
     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 {
   /**
@@ -59037,9 +59043,9 @@ class Raycaster3 {
     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,
@@ -59068,7 +59074,7 @@ const defaultSceneSettings = {
   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) => {
@@ -59081,15 +59087,26 @@ var VimLoadingStatus = /* @__PURE__ */ ((VimLoadingStatus2) => {
   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;
   }
@@ -59099,9 +59116,10 @@ class RpcSafeClient {
    * and scene-wide settings.
    ******************************************************************************/
   /**
-   * Initializes and starts the scene with specified settings.
+   * Initializes and starts the scene with the given settings.
    * @param settings - Optional partial scene settings to override defaults
-   * @remarks If no settings are provided, default values will be used
+   * @returns Promise resolving to true if the scene started successfully, false otherwise
+   * @remarks Missing values will be filled from {@link defaultSceneSettings}
    */
   async RPCStartScene(settings2) {
     const s = { ...defaultSceneSettings, ...settings2 ?? {} };
@@ -59111,15 +59129,15 @@ class RpcSafeClient {
         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;
@@ -59128,43 +59146,80 @@ class RpcSafeClient {
       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
@@ -59176,7 +59231,6 @@ class RpcSafeClient {
    * @param color - The color of the text
    * @param text - The content to display
    * @returns Promise resolving to the handle of the created text component
-   * @throws {Error} If the text is empty
    */
   async RPCCreateText(position, color, text) {
     if (!Validation.isNonEmptyString(text)) return INVALID_HANDLE;
@@ -59189,19 +59243,26 @@ class RpcSafeClient {
   /**
    * 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(
       {
@@ -59210,6 +59271,10 @@ class RpcSafeClient {
       }
     );
   }
+  /**
+   * 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(),
@@ -59266,52 +59331,52 @@ class RpcSafeClient {
   }
   /**
    * 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);
@@ -59322,53 +59387,51 @@ class RpcSafeClient {
     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;
@@ -59382,7 +59445,6 @@ class RpcSafeClient {
    * 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;
@@ -59399,12 +59461,15 @@ class RpcSafeClient {
   /**
    * Sets the camera movement speed.
    * @param speed - The desired movement speed (must be positive)
-   * @throws {Error} If speed is not positive
    */
   RPCSetCameraSpeed(speed) {
     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"
@@ -59413,9 +59478,8 @@ class RpcSafeClient {
   }
   /**
    * 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;
@@ -59424,13 +59488,12 @@ class RpcSafeClient {
   }
   /*******************************************************************************
    * 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;
@@ -59442,9 +59505,8 @@ class RpcSafeClient {
   }
   /**
    * 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;
@@ -59454,17 +59516,16 @@ class RpcSafeClient {
     );
   }
   /**
-   * 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)) {
@@ -59473,16 +59534,7 @@ class RpcSafeClient {
     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();
@@ -59498,7 +59550,7 @@ class RpcSafeClient {
   /**
    * Performs hit testing at a specified screen position.
    * @param pos - Normalized screen coordinates (0-1, 0-1)
-   * @returns Promise resolving to hit test result if something was hit, undefined otherwise
+   * @returns Promise resolving to hit test result if a valid hit was detected, undefined otherwise
    */
   async RPCPerformHitTest(pos) {
     if (!Validation.isRelativeVector2(pos)) return;
@@ -59506,7 +59558,7 @@ class RpcSafeClient {
       () => this.rpc.RPCPerformHitTest(pos),
       void 0
     );
-    if (!result || result.nodeIndex < 0) {
+    if (!result || result.vimIndex === INVALID_HANDLE) {
       return void 0;
     }
     return result;
@@ -59516,7 +59568,6 @@ class RpcSafeClient {
    * @param position - The normalized screen coordinates (0-1, 0-1)
    * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
    * @param down - True if button is pressed down, false if released
-   * @throws {Error} If mouseButton is not a valid positive integer
    */
   RPCMouseButtonEvent(position, mouseButton, down) {
     if (!Validation.isPositiveInteger(mouseButton)) return;
@@ -59527,7 +59578,6 @@ class RpcSafeClient {
    * 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;
@@ -59554,7 +59604,6 @@ class RpcSafeClient {
    * Sends a mouse selection event to the viewer.
    * @param position - The normalized screen coordinates (0-1, 0-1)
    * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
-   * @throws {Error} If mouseButton is not a valid positive integer
    */
   RPCMouseSelectEvent(position, mouseButton) {
     if (!Validation.isPositiveInteger(mouseButton)) return;
@@ -59581,7 +59630,6 @@ class RpcSafeClient {
    * @param smoothness - The smoothness value to apply (clamped between 0 and 1)
    * @param colors - Array of colors for each material instance
    * @returns Array of handles for the created material instances
-   * @throws {Error} If the material handle is invalid or smoothness is out of range
    */
   async RPCCreateMaterialInstances(materialHandle, smoothness, colors) {
     if (!Validation.isMaterialHandle(materialHandle)) return;
@@ -59604,46 +59652,41 @@ class RpcSafeClient {
   }
   /**
    * 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
@@ -59793,7 +59836,7 @@ class Renderer2 {
    * @returns Current background blur
    */
   get backgroundBlur() {
-    return this._settings.backGroundBlur;
+    return this._settings.backgroundBlur;
   }
   /**
    * Gets the background color
@@ -59864,8 +59907,8 @@ class Renderer2 {
    */
   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();
   }
@@ -59881,7 +59924,7 @@ class Renderer2 {
     this.requestSettingsUpdate();
   }
   getBoundingBox() {
-    return this._rpc.RPCGetAABBForAll();
+    return this._rpc.RPCGetAABBForScene();
   }
   /**
    * Requests an update to be performed on the next animation frame.
@@ -60020,7 +60063,7 @@ var VisibilityState$1 = /* @__PURE__ */ ((VisibilityState2) => {
   VisibilityState2[VisibilityState2["GHOSTED_HIGHLIGHTED"] = 18] = "GHOSTED_HIGHLIGHTED";
   return VisibilityState2;
 })(VisibilityState$1 || {});
-class StateSynchronizer {
+class VisibilitySynchronizer {
   /**
    * Creates a new StateSynchronizer instance.
    * 
@@ -60038,7 +60081,7 @@ class StateSynchronizer {
     __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;
@@ -60087,7 +60130,7 @@ class StateSynchronizer {
    * @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();
   }
@@ -60151,7 +60194,7 @@ class StateSynchronizer {
     this._onUpdate();
   }
 }
-class StateTracker {
+class VisibilityTracker {
   /**
    * Creates a new StateTracker instance.
    * 
@@ -60788,7 +60831,7 @@ class Element3D2 {
     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.
@@ -60818,19 +60861,21 @@ class Vim2 {
     __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,
@@ -60857,7 +60902,10 @@ class Vim2 {
     throw new Error("Method not implemented.");
   }
   getAllElements() {
-    throw new Error("Method not implemented.");
+    for (var i = 0; i < this._elementCount; i++) {
+      this.getElement(i);
+    }
+    return Array.from(this._objects.values());
   }
   get handle() {
     return this._handle;
@@ -60888,7 +60936,6 @@ class Vim2 {
     (_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;
     }
   }
@@ -60910,12 +60957,12 @@ class Vim2 {
           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) {
@@ -60996,18 +61043,18 @@ class Vim2 {
     }
     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() {
@@ -61032,7 +61079,7 @@ class Vim2 {
     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();
   }
 }
@@ -61333,6 +61380,9 @@ let Viewer$2 = class Viewer2 {
     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.
    */