vim-web 0.5.0-dev.0 → 0.5.0-dev.10

package/dist/vim-web.js

@@ -46769,6 +46769,11 @@ let Vim$1 = class Vim {
   * @param {boolean} isLegacy - Indicates whether the Vim object uses a legacy loading pipeline.
   */
   constructor(header, document2, g3d2, scene, settings2, map, builder, source, format) {
+    /**
+     * The type of the viewer, indicating it is a WebGL viewer.
+     * Useful for distinguishing between different viewer types in a multi-viewer application.
+     */
+    __publicField(this, "type", "webgl");
     /**
      * Indicates whether the vim was opened from a vim or vimx file.
      */
@@ -50825,6 +50830,164 @@ function isFilePathOrUri(input) {
   }
   return true;
 }
+class Segment {
+  constructor(origin = new Vector3(), target = new Vector3()) {
+    __publicField(this, "origin");
+    __publicField(this, "target");
+    this.origin = origin;
+    this.target = target;
+  }
+  static fromArray(array) {
+    return new Segment(
+      new Vector3(array[0], array[1], array[2]),
+      new Vector3(array[3], array[4], array[5])
+    );
+  }
+  toArray() {
+    return [this.origin.x, this.origin.y, this.origin.z, this.target.x, this.target.y, this.target.z];
+  }
+  isValid() {
+    return !this.origin.equals(this.target);
+  }
+  equals(segment) {
+    return this.origin.equals(segment.origin) && this.target.equals(segment.target);
+  }
+}
+class RGBA {
+  constructor(r, g, b, a = 1) {
+    __publicField(this, "r");
+    __publicField(this, "g");
+    __publicField(this, "b");
+    __publicField(this, "a");
+    this.r = r;
+    this.g = g;
+    this.b = b;
+    this.a = a;
+  }
+  static fromThree(color, opacity = 1) {
+    return new RGBA(color.r, color.g, color.b, opacity);
+  }
+  toThree() {
+    return new Color(this.r, this.g, this.b);
+  }
+  clone() {
+    return new RGBA(this.r, this.g, this.b, this.a);
+  }
+  isValid() {
+    return Number.isFinite(this.r) && Number.isFinite(this.g) && Number.isFinite(this.b) && Number.isFinite(this.a);
+  }
+  equals(color) {
+    return this.r === color.r && this.g === color.g && this.b === color.b && this.a === color.a;
+  }
+  static fromString(str) {
+    str = str.trim();
+    if (str.startsWith("(")) {
+      str = str.substring(1);
+    }
+    if (str.endsWith(")")) {
+      str = str.substring(0, str.length - 1);
+    }
+    const parts = str.split(",");
+    if (parts.length < 3 || parts.length > 4) {
+      throw new Error("Invalid color string format. Expected 3 or 4 components.");
+    }
+    const r = parseFloat(parts[0]);
+    const g = parseFloat(parts[1]);
+    const b = parseFloat(parts[2]);
+    const a = parts.length === 4 ? parseFloat(parts[3]) : 1;
+    if ([r, g, b, a].some((n) => isNaN(n))) {
+      throw new Error("Invalid number in color string.");
+    }
+    return new RGBA(r, g, b, a);
+  }
+}
+class RGB {
+  constructor(r, g, b) {
+    __publicField(this, "r");
+    __publicField(this, "g");
+    __publicField(this, "b");
+    this.r = r;
+    this.g = g;
+    this.b = b;
+  }
+}
+class RGBA32 {
+  constructor(hex) {
+    __publicField(this, "hex");
+    if (!Number.isInteger(hex) || hex < 0 || hex > 4294967295) {
+      throw new Error("Invalid value: must be a 32-bit unsigned integer");
+    }
+    this.hex = hex;
+  }
+  static fromThree(color, opacity = 1) {
+    return this.fromFloats(color.r, color.g, color.b, opacity);
+  }
+  static fromInts(r, g, b, a = 1) {
+    if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255) {
+      throw new Error("Each RGBA component must be in the range 0-255.");
+    }
+    const hex = r * 2 ** 24 + g * 2 ** 16 + b * 2 ** 8 + a;
+    return new RGBA32(hex);
+  }
+  static fromFloats(r, g, b, a = 1) {
+    return this.fromInts(
+      remap(r, 255),
+      remap(g, 255),
+      remap(b, 255),
+      remap(a, 255)
+    );
+  }
+  static fromString(str) {
+    if (str.startsWith("#")) {
+      str = str.slice(1);
+    }
+    if (str.length === 3 || str.length === 4) {
+      str = str.split("").map((c) => c + c).join("");
+    }
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 255;
+    if (str.length === 6 || str.length === 8) {
+      r = parseInt(str.slice(0, 2), 16);
+      g = parseInt(str.slice(2, 4), 16);
+      b = parseInt(str.slice(4, 6), 16);
+      if (str.length === 8) {
+        a = parseInt(str.slice(6, 8), 16);
+      }
+    } else {
+      throw new Error("Invalid color string format");
+    }
+    if ([r, g, b, a].some((v) => isNaN(v))) {
+      throw new Error("Invalid color string format");
+    }
+    return this.fromInts(r, g, b, a);
+  }
+  /**
+   * The red component of the color in the range [0-255].
+   */
+  get r() {
+    return this.hex >>> 24;
+  }
+  /**
+   * The green component of the color in the range [0-255].
+   */
+  get g() {
+    return this.hex >>> 16 & 255;
+  }
+  /**
+   * The blue component of the color in the range [0-255].
+   */
+  get b() {
+    return this.hex >>> 8 & 255;
+  }
+  /**
+   * The alpha component of the color in the range [0-255].
+   */
+  get a() {
+    return this.hex & 255;
+  }
+}
 class Validation {
   //= ===========================================================================
   // BASIC NUMBER VALIDATIONS
@@ -50876,16 +51039,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)) {
@@ -50934,23 +51097,6 @@ class Validation {
     return true;
   }
   //= ===========================================================================
-  // COLOR VALIDATIONS
-  //= ===========================================================================
-  static isRelativeRGBA(color) {
-    if (color.r < 0 || color.r > 1 || color.g < 0 || color.g > 1 || color.b < 0 || color.b > 1) {
-      console.warn("Invalid value: must be a relative color (0-1, 0-1, 0-1)");
-      return false;
-    }
-    return true;
-  }
-  static isRelativeRGB(color) {
-    if (color.r < 0 || color.r > 1 || color.g < 0 || color.g > 1 || color.b < 0 || color.b > 1) {
-      console.warn("Invalid value: must be a relative color (0-1, 0-1, 0-1)");
-      return false;
-    }
-    return true;
-  }
-  //= ===========================================================================
   // STRING AND URL VALIDATIONS
   //= ===========================================================================
   static isNonEmptyString(value) {
@@ -51037,6 +51183,13 @@ class Validation {
     }
     return value;
   }
+  static clampColor01(value) {
+    return new Color(
+      this.clamp01(value.r),
+      this.clamp01(value.g),
+      this.clamp01(value.b)
+    );
+  }
   static clampRGBA01(value) {
     return new RGBA(
       this.clamp01(value.r),
@@ -56993,6 +57146,11 @@ let Renderer$1 = class Renderer {
 };
 let Viewer$3 = class Viewer {
   constructor(settings2) {
+    /**
+     * The type of the viewer, indicating it is a WebGL viewer.
+     * Useful for distinguishing between different viewer types in a multi-viewer application.
+     */
+    __publicField(this, "type", "webgl");
     /**
      * The settings configuration used by the viewer.
      */
@@ -57317,155 +57475,6 @@ const index$8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   getDefaultVimSettings,
   request: requestVim
 }, Symbol.toStringTag, { value: "Module" }));
-class Segment {
-  constructor(origin = new Vector3(), target = new Vector3()) {
-    __publicField(this, "origin");
-    __publicField(this, "target");
-    this.origin = origin;
-    this.target = target;
-  }
-  static fromArray(array) {
-    return new Segment(
-      new Vector3(array[0], array[1], array[2]),
-      new Vector3(array[3], array[4], array[5])
-    );
-  }
-  toArray() {
-    return [this.origin.x, this.origin.y, this.origin.z, this.target.x, this.target.y, this.target.z];
-  }
-  isValid() {
-    return !this.origin.equals(this.target);
-  }
-  equals(segment) {
-    return this.origin.equals(segment.origin) && this.target.equals(segment.target);
-  }
-}
-class RGBA {
-  constructor(r, g, b, a = 1) {
-    __publicField(this, "r");
-    __publicField(this, "g");
-    __publicField(this, "b");
-    __publicField(this, "a");
-    this.r = r;
-    this.g = g;
-    this.b = b;
-    this.a = a;
-  }
-  clone() {
-    return new RGBA(this.r, this.g, this.b, this.a);
-  }
-  isValid() {
-    return Number.isFinite(this.r) && Number.isFinite(this.g) && Number.isFinite(this.b) && Number.isFinite(this.a);
-  }
-  equals(color) {
-    return this.r === color.r && this.g === color.g && this.b === color.b && this.a === color.a;
-  }
-  static fromString(str) {
-    str = str.trim();
-    if (str.startsWith("(")) {
-      str = str.substring(1);
-    }
-    if (str.endsWith(")")) {
-      str = str.substring(0, str.length - 1);
-    }
-    const parts = str.split(",");
-    if (parts.length < 3 || parts.length > 4) {
-      throw new Error("Invalid color string format. Expected 3 or 4 components.");
-    }
-    const r = parseFloat(parts[0]);
-    const g = parseFloat(parts[1]);
-    const b = parseFloat(parts[2]);
-    const a = parts.length === 4 ? parseFloat(parts[3]) : 1;
-    if ([r, g, b, a].some((n) => isNaN(n))) {
-      throw new Error("Invalid number in color string.");
-    }
-    return new RGBA(r, g, b, a);
-  }
-}
-class RGB {
-  constructor(r, g, b) {
-    __publicField(this, "r");
-    __publicField(this, "g");
-    __publicField(this, "b");
-    this.r = r;
-    this.g = g;
-    this.b = b;
-  }
-}
-class RGBA32 {
-  constructor(hex) {
-    __publicField(this, "hex");
-    if (!Number.isInteger(hex) || hex < 0 || hex > 4294967295) {
-      throw new Error("Invalid value: must be a 32-bit unsigned integer");
-    }
-    this.hex = hex;
-  }
-  static fromInts(r, g, b, a = 1) {
-    if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255) {
-      throw new Error("Each RGBA component must be in the range 0-255.");
-    }
-    const hex = r * 2 ** 24 + g * 2 ** 16 + b * 2 ** 8 + a;
-    return new RGBA32(hex);
-  }
-  static fromFloats(r, g, b, a = 1) {
-    return this.fromInts(
-      remap(r, 255),
-      remap(g, 255),
-      remap(b, 255),
-      remap(a, 255)
-    );
-  }
-  static fromString(str) {
-    if (str.startsWith("#")) {
-      str = str.slice(1);
-    }
-    if (str.length === 3 || str.length === 4) {
-      str = str.split("").map((c) => c + c).join("");
-    }
-    let r = 0;
-    let g = 0;
-    let b = 0;
-    let a = 255;
-    if (str.length === 6 || str.length === 8) {
-      r = parseInt(str.slice(0, 2), 16);
-      g = parseInt(str.slice(2, 4), 16);
-      b = parseInt(str.slice(4, 6), 16);
-      if (str.length === 8) {
-        a = parseInt(str.slice(6, 8), 16);
-      }
-    } else {
-      throw new Error("Invalid color string format");
-    }
-    if ([r, g, b, a].some((v) => isNaN(v))) {
-      throw new Error("Invalid color string format");
-    }
-    return this.fromInts(r, g, b, a);
-  }
-  /**
-   * The red component of the color in the range [0-255].
-   */
-  get r() {
-    return this.hex >>> 24;
-  }
-  /**
-   * The green component of the color in the range [0-255].
-   */
-  get g() {
-    return this.hex >>> 16 & 255;
-  }
-  /**
-   * The blue component of the color in the range [0-255].
-   */
-  get b() {
-    return this.hex >>> 8 & 255;
-  }
-  /**
-   * The alpha component of the color in the range [0-255].
-   */
-  get a() {
-    return this.hex & 255;
-  }
-}
 class Camera3 {
   /** 
    * Creates a new Camera instance
@@ -57529,7 +57538,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 +57555,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 +57647,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 +57797,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 +57937,22 @@ class RpcClient {
   get url() {
     return this._socket.url;
   }
-  RPCClearMaterialOverrides(componentHandle) {
+  RPCClearMaterialOverridesForElements(vimIndex, elementIndices) {
     const marshal = new Marshal();
-    marshal.writeString("RPCClearMaterialOverrides");
-    marshal.writeUInt(componentHandle);
+    marshal.writeString("RPCClearMaterialOverridesForElements");
+    marshal.writeUInt(vimIndex);
+    marshal.writeArrayOfUInt(elementIndices);
+    this._socket.sendRPC(marshal);
+  }
+  RPCClearMaterialOverridesForScene() {
+    const marshal = new Marshal();
+    marshal.writeString("RPCClearMaterialOverridesForScene");
+    this._socket.sendRPC(marshal);
+  }
+  RPCClearMaterialOverridesForVim(vimIndex) {
+    const marshal = new Marshal();
+    marshal.writeString("RPCClearMaterialOverridesForVim");
+    marshal.writeUInt(vimIndex);
     this._socket.sendRPC(marshal);
   }
   async RPCCreateMaterialInstances(materialHandle, smoothness, colors) {
@@ -57954,10 +57975,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 +58002,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;
@@ -58039,25 +58060,32 @@ class RpcClient {
     const ret = returnMarshal.readString();
     return ret;
   }
-  async RPCGetCameraView() {
+  async RPCGetCameraPose() {
     const marshal = new Marshal();
-    marshal.writeString("RPCGetCameraView");
+    marshal.writeString("RPCGetCameraPose");
     const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
     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 RPCGetElementIds(componentHandle) {
+  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(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 +58097,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 +58112,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;
@@ -58177,6 +58205,13 @@ class RpcClient {
     marshal.writeBoolean(orbit2);
     this._socket.sendRPC(marshal);
   }
+  RPCSetCameraPose(state, blendTime) {
+    const marshal = new Marshal();
+    marshal.writeString("RPCSetCameraPose");
+    marshal.writeSegment(state);
+    marshal.writeFloat(blendTime);
+    this._socket.sendRPC(marshal);
+  }
   RPCSetCameraPosition(position, blendTime) {
     const marshal = new Marshal();
     marshal.writeString("RPCSetCameraPosition");
@@ -58197,13 +58232,6 @@ class RpcClient {
     marshal.writeFloat(blendTime);
     this._socket.sendRPC(marshal);
   }
-  RPCSetCameraView(state, blendTime) {
-    const marshal = new Marshal();
-    marshal.writeString("RPCSetCameraView");
-    marshal.writeSegment(state);
-    marshal.writeFloat(blendTime);
-    this._socket.sendRPC(marshal);
-  }
   RPCSetGhostColor(ghostColor) {
     const marshal = new Marshal();
     marshal.writeString("RPCSetGhostColor");
@@ -58221,10 +58249,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 +58263,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);
   }
-  RPCSetStatesElements(componentHandle, elementIndices, states) {
+  RPCSetStateVim(vimIndex, state) {
+    const marshal = new Marshal();
+    marshal.writeString("RPCSetStateVim");
+    marshal.writeUInt(vimIndex);
+    marshal.writeUInt(state);
+    this._socket.sendRPC(marshal);
+  }
+  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 +58315,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 {
   /**
@@ -58318,35 +58346,7 @@ class RemoteColor {
    * @returns {number} The color value as a hexadecimal number.
    */
   get hex() {
-    return this.color.hex;
-  }
-  /**
-   * Gets the red component of the color.
-   * @returns {number} The red component value in the range [0-255].
-   */
-  get r() {
-    return this.color.r;
-  }
-  /**
-   * Gets the green component of the color.
-   * @returns {number} The green component value in the range [0-255].
-   */
-  get g() {
-    return this.color.g;
-  }
-  /**
-   * Gets the blue component of the color.
-   * @returns {number} The blue component value in the range [0-255].
-   */
-  get b() {
-    return this.color.b;
-  }
-  /**
-   * Gets the alpha (opacity) component of the color.
-   * @returns {number} The alpha component value in the range [0-255].
-   */
-  get a() {
-    return this.color.a;
+    return this.color.getHex();
   }
   /**
    * Disposes of the color handle and releases associated resources.
@@ -58359,6 +58359,12 @@ class RemoteColor {
     this._disposed = true;
   }
 }
+function RGBAfromThree(color, opacity = 1) {
+  return new RGBA(color.r, color.g, color.b, opacity);
+}
+function RGBA32fromThree(color, opacity = 1) {
+  return RGBA32.fromFloats(color.r, color.g, color.b, opacity);
+}
 const MAX_BATCH_SIZE = 3e3;
 class ColorManager {
   /**
@@ -58378,39 +58384,48 @@ class ColorManager {
    * @param hex - The RGBA32 color value
    * @returns Promise resolving to a ColorHandle, or undefined if creation fails
    */
-  async getColor(hex) {
-    const colors = await this.getColors([hex]);
+  async getColor(color) {
+    const colors = await this.getColors([color]);
     if (!colors) return void 0;
     return colors[0];
   }
   /**
    * Creates or retrieves cached color instances for multiple hex values.
-   * @param c - Array of RGBA32 color values
+   * @param colors - Array of color values or undefined for no color
    * @returns Promise resolving to an array of ColorHandles in the same order as input, or undefined if creation fails
    * @remarks Duplicate hex values will be mapped to the same color instance for efficiency
    */
-  async getColors(c) {
-    const result = new Array(c.length);
+  async getColors(colors) {
+    const result = new Array(colors.length);
     const hexToIndices = /* @__PURE__ */ new Map();
     const toCreate = [];
-    for (let i = 0; i < c.length; i++) {
-      const color = c[i];
-      if (this._hexToColor.has(color.hex)) {
-        result[i] = this._hexToColor.get(color.hex);
-      } else if (hexToIndices.has(color.hex)) {
-        hexToIndices.get(color.hex).push(i);
-      } else {
-        toCreate.push(color);
-        hexToIndices.set(color.hex, [i]);
+    for (let i = 0; i < colors.length; i++) {
+      const color = colors[i];
+      if (color === void 0) {
+        result[i] = void 0;
+        continue;
+      }
+      const hex = (color == null ? void 0 : color.getHex()) ?? -1;
+      const remoteColor = this._hexToColor.get(hex);
+      if (remoteColor) {
+        result[i] = remoteColor;
+        continue;
       }
+      const indices = hexToIndices.get(hex);
+      if (indices) {
+        hexToIndices.get(hex).push(i);
+        continue;
+      }
+      toCreate.push(color);
+      hexToIndices.set(hex, [i]);
     }
-    const colors = await this._createColors(toCreate);
-    if (!colors) return void 0;
-    for (let i = 0; i < colors.length; i++) {
+    const remoteColors = await this._createColors(toCreate);
+    if (!remoteColors) return void 0;
+    for (let i = 0; i < remoteColors.length; i++) {
       const color = toCreate[i];
-      const indices = hexToIndices.get(color.hex);
+      const indices = hexToIndices.get(color.getHex());
       for (const index2 of indices) {
-        result[index2] = colors[i];
+        result[index2] = remoteColors[i];
       }
     }
     return result;
@@ -58453,7 +58468,8 @@ class ColorManager {
     if (colors.length === 0) {
       return result;
     }
-    const instances = await this._rpc.RPCCreateMaterialInstances(MaterialHandles.StandardOpaque, 1, colors);
+    const rpcColors = colors.map((c) => RGBA32fromThree(c));
+    const instances = await this._rpc.RPCCreateMaterialInstances(MaterialHandles.StandardOpaque, 1, rpcColors);
     if (!instances) return void 0;
     for (let i = 0; i < colors.length; i++) {
       const color = this._createColor(colors[i], instances[i]);
@@ -58470,7 +58486,7 @@ class ColorManager {
    */
   _createColor(color, id2) {
     const handle = new RemoteColor(color, id2, this);
-    this._hexToColor.set(color.hex, handle);
+    this._hexToColor.set(color.getHex(), handle);
     this._idToColor.set(handle.id, handle);
     return handle;
   }
@@ -59037,9 +59053,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 +59084,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 +59097,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 +59126,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 +59139,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 +59156,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 +59241,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 +59253,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 +59281,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(),
@@ -59226,7 +59301,7 @@ class RpcSafeClient {
    */
   async RPCGetCameraView() {
     return await this.safeCall(
-      () => this.rpc.RPCGetCameraView(),
+      () => this.rpc.RPCGetCameraPose(),
       void 0
     );
   }
@@ -59238,7 +59313,7 @@ class RpcSafeClient {
   RPCSetCameraView(segment, blendTime) {
     if (!Validation.isValidSegment(segment)) return;
     blendTime = Validation.clamp01(blendTime);
-    this.rpc.RPCSetCameraView(segment, blendTime);
+    this.rpc.RPCSetCameraPose(segment, blendTime);
   }
   /**
    * Sets the camera's position without changing its target.
@@ -59266,52 +59341,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 +59397,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 +59455,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 +59471,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 +59488,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 +59498,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 +59515,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 +59526,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 +59544,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 +59560,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 +59568,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 +59578,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 +59588,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 +59614,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 +59640,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 +59662,56 @@ 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);
+  RPCClearMaterialOverridesForScene() {
+    this.rpc.RPCClearMaterialOverridesForScene();
+  }
+  /**
+   * Clears all material overrides for a specific loaded vim.
+   * @param vimIndex - The index of the loaded vim
+   */
+  RPCClearMaterialOverridesForVim(vimIndex) {
+    this.rpc.RPCClearMaterialOverridesForVim(vimIndex);
+  }
+  /**
+   * Clears all material overrides for specific elements in a loaded vim.
+   * @param vimIndex - The index of the loaded vim
+   * @param vimElementIndices - Array of vim-based element indices to clear overrides for
+   */
+  RPCClearMaterialOverridesForElements(vimIndex, vimElementIndices) {
+    this.rpc.RPCClearMaterialOverridesForElements(vimIndex, vimElementIndices);
   }
   /*******************************************************************************
    * DEBUG AND UTILITY METHODS
@@ -59700,7 +59768,8 @@ class RpcSafeClient {
 }
 const defaultRenderSettings = {
   ...defaultSceneSettings,
-  ghostColor: new RGBA(14 / 255, 14 / 255, 14 / 255, 64 / 255)
+  ghostColor: new Color(14 / 255, 14 / 255, 14 / 255),
+  ghostOpacity: 64 / 255
 };
 class Renderer2 {
   /**
@@ -59747,7 +59816,8 @@ class Renderer2 {
    * Sets up initial scene settings, ghost color, and IBL rotation
    */
   onConnect() {
-    this._rpc.RPCSetGhostColor(this._settings.ghostColor);
+    const color = RGBAfromThree(this._settings.ghostColor, this._settings.ghostOpacity);
+    this._rpc.RPCSetGhostColor(color);
   }
   notifySceneUpdated() {
     this._onSceneUpdated.dispatch();
@@ -59755,11 +59825,14 @@ class Renderer2 {
   // Getters
   /**
    * Gets the ghost color used for transparent rendering
-   * @returns Current ghost color as RGBA
+   * @returns Current ghost color as a THREE.Color
    */
   get ghostColor() {
     return this._settings.ghostColor;
   }
+  get ghostOpacity() {
+    return this._settings.ghostOpacity;
+  }
   /**
    * Gets the tone mapping white point value
    * @returns Current tone mapping white point
@@ -59793,27 +59866,33 @@ class Renderer2 {
    * @returns Current background blur
    */
   get backgroundBlur() {
-    return this._settings.backGroundBlur;
+    return this._settings.backgroundBlur;
   }
   /**
    * Gets the background color
    * @returns Current background color as RGBA
    */
   get backgroundColor() {
-    return this._settings.backgroundColor;
+    return this._settings.backgroundColor.toThree();
   }
   // Setters
   /**
    * Updates the ghost color used for transparent rendering
-   * @param value - New ghost color as RGBA
+   * @param value - New ghost color as THREE.Color
    */
   set ghostColor(value) {
-    value = Validation.clampRGBA01(value);
     if (this._settings.ghostColor.equals(value)) return;
     this._settings.ghostColor = value;
     this._updateGhostColor = true;
     this.requestSettingsUpdate();
   }
+  set ghostOpacity(value) {
+    value = Validation.clamp01(value);
+    if (this._settings.ghostOpacity === value) return;
+    this._settings.ghostOpacity = value;
+    this._updateGhostColor = true;
+    this.requestSettingsUpdate();
+  }
   /**
    * Sets the tone mapping white point value
    * @param value - New tone mapping white point value
@@ -59864,24 +59943,24 @@ 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();
   }
   /**
    * Sets the background color
-   * @param value - New background color as RGBA
+   * @param value - New background color as THREE.Color
    */
   set backgroundColor(value) {
-    value = Validation.clampRGBA01(value);
-    if (this._settings.backgroundColor.equals(value)) return;
-    this._settings.backgroundColor = value;
+    const color = RGBAfromThree(value, 1);
+    if (this._settings.backgroundColor.equals(color)) return;
+    this._settings.backgroundColor = color;
     this._updateLighting = true;
     this.requestSettingsUpdate();
   }
   getBoundingBox() {
-    return this._rpc.RPCGetAABBForAll();
+    return this._rpc.RPCGetAABBForScene();
   }
   /**
    * Requests an update to be performed on the next animation frame.
@@ -59896,7 +59975,10 @@ class Renderer2 {
   }
   async applySettings() {
     if (this._updateLighting) await this._rpc.RPCSetLighting(this._settings);
-    if (this._updateGhostColor) await this._rpc.RPCSetGhostColor(this._settings.ghostColor);
+    if (this._updateGhostColor) {
+      const color = RGBAfromThree(this._settings.ghostColor, this._settings.ghostOpacity);
+      await this._rpc.RPCSetGhostColor(color);
+    }
     this._updateLighting = false;
     this._updateGhostColor = false;
     this._animationFrame = void 0;
@@ -59996,7 +60078,7 @@ class SectionBox2 {
    * Fits the given box, invalid dimensions will be reversed.
    * @param box - The new bounding box.
    */
-  fitBox(box) {
+  setBox(box) {
     box = safeBox(box);
     this._box = box;
     this.scheduleUpdate();
@@ -60020,7 +60102,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 +60120,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 +60169,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 +60233,7 @@ class StateSynchronizer {
     this._onUpdate();
   }
 }
-class StateTracker {
+class VisibilityTracker {
   /**
    * Creates a new StateTracker instance.
    * 
@@ -60788,7 +60870,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.
@@ -60805,11 +60887,12 @@ class Element3D2 {
    * @returns A promise resolving to the element's bounding box.
    */
   async getBoundingBox() {
-    return this.vim.getBoundingBoxNodes([this.element]);
+    return this.vim.getBoundingBoxForElements([this.element]);
   }
 }
 class Vim2 {
   constructor(rpc, color, renderer, source, logger) {
+    __publicField(this, "type", "ultra");
     __publicField(this, "source");
     __publicField(this, "_handle", -1);
     __publicField(this, "_request");
@@ -60818,19 +60901,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, "_elementColors", /* @__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,
@@ -60839,6 +60924,7 @@ class Vim2 {
       // default state
     );
   }
+  //TODO: Rename this to getElementFromNode, prefer using element instead
   getElement(elementIndex) {
     if (this._objects.has(elementIndex)) {
       return this._objects.get(elementIndex);
@@ -60851,13 +60937,16 @@ class Vim2 {
     throw new Error("Method not implemented.");
   }
   getElementFromIndex(element) {
-    throw new Error("Method not implemented.");
+    return this.getElement(element);
   }
   getObjectsInBox(box) {
     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 +60977,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 +60998,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) {
@@ -60955,14 +61043,14 @@ class Vim2 {
     }
     return handle;
   }
-  async getBoundingBoxNodes(nodes) {
-    if (!this.connected || nodes !== "all" && nodes.length === 0) {
+  async getBoundingBoxForElements(elements) {
+    if (!this.connected || elements !== "all" && elements.length === 0) {
       return Promise.resolve(void 0);
     }
-    if (nodes === "all") {
+    if (elements === "all") {
       return await this._rpc.RPCGetAABBForVim(this._handle);
     }
-    return await this._rpc.RPCGetAABBForElements(this._handle, nodes);
+    return await this._rpc.RPCGetAABBForElements(this._handle, elements);
   }
   async getBoundingBox() {
     if (!this.connected) {
@@ -60970,49 +61058,49 @@ class Vim2 {
     }
     return await this._rpc.RPCGetAABBForVim(this._handle);
   }
-  getColor(node) {
-    return this._nodeColors.get(node);
+  getColor(elementIndex) {
+    return this._elementColors.get(elementIndex);
   }
-  async setColor(nodes, color) {
-    const colors = new Array(nodes.length).fill(color);
-    this.applyColor(nodes, colors);
+  async setColor(elementIndex, color) {
+    const colors = new Array(elementIndex.length).fill(color);
+    this.applyColor(elementIndex, colors);
   }
-  async setColors(nodes, color) {
-    if (color.length !== nodes.length) {
-      throw new Error("Color and nodes length must be equal");
+  async setColors(elements, color) {
+    if (color.length !== elements.length) {
+      throw new Error("Color and elements length must be equal");
     }
-    this.applyColor(nodes, color);
+    this.applyColor(elements, color);
   }
-  applyColor(nodes, color) {
+  applyColor(elements, color) {
     for (let i = 0; i < color.length; i++) {
       const c = color[i];
-      const n = nodes[i];
+      const element = elements[i];
       if (c === void 0) {
-        this._nodeColors.delete(n);
+        this._elementColors.delete(element);
       } else {
-        this._nodeColors.set(n, c);
+        this._elementColors.set(element, c);
       }
-      this._updatedColors.add(n);
+      this._updatedColors.add(element);
     }
     this.scheduleColorUpdate();
   }
-  clearColor(nodes) {
-    if (nodes === "all") {
-      this._nodeColors.clear();
+  //TODO: Remove and rely on element.color
+  clearColor(elements) {
+    if (elements === "all") {
+      this._elementColors.clear();
     } else {
-      nodes.forEach((n) => this._nodeColors.delete(n));
+      elements.forEach((n) => this._elementColors.delete(n));
     }
     if (!this.connected) return;
-    if (nodes === "all") {
-      this._rpc.RPCClearMaterialOverrides(this._handle);
+    if (elements === "all") {
+      this._rpc.RPCClearMaterialOverridesForVim(this._handle);
     } else {
-      const ids = new Array(nodes.length).fill(MaterialHandles.Invalid);
-      this._rpc.RPCSetMaterialOverrides(this._handle, nodes, ids);
+      this._rpc.RPCClearMaterialOverridesForElements(this._handle, elements);
     }
   }
   reapplyColors() {
     this._updatedColors.clear();
-    this._nodeColors.forEach((c, n) => this._updatedColors.add(n));
+    this._elementColors.forEach((c, n) => this._updatedColors.add(n));
     this.scheduleColorUpdate();
   }
   scheduleColorUpdate() {
@@ -61028,11 +61116,11 @@ class Vim2 {
     this._renderer.notifySceneUpdated();
   }
   async updateRemoteColors() {
-    const nodes = Array.from(this._updatedColors);
-    const colors = nodes.map((n) => this._nodeColors.get(n));
+    const elements = Array.from(this._updatedColors);
+    const colors = elements.map((n) => this._elementColors.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, elements, colorIds);
     this._updatedColors.clear();
   }
 }
@@ -61110,6 +61198,11 @@ let Viewer$2 = class Viewer2 {
    * @param logger - Optional logger for logging messages.
    */
   constructor(canvas, logger) {
+    /**
+     * The type of the viewer, indicating it is a WebGL viewer.
+     * Useful for distinguishing between different viewer types in a multi-viewer application.
+     */
+    __publicField(this, "type", "ultra");
     __publicField(this, "_decoder");
     __publicField(this, "_socketClient");
     __publicField(this, "_input");
@@ -61333,6 +61426,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.
    */
@@ -61354,9 +61450,6 @@ const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   INVALID_HANDLE,
   InputMode,
   MaterialHandles,
-  RGB,
-  RGBA,
-  RGBA32,
   Segment,
   Viewer: Viewer$2,
   VimLoadingStatus,
@@ -76147,7 +76240,7 @@ function useUltraSectionBox(viewer) {
       viewer.sectionBox.interactive = b;
     },
     getBox: () => viewer.sectionBox.getBox(),
-    setBox: (box) => viewer.sectionBox.fitBox(box),
+    setBox: (box) => viewer.sectionBox.setBox(box),
     onSelectionChanged: viewer.selection.onSelectionChanged,
     getSelectionBox: () => viewer.selection.getBoundingBox(),
     getSceneBox: () => viewer.renderer.getBoundingBox()
@@ -76228,6 +76321,7 @@ function createAdapter(viewer) {
         obj.state = VisibilityState.HIGHLIGHTED;
       });
     },
+    // TODO: Change this api to use elements
     isolate: (instances) => {
       hide("all");
       viewer.selection.getAll().forEach((obj) => {
@@ -76261,11 +76355,9 @@ function createAdapter(viewer) {
         }
       }
     },
-    getGhostOpacity: () => viewer.renderer.ghostColor.a,
+    getGhostOpacity: () => viewer.renderer.ghostOpacity,
     setGhostOpacity: (opacity) => {
-      const c = viewer.renderer.ghostColor.clone();
-      c.a = opacity;
-      viewer.renderer.ghostColor = c;
+      viewer.renderer.ghostOpacity = opacity;
     },
     getShowRooms: () => true,
     setShowRooms: (show) => {