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

package/dist/vim-web.iife.js

@@ -46785,6 +46785,11 @@ void main() {
     * @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.
        */
@@ -50841,6 +50846,164 @@ void main() {
     }
     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
@@ -50892,16 +51055,16 @@ void main() {
     //= ===========================================================================
     // HANDLE VALIDATIONS
     //= ===========================================================================
-    static isComponentHandle(handle) {
-      if (!this.isPositiveInteger(handle)) return false;
-      if (handle === INVALID_HANDLE) {
-        console.warn(`Invalid handle ${handle}. Aborting operation.`);
+    static isIndex(index2) {
+      if (!this.isPositiveInteger(index2)) return false;
+      if (index2 === INVALID_HANDLE) {
+        console.warn(`Invalid index ${index2}. Aborting operation.`);
         return false;
       }
       return true;
     }
-    static areComponentHandles(handles) {
-      return handles.every((h) => this.isComponentHandle(h));
+    static areIndices(indices) {
+      return indices.every((h) => this.isIndex(h));
     }
     static isMaterialHandle(handle) {
       if (!materialHandles.includes(handle)) {
@@ -50950,23 +51113,6 @@ void main() {
       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) {
@@ -51053,6 +51199,13 @@ void main() {
       }
       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),
@@ -57009,6 +57162,11 @@ void main() {
   };
   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.
        */
@@ -57333,155 +57491,6 @@ void main() {
     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 Camera {
     /** 
      * Creates a new Camera instance
@@ -57545,7 +57554,7 @@ void main() {
      * @returns Promise that resolves when the framing animation is complete
      */
     async frameAll(blendTime = this._defaultBlendTime) {
-      const segment = await this._rpc.RPCFrameAll(blendTime);
+      const segment = await this._rpc.RPCFrameScene(blendTime);
       this._savedPosition = this._savedPosition ?? segment;
       return segment;
     }
@@ -57562,16 +57571,16 @@ void main() {
     /**
      * Frames specific nodes of a Vim model in the camera view
      * @param vim - The Vim model containing the nodes to frame
-     * @param nodes - Array of node indices to frame, or 'all' to frame the entire model
+     * @param elements - Array of element indices to frame, or 'all' to frame the entire model
      * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
      * @returns Promise that resolves when the framing animation is complete
      */
-    async frameVim(vim, nodes, blendTime = this._defaultBlendTime) {
+    async frameVim(vim, elements, blendTime = this._defaultBlendTime) {
       let segment;
-      if (nodes === "all") {
+      if (elements === "all") {
         segment = await this._rpc.RPCFrameVim(vim.handle, blendTime);
       } else {
-        segment = await this._rpc.RPCFrameElements(vim.handle, nodes, blendTime);
+        segment = await this._rpc.RPCFrameElements(vim.handle, elements, blendTime);
       }
       this._savedPosition = this._savedPosition ?? segment;
       return segment;
@@ -57654,9 +57663,9 @@ void main() {
     // -------------------- HitCheckResult -------------------
     writeHitCheckResult(data2) {
       this.ensureCapacity(4 + 4 + 4 + 4 * 3 + 4 * 3);
-      this.writeUInt(data2.vimHandle);
-      this.writeUInt(data2.nodeIndex);
-      this.writeUInt(data2.elementIndex);
+      this.writeUInt(data2.vimIndex);
+      this.writeUInt(data2.vimElementIndex);
+      this.writeUInt(data2.sceneElementIndex);
       this.writeVector3(data2.worldPosition);
       this.writeVector3(data2.worldNormal);
     }
@@ -57804,15 +57813,15 @@ void main() {
       return textDecoder.decode(stringData);
     }
     readHitCheckResult() {
-      const vimHandle = this.readUInt();
-      const nodeIndex = this.readUInt();
-      const mElementIndex = this.readUInt();
+      const vimIndex = this.readUInt();
+      const vimElementIndex = this.readUInt();
+      const sceneElementIndex = this.readUInt();
       const worldPosition = this.readVector3();
       const worldNormal = this.readVector3();
       return {
-        vimHandle,
-        nodeIndex,
-        elementIndex: mElementIndex,
+        vimIndex,
+        vimElementIndex,
+        sceneElementIndex,
         worldPosition,
         worldNormal
       };
@@ -57944,10 +57953,22 @@ void main() {
     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) {
@@ -57970,10 +57991,10 @@ void main() {
       const ret = returnMarshal.readUInt();
       return ret;
     }
-    RPCDestroyMaterialInstances(materialInstanceHandle) {
+    RPCDestroyMaterialInstances(materialInstanceHandles) {
       const marshal = new Marshal();
       marshal.writeString("RPCDestroyMaterialInstances");
-      marshal.writeArrayOfUInt(materialInstanceHandle);
+      marshal.writeArrayOfUInt(materialInstanceHandles);
       this._socket.sendRPC(marshal);
     }
     RPCDestroyText(componentHandle) {
@@ -57997,53 +58018,53 @@ void main() {
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCFrameAll(blendTime) {
+    async RPCFrameElements(vimIndex, elementIndices, blendTime) {
       const marshal = new Marshal();
-      marshal.writeString("RPCFrameAll");
+      marshal.writeString("RPCFrameElements");
+      marshal.writeUInt(vimIndex);
+      marshal.writeArrayOfUInt(elementIndices);
       marshal.writeFloat(blendTime);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCFrameElements(componentHandle, elementIndices, blendTime) {
+    async RPCFrameScene(blendTime) {
       const marshal = new Marshal();
-      marshal.writeString("RPCFrameElements");
-      marshal.writeUInt(componentHandle);
-      marshal.writeArrayOfUInt(elementIndices);
+      marshal.writeString("RPCFrameScene");
       marshal.writeFloat(blendTime);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCFrameVim(componentHandle, blendTime) {
+    async RPCFrameVim(vimIndex, blendTime) {
       const marshal = new Marshal();
       marshal.writeString("RPCFrameVim");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       marshal.writeFloat(blendTime);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
-    async RPCGetAABBForAll() {
+    async RPCGetAABBForElements(vimIndex, elementIndices) {
       const marshal = new Marshal();
-      marshal.writeString("RPCGetAABBForAll");
+      marshal.writeString("RPCGetAABBForElements");
+      marshal.writeUInt(vimIndex);
+      marshal.writeArrayOfUInt(elementIndices);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readBox3();
       return ret;
     }
-    async RPCGetAABBForElements(componentHandle, elementIndices) {
+    async RPCGetAABBForScene() {
       const marshal = new Marshal();
-      marshal.writeString("RPCGetAABBForElements");
-      marshal.writeUInt(componentHandle);
-      marshal.writeArrayOfUInt(elementIndices);
+      marshal.writeString("RPCGetAABBForScene");
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readBox3();
       return ret;
     }
-    async RPCGetAABBForVim(componentHandle) {
+    async RPCGetAABBForVim(vimIndex) {
       const marshal = new Marshal();
       marshal.writeString("RPCGetAABBForVim");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readBox3();
       return ret;
@@ -58055,25 +58076,32 @@ void main() {
       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;
@@ -58085,10 +58113,10 @@ void main() {
       const ret = returnMarshal.readString();
       return ret;
     }
-    async RPCGetRoomElements(componentHandle) {
+    async RPCGetRoomElements(vimIndex) {
       const marshal = new Marshal();
       marshal.writeString("RPCGetRoomElements");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readArrayOfUInt();
       return ret;
@@ -58100,10 +58128,10 @@ void main() {
       const ret = returnMarshal.readSectionBoxState();
       return ret;
     }
-    async RPCGetVimLoadingState(componentHandle) {
+    async RPCGetVimLoadingState(vimIndex) {
       const marshal = new Marshal();
       marshal.writeString("RPCGetVimLoadingState");
-      marshal.writeUInt(componentHandle);
+      marshal.writeUInt(vimIndex);
       const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readVimStatus();
       return ret;
@@ -58193,6 +58221,13 @@ void main() {
       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");
@@ -58213,13 +58248,6 @@ void main() {
       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");
@@ -58237,10 +58265,10 @@ void main() {
       marshal.writeRGBA(backgroundColor);
       this._socket.sendRPC(marshal);
     }
-    RPCSetMaterialOverrides(componentHandle, elementIndices, materialInstanceHandles) {
+    RPCSetMaterialOverridesForElements(vimIndex, elementIndices, materialInstanceHandles) {
       const marshal = new Marshal();
-      marshal.writeString("RPCSetMaterialOverrides");
-      marshal.writeUInt(componentHandle);
+      marshal.writeString("RPCSetMaterialOverridesForElements");
+      marshal.writeUInt(vimIndex);
       marshal.writeArrayOfUInt(elementIndices);
       marshal.writeArrayOfUInt(materialInstanceHandles);
       this._socket.sendRPC(marshal);
@@ -58251,25 +58279,31 @@ void main() {
       marshal.writeSectionBoxState(state);
       this._socket.sendRPC(marshal);
     }
-    RPCSetStateVim(componentHandle, state) {
+    RPCSetStateElements(vimIndex, elementIndices, state) {
       const marshal = new Marshal();
-      marshal.writeString("RPCSetStateVim");
-      marshal.writeUInt(componentHandle);
+      marshal.writeString("RPCSetStateElements");
+      marshal.writeUInt(vimIndex);
+      marshal.writeArrayOfUInt(elementIndices);
       marshal.writeUInt(state);
       this._socket.sendRPC(marshal);
     }
-    RPCSetStateElements(componentHandle, elementIndices, state) {
+    RPCSetStateScene(state) {
       const marshal = new Marshal();
-      marshal.writeString("RPCSetStateElements");
-      marshal.writeUInt(componentHandle);
-      marshal.writeArrayOfUInt(elementIndices);
+      marshal.writeString("RPCSetStateScene");
       marshal.writeUInt(state);
       this._socket.sendRPC(marshal);
     }
-    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);
@@ -58297,12 +58331,6 @@ void main() {
       marshal.writeString("RPCUnloadAll");
       this._socket.sendRPC(marshal);
     }
-    RPCUnloadVim(componentHandle) {
-      const marshal = new Marshal();
-      marshal.writeString("RPCUnloadVim");
-      marshal.writeUInt(componentHandle);
-      this._socket.sendRPC(marshal);
-    }
   }
   class RemoteColor {
     /**
@@ -58334,35 +58362,7 @@ void main() {
      * @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.
@@ -58375,6 +58375,12 @@ void main() {
       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 {
     /**
@@ -58394,39 +58400,48 @@ void main() {
      * @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 i2 = 0; i2 < c.length; i2++) {
-        const color = c[i2];
-        if (this._hexToColor.has(color.hex)) {
-          result[i2] = this._hexToColor.get(color.hex);
-        } else if (hexToIndices.has(color.hex)) {
-          hexToIndices.get(color.hex).push(i2);
-        } else {
-          toCreate.push(color);
-          hexToIndices.set(color.hex, [i2]);
+      for (let i2 = 0; i2 < colors.length; i2++) {
+        const color = colors[i2];
+        if (color === void 0) {
+          result[i2] = void 0;
+          continue;
+        }
+        const hex = (color == null ? void 0 : color.getHex()) ?? -1;
+        const remoteColor = this._hexToColor.get(hex);
+        if (remoteColor) {
+          result[i2] = remoteColor;
+          continue;
         }
+        const indices = hexToIndices.get(hex);
+        if (indices) {
+          hexToIndices.get(hex).push(i2);
+          continue;
+        }
+        toCreate.push(color);
+        hexToIndices.set(hex, [i2]);
       }
-      const colors = await this._createColors(toCreate);
-      if (!colors) return void 0;
-      for (let i2 = 0; i2 < colors.length; i2++) {
+      const remoteColors = await this._createColors(toCreate);
+      if (!remoteColors) return void 0;
+      for (let i2 = 0; i2 < remoteColors.length; i2++) {
         const color = toCreate[i2];
-        const indices = hexToIndices.get(color.hex);
+        const indices = hexToIndices.get(color.getHex());
         for (const index2 of indices) {
-          result[index2] = colors[i2];
+          result[index2] = remoteColors[i2];
         }
       }
       return result;
@@ -58469,7 +58484,8 @@ void main() {
       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 i2 = 0; i2 < colors.length; i2++) {
         const color = this._createColor(colors[i2], instances[i2]);
@@ -58486,7 +58502,7 @@ void main() {
      */
     _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;
     }
@@ -59053,9 +59069,9 @@ void main() {
       if (!Validation.isRelativeVector2(position)) return void 0;
       const test2 = await this._rpc.RPCPerformHitTest(position);
       if (!test2) return void 0;
-      const vim = this._vims.getFromHandle(test2.vimHandle);
+      const vim = this._vims.getFromHandle(test2.vimIndex);
       if (!vim) return void 0;
-      const object = vim.getElement(test2.elementIndex);
+      const object = vim.getElement(test2.vimElementIndex);
       if (!object) return void 0;
       return new UltraRaycastResult(
         object,
@@ -59084,7 +59100,7 @@ void main() {
     hdrScale: 1.37,
     hdrBackgroundScale: 1,
     hdrBackgroundSaturation: 1,
-    backGroundBlur: 1,
+    backgroundBlur: 1,
     backgroundColor: new RGBA(0.9, 0.9, 0.9, 1)
   };
   var VimLoadingStatus = /* @__PURE__ */ ((VimLoadingStatus2) => {
@@ -59097,15 +59113,26 @@ void main() {
     return VimLoadingStatus2;
   })(VimLoadingStatus || {});
   class RpcSafeClient {
+    /**
+     * Creates a new RpcSafeClient instance.
+     * @param rpc - The underlying RpcClient used for communication
+     * @param batchSize - Maximum size of batched data for operations (default: 10000)
+     */
     constructor(rpc, batchSize = defaultBatchSize) {
       __publicField(this, "rpc");
       __publicField(this, "batchSize");
       this.rpc = rpc;
       this.batchSize = batchSize;
     }
+    /**
+     * The URL used by the underlying RPC connection.
+     */
     get url() {
       return this.rpc.url;
     }
+    /**
+     * Indicates whether the RPC client is currently connected.
+     */
     get connected() {
       return this.rpc.connected;
     }
@@ -59115,9 +59142,10 @@ void main() {
      * and scene-wide settings.
      ******************************************************************************/
     /**
-     * Initializes and starts the scene with specified settings.
+     * Initializes and starts the scene with the given settings.
      * @param settings - Optional partial scene settings to override defaults
-     * @remarks If no settings are provided, default values will be used
+     * @returns Promise resolving to true if the scene started successfully, false otherwise
+     * @remarks Missing values will be filled from {@link defaultSceneSettings}
      */
     async RPCStartScene(settings2) {
       const s = { ...defaultSceneSettings, ...settings2 ?? {} };
@@ -59127,15 +59155,15 @@ void main() {
           Validation.min0(s.hdrScale),
           Validation.clamp01(s.hdrBackgroundScale),
           Validation.clamp01(s.hdrBackgroundSaturation),
-          Validation.clamp01(s.backGroundBlur),
+          Validation.clamp01(s.backgroundBlur),
           Validation.clampRGBA01(s.backgroundColor)
         ),
         false
       );
     }
     /**
-     * Sets the lighting settings for the scene.
-     * @param settings - The lighting settings to apply
+     * Updates the scene’s lighting configuration.
+     * @param settings - The complete lighting and background settings to apply
      */
     RPCSetLighting(settings2) {
       const s = settings2;
@@ -59144,43 +59172,80 @@ void main() {
         Validation.min0(s.hdrScale),
         Validation.clamp01(s.hdrBackgroundScale),
         Validation.clamp01(s.hdrBackgroundSaturation),
-        Validation.clamp01(s.backGroundBlur),
+        Validation.clamp01(s.backgroundBlur),
         Validation.clampRGBA01(s.backgroundColor)
       );
     }
+    /**
+     * Retrieves the total number of elements across the entire scene.
+     * @returns Promise resolving to the total number of elements (0 on failure).
+     */
+    RPCGetElementCountForScene() {
+      return this.safeCall(
+        () => this.rpc.RPCGetElementCountForScene(),
+        0
+      );
+    }
+    /**
+     * Retrieves the number of elements within a specific loaded vim.
+     * @param vimIndex - Index of the loaded vim to query
+     * @returns Promise resolving to the element count (0 on failure)
+     */
+    RPCGetElementCountForVim(vimIndex) {
+      return this.safeCall(
+        () => this.rpc.RPCGetElementCountForVim(vimIndex),
+        0
+      );
+    }
     /*******************************************************************************
-     * NODE VISIBILITY METHODS
-     * Methods for controlling node visibility, including show/hide, ghosting,
+     * ELEMENTS VISIBILITY METHODS
+     * Methods for controlling element visibility, including show/hide, ghosting,
      * and highlighting functionality.
      ******************************************************************************/
     /**
-     * Highlights specified nodes in a component.
-     * Large node arrays are automatically processed in batches.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices to highlight
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
-     */
-    RPCSetStateElements(componentHandle, elements, state) {
-      if (elements.length === 0) return;
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(elements)) return;
-      const batches = batchArray(elements, this.batchSize);
+     * Sets a single visibility state for given elements within a loaded vim.
+     * The operation is automatically split into batches if the array is large.
+     *
+     * @param vimIndex - The index of the loaded vim containing the elements
+     * @param vimElementIndices - Array of vim-based element indices to apply the state to
+     * @param state - The visibility state to apply (e.g., VISIBLE, HIDDEN)
+     */
+    RPCSetStateElements(vimIndex, vimElementIndices, state) {
+      if (vimElementIndices.length === 0) return;
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
+      const batches = batchArray(vimElementIndices, this.batchSize);
       for (const batch of batches) {
-        this.rpc.RPCSetStateElements(componentHandle, batch, state);
+        this.rpc.RPCSetStateElements(vimIndex, batch, state);
       }
     }
-    RPCSetStatesElements(componentHandle, elements, states) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(elements)) return;
-      if (!Validation.areSameLength(elements, states)) return;
-      const batches = batchArrays(elements, states, this.batchSize);
+    /**
+     * Sets individual visibility states for multiple elements in a vim.
+     * Each element receives a corresponding visibility state from the input array.
+     * The operation is automatically split into batches if the array is large.
+     *
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices
+     * @param states - Array of visibility states to apply, one per element
+     */
+    RPCSetStatesElements(vimIndex, vimElementIndices, states) {
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
+      if (!Validation.areSameLength(vimElementIndices, states)) return;
+      const batches = batchArrays(vimElementIndices, states, this.batchSize);
       for (const [batchedElements, batchedStates] of batches) {
-        this.rpc.RPCSetStatesElements(componentHandle, batchedElements, batchedStates);
+        this.rpc.RPCSetStatesElements(vimIndex, batchedElements, batchedStates);
       }
     }
-    RPCSetStateVim(componentHandle, state) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      this.rpc.RPCSetStateVim(componentHandle, state);
+    /**
+     * Applies a single visibility state to all elements of a loaded vim.
+     *
+     * @param vimIndex - The index of the loaded vim
+     * @param state - The visibility state to apply (e.g., VISIBLE, HIDDEN)
+     */
+    RPCSetStateVim(vimIndex, state) {
+      if (!Validation.isIndex(vimIndex)) return;
+      this.rpc.RPCSetStateVim(vimIndex, state);
     }
     /*******************************************************************************
      * TEXT AND UI METHODS
@@ -59192,7 +59257,6 @@ void main() {
      * @param color - The color of the text
      * @param text - The content to display
      * @returns Promise resolving to the handle of the created text component
-     * @throws {Error} If the text is empty
      */
     async RPCCreateText(position, color, text) {
       if (!Validation.isNonEmptyString(text)) return INVALID_HANDLE;
@@ -59205,19 +59269,26 @@ void main() {
     /**
      * Destroys a text component, removing it from the scene.
      * @param componentHandle - The handle of the text component to destroy
-     * @throws {Error} If the component handle is invalid
      */
     RPCDestroyText(componentHandle) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
+      if (!Validation.isIndex(componentHandle)) return;
       this.rpc.RPCDestroyText(componentHandle);
     }
     /*******************************************************************************
      * SECTION BOX METHODS
      * Methods for controlling section box visibility and position.
      ******************************************************************************/
+    /**
+     * Enables or disables the section box.
+     * @param enable - True to enable the section box, false to disable it
+     */
     RPCEnableSectionBox(enable) {
       this.rpc.RPCEnableSectionBox(enable);
     }
+    /**
+     * Sets the parameters of the section box.
+     * @param state - The new section box state, including visibility and bounding box
+     */
     RPCSetSectionBox(state) {
       this.rpc.RPCSetSectionBox(
         {
@@ -59226,6 +59297,10 @@ void main() {
         }
       );
     }
+    /**
+     * Retrieves the current section box state.
+     * @returns Promise resolving to the section box state or undefined on failure
+     */
     async RPCGetSectionBox() {
       return await this.safeCall(
         () => this.rpc.RPCGetSectionBox(),
@@ -59242,7 +59317,7 @@ void main() {
      */
     async RPCGetCameraView() {
       return await this.safeCall(
-        () => this.rpc.RPCGetCameraView(),
+        () => this.rpc.RPCGetCameraPose(),
         void 0
       );
     }
@@ -59254,7 +59329,7 @@ void main() {
     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.
@@ -59282,52 +59357,52 @@ void main() {
     }
     /**
      * Retrieves the axis-aligned bounding box (AABB) that encompasses the entire scene.
-     * This includes all loaded geometry across all VIM components.
+     * This includes all loaded geometry across all loaded vims.
      *
      * @returns Promise resolving to the global AABB of the scene, or undefined on failure
      */
-    RPCGetAABBForAll() {
+    RPCGetAABBForScene() {
       return this.safeCall(
-        () => this.rpc.RPCGetAABBForAll(),
+        () => this.rpc.RPCGetAABBForScene(),
         void 0
       );
     }
     /**
-     * Retrieves the axis-aligned bounding box (AABB) for a specific VIM component.
-     * This bounding box represents the spatial bounds of all geometry within the given component.
+     * Retrieves the axis-aligned bounding box (AABB) for a specific loaded vim.
+     * This bounding box represents the spatial bounds of all geometry within the given loaded vim.
      *
-     * @param componentHandle - The handle of the VIM component to query
-     * @returns Promise resolving to the component’s bounding box, or undefined on failure
+     * @param vimIndex - The index of the loaded vim to query
+     * @returns Promise resolving to the vim bounding box, or undefined on failure
      */
-    async RPCGetAABBForVim(componentHandle) {
+    async RPCGetAABBForVim(vimIndex) {
+      if (!Validation.isIndex(vimIndex)) return void 0;
       return await this.safeCall(
-        () => this.rpc.RPCGetAABBForVim(componentHandle),
+        () => this.rpc.RPCGetAABBForVim(vimIndex),
         void 0
       );
     }
     /**
-     * Calculates the bounding box for specified nodes in a component.
-     * Large node arrays are automatically processed in batches for better performance.
-     * @param componentHandle - The component containing the nodes
-     * @param elements - Array of node indices to calculate bounds for
-     * @returns Promise resolving to the combined bounding box
-     * @throws {Error} If the component handle is invalid or nodes array is invalid
+     * Calculates the bounding box for specified elements of a loaded vim.
+     * Large element arrays are automatically processed in batches.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to calculate bounds for
+     * @returns Promise resolving to the combined bounding box or undefined on failure
      */
-    async RPCGetAABBForElements(componentHandle, elements) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(elements)) return;
+    async RPCGetAABBForElements(vimIndex, vimElementIndices) {
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
       return await this.safeCall(
-        () => this.RPCGetAABBForElementsBatched(componentHandle, elements),
+        () => this.RPCGetAABBForElementsBatched(vimIndex, vimElementIndices),
         void 0
       );
     }
-    async RPCGetAABBForElementsBatched(componentHandle, elements) {
-      if (elements.length === 0) {
+    async RPCGetAABBForElementsBatched(vimIndex, vimElementIndices) {
+      if (vimElementIndices.length === 0) {
         return new Box3();
       }
-      const batches = batchArray(elements, this.batchSize);
+      const batches = batchArray(vimElementIndices, this.batchSize);
       const promises = batches.map(async (batch) => {
-        const aabb = await this.rpc.RPCGetAABBForElements(componentHandle, batch);
+        const aabb = await this.rpc.RPCGetAABBForElements(vimIndex, batch);
         const v1 = new Vector3(aabb.min.x, aabb.min.y, aabb.min.z);
         const v2 = new Vector3(aabb.max.x, aabb.max.y, aabb.max.z);
         return new Box3(v1, v2);
@@ -59338,53 +59413,51 @@ void main() {
       return box;
     }
     /**
-     * Frames the camera to show all components in the scene.
+     * Frames the camera to show all elements in the scene.
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
      */
-    async RPCFrameAll(blendTime) {
+    async RPCFrameScene(blendTime) {
       blendTime = Validation.clamp01(blendTime);
       return await this.safeCall(
-        () => this.rpc.RPCFrameAll(blendTime),
+        () => this.rpc.RPCFrameScene(blendTime),
         void 0
       );
     }
     /**
-     * Frames a specific VIM component in the scene.
-     * @param componentHandle - The handle of the VIM component to frame
+     * Frames a specific vim in the scene.
+     * @param vimIndex - The index of the loaded vim to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
-     * @throws {Error} If the component handle is invalid
      */
-    async RPCFrameVim(componentHandle, blendTime) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
+    async RPCFrameVim(vimIndex, blendTime) {
+      if (!Validation.isIndex(vimIndex)) return;
       blendTime = Validation.clamp01(blendTime);
       return await this.safeCall(
-        () => this.rpc.RPCFrameVim(componentHandle, blendTime),
+        () => this.rpc.RPCFrameVim(vimIndex, blendTime),
         void 0
       );
     }
     /**
-     * Frames specific instances within a component. For large numbers of instances,
-     * automatically switches to bounding box framing for better performance.
-     * @param componentHandle - The component containing the instances
-     * @param elements - Array of node indices to frame
+     * Frames specific elements of a loaded vim.
+     * Automatically batches large arrays of elements.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
-     * @throws {Error} If the component handle is invalid or nodes array is empty
      */
-    async RPCFrameElements(componentHandle, elements, blendTime) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(elements)) return;
+    async RPCFrameElements(vimIndex, vimElementIndices, blendTime) {
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
       blendTime = Validation.clamp01(blendTime);
-      if (elements.length < this.batchSize) {
+      if (vimElementIndices.length < this.batchSize) {
         return await this.safeCall(
-          () => this.rpc.RPCFrameElements(componentHandle, elements, blendTime),
+          () => this.rpc.RPCFrameElements(vimIndex, vimElementIndices, blendTime),
           void 0
         );
       } else {
         const box = await this.safeCall(
-          () => this.RPCGetAABBForElementsBatched(componentHandle, elements),
+          () => this.RPCGetAABBForElementsBatched(vimIndex, vimElementIndices),
           void 0
         );
         if (!box) return void 0;
@@ -59398,7 +59471,6 @@ void main() {
      * Frames the camera to show a specific bounding box.
      * @param box - The bounding box to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
-     * @throws {Error} If the box is invalid (min values must be less than max values)
      */
     async RPCFrameAABB(box, blendTime) {
       if (!Validation.isValidBox(box)) return;
@@ -59415,12 +59487,15 @@ void main() {
     /**
      * Sets the camera movement speed.
      * @param speed - The desired movement speed (must be positive)
-     * @throws {Error} If speed is not positive
      */
     RPCSetCameraSpeed(speed) {
       speed = Validation.min0(speed);
       this.rpc.RPCSetCameraSpeed(speed);
     }
+    /**
+     * Sets the camera control mode.
+     * @param mode - The desired input mode (e.g., {@link InputMode.Orbit} or {@link InputMode.Free})
+     */
     RPCSetCameraMode(mode) {
       this.rpc.RPCSetCameraMode(
         mode === "orbit"
@@ -59429,9 +59504,8 @@ void main() {
     }
     /**
      * Sets the viewer's aspect ratio.
-     * @param width - The width component of the aspect ratio
-     * @param height - The height component of the aspect ratio
-     * @throws {Error} If width or height are not positive integers
+     * @param width - The width of the desired aspect ratio
+     * @param height - The height of the desired aspect ratio
      */
     RPCSetCameraAspectRatio(width, height) {
       if (!Validation.isPositiveInteger(width)) return;
@@ -59440,13 +59514,12 @@ void main() {
     }
     /*******************************************************************************
      * VIM FILE MANAGEMENT METHODS
-     * Methods for loading, unloading, and managing VIM files and components.
+     * Methods for loading, unloading, and managing VIM files.
      ******************************************************************************/
     /**
      * Loads a VIM file from the local filesystem.
      * @param source - The path to the VIM file (supports file:// protocol)
-     * @returns Promise resolving to the handle of the loaded VIM component
-     * @throws {Error} If the filename is invalid or empty
+     * @returns Promise resolving to the index of the loaded vim
      */
     async RPCLoadVim(source) {
       if (!Validation.isNonEmptyString(source.url)) return INVALID_HANDLE;
@@ -59458,9 +59531,8 @@ void main() {
     }
     /**
      * Loads a VIM file from a remote URL.
-     * @param url - The URL of the VIM file to load
-     * @returns Promise resolving to the handle of the loaded VIM component
-     * @throws {Error} If the URL is invalid
+     * @param source - The URL or file path of the VIM file to load
+     * @returns Promise resolving to the index of the loaded vim
      */
     async RPCLoadVimURL(source) {
       if (!Validation.isURL(source.url)) return INVALID_HANDLE;
@@ -59470,17 +59542,16 @@ void main() {
       );
     }
     /**
-     * Retrieves the current loading state and progress of a VIM component.
-     * @param componentHandle - The handle of the VIM component
+     * Retrieves the current loading state and progress of a vim.
+     * @param vimIndex - The index of the vim being loaded
      * @returns Promise resolving to the current loading state and progress
-     * @throws {Error} If the component handle is invalid
      */
-    async RPCGetVimLoadingState(componentHandle) {
-      if (!Validation.isComponentHandle(componentHandle)) {
+    async RPCGetVimLoadingState(vimIndex) {
+      if (!Validation.isIndex(vimIndex)) {
         return { status: 0, progress: 0 };
       }
       const result = await this.safeCall(
-        () => this.rpc.RPCGetVimLoadingState(componentHandle),
+        () => this.rpc.RPCGetVimLoadingState(vimIndex),
         { status: 0, progress: 0 }
       );
       if (!(result.status in VimLoadingStatus)) {
@@ -59489,16 +59560,7 @@ void main() {
       return result;
     }
     /**
-     * Unloads a VIM component and frees associated resources.
-     * @param componentHandle - The handle of the component to unload
-     * @throws {Error} If the component handle is invalid
-     */
-    RPCUnloadVim(componentHandle) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      this.rpc.RPCUnloadVim(componentHandle);
-    }
-    /**
-     * Clears the entire scene, removing all components and resetting to initial state.
+     * Clears the entire scene, unloading all vims and resetting to initial state.
      */
     RPCUnloadAll() {
       this.rpc.RPCUnloadAll();
@@ -59514,7 +59576,7 @@ void main() {
     /**
      * Performs hit testing at a specified screen position.
      * @param pos - Normalized screen coordinates (0-1, 0-1)
-     * @returns Promise resolving to hit test result if something was hit, undefined otherwise
+     * @returns Promise resolving to hit test result if a valid hit was detected, undefined otherwise
      */
     async RPCPerformHitTest(pos) {
       if (!Validation.isRelativeVector2(pos)) return;
@@ -59522,7 +59584,7 @@ void main() {
         () => this.rpc.RPCPerformHitTest(pos),
         void 0
       );
-      if (!result || result.nodeIndex < 0) {
+      if (!result || result.vimIndex === INVALID_HANDLE) {
         return void 0;
       }
       return result;
@@ -59532,7 +59594,6 @@ void main() {
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
      * @param down - True if button is pressed down, false if released
-     * @throws {Error} If mouseButton is not a valid positive integer
      */
     RPCMouseButtonEvent(position, mouseButton, down) {
       if (!Validation.isPositiveInteger(mouseButton)) return;
@@ -59543,7 +59604,6 @@ void main() {
      * Sends a mouse double-click event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
-     * @throws {Error} If mouseButton is not a valid positive integer
      */
     RPCMouseDoubleClickEvent(position, mouseButton) {
       if (!Validation.isPositiveInteger(mouseButton)) return;
@@ -59570,7 +59630,6 @@ void main() {
      * Sends a mouse selection event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
-     * @throws {Error} If mouseButton is not a valid positive integer
      */
     RPCMouseSelectEvent(position, mouseButton) {
       if (!Validation.isPositiveInteger(mouseButton)) return;
@@ -59597,7 +59656,6 @@ void main() {
      * @param smoothness - The smoothness value to apply (clamped between 0 and 1)
      * @param colors - Array of colors for each material instance
      * @returns Array of handles for the created material instances
-     * @throws {Error} If the material handle is invalid or smoothness is out of range
      */
     async RPCCreateMaterialInstances(materialHandle, smoothness, colors) {
       if (!Validation.isMaterialHandle(materialHandle)) return;
@@ -59620,46 +59678,56 @@ void main() {
     }
     /**
      * Destroys multiple material instances, freeing associated resources.
-     * @param materialInstanceHandle - Array of handles for material instances to destroy
-     * @throws {Error} If any handle in the array is invalid
+     * @param materialInstanceHandles - Array of handles for material instances to destroy
      */
-    RPCDestroyMaterialInstances(materialInstanceHandle) {
-      if (!Validation.areComponentHandles(materialInstanceHandle)) return;
-      this.rpc.RPCDestroyMaterialInstances(materialInstanceHandle);
+    RPCDestroyMaterialInstances(materialInstanceHandles) {
+      if (!Validation.areIndices(materialInstanceHandles)) return;
+      this.rpc.RPCDestroyMaterialInstances(materialInstanceHandles);
     }
     /**
-     * Sets material overrides for specific nodes in a component.
-     * Large arrays are automatically processed in batches for better performance.
-     * @param componentHandle - The component containing the nodes
-     * @param nodes - Array of node indices to override
-     * @param materialInstanceHandles - Array of material instance handles to apply (must match nodes length)
-     * @throws {Error} If arrays have different lengths or any handle is invalid
+     * Sets material overrides for specific elements in a loaded vim.
+     * Large arrays are automatically processed in batches.
+     * @param vimIndex - The index of the loaded vim
+     * @param vimElementIndices - Array of vim-based element indices to override
+     * @param materialInstanceHandles - Array of material instance handles to apply (must match element length)
      */
-    RPCSetMaterialOverrides(componentHandle, nodes, materialInstanceHandles) {
-      if (!Validation.areSameLength(nodes, materialInstanceHandles)) return;
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      if (!Validation.areComponentHandles(nodes)) return;
+    RPCSetMaterialOverridesForElements(vimIndex, vimElementIndices, materialInstanceHandles) {
+      if (!Validation.areSameLength(vimElementIndices, materialInstanceHandles)) return;
+      if (!Validation.isIndex(vimIndex)) return;
+      if (!Validation.areIndices(vimElementIndices)) return;
       if (!Validation.areIntegers(materialInstanceHandles)) return;
       this.setMaterialOverridesBatched(
-        componentHandle,
-        nodes,
+        vimIndex,
+        vimElementIndices,
         materialInstanceHandles
       );
     }
-    setMaterialOverridesBatched(componentHandle, nodes, materialInstanceHandles) {
-      const batches = batchArrays(nodes, materialInstanceHandles, this.batchSize);
-      for (const [batchedNodes, batchedMaterials] of batches) {
-        this.rpc.RPCSetMaterialOverrides(componentHandle, batchedNodes, batchedMaterials);
+    setMaterialOverridesBatched(vimIndex, vimElementIndices, materialInstanceHandles) {
+      const batches = batchArrays(vimElementIndices, materialInstanceHandles, this.batchSize);
+      for (const [batchedElements, batchedMaterials] of batches) {
+        this.rpc.RPCSetMaterialOverridesForElements(vimIndex, batchedElements, batchedMaterials);
       }
     }
     /**
-     * Clears all material overrides for the specified component, restoring default materials.
-     * @param componentHandle - The unique identifier of the component
-     * @throws {Error} If the component handle is invalid or INVALID_HANDLE
+     * Clears all material overrides for the entire scene.
      */
-    RPCClearMaterialOverrides(componentHandle) {
-      if (!Validation.isComponentHandle(componentHandle)) return;
-      this.rpc.RPCClearMaterialOverrides(componentHandle);
+    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
@@ -59716,7 +59784,8 @@ void main() {
   }
   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 Renderer {
     /**
@@ -59763,7 +59832,8 @@ void main() {
      * 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();
@@ -59771,11 +59841,14 @@ void main() {
     // 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
@@ -59809,27 +59882,33 @@ void main() {
      * @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
@@ -59880,24 +59959,24 @@ void main() {
      */
     set backgroundBlur(value) {
       value = Validation.clamp01(value);
-      if (this._settings.backGroundBlur === value) return;
-      this._settings.backGroundBlur = value;
+      if (this._settings.backgroundBlur === value) return;
+      this._settings.backgroundBlur = value;
       this._updateLighting = true;
       this.requestSettingsUpdate();
     }
     /**
      * 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.
@@ -59912,7 +59991,10 @@ void main() {
     }
     async applySettings() {
       if (this._updateLighting) await this._rpc.RPCSetLighting(this._settings);
-      if (this._updateGhostColor) await this._rpc.RPCSetGhostColor(this._settings.ghostColor);
+      if (this._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;
@@ -60012,7 +60094,7 @@ void main() {
      * 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();
@@ -60036,7 +60118,7 @@ void main() {
     VisibilityState2[VisibilityState2["GHOSTED_HIGHLIGHTED"] = 18] = "GHOSTED_HIGHLIGHTED";
     return VisibilityState2;
   })(VisibilityState$1 || {});
-  class StateSynchronizer {
+  class VisibilitySynchronizer {
     /**
      * Creates a new StateSynchronizer instance.
      * 
@@ -60054,7 +60136,7 @@ void main() {
       __publicField(this, "_onUpdate");
       __publicField(this, "_isConnected");
       __publicField(this, "_animationFrame");
-      this._tracker = new StateTracker(defaultState);
+      this._tracker = new VisibilityTracker(defaultState);
       this._rpc = rpc;
       this._onUpdate = onUpdate;
       this._getHandle = getHandle;
@@ -60103,7 +60185,7 @@ void main() {
      * @param elementIndex - The element index to update
      * @param state - The new state to apply
      */
-    setElementState(elementIndex, state) {
+    setStateForElement(elementIndex, state) {
       this._tracker.setState(elementIndex, state);
       this.scheduleUpdate();
     }
@@ -60167,7 +60249,7 @@ void main() {
       this._onUpdate();
     }
   }
-  class StateTracker {
+  class VisibilityTracker {
     /**
      * Creates a new StateTracker instance.
      * 
@@ -60804,7 +60886,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       return this.vim.visibility.getElementState(this.element);
     }
     set state(state) {
-      this.vim.visibility.setElementState(this.element, state);
+      this.vim.visibility.setStateForElement(this.element, state);
     }
     /**
      * Gets or sets the color override of the element.
@@ -60821,11 +60903,12 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @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 Vim {
     constructor(rpc, color, renderer, source, logger) {
+      __publicField(this, "type", "ultra");
       __publicField(this, "source");
       __publicField(this, "_handle", -1);
       __publicField(this, "_request");
@@ -60834,19 +60917,21 @@ Averrage Date/Second ${avgDataRatePS} kb
       __publicField(this, "_renderer");
       __publicField(this, "_logger");
       // The StateSynchronizer wraps a StateTracker and handles RPC synchronization.
+      // Should be private
       __publicField(this, "visibility");
       // Color tracking remains unchanged.
-      __publicField(this, "_nodeColors", /* @__PURE__ */ new Map());
+      __publicField(this, "_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,
@@ -60855,6 +60940,7 @@ Averrage Date/Second ${avgDataRatePS} kb
         // default state
       );
     }
+    //TODO: Rename this to getElementFromNode, prefer using element instead
     getElement(elementIndex) {
       if (this._objects.has(elementIndex)) {
         return this._objects.get(elementIndex);
@@ -60867,13 +60953,16 @@ Averrage Date/Second ${avgDataRatePS} kb
       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 i2 = 0; i2 < this._elementCount; i2++) {
+        this.getElement(i2);
+      }
+      return Array.from(this._objects.values());
     }
     get handle() {
       return this._handle;
@@ -60904,7 +60993,6 @@ Averrage Date/Second ${avgDataRatePS} kb
       (_a3 = this._request) == null ? void 0 : _a3.error("cancelled", "The request was cancelled");
       this._request = void 0;
       if (this.connected) {
-        this._rpc.RPCUnloadVim(this._handle);
         this._handle = -1;
       }
     }
@@ -60926,12 +61014,12 @@ Averrage Date/Second ${avgDataRatePS} kb
             case VimLoadingStatus.FailedToDownload:
             case VimLoadingStatus.FailedToLoad:
             case VimLoadingStatus.Unknown:
-              this._rpc.RPCUnloadVim(handle);
               const details = await this._rpc.RPCGetLastError();
               const error = this.getErrorType(state.status);
               return result.error(error, details);
             case VimLoadingStatus.Done:
               this._handle = handle;
+              this._elementCount = await this._rpc.RPCGetElementCountForVim(handle);
               return result.success(this);
           }
         } catch (e) {
@@ -60971,14 +61059,14 @@ Averrage Date/Second ${avgDataRatePS} kb
       }
       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) {
@@ -60986,49 +61074,49 @@ Averrage Date/Second ${avgDataRatePS} kb
       }
       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 i2 = 0; i2 < color.length; i2++) {
         const c = color[i2];
-        const n = nodes[i2];
+        const element = elements[i2];
         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() {
@@ -61044,11 +61132,11 @@ Averrage Date/Second ${avgDataRatePS} kb
       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();
     }
   }
@@ -61126,6 +61214,11 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @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");
@@ -61349,6 +61442,9 @@ Averrage Date/Second ${avgDataRatePS} kb
       this._vims.getAll().forEach((vim) => vim.disconnect());
       this._vims.clear();
     }
+    getElement3Ds() {
+      return this.rpc.RPCGetElementCountForScene();
+    }
     /**
      * Disposes all resources used by the viewer and disconnects from the server.
      */
@@ -61370,9 +61466,6 @@ Averrage Date/Second ${avgDataRatePS} kb
     INVALID_HANDLE,
     InputMode,
     MaterialHandles,
-    RGB,
-    RGBA,
-    RGBA32,
     Segment,
     Viewer: Viewer$2,
     VimLoadingStatus,
@@ -76163,7 +76256,7 @@ Averrage Date/Second ${avgDataRatePS} kb
         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()
@@ -76244,6 +76337,7 @@ Averrage Date/Second ${avgDataRatePS} kb
           obj.state = VisibilityState.HIGHLIGHTED;
         });
       },
+      // TODO: Change this api to use elements
       isolate: (instances) => {
         hide("all");
         viewer.selection.getAll().forEach((obj) => {
@@ -76277,11 +76371,9 @@ Averrage Date/Second ${avgDataRatePS} kb
           }
         }
       },
-      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) => {