vim-web 0.3.43 → 0.3.44-dev.1

package/dist/vim-web.iife.js

@@ -47164,6 +47164,154 @@ void main() {
       this.scene.dispose();
     }
   };
+  function mergeGeometries(geometries, useGroups = false) {
+    const isIndexed = geometries[0].index !== null;
+    const attributesUsed = new Set(Object.keys(geometries[0].attributes));
+    const morphAttributesUsed = new Set(Object.keys(geometries[0].morphAttributes));
+    const attributes = {};
+    const morphAttributes = {};
+    const morphTargetsRelative = geometries[0].morphTargetsRelative;
+    const mergedGeometry = new BufferGeometry();
+    let offset = 0;
+    for (let i2 = 0; i2 < geometries.length; ++i2) {
+      const geometry = geometries[i2];
+      let attributesCount = 0;
+      if (isIndexed !== (geometry.index !== null)) {
+        console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + i2 + ". All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.");
+        return null;
+      }
+      for (const name in geometry.attributes) {
+        if (!attributesUsed.has(name)) {
+          console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + i2 + '. All geometries must have compatible attributes; make sure "' + name + '" attribute exists among all geometries, or in none of them.');
+          return null;
+        }
+        if (attributes[name] === void 0) attributes[name] = [];
+        attributes[name].push(geometry.attributes[name]);
+        attributesCount++;
+      }
+      if (attributesCount !== attributesUsed.size) {
+        console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + i2 + ". Make sure all geometries have the same number of attributes.");
+        return null;
+      }
+      if (morphTargetsRelative !== geometry.morphTargetsRelative) {
+        console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + i2 + ". .morphTargetsRelative must be consistent throughout all geometries.");
+        return null;
+      }
+      for (const name in geometry.morphAttributes) {
+        if (!morphAttributesUsed.has(name)) {
+          console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + i2 + ".  .morphAttributes must be consistent throughout all geometries.");
+          return null;
+        }
+        if (morphAttributes[name] === void 0) morphAttributes[name] = [];
+        morphAttributes[name].push(geometry.morphAttributes[name]);
+      }
+      if (useGroups) {
+        let count;
+        if (isIndexed) {
+          count = geometry.index.count;
+        } else if (geometry.attributes.position !== void 0) {
+          count = geometry.attributes.position.count;
+        } else {
+          console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + i2 + ". The geometry must have either an index or a position attribute");
+          return null;
+        }
+        mergedGeometry.addGroup(offset, count, i2);
+        offset += count;
+      }
+    }
+    if (isIndexed) {
+      let indexOffset = 0;
+      const mergedIndex = [];
+      for (let i2 = 0; i2 < geometries.length; ++i2) {
+        const index2 = geometries[i2].index;
+        for (let j = 0; j < index2.count; ++j) {
+          mergedIndex.push(index2.getX(j) + indexOffset);
+        }
+        indexOffset += geometries[i2].attributes.position.count;
+      }
+      mergedGeometry.setIndex(mergedIndex);
+    }
+    for (const name in attributes) {
+      const mergedAttribute = mergeAttributes(attributes[name]);
+      if (!mergedAttribute) {
+        console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the " + name + " attribute.");
+        return null;
+      }
+      mergedGeometry.setAttribute(name, mergedAttribute);
+    }
+    for (const name in morphAttributes) {
+      const numMorphTargets = morphAttributes[name][0].length;
+      if (numMorphTargets === 0) break;
+      mergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {};
+      mergedGeometry.morphAttributes[name] = [];
+      for (let i2 = 0; i2 < numMorphTargets; ++i2) {
+        const morphAttributesToMerge = [];
+        for (let j = 0; j < morphAttributes[name].length; ++j) {
+          morphAttributesToMerge.push(morphAttributes[name][j][i2]);
+        }
+        const mergedMorphAttribute = mergeAttributes(morphAttributesToMerge);
+        if (!mergedMorphAttribute) {
+          console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the " + name + " morphAttribute.");
+          return null;
+        }
+        mergedGeometry.morphAttributes[name].push(mergedMorphAttribute);
+      }
+    }
+    return mergedGeometry;
+  }
+  function mergeAttributes(attributes) {
+    let TypedArray;
+    let itemSize;
+    let normalized;
+    let gpuType = -1;
+    let arrayLength = 0;
+    for (let i2 = 0; i2 < attributes.length; ++i2) {
+      const attribute = attributes[i2];
+      if (TypedArray === void 0) TypedArray = attribute.array.constructor;
+      if (TypedArray !== attribute.array.constructor) {
+        console.error("THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.");
+        return null;
+      }
+      if (itemSize === void 0) itemSize = attribute.itemSize;
+      if (itemSize !== attribute.itemSize) {
+        console.error("THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.");
+        return null;
+      }
+      if (normalized === void 0) normalized = attribute.normalized;
+      if (normalized !== attribute.normalized) {
+        console.error("THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.");
+        return null;
+      }
+      if (gpuType === -1) gpuType = attribute.gpuType;
+      if (gpuType !== attribute.gpuType) {
+        console.error("THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes.");
+        return null;
+      }
+      arrayLength += attribute.count * itemSize;
+    }
+    const array = new TypedArray(arrayLength);
+    const result = new BufferAttribute(array, itemSize, normalized);
+    let offset = 0;
+    for (let i2 = 0; i2 < attributes.length; ++i2) {
+      const attribute = attributes[i2];
+      if (attribute.isInterleavedBufferAttribute) {
+        const tupleOffset = offset / itemSize;
+        for (let j = 0, l = attribute.count; j < l; j++) {
+          for (let c = 0; c < itemSize; c++) {
+            const value = attribute.getComponent(j, c);
+            result.setComponent(j + tupleOffset, c, value);
+          }
+        }
+      } else {
+        array.set(attribute.array, offset);
+      }
+      offset += attribute.count * itemSize;
+    }
+    if (gpuType !== void 0) {
+      result.gpuType = gpuType;
+    }
+    return result;
+  }
   function estimateBytesUsed(geometry) {
     let mem = 0;
     for (const name in geometry.attributes) {
@@ -50120,7 +50268,7 @@ void main() {
       fov: 50,
       zoom: 1,
       // 45 deg down looking down z.
-      forward: new Vector3$1(1, -1, 1),
+      forward: new Vector3$1(1, -1, -1),
       controls: {
         orbit: true,
         rotateSpeed: 1,
@@ -50444,18 +50592,18 @@ void main() {
     orbitTowards(direction) {
       const forward = this._camera.forward;
       const _direction = direction.clone();
-      if (_direction.x === 0 && _direction.z === 0) {
+      if (_direction.x === 0 && _direction.y === 0) {
         _direction.x = this._camera.forward.x * 1e-3;
-        _direction.z = this._camera.forward.z * 1e-3;
+        _direction.y = this._camera.forward.y * 1e-3;
         _direction.normalize();
       }
-      const flatForward = forward.clone().setY(0);
-      const flatDirection = _direction.clone().setY(0);
+      const flatForward = forward.clone().setZ(0);
+      const flatDirection = _direction.clone().setZ(0);
       const cross = flatForward.clone().cross(flatDirection);
-      const clockwise = cross.y === 0 ? 1 : Math.sign(cross.y);
+      const clockwise = cross.z === 0 ? 1 : Math.sign(cross.z);
       const azimuth = flatForward.angleTo(flatDirection) * clockwise;
-      const angleForward = flatForward.angleTo(forward) * Math.sign(forward.y);
-      const angleDirection = flatDirection.angleTo(_direction) * Math.sign(_direction.y);
+      const angleForward = flatForward.angleTo(forward) * Math.sign(forward.z);
+      const angleDirection = flatDirection.angleTo(_direction) * Math.sign(_direction.z);
       const declination = angleForward - angleDirection;
       const angle = new Vector2$1(-declination, azimuth);
       angle.multiplyScalar(180 / Math.PI);
@@ -50663,12 +50811,30 @@ void main() {
       this.set(pos, target);
     }
     set(position, target) {
-      const locked = this.lockVector(position, this._camera.position);
-      this._camera.position.copy(locked);
       target = target ?? this._camera.target;
+      const direction = new Vector3$1().subVectors(position, target);
+      const dist2 = direction.length();
+      if (dist2 > 1e-6) {
+        const up = new Vector3$1(0, 0, 1);
+        const angle = direction.angleTo(up);
+        const minAngle = MathUtils.degToRad(5);
+        const maxAngle = MathUtils.degToRad(175);
+        if (angle < minAngle) {
+          const axis = new Vector3$1().crossVectors(up, direction).normalize();
+          const delta = minAngle - angle;
+          direction.applyQuaternion(new Quaternion().setFromAxisAngle(axis, delta));
+        } else if (angle > maxAngle) {
+          const axis = new Vector3$1().crossVectors(up, direction).normalize();
+          const delta = maxAngle - angle;
+          direction.applyQuaternion(new Quaternion().setFromAxisAngle(axis, delta));
+        }
+        position.copy(target).add(direction);
+      }
+      const lockedPos = this.lockVector(position, this._camera.position);
+      this._camera.position.copy(lockedPos);
       this._camera.target.copy(target);
+      this._camera.camPerspective.camera.up.set(0, 0, 1);
       this._camera.camPerspective.camera.lookAt(target);
-      this._camera.camPerspective.camera.up.set(0, 1, 0);
     }
     lockVector(position, fallback) {
       const x = this._camera.allowedMovement.x === 0 ? fallback.x : position.x;
@@ -50679,17 +50845,14 @@ void main() {
     predictOrbit(angle) {
       const rotation = this.predictRotate(angle);
       const delta = new Vector3$1(0, 0, 1).applyQuaternion(rotation).multiplyScalar(this._camera.orbitDistance);
-      return this._camera.target.clone().add(delta);
+      const pos = this._camera.target.clone().add(delta);
+      return pos;
     }
     predictRotate(angle) {
-      const euler = new Euler(0, 0, 0, "YXZ");
-      euler.setFromQuaternion(this._camera.quaternion);
-      euler.x += angle.x * Math.PI / 180;
-      euler.y += angle.y * Math.PI / 180;
-      euler.z = 0;
-      const max2 = Math.PI * 0.4999;
-      euler.x = Math.max(-max2, Math.min(max2, euler.x));
-      const rotation = new Quaternion().setFromEuler(euler);
+      const xQuat = new Quaternion().setFromAxisAngle(new Vector3$1(1, 0, 0), angle.x * Math.PI / 180);
+      const zQuat = new Quaternion().setFromAxisAngle(new Vector3$1(0, 1, 0), angle.y * Math.PI / 180);
+      const rotation = this._camera.quaternion.clone();
+      rotation.multiply(xQuat).multiply(zQuat);
       return rotation;
     }
   }
@@ -50738,6 +50901,8 @@ void main() {
       __publicField(this, "_velocityBlendFactor", 1e-4);
       __publicField(this, "_moveSpeed", 1);
       this.camPerspective = new PerspectiveWrapper(new PerspectiveCamera());
+      this.camPerspective.camera.up = new Vector3$1(0, 0, 1);
+      this.camPerspective.camera.lookAt(new Vector3$1(0, 1, 0));
       this.camOrthographic = new OrthographicWrapper(
         new OrthographicCamera()
       );
@@ -50798,7 +50963,7 @@ void main() {
     }
     set defaultForward(value) {
       if (value.x === 0 && value.y === 0 && value.z === 0) {
-        this._defaultForward.set(1, -1, 1).normalize();
+        this._defaultForward.set(1, -1, -1).normalize();
       } else {
         this._defaultForward.copy(value).normalize();
       }
@@ -54885,8 +55050,314 @@ void main() {
       this._meshes = void 0;
     }
   }
-  class BoxOutline extends LineSegments {
+  const MIN_BOX_SIZE = 3;
+  class BoxInputs {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    /**
+     * Creates a new BoxInputs instance for pointer-driven box resizing.
+     * 
+     * @param viewer - The parent {@link Viewer} that renders the scene.
+     * @param handles - A {@link SectionBoxHandles} instance containing the draggable mesh handles.
+     * @param box - The shared bounding box (`Box3`) that will be updated by dragging.
+     */
+    constructor(viewer, handles, box) {
+      // -------------------------------------------------------------------------
+      // Dependencies and shared resources
+      // -------------------------------------------------------------------------
+      /** The parent Viewer controlling the scene. */
+      __publicField(this, "_viewer");
+      /** The handles mesh group containing the draggable cones/faces. */
+      __publicField(this, "_handles");
+      /** The main box that is being reshaped by dragging handles. */
+      __publicField(this, "_sharedBox");
+      // -------------------------------------------------------------------------
+      // Internal state
+      // -------------------------------------------------------------------------
+      /** The currently hovered/dragged handle, if any. */
+      __publicField(this, "_handle");
+      /** The origin point for dragging, updated on pointer down. */
+      __publicField(this, "_dragOrigin", new Vector3$1());
+      /** The plane used for drag intersection (perpendicular to the camera direction). */
+      __publicField(this, "_dragPlane", new Plane());
+      /** Whether a pointer is currently down on a handle. */
+      __publicField(this, "_mouseDown", false);
+      /** A reusable Raycaster for picking and plane intersection. */
+      __publicField(this, "_raycaster", new Raycaster$1());
+      /** The box state before the current drag. */
+      __publicField(this, "_lastBox", new Box3$1());
+      /** A collection of unregister callbacks for event listeners. */
+      __publicField(this, "_unregisters", []);
+      /** The ID of the pointer that is captured, if any. */
+      __publicField(this, "_capturedPointerId");
+      // -------------------------------------------------------------------------
+      // Callbacks
+      // -------------------------------------------------------------------------
+      /**
+       * Called when the pointer enters or leaves a handle face.
+       * @param normal - The normal (forward) vector of the hovered handle, or a zero vector if none.
+       */
+      __publicField(this, "onFaceEnter");
+      /**
+       * Called continuously as the box is reshaped by dragging.
+       * @param box - The updated box after the latest drag move.
+       */
+      __publicField(this, "onBoxStretch");
+      /**
+       * Called when the user has finished reshaping the box (pointer up).
+       * @param box - The final box after dragging ends.
+       */
+      __publicField(this, "onBoxConfirm");
+      this._viewer = viewer;
+      this._handles = handles;
+      this._sharedBox = box;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Registers pointer event listeners on the viewer's canvas. 
+     * If already registered, it does nothing.
+     */
+    register() {
+      if (this._unregisters.length > 0) return;
+      const canvas = this._viewer.viewport.canvas;
+      this.reg(canvas, "pointerdown", (e) => this.onMouseDown(e));
+      this.reg(canvas, "pointermove", (e) => this.onMouseMove(e));
+      this.reg(canvas, "pointerup", (e) => this.onMouseUp(e));
+      this.reg(canvas, "pointerleave", (e) => this.onPointerLeave(e));
+    }
+    /**
+     * Unregisters any previously set pointer event listeners, releasing pointer capture
+     * and resetting drag state.
+     */
+    unregister() {
+      var _a2;
+      this._mouseDown = false;
+      (_a2 = this._handle) == null ? void 0 : _a2.highlight(false);
+      this._handle = void 0;
+      this.releasePointer();
+      this._viewer.inputs.registerAll();
+      this._unregisters.forEach((unreg) => unreg());
+      this._unregisters.length = 0;
+    }
+    /**
+     * Indicates if a pointer is currently captured for dragging.
+     */
+    get pointerCaptured() {
+      return this._capturedPointerId !== void 0;
+    }
+    // -------------------------------------------------------------------------
+    // Private Methods
+    // -------------------------------------------------------------------------
+    /**
+     * A helper method to attach an event listener and store its unregister callback.
+     * 
+     * @param handler - The DOM element or Window to attach the listener to.
+     * @param type - The pointer event type, e.g. 'pointerdown'.
+     * @param listener - The event handler function.
+     */
+    reg(handler, type, listener2) {
+      handler.addEventListener(type, listener2);
+      this._unregisters.push(() => handler.removeEventListener(type, listener2));
+    }
+    /**
+     * Called when the pointer leaves the canvas. If not dragging,
+     * invokes {@link onFaceEnter} to indicate no active handle is hovered.
+     * 
+     * @param event - The pointerleave event.
+     */
+    onPointerLeave(event) {
+      var _a2, _b2;
+      if (!this.pointerCaptured) {
+        (_b2 = this.onFaceEnter) == null ? void 0 : _b2.call(this, ((_a2 = this._handle) == null ? void 0 : _a2.forward) ?? new Vector3$1());
+      }
+    }
+    /**
+     * Sets pointer capture on the canvas for a specific pointer (ID).
+     * 
+     * @param pointerId - The pointer ID to capture.
+     */
+    capturePointer(pointerId) {
+      this.releasePointer();
+      this._viewer.viewport.canvas.setPointerCapture(pointerId);
+      this._capturedPointerId = pointerId;
+    }
+    /**
+     * Releases any captured pointer on the canvas, if present.
+     */
+    releasePointer() {
+      if (this.pointerCaptured) {
+        this._viewer.viewport.canvas.releasePointerCapture(this._capturedPointerId);
+        this._capturedPointerId = void 0;
+      }
+    }
+    /**
+     * Handles pointer movement events.
+     * - If dragging, calls {@link onDrag}.
+     * - Otherwise, performs a raycast to detect which handle is under the pointer.
+     * 
+     * @param event - The pointermove event.
+     */
+    onMouseMove(event) {
+      var _a2, _b2, _c, _d;
+      if (this._mouseDown) {
+        this.onDrag(event);
+        return;
+      }
+      const hits = this.raycast(new Vector2$1(event.offsetX, event.offsetY));
+      const handle = (_b2 = (_a2 = hits == null ? void 0 : hits[0]) == null ? void 0 : _a2.object) == null ? void 0 : _b2.userData.handle;
+      if (handle !== this._handle) {
+        (_c = this._handle) == null ? void 0 : _c.highlight(false);
+        handle == null ? void 0 : handle.highlight(true);
+        this._handle = handle;
+        (_d = this.onFaceEnter) == null ? void 0 : _d.call(this, (handle == null ? void 0 : handle.forward) ?? new Vector3$1());
+      }
+    }
+    /**
+     * Handles pointer up events. Ends dragging and triggers {@link onBoxConfirm}.
+     * 
+     * @param event - The pointerup event.
+     */
+    onMouseUp(event) {
+      var _a2, _b2;
+      this.releasePointer();
+      if (this._mouseDown) {
+        this._mouseDown = false;
+        this._viewer.inputs.registerAll();
+        if (event.pointerType === "mouse") {
+          this.onMouseMove(event);
+        } else {
+          this._handle = void 0;
+          (_a2 = this.onFaceEnter) == null ? void 0 : _a2.call(this, new Vector3$1());
+        }
+        (_b2 = this.onBoxConfirm) == null ? void 0 : _b2.call(this, this._sharedBox);
+      }
+    }
+    /**
+     * Handles pointer down events. Begins drag if a handle is hit, capturing the pointer.
+     * 
+     * @param event - The pointerdown event.
+     */
+    onMouseDown(event) {
+      var _a2, _b2, _c, _d;
+      const hits = this.raycast(new Vector2$1(event.offsetX, event.offsetY));
+      const handle = (_c = (_b2 = (_a2 = hits == null ? void 0 : hits[0]) == null ? void 0 : _a2.object) == null ? void 0 : _b2.userData) == null ? void 0 : _c.handle;
+      if (!handle) return;
+      this._handle = handle;
+      this.capturePointer(event.pointerId);
+      this._lastBox.copy(this._sharedBox);
+      this._dragOrigin.copy(handle.position);
+      const dist2 = handle.position.clone().dot(this._viewer.camera.forward);
+      this._dragPlane.set(this._viewer.camera.forward, -dist2);
+      this._mouseDown = true;
+      this._viewer.inputs.unregisterAll();
+      (_d = this.onFaceEnter) == null ? void 0 : _d.call(this, this._handle.forward.clone());
+    }
+    /**
+     * Continues the drag operation. Determines the new position on the drag plane
+     * and computes how far we moved along the handle's forward axis.
+     * 
+     * @param event - The pointermove event while dragging.
+     */
+    onDrag(event) {
+      var _a2;
+      if (!this._handle) return;
+      const point = this.raycastPlane(new Vector2$1(event.offsetX, event.offsetY)) ?? this._dragOrigin.clone();
+      const delta = point.sub(this._dragOrigin);
+      const amount = delta.dot(this._handle.forward);
+      const box = this.stretch(this._handle.axis, this._handle.sign, amount);
+      (_a2 = this.onBoxStretch) == null ? void 0 : _a2.call(this, box);
+    }
+    /**
+     * Expands or contracts the `_sharedBox` along one axis by a certain amount, 
+     * ensuring the box cannot shrink below the minimum size (`MIN_BOX_SIZE`). 
+     * 
+     * @param axis - The axis ('x', 'y', or 'z') to stretch.
+     * @param sign - +1 if stretching the 'max' side, -1 if stretching the 'min' side.
+     * @param amount - The numeric offset along that axis to add or subtract.
+     * @returns A **new** `Box3` instance with updated min/max coordinates.
+     */
+    stretch(axis, sign2, amount) {
+      const box = this._sharedBox.clone();
+      const direction = sign2 > 0 ? "max" : "min";
+      const opposite = sign2 > 0 ? "min" : "max";
+      const target = this._lastBox[direction][axis] + amount * sign2;
+      const minBoundary = this._lastBox[opposite][axis] + MIN_BOX_SIZE * sign2;
+      box[direction][axis] = target;
+      if (sign2 * (target - minBoundary) < 0) {
+        box[opposite][axis] = target - MIN_BOX_SIZE * sign2;
+      }
+      return box;
+    }
+    /**
+     * Prepares the internal raycaster for a given 2D pointer position.
+     * 
+     * @param position - The pointer position in canvas coordinates.
+     * @returns The updated raycaster pointing from the camera through this position.
+     */
+    getRaycaster(position) {
+      return this._viewer.raycaster.fromPoint2(position, this._raycaster);
+    }
+    /**
+     * Raycasts into the handle meshes from the given pointer position.
+     * 
+     * @param position - The pointer position in canvas coordinates.
+     * @returns An array of intersection results, if any.
+     */
+    raycast(position) {
+      return this.getRaycaster(position).intersectObject(this._handles.meshes);
+    }
+    /**
+     * Raycasts into the drag plane from the given pointer position.
+     * 
+     * @param position - The pointer position in canvas coordinates.
+     * @returns The intersection point in 3D space, or `null` if none.
+     */
+    raycastPlane(position) {
+      return this.getRaycaster(position).ray.intersectPlane(
+        this._dragPlane,
+        new Vector3$1()
+      );
+    }
+  }
+  class SectionBoxMesh extends Mesh {
     constructor() {
+      const geo = new BoxGeometry();
+      const mat = new MeshBasicMaterial({
+        opacity: 0.3,
+        transparent: true,
+        color: new Color(20667),
+        depthTest: false
+      });
+      super(geo, mat);
+    }
+    /**
+     * Resize the mesh to the given box.
+     */
+    fitBox(box) {
+      this.scale.set(
+        box.max.x - box.min.x,
+        box.max.y - box.min.y,
+        box.max.z - box.min.z
+      );
+      this.position.set(
+        (box.max.x + box.min.x) / 2,
+        (box.max.y + box.min.y) / 2,
+        (box.max.z + box.min.z) / 2
+      );
+    }
+    /**
+     * Disposes of all resources.
+     */
+    dispose() {
+      this.geometry.dispose();
+      this.material.dispose();
+    }
+  }
+  class SectionBoxOutline extends LineSegments {
+    constructor(color) {
       const vertices = new Float32Array([
         -0.5,
         -0.5,
@@ -54942,7 +55413,7 @@ void main() {
       const geo = new BufferGeometry();
       const mat = new LineBasicMaterial({
         opacity: 1,
-        color: new Color(0)
+        color
       });
       geo.setAttribute("position", new BufferAttribute(vertices, 3));
       geo.setIndex(indices);
@@ -54971,305 +55442,169 @@ void main() {
       this.material.dispose();
     }
   }
-  class BoxMesh extends Mesh {
-    constructor() {
-      const geo = new BoxGeometry();
-      const mat = new MeshBasicMaterial({
-        opacity: 0.3,
+  class SectionBoxHandle extends Mesh {
+    constructor(axes, sign2, size, color) {
+      const geo = createDoubleCone(size);
+      geo.clearGroups();
+      geo.addGroup(0, Infinity, 0);
+      geo.addGroup(0, Infinity, 1);
+      const matBehind = new MeshBasicMaterial({
         transparent: true,
-        color: new Color(20667),
-        depthTest: false
+        opacity: 0.5,
+        color: color ?? new Color(0),
+        depthTest: false,
+        side: FrontSide
       });
-      super(geo, mat);
+      const matAlways = new MeshBasicMaterial({
+        color: color ?? new Color(0),
+        side: FrontSide
+      });
+      super(geo, [matAlways, matBehind]);
+      __publicField(this, "axis");
+      __publicField(this, "sign");
+      __publicField(this, "_forward");
+      __publicField(this, "_color");
+      __publicField(this, "_highlightColor");
+      __publicField(this, "_materials");
+      this._materials = [matAlways, matBehind];
+      this._forward = new Vector3$1();
+      this.forward[axes] = sign2;
+      this.axis = axes;
+      this.sign = sign2;
+      this._color = color ?? new Color(0);
+      this._highlightColor = this._color.clone().lerp(new Color(13421772), 0.8);
+      this.userData.handle = this;
+      this.quaternion.setFromUnitVectors(new Vector3$1(0, -1, 0), this._forward);
     }
-    /**
-     * Resize the mesh to the given box.
-     */
-    fitBox(box) {
-      this.scale.set(
-        box.max.x - box.min.x,
-        box.max.y - box.min.y,
-        box.max.z - box.min.z
-      );
-      this.position.set(
-        (box.max.x + box.min.x) / 2,
-        (box.max.y + box.min.y) / 2,
-        (box.max.z + box.min.z) / 2
-      );
+    setPosition(position) {
+      this.position.copy(position);
+    }
+    get forward() {
+      return this._forward;
+    }
+    highlight(value) {
+      this.material[0].color.set(value ? this._highlightColor : this._color);
+      this.material[1].color.set(value ? this._highlightColor : this._color);
     }
-    /**
-     * Disposes of all resources.
-     */
     dispose() {
       this.geometry.dispose();
-      this.material.dispose();
-    }
-  }
-  class BoxHighlight extends Mesh {
+      this._materials.forEach((m) => m.dispose());
+    }
+  }
+  function createDoubleCone(size) {
+    const coneHeight = 2 * size;
+    const cone1 = new ConeGeometry(size, coneHeight, 12);
+    cone1.translate(0, coneHeight * 0.75, 0);
+    const cone2 = new ConeGeometry(size, coneHeight, 12);
+    cone2.rotateZ(Math.PI);
+    cone2.translate(0, -coneHeight * 0.75, 0);
+    const mergedGeo = mergeGeometries([cone1, cone2]);
+    cone1.dispose();
+    cone2.dispose();
+    return mergedGeo;
+  }
+  class SectionBoxHandles {
     constructor() {
-      const geo = new BufferGeometry();
-      geo.setAttribute(
-        "position",
-        new BufferAttribute(new Float32Array(12), 3)
-      );
-      geo.setIndex([0, 1, 2, 0, 2, 3]);
-      const mat = new MeshBasicMaterial({
-        opacity: 0.7,
-        transparent: true,
-        depthTest: false,
-        side: DoubleSide
-      });
-      super(geo, mat);
-      this.renderOrder = 1;
-      this.frustumCulled = false;
+      __publicField(this, "up");
+      __publicField(this, "down");
+      __publicField(this, "left");
+      __publicField(this, "right");
+      __publicField(this, "front");
+      __publicField(this, "back");
+      __publicField(this, "meshes");
+      const size = 2;
+      this.up = new SectionBoxHandle("y", 1, size, new Color(65280));
+      this.down = new SectionBoxHandle("y", -1, size, new Color(65280));
+      this.left = new SectionBoxHandle("x", -1, size, new Color(16711680));
+      this.right = new SectionBoxHandle("x", 1, size, new Color(16711680));
+      this.front = new SectionBoxHandle("z", 1, size, new Color(255));
+      this.back = new SectionBoxHandle("z", -1, size, new Color(255));
+      this.meshes = new Group();
+      this.meshes.add(this.up);
+      this.meshes.add(this.down);
+      this.meshes.add(this.left);
+      this.meshes.add(this.right);
+      this.meshes.add(this.front);
+      this.meshes.add(this.back);
     }
-    /**
-     * Sets the face to highlight
-     * @param normal a direction vector from theses options (X,-X, Y,-Y, Z,-Z)
-     */
-    highlight(box, normal) {
-      this.visible = false;
-      const positions = this.geometry.getAttribute("position");
-      if (normal.x > 0.1) {
-        positions.setXYZ(0, box.max.x, box.max.y, box.max.z);
-        positions.setXYZ(1, box.max.x, box.min.y, box.max.z);
-        positions.setXYZ(2, box.max.x, box.min.y, box.min.z);
-        positions.setXYZ(3, box.max.x, box.max.y, box.min.z);
-        this.visible = true;
-      }
-      if (normal.x < -0.1) {
-        positions.setXYZ(0, box.min.x, box.max.y, box.max.z);
-        positions.setXYZ(1, box.min.x, box.min.y, box.max.z);
-        positions.setXYZ(2, box.min.x, box.min.y, box.min.z);
-        positions.setXYZ(3, box.min.x, box.max.y, box.min.z);
-        this.visible = true;
-      }
-      if (normal.y > 0.1) {
-        positions.setXYZ(0, box.max.x, box.max.y, box.max.z);
-        positions.setXYZ(1, box.min.x, box.max.y, box.max.z);
-        positions.setXYZ(2, box.min.x, box.max.y, box.min.z);
-        positions.setXYZ(3, box.max.x, box.max.y, box.min.z);
-        this.visible = true;
-      }
-      if (normal.y < -0.1) {
-        positions.setXYZ(0, box.max.x, box.min.y, box.max.z);
-        positions.setXYZ(1, box.min.x, box.min.y, box.max.z);
-        positions.setXYZ(2, box.min.x, box.min.y, box.min.z);
-        positions.setXYZ(3, box.max.x, box.min.y, box.min.z);
-        this.visible = true;
-      }
-      if (normal.z > 0.1) {
-        positions.setXYZ(0, box.max.x, box.max.y, box.max.z);
-        positions.setXYZ(1, box.min.x, box.max.y, box.max.z);
-        positions.setXYZ(2, box.min.x, box.min.y, box.max.z);
-        positions.setXYZ(3, box.max.x, box.min.y, box.max.z);
-        this.visible = true;
-      }
-      if (normal.z < -0.1) {
-        positions.setXYZ(0, box.max.x, box.max.y, box.min.z);
-        positions.setXYZ(1, box.min.x, box.max.y, box.min.z);
-        positions.setXYZ(2, box.min.x, box.min.y, box.min.z);
-        positions.setXYZ(3, box.max.x, box.min.y, box.min.z);
-        this.visible = true;
-      }
-      positions.needsUpdate = true;
+    get visible() {
+      return this.meshes.visible;
+    }
+    set visible(value) {
+      this.meshes.visible = value;
+    }
+    fitBox(box) {
+      const center = box.getCenter(new Vector3$1());
+      this.up.setPosition(new Vector3$1(center.x, box.max.y, center.z));
+      this.down.setPosition(new Vector3$1(center.x, box.min.y, center.z));
+      this.left.setPosition(new Vector3$1(box.min.x, center.y, center.z));
+      this.right.setPosition(new Vector3$1(box.max.x, center.y, center.z));
+      this.front.setPosition(new Vector3$1(center.x, center.y, box.max.z));
+      this.back.setPosition(new Vector3$1(center.x, center.y, box.min.z));
     }
-    /**
-     * Disposes all resources.
-     */
     dispose() {
-      this.geometry.dispose();
-      this.material.dispose();
+      this.up.dispose();
+      this.down.dispose();
+      this.left.dispose();
+      this.right.dispose();
+      this.front.dispose();
+      this.back.dispose();
     }
   }
-  class BoxInputs {
-    constructor(viewer, cube, box) {
-      // dependencies
-      __publicField(this, "viewer");
+  class SectionBoxGizmo {
+    constructor(renderer) {
+      __publicField(this, "_renderer");
       __publicField(this, "cube");
-      __publicField(this, "sharedBox");
-      // state
-      __publicField(this, "faceNormal", new Vector3$1());
-      __publicField(this, "dragOrigin", new Vector3$1());
-      __publicField(this, "dragpPlane", new Plane());
-      __publicField(this, "mouseDown");
-      __publicField(this, "raycaster", new Raycaster$1());
-      __publicField(this, "lastBox", new Box3$1());
-      __publicField(this, "unregisters", []);
-      __publicField(this, "lastMouse");
-      __publicField(this, "ctrlDown", false);
-      __publicField(this, "capturedId");
-      // Called when mouse enters or leave a face
-      __publicField(this, "onFaceEnter");
-      // Called the box is reshaped
-      __publicField(this, "onBoxStretch");
-      // Called when the user is done reshaping the box
-      __publicField(this, "onBoxConfirm");
-      __publicField(this, "reg", (handler, type, listener2) => {
-        handler.addEventListener(type, listener2);
-        this.unregisters.push(() => handler.removeEventListener(type, listener2));
-      });
-      this.viewer = viewer;
-      this.cube = cube;
-      this.sharedBox = box;
-    }
-    register() {
-      if (this.unregister.length > 0) return;
-      const canvas = this.viewer.viewport.canvas;
-      this.reg(window, "keydown", this.onKey.bind(this));
-      this.reg(window, "keyup", this.onKey.bind(this));
-      this.reg(canvas, "pointerdown", this.onMouseDown.bind(this));
-      this.reg(canvas, "pointermove", this.onMouseMove.bind(this));
-      this.reg(canvas, "pointerup", this.onMouseUp.bind(this));
-      this.reg(canvas, "pointerleave", this.onPointerLeave.bind(this));
-    }
-    onPointerLeave(event) {
-      var _a2;
-      if (this.capturedId !== void 0) {
-        return;
-      }
-      this.faceNormal.set(0, 0, 0);
-      (_a2 = this.onFaceEnter) == null ? void 0 : _a2.call(this, this.faceNormal);
-    }
-    capturePointer(pointerId) {
-      this.releasePointer();
-      this.viewer.viewport.canvas.setPointerCapture(pointerId);
-      this.capturedId = pointerId;
-    }
-    releasePointer() {
-      if (this.capturedId === void 0) return;
-      this.viewer.viewport.canvas.releasePointerCapture(this.capturedId);
-      this.capturedId = void 0;
-    }
-    unregister() {
-      this.ctrlDown = false;
-      this.mouseDown = false;
-      this.releasePointer();
-      this.viewer.inputs.registerAll();
-      this.unregisters.forEach((unreg) => unreg());
-      this.unregisters.length = 0;
-    }
-    onKey(event) {
-      if (this.ctrlDown !== event.ctrlKey) {
-        this.ctrlDown = event.ctrlKey;
-        this.onMouseMove(this.lastMouse);
-      }
-    }
-    onMouseMove(event) {
-      var _a2, _b2, _c;
-      this.lastMouse = event;
-      if (this.mouseDown) {
-        this.onDrag(event);
-        return;
-      }
-      const hits = this.raycast(
-        new Vector2$1(event.offsetX, event.offsetY),
-        this.ctrlDown
-      );
-      const hit = hits == null ? void 0 : hits[0];
-      const norm = (_a2 = hit == null ? void 0 : hit.face) == null ? void 0 : _a2.normal;
-      if (!norm) {
-        if (this.faceNormal.x !== 0 || this.faceNormal.y !== 0 || this.faceNormal.z !== 0) {
-          this.faceNormal.set(0, 0, 0);
-          (_b2 = this.onFaceEnter) == null ? void 0 : _b2.call(this, this.faceNormal);
-        }
-        return;
-      }
-      if (this.faceNormal.equals(norm)) {
-        return;
-      }
-      this.faceNormal = norm;
-      (_c = this.onFaceEnter) == null ? void 0 : _c.call(this, this.faceNormal);
-    }
-    onMouseUp(event) {
-      var _a2, _b2;
-      this.releasePointer();
-      if (this.mouseDown) {
-        this.mouseDown = false;
-        this.viewer.inputs.registerAll();
-        if (event.pointerType === "mouse") {
-          this.onMouseMove(event);
-        } else {
-          this.faceNormal = new Vector3$1();
-          (_a2 = this.onFaceEnter) == null ? void 0 : _a2.call(this, this.faceNormal);
-        }
-        (_b2 = this.onBoxConfirm) == null ? void 0 : _b2.call(this, this.sharedBox);
-      }
+      __publicField(this, "outline");
+      __publicField(this, "handles");
+      __publicField(this, "_visible", false);
+      this._renderer = renderer;
+      this.cube = new SectionBoxMesh();
+      this.outline = new SectionBoxOutline(new Color(8882833));
+      this.handles = new SectionBoxHandles();
+      this._renderer.add(this.outline);
+      this._renderer.add(this.handles.meshes);
+      this.visible = false;
     }
-    onMouseDown(event) {
-      var _a2, _b2;
-      const hits = this.raycast(
-        new Vector2$1(event.offsetX, event.offsetY),
-        this.ctrlDown
-      );
-      const hit = hits == null ? void 0 : hits[0];
-      if (!((_a2 = hit == null ? void 0 : hit.face) == null ? void 0 : _a2.normal)) return;
-      this.capturePointer(event.pointerId);
-      this.lastBox.copy(this.sharedBox);
-      this.faceNormal = hit.face.normal;
-      this.dragOrigin.copy(hit.point);
-      const dist2 = hit.point.clone().dot(this.viewer.camera.forward);
-      this.dragpPlane.set(this.viewer.camera.forward, -dist2);
-      this.mouseDown = true;
-      this.viewer.inputs.unregisterAll();
-      (_b2 = this.onFaceEnter) == null ? void 0 : _b2.call(this, this.faceNormal);
+    get visible() {
+      return this._visible;
     }
-    onDrag(event) {
-      var _a2;
-      this.raycaster = this.viewer.raycaster.fromPoint2(
-        new Vector2$1(event.offsetX, event.offsetY),
-        this.raycaster
-      );
-      const point = this.raycaster.ray.intersectPlane(this.dragpPlane, new Vector3$1()) ?? this.dragOrigin.clone();
-      const delta = point.sub(this.dragOrigin);
-      const amount = delta.dot(this.faceNormal);
-      const box = this.stretch(this.faceNormal, amount);
-      (_a2 = this.onBoxStretch) == null ? void 0 : _a2.call(this, box);
+    set visible(value) {
+      this._visible = value;
+      this.cube.visible = value;
+      this.outline.visible = value;
+      this.handles.visible = value;
     }
-    stretch(normal, amount) {
-      const result = this.sharedBox.clone();
-      if (normal.x > 0.1) {
-        result.max.setX(Math.max(this.lastBox.max.x + amount, result.min.x - 1));
-      }
-      if (normal.x < -0.1) {
-        result.min.setX(Math.min(this.lastBox.min.x - amount, result.max.x + 1));
-      }
-      if (normal.y > 0.1) {
-        result.max.setY(Math.max(this.lastBox.max.y + amount, result.min.y - 1));
-      }
-      if (normal.y < -0.1) {
-        result.min.setY(Math.min(this.lastBox.min.y - amount, result.max.y + 1));
-      }
-      if (normal.z > 0.1) {
-        result.max.setZ(Math.max(this.lastBox.max.z + amount, result.min.z - 1));
-      }
-      if (normal.z < -0.1) {
-        result.min.setZ(Math.min(this.lastBox.min.z - amount, result.max.z + 1));
-      }
-      return result;
+    fitBox(box) {
+      this.cube.fitBox(box);
+      this.outline.fitBox(box);
+      this.handles.fitBox(box);
     }
-    raycast(position, reverse) {
-      this.raycaster = this.viewer.raycaster.fromPoint2(position, this.raycaster);
-      if (reverse) {
-        this.raycaster.ray.set(
-          this.raycaster.ray.origin.clone().add(this.raycaster.ray.direction.clone().multiplyScalar(this.viewer.settings.camera.far)),
-          this.raycaster.ray.direction.negate()
-        );
-      }
-      return this.raycaster.intersectObject(this.cube);
+    dispose() {
+      this._renderer.remove(this.cube);
+      this._renderer.remove(this.outline);
+      this._renderer.remove(this.handles.meshes);
+      this.cube.dispose();
+      this.outline.dispose();
+      this.handles.dispose();
     }
   }
-  class SectionBox {
+  let SectionBox$1 = class SectionBox {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    /**
+     * Creates a new SectionBox gizmo controller.
+     * 
+     * @param viewer - The parent {@link Viewer} in which the section box is rendered.
+     */
     constructor(viewer) {
-      // dependencies
+      // -------------------------------------------------------------------------
+      // Private fields
+      // -------------------------------------------------------------------------
       __publicField(this, "_viewer");
-      // resources
+      __publicField(this, "_gizmos");
       __publicField(this, "_inputs");
-      __publicField(this, "_cube");
-      __publicField(this, "_outline");
-      __publicField(this, "_highlight");
-      // State
-      __publicField(this, "_normal");
       __publicField(this, "_clip");
       __publicField(this, "_visible");
       __publicField(this, "_interactive");
@@ -55277,21 +55612,13 @@ void main() {
       __publicField(this, "_onBoxConfirm", new distExports.SimpleEventDispatcher());
       __publicField(this, "_onHover", new distExports.SimpleEventDispatcher());
       this._viewer = viewer;
-      this._normal = new Vector3$1();
-      this._cube = new BoxMesh();
-      this._outline = new BoxOutline();
-      this._highlight = new BoxHighlight();
-      this.renderer.add(this._cube);
-      this.renderer.add(this._outline);
-      this.renderer.add(this._highlight);
+      this._gizmos = new SectionBoxGizmo(viewer.renderer);
       this._inputs = new BoxInputs(
         viewer,
-        this._cube,
+        this._gizmos.handles,
         this._viewer.renderer.section.box
       );
       this._inputs.onFaceEnter = (normal) => {
-        this._normal = normal;
-        if (this.visible) this._highlight.highlight(this.section.box, normal);
         this._onHover.dispatch(normal.x !== 0 || normal.y !== 0 || normal.z !== 0);
         this.renderer.needsUpdate = true;
       };
@@ -55306,37 +55633,61 @@ void main() {
       this.update();
     }
     /**
-     * Signal dispatched when clip, show, or interactive are updated.
+     * @internal
+     * A convenience getter to the viewer's renderer.
+     */
+    get renderer() {
+      return this._viewer.renderer;
+    }
+    /**
+     * @internal
+     * A convenience getter to the `Section` module in the renderer.
+     */
+    get section() {
+      return this._viewer.renderer.section;
+    }
+    // -------------------------------------------------------------------------
+    // Public Signals
+    // -------------------------------------------------------------------------
+    /**
+     * Dispatches when any of the following properties change:
+     * - {@link clip} (clipping planes active)
+     * - {@link visible} (gizmo visibility)
+     * - {@link interactive} (pointer inputs active)
      */
     get onStateChanged() {
       return this._onStateChanged.asEvent();
     }
     /**
-     * Signal dispatched when user is done manipulating the box.
+     * Dispatches when the user finishes manipulating (dragging) the box.
+     * The payload is the final {@link THREE.Box3} used for clipping.
      */
     get onBoxConfirm() {
       return this._onBoxConfirm.asEvent();
     }
     /**
-     * Signal dispatched with true when pointer enters box and false when pointer leaves.
+     * Dispatches a boolean indicating pointer hover state on the box handles:
+     *  - `true` if the pointer has entered a handle
+     *  - `false` if it has left or no handle is hovered
      */
     get onHover() {
       return this._onHover.asEvent();
     }
-    get renderer() {
-      return this._viewer.renderer;
-    }
-    get section() {
-      return this._viewer.renderer.section;
-    }
+    // -------------------------------------------------------------------------
+    // Public Properties
+    // -------------------------------------------------------------------------
     /**
-     * Section bounding box, to update the box use fitBox.
+     * The shared bounding box that defines the section region.
+     * 
+     * To programmatically update the box, see {@link fitBox}.
      */
     get box() {
       return this.section.box;
     }
     /**
-     * Determines whether the section gizmo will section the model with clipping planes.
+     * Determines whether the section gizmo applies clipping planes to the model.
+     * 
+     * When `true`, `renderer.section.active` is enabled.
      */
     get clip() {
       return this._clip ?? false;
@@ -55348,71 +55699,79 @@ void main() {
       this._onStateChanged.dispatch();
     }
     /**
-     * Determines whether the gizmo reacts to user inputs.
+     * Determines whether the gizmo is interactive (i.e. responds to pointer events).
+     * 
+     * When `true`, pointer events are registered and box handles can be dragged.
      */
     get interactive() {
       return this._interactive ?? false;
     }
     set interactive(value) {
       if (value === this._interactive) return;
-      if (!this._interactive && value) this._inputs.register();
-      if (this._interactive && !value) this._inputs.unregister();
+      if (!this._interactive && value) {
+        this._inputs.register();
+      }
+      if (this._interactive && !value) {
+        this._inputs.unregister();
+      }
       this._interactive = value;
-      this._highlight.visible = false;
       this.renderer.needsUpdate = true;
       this._onStateChanged.dispatch();
     }
     /**
-     * Determines whether the gizmo will be rendered.
+     * Determines whether the section box gizmo is visible in the scene.
      */
     get visible() {
       return this._visible ?? false;
     }
     set visible(value) {
       if (value === this._visible) return;
-      this._visible = value;
-      this._cube.visible = value;
-      this._outline.visible = value;
-      this._highlight.visible = value;
-      if (value) this.update();
+      this._gizmos.visible = value;
+      if (value) {
+        this.update();
+      }
       this.renderer.needsUpdate = true;
       this._onStateChanged.dispatch();
     }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
     /**
-     * Sets the section gizmo size to match the given box.
-     * @param {THREE.Box3} box - The box to match the section gizmo size to.
-     * @param {number} [padding=1] - The padding to apply to the box.
+     * Resizes the section gizmo to match the given box, optionally expanded by a padding.
+     * After resizing, this method also updates the renderer's clipping box.
+     * 
+     * @param box - The bounding box to match (required).
+     * @param padding - The scalar amount by which to expand the bounding box. Default is `1`.
      */
     fitBox(box, padding = 1) {
       if (!box) return;
       const b = box.expandByScalar(padding);
-      this._cube.fitBox(b);
-      this._outline.fitBox(b);
+      this._gizmos.fitBox(b);
       this.renderer.section.fitBox(b);
       this._onBoxConfirm.dispatch(this.box);
       this.renderer.needsUpdate = true;
     }
     /**
-     * Call this if there were direct changes to renderer.section
+     * Updates the section box to match the current size of `this.section.box`.
+     * 
+     * Call this if the renderer's section box is changed by code outside this class.
      */
     update() {
       this.fitBox(this.section.box, 0);
-      this._highlight.highlight(this.section.box, this._normal);
       this.renderer.needsUpdate = true;
     }
     /**
-     * Removes gizmo from rendering and inputs and dispose all resources.
+     * Disposes of the gizmo and input event listeners, cleaning up related resources.
+     * 
+     * After disposal, this `SectionBox` instance should no longer be used.
      */
     dispose() {
-      this.renderer.remove(this._cube);
-      this.renderer.remove(this._outline);
-      this.renderer.remove(this._highlight);
+      this._onBoxConfirm.clear();
+      this._onHover.clear();
+      this._gizmos.dispose();
       this._inputs.unregister();
-      this._cube.dispose();
-      this._outline.dispose();
-      this._highlight.dispose();
     }
-  }
+  };
   class Gizmos {
     constructor(viewer, camera2) {
       __publicField(this, "viewer");
@@ -55444,7 +55803,7 @@ void main() {
       var _a2;
       this.viewer = viewer;
       this._measure = new Measure(viewer);
-      this.section = new SectionBox(viewer);
+      this.section = new SectionBox$1(viewer);
       this.loading = new GizmoLoading(viewer);
       this.orbit = new GizmoOrbit(
         viewer.renderer,
@@ -57677,17 +58036,16 @@ void main() {
   class Marshal {
     constructor(initialSize = 1024) {
       __publicField(this, "buffer");
-      __publicField(this, "dataView");
-      __publicField(this, "readOffset", 0);
-      __publicField(this, "writeOffset", 0);
+      __publicField(this, "_dataView");
+      __publicField(this, "_offset", 0);
       this.buffer = new ArrayBuffer(initialSize);
-      this.dataView = new DataView(this.buffer);
+      this._dataView = new DataView(this.buffer);
     }
     getBuffer() {
-      return this.buffer.slice(0, this.writeOffset);
+      return this.buffer.slice(0, this._offset);
     }
     ensureCapacity(additionalSize) {
-      const requiredSize = this.writeOffset + additionalSize;
+      const requiredSize = this._offset + additionalSize;
       if (requiredSize > this.buffer.byteLength) {
         let newLength = this.buffer.byteLength;
         while (newLength < requiredSize) {
@@ -57696,21 +58054,162 @@ void main() {
         const newBuffer = new ArrayBuffer(newLength);
         new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
         this.buffer = newBuffer;
-        this.dataView = new DataView(this.buffer);
+        this._dataView = new DataView(this.buffer);
       }
     }
     writeData(data2) {
       this.ensureCapacity(data2.byteLength);
-      new Uint8Array(this.buffer, this.writeOffset).set(new Uint8Array(data2));
-      this.writeOffset += data2.byteLength;
+      new Uint8Array(this.buffer, this._offset).set(new Uint8Array(data2));
+      this._offset += data2.byteLength;
     }
-    // -------------------- Matrix44 Methods --------------------
+    // -------------------- Matrix44 -------------------
     writeMatrix44(data2) {
       this.ensureCapacity(4 * 4 * 4);
       this.writeArray(data2.toArray(), 4, (element) => {
         this.writeFloat(element);
       });
     }
+    // -------------------- Boolean -------------------
+    writeBoolean(value) {
+      this.ensureCapacity(4);
+      this._dataView.setUint32(this._offset, value ? 1 : 0, true);
+      this._offset += 4;
+    }
+    // -------------------- Int -------------------
+    writeInt(value) {
+      this.ensureCapacity(4);
+      this._dataView.setInt32(this._offset, value, true);
+      this._offset += 4;
+    }
+    // -------------------- UInt -------------------
+    writeUInt(value) {
+      this.ensureCapacity(4);
+      this._dataView.setUint32(this._offset, value, true);
+      this._offset += 4;
+    }
+    // -------------------- Float -------------------
+    writeFloat(value) {
+      this.ensureCapacity(4);
+      this._dataView.setFloat32(this._offset, value, true);
+      this._offset += 4;
+    }
+    // -------------------- String -------------------
+    writeString(value) {
+      const textEncoder = new TextEncoder();
+      const encodedString = textEncoder.encode(value + "\0");
+      this.ensureCapacity(4 + encodedString.byteLength);
+      this.writeUInt(encodedString.length);
+      new Uint8Array(this.buffer, this._offset).set(encodedString);
+      this._offset += encodedString.length;
+    }
+    // -------------------- HitCheckResult -------------------
+    writeHitCheckResult(data2) {
+      this.ensureCapacity(4 + 4 + 4 * 3 + 4 * 3);
+      this.writeUInt(data2.vimHandle);
+      this.writeUInt(data2.nodeIndex);
+      this.writeVector3(data2.worldPosition);
+      this.writeVector3(data2.worldNormal);
+    }
+    // -------------------- VimStatus -------------------
+    writeVimStatus(data2) {
+      this.ensureCapacity(4 + 4);
+      this.writeUInt(data2.status);
+      this.writeFloat(data2.progress);
+    }
+    // -------------------- Vector2 -------------------
+    writeVector2(data2) {
+      this.ensureCapacity(4 + 4);
+      this.writeFloat(data2.x);
+      this.writeFloat(data2.y);
+    }
+    // -------------------- Vector3 -------------------
+    writeVector3(data2) {
+      this.ensureCapacity(4 + 4 + 4);
+      this.writeFloat(data2.x);
+      this.writeFloat(data2.y);
+      this.writeFloat(data2.z);
+    }
+    // -------------------- Vector4 -------------------
+    writeVector4(data2) {
+      this.ensureCapacity(4 + 4 + 4 + 4);
+      this.writeFloat(data2.x);
+      this.writeFloat(data2.y);
+      this.writeFloat(data2.z);
+      this.writeFloat(data2.w);
+    }
+    // -------------------- RGBA -------------------
+    writeRGBA(color) {
+      this.ensureCapacity(4 + 4 + 4 + 4);
+      this.writeFloat(color.r);
+      this.writeFloat(color.g);
+      this.writeFloat(color.b);
+      this.writeFloat(color.a);
+    }
+    // -------------------- RGB -------------------
+    writeRGB(color) {
+      this.ensureCapacity(4 + 4 + 4 + 4);
+      this.writeFloat(color.r);
+      this.writeFloat(color.g);
+      this.writeFloat(color.b);
+    }
+    // -------------------- RGBA32 -------------------
+    writeRGBA32(color) {
+      this.ensureCapacity(4);
+      this.writeUInt(color.hex);
+    }
+    // -------------------- CameraPositionAndTarget -------------------
+    writeSegment(segment) {
+      this.ensureCapacity(4 * 3 * 2);
+      this.writeVector3(segment.origin);
+      this.writeVector3(segment.target);
+    }
+    // -------------------- Box3 -------------------
+    writeBox3(data2) {
+      this.ensureCapacity(4 * 3 * 2);
+      this.writeVector3(data2.min);
+      this.writeVector3(data2.max);
+    }
+    // -------------------- SectionBox -------------------
+    writeSectionBoxState(data2) {
+      this.writeBoolean(data2.enabled);
+      this.writeBoolean(data2.visible);
+      this.writeBoolean(data2.interactible);
+      this.writeBoolean(data2.clip);
+      this.writeBox3(data2.box);
+    }
+    // -------------------- Array of Int -------------------
+    writeArrayOfInt(values) {
+      this.writeArray(values, 4, (v) => this.writeInt(v));
+    }
+    // -------------------- Array of UInt -------------------
+    writeArrayOfUInt(values) {
+      this.writeArray(values, 4, (v) => this.writeUInt(v));
+    }
+    // -------------------- Array of Float -------------------
+    writeArrayOfFloat(values) {
+      this.writeArray(values, 4, (v) => this.writeFloat(v));
+    }
+    // -------------------- Array of Bool -------------------
+    writeArrayOfBool(values) {
+      this.writeArray(values, 4, (v) => this.writeBoolean(v));
+    }
+    // -------------------- Array of RGBA32 -------------------
+    writeArrayOfRGBA32(values) {
+      this.writeArray(values, 4, (v) => this.writeRGBA32(v));
+    }
+    // -------------------- Helpers --------------------
+    writeArray(data2, sizeT, write) {
+      this.ensureCapacity(4 + data2.length * sizeT);
+      this.writeUInt(data2.length);
+      data2.forEach((value) => write(value));
+    }
+  }
+  class ReadMarshal {
+    constructor(buffer) {
+      __publicField(this, "_dataView");
+      __publicField(this, "_offset", 0);
+      this._dataView = new DataView(buffer);
+    }
     readMatrix44() {
       const m00 = this.readFloat();
       const m01 = this.readFloat();
@@ -57730,74 +58229,33 @@ void main() {
       const m33 = this.readFloat();
       return new Matrix4(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33);
     }
-    // -------------------- Boolean Methods --------------------
-    writeBoolean(value) {
-      this.ensureCapacity(4);
-      this.dataView.setUint32(this.writeOffset, value ? 1 : 0, true);
-      this.writeOffset += 4;
-    }
-    readBoolean() {
-      const value = this.dataView.getUint32(this.readOffset, true);
-      this.readOffset += 4;
-      return value !== 0;
-    }
-    // -------------------- Int Methods --------------------
-    writeInt(value) {
-      this.ensureCapacity(4);
-      this.dataView.setInt32(this.writeOffset, value, true);
-      this.writeOffset += 4;
-    }
     readInt() {
-      const value = this.dataView.getInt32(this.readOffset, true);
-      this.readOffset += 4;
+      const value = this._dataView.getInt32(this._offset, true);
+      this._offset += 4;
       return value;
     }
-    // -------------------- UInt Methods --------------------
-    writeUInt(value) {
-      this.ensureCapacity(4);
-      this.dataView.setUint32(this.writeOffset, value, true);
-      this.writeOffset += 4;
-    }
     readUInt() {
-      const value = this.dataView.getUint32(this.readOffset, true);
-      this.readOffset += 4;
+      const value = this._dataView.getUint32(this._offset, true);
+      this._offset += 4;
       return value;
     }
-    // -------------------- Float Methods --------------------
-    writeFloat(value) {
-      this.ensureCapacity(4);
-      this.dataView.setFloat32(this.writeOffset, value, true);
-      this.writeOffset += 4;
-    }
     readFloat() {
-      const value = this.dataView.getFloat32(this.readOffset, true);
-      this.readOffset += 4;
+      const value = this._dataView.getFloat32(this._offset, true);
+      this._offset += 4;
       return value;
     }
-    // -------------------- String Methods --------------------
-    writeString(value) {
-      const textEncoder = new TextEncoder();
-      const encodedString = textEncoder.encode(value + "\0");
-      this.ensureCapacity(4 + encodedString.byteLength);
-      this.writeUInt(encodedString.length);
-      new Uint8Array(this.buffer, this.writeOffset).set(encodedString);
-      this.writeOffset += encodedString.length;
+    readBoolean() {
+      const value = this._dataView.getUint32(this._offset, true);
+      this._offset += 4;
+      return value !== 0;
     }
     readString() {
       const length = this.readUInt();
       const textDecoder = new TextDecoder();
-      const stringData = new Uint8Array(this.buffer, this.readOffset, length - 1);
-      this.readOffset += length;
+      const stringData = new Uint8Array(this._dataView.buffer, this._offset, length - 1);
+      this._offset += length;
       return textDecoder.decode(stringData);
     }
-    // -------------------- HitCheckResult Methods --------------------
-    writeHitCheckResult(data2) {
-      this.ensureCapacity(4 + 4 + 4 * 3 + 4 * 3);
-      this.writeUInt(data2.vimHandle);
-      this.writeUInt(data2.nodeIndex);
-      this.writeVector3(data2.worldPosition);
-      this.writeVector3(data2.worldNormal);
-    }
     readHitCheckResult() {
       const vimHandle = this.readUInt();
       const nodeIndex = this.readUInt();
@@ -57810,12 +58268,6 @@ void main() {
         worldNormal
       };
     }
-    // -------------------- VimStatus Methods --------------------
-    writeVimStatus(data2) {
-      this.ensureCapacity(4 + 4);
-      this.writeUInt(data2.status);
-      this.writeFloat(data2.progress);
-    }
     readVimStatus() {
       const status = this.readUInt();
       const progress = this.readFloat();
@@ -57824,38 +58276,17 @@ void main() {
         progress
       };
     }
-    // -------------------- Vector2 Methods --------------------
-    writeVector2(data2) {
-      this.ensureCapacity(4 + 4);
-      this.writeFloat(data2.x);
-      this.writeFloat(data2.y);
-    }
     readVector2() {
       const x = this.readFloat();
       const y = this.readFloat();
       return new Vector2(x, y);
     }
-    // -------------------- Vector3 Methods --------------------
-    writeVector3(data2) {
-      this.ensureCapacity(4 + 4 + 4);
-      this.writeFloat(data2.x);
-      this.writeFloat(data2.y);
-      this.writeFloat(data2.z);
-    }
     readVector3() {
       const x = this.readFloat();
       const y = this.readFloat();
       const z = this.readFloat();
       return new Vector3(x, y, z);
     }
-    // -------------------- Vector4 Methods --------------------
-    writeVector4(data2) {
-      this.ensureCapacity(4 + 4 + 4 + 4);
-      this.writeFloat(data2.x);
-      this.writeFloat(data2.y);
-      this.writeFloat(data2.z);
-      this.writeFloat(data2.w);
-    }
     readVector4() {
       const x = this.readFloat();
       const y = this.readFloat();
@@ -57868,14 +58299,6 @@ void main() {
         w
       };
     }
-    // -------------------- RGBA Methods --------------------
-    writeRGBA(color) {
-      this.ensureCapacity(4 + 4 + 4 + 4);
-      this.writeFloat(color.r);
-      this.writeFloat(color.g);
-      this.writeFloat(color.b);
-      this.writeFloat(color.a);
-    }
     readRGBA() {
       const r = this.readFloat();
       const g = this.readFloat();
@@ -57883,91 +58306,55 @@ void main() {
       const a = this.readFloat();
       return new RGBA(r, g, b, a);
     }
-    // -------------------- RGB Methods --------------------
-    writeRGB(color) {
-      this.ensureCapacity(4 + 4 + 4 + 4);
-      this.writeFloat(color.r);
-      this.writeFloat(color.g);
-      this.writeFloat(color.b);
-    }
     readRGB() {
       const r = this.readFloat();
       const g = this.readFloat();
       const b = this.readFloat();
       return new RGB(r, g, b);
     }
-    // -------------------- RGBA32 Methods --------------------
-    writeRGBA32(color) {
-      this.ensureCapacity(4);
-      this.writeUInt(color.hex);
-    }
     readRGBA32() {
       const hex = this.readUInt();
       return new RGBA32(hex);
     }
-    // -------------------- CameraPositionAndTarget Methods --------------------
-    writeSegment(segment) {
-      this.ensureCapacity(4 * 3 * 2);
-      this.writeVector3(segment.origin);
-      this.writeVector3(segment.target);
+    readBox3() {
+      const min2 = this.readVector3();
+      const max2 = this.readVector3();
+      return new Box3(min2, max2);
     }
     readSegment() {
       const position = this.readVector3();
       const target = this.readVector3();
       return new Segment(position, target);
     }
-    // -------------------- Box3 Methods --------------------
-    writeBox3(data2) {
-      this.ensureCapacity(4 * 3 * 2);
-      this.writeVector3(data2.min);
-      this.writeVector3(data2.max);
-    }
-    readBox3() {
-      const min2 = this.readVector3();
-      const max2 = this.readVector3();
-      return new Box3(min2, max2);
-    }
-    // -------------------- Array of Int Methods --------------------
-    writeArrayOfInt(values) {
-      this.writeArray(values, 4, (v) => this.writeInt(v));
+    readSectionBoxState() {
+      const enabled = this.readBoolean();
+      const visible2 = this.readBoolean();
+      const interactible = this.readBoolean();
+      const clip = this.readBoolean();
+      const box = this.readBox3();
+      return {
+        enabled,
+        visible: visible2,
+        interactible,
+        clip,
+        box
+      };
     }
     readArrayOfInt() {
       return this.readArray(() => this.readInt());
     }
-    // -------------------- Array of UInt Methods --------------------
-    writeArrayOfUInt(values) {
-      this.writeArray(values, 4, (v) => this.writeUInt(v));
-    }
     readArrayOfUInt() {
       return this.readArray(() => this.readUInt());
     }
-    // -------------------- Array of Float Methods --------------------
-    writeArrayOfFloat(values) {
-      this.writeArray(values, 4, (v) => this.writeFloat(v));
-    }
     readArrayOfFloat() {
       return this.readArray(() => this.readFloat());
     }
-    // -------------------- Array of Bool Methods --------------------
-    writeArrayOfBool(values) {
-      this.writeArray(values, 4, (v) => this.writeBoolean(v));
-    }
     readArrayOfBool() {
       return this.readArray(() => this.readBoolean());
     }
-    // -------------------- Array of RGBA32 Methods --------------------
-    writeArrayOfRGBA32(values) {
-      this.writeArray(values, 4, (v) => this.writeRGBA32(v));
-    }
     readArrayOfRGBA32() {
       return this.readArray(() => this.readRGBA32());
     }
-    // -------------------- Helpers --------------------
-    writeArray(data2, sizeT, write) {
-      this.ensureCapacity(4 + data2.length * sizeT);
-      this.writeUInt(data2.length);
-      data2.forEach((value) => write(value));
-    }
     readArray(read) {
       const length = this.readUInt();
       const array = [];
@@ -58002,17 +58389,17 @@ void main() {
     MaterialHandles.Invisible
   ];
   class RpcClient {
-    constructor(_messenger) {
-      __publicField(this, "_messenger");
+    constructor(_socket) {
+      __publicField(this, "_socket");
       // RPC Generated Code
-      __publicField(this, "API_VERSION", "5.0.0");
-      this._messenger = _messenger;
-    }
-    get url() {
-      return this._messenger.url;
+      __publicField(this, "API_VERSION", "5.1.0");
+      this._socket = _socket;
     }
     get connected() {
-      return this._messenger.state.status === "connected";
+      return this._socket.state.status === "connected";
+    }
+    get url() {
+      return this._socket.url;
     }
     RPCAddNodeFlags(componentHandle, nodes, flags) {
       const marshal = new Marshal();
@@ -58020,18 +58407,18 @@ void main() {
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
       marshal.writeUInt(flags);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCClearMaterialOverrides(componentHandle) {
       const marshal = new Marshal();
       marshal.writeString("RPCClearMaterialOverrides");
       marshal.writeUInt(componentHandle);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCClearScene() {
       const marshal = new Marshal();
       marshal.writeString("RPCClearScene");
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     async RPCCreateMaterialInstances(materialHandle, smoothness, colors) {
       const marshal = new Marshal();
@@ -58039,7 +58426,7 @@ void main() {
       marshal.writeUInt(materialHandle);
       marshal.writeUInt(smoothness);
       marshal.writeArrayOfRGBA32(colors);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readUInt();
       return ret;
     }
@@ -58049,7 +58436,7 @@ void main() {
       marshal.writeVector3(position);
       marshal.writeRGBA32(color);
       marshal.writeString(text);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readUInt();
       return ret;
     }
@@ -58057,25 +58444,19 @@ void main() {
       const marshal = new Marshal();
       marshal.writeString("RPCDestroyMaterialInstances");
       marshal.writeArrayOfUInt(materialInstanceHandle);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCDestroyText(componentHandle) {
       const marshal = new Marshal();
       marshal.writeString("RPCDestroyText");
       marshal.writeUInt(componentHandle);
-      this._messenger.sendRPC(marshal);
-    }
-    RPCEnableSectionBox(enable) {
-      const marshal = new Marshal();
-      marshal.writeString("RPCEnableSectionBox");
-      marshal.writeBoolean(enable);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     async RPCFrameAll(blendTime) {
       const marshal = new Marshal();
       marshal.writeString("RPCFrameAll");
       marshal.writeFloat(blendTime);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
@@ -58084,7 +58465,7 @@ void main() {
       marshal.writeString("RPCFrameBox");
       marshal.writeBox3(box);
       marshal.writeFloat(blendTime);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
@@ -58094,7 +58475,7 @@ void main() {
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
       marshal.writeFloat(blendTime);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
@@ -58103,14 +58484,14 @@ void main() {
       marshal.writeString("RPCFrameVim");
       marshal.writeUInt(componentHandle);
       marshal.writeFloat(blendTime);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
     async RPCGetAPIVersion() {
       const marshal = new Marshal();
       marshal.writeString("RPCGetAPIVersion");
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readString();
       return ret;
     }
@@ -58119,36 +58500,58 @@ void main() {
       marshal.writeString("RPCGetBoundingBox");
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
+      const ret = returnMarshal.readBox3();
+      return ret;
+    }
+    async RPCGetBoundingBoxAll(componentHandle) {
+      const marshal = new Marshal();
+      marshal.writeString("RPCGetBoundingBoxAll");
+      marshal.writeUInt(componentHandle);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readBox3();
       return ret;
     }
     async RPCGetCameraPosition() {
       const marshal = new Marshal();
       marshal.writeString("RPCGetCameraPosition");
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readSegment();
       return ret;
     }
     async RPCGetIblRotation() {
       const marshal = new Marshal();
       marshal.writeString("RPCGetIblRotation");
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readMatrix44();
       return ret;
     }
     async RPCGetLastError() {
       const marshal = new Marshal();
       marshal.writeString("RPCGetLastError");
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readString();
       return ret;
     }
+    async RPCGetSceneAABB() {
+      const marshal = new Marshal();
+      marshal.writeString("RPCGetSceneAABB");
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
+      const ret = returnMarshal.readBox3();
+      return ret;
+    }
+    async RPCGetSectionBox() {
+      const marshal = new Marshal();
+      marshal.writeString("RPCGetSectionBox");
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
+      const ret = returnMarshal.readSectionBoxState();
+      return ret;
+    }
     async RPCGetVimLoadingState(componentHandle) {
       const marshal = new Marshal();
       marshal.writeString("RPCGetVimLoadingState");
       marshal.writeUInt(componentHandle);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readVimStatus();
       return ret;
     }
@@ -58157,65 +58560,65 @@ void main() {
       marshal.writeString("RPCGhost");
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCGhostAll(componentHandle) {
       const marshal = new Marshal();
       marshal.writeString("RPCGhostAll");
       marshal.writeUInt(componentHandle);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCHide(componentHandle, nodes) {
       const marshal = new Marshal();
       marshal.writeString("RPCHide");
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCHideAABBs(componentHandle, nodes) {
       const marshal = new Marshal();
       marshal.writeString("RPCHideAABBs");
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCHideAll(componentHandle) {
       const marshal = new Marshal();
       marshal.writeString("RPCHideAll");
       marshal.writeUInt(componentHandle);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCHideAllAABBs(componentHandle) {
       const marshal = new Marshal();
       marshal.writeString("RPCHideAllAABBs");
       marshal.writeUInt(componentHandle);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCHighlight(componentHandle, nodes) {
       const marshal = new Marshal();
       marshal.writeString("RPCHighlight");
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCHighlightAll(componentHandle) {
       const marshal = new Marshal();
       marshal.writeString("RPCHighlightAll");
       marshal.writeUInt(componentHandle);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCKeyEvent(keyCode, down) {
       const marshal = new Marshal();
       marshal.writeString("RPCKeyEvent");
       marshal.writeInt(keyCode);
       marshal.writeBoolean(down);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     async RPCLoadVim(fileName) {
       const marshal = new Marshal();
       marshal.writeString("RPCLoadVim");
       marshal.writeString(fileName);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readUInt();
       return ret;
     }
@@ -58224,7 +58627,7 @@ void main() {
       marshal.writeString("RPCLoadVimURL");
       marshal.writeString(url);
       marshal.writeString(authToken);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readUInt();
       return ret;
     }
@@ -58232,7 +58635,7 @@ void main() {
       const marshal = new Marshal();
       marshal.writeString("RPCLockIblRotation");
       marshal.writeBoolean(lock);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCMouseButtonEvent(mousePos, mouseButton, down) {
       const marshal = new Marshal();
@@ -58240,33 +58643,33 @@ void main() {
       marshal.writeVector2(mousePos);
       marshal.writeInt(mouseButton);
       marshal.writeBoolean(down);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCMouseDoubleClickEvent(mousePos, mouseButton) {
       const marshal = new Marshal();
       marshal.writeString("RPCMouseDoubleClickEvent");
       marshal.writeVector2(mousePos);
       marshal.writeInt(mouseButton);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCMouseMoveEvent(mousePos) {
       const marshal = new Marshal();
       marshal.writeString("RPCMouseMoveEvent");
       marshal.writeVector2(mousePos);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCMouseScrollEvent(scrollValue) {
       const marshal = new Marshal();
       marshal.writeString("RPCMouseScrollEvent");
       marshal.writeInt(scrollValue);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCMouseSelectEvent(mousePos, mouseButton) {
       const marshal = new Marshal();
       marshal.writeString("RPCMouseSelectEvent");
       marshal.writeVector2(mousePos);
       marshal.writeInt(mouseButton);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCMoveCameraTo(usePosition, useTarget, position, target, blendTime) {
       const marshal = new Marshal();
@@ -58276,19 +58679,19 @@ void main() {
       marshal.writeVector3(position);
       marshal.writeVector3(target);
       marshal.writeFloat(blendTime);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCPauseRendering(pause) {
       const marshal = new Marshal();
       marshal.writeString("RPCPauseRendering");
       marshal.writeBoolean(pause);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     async RPCPerformHitTest(pos) {
       const marshal = new Marshal();
       marshal.writeString("RPCPerformHitTest");
       marshal.writeVector2(pos);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readHitCheckResult();
       return ret;
     }
@@ -58298,39 +58701,39 @@ void main() {
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
       marshal.writeUInt(flags);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCSetAspectRatio(width, height) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetAspectRatio");
       marshal.writeUInt(width);
       marshal.writeUInt(height);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCSetCameraMode(orbit2) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetCameraMode");
       marshal.writeBoolean(orbit2);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCSetCameraPosition(state, blendTime) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetCameraPosition");
       marshal.writeSegment(state);
       marshal.writeFloat(blendTime);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCSetGhostColor(ghostColor) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetGhostColor");
       marshal.writeRGBA(ghostColor);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCSetIblRotation(transform) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetIblRotation");
       marshal.writeMatrix44(transform);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCSetLighting(toneMappingWhitePoint, hdrScale, hdrBackgroundScale, hdrBackgroundSaturation, backgroundBlur, backgroundColor) {
       const marshal = new Marshal();
@@ -58341,7 +58744,7 @@ void main() {
       marshal.writeFloat(hdrBackgroundSaturation);
       marshal.writeFloat(backgroundBlur);
       marshal.writeRGBA(backgroundColor);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCSetMaterialOverrides(componentHandle, nodes, materialInstanceHandles) {
       const marshal = new Marshal();
@@ -58349,26 +58752,26 @@ void main() {
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
       marshal.writeArrayOfUInt(materialInstanceHandles);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCSetMoveSpeed(speed) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetMoveSpeed");
       marshal.writeFloat(speed);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
-    RPCSetSectionBox(aabb) {
+    RPCSetSectionBox(state) {
       const marshal = new Marshal();
       marshal.writeString("RPCSetSectionBox");
-      marshal.writeBox3(aabb);
-      this._messenger.sendRPC(marshal);
+      marshal.writeSectionBoxState(state);
+      this._socket.sendRPC(marshal);
     }
     RPCShow(componentHandle, nodes) {
       const marshal = new Marshal();
       marshal.writeString("RPCShow");
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCShowAABBs(componentHandle, nodes, colors) {
       const marshal = new Marshal();
@@ -58376,13 +58779,13 @@ void main() {
       marshal.writeUInt(componentHandle);
       marshal.writeArrayOfUInt(nodes);
       marshal.writeArrayOfRGBA32(colors);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCShowAll(componentHandle) {
       const marshal = new Marshal();
       marshal.writeString("RPCShowAll");
       marshal.writeUInt(componentHandle);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     async RPCStartScene(toneMappingWhitePoint, hdrScale, hdrBackgroundScale, hdrBackgroundSaturation, backgroundBlur, backgroundColor) {
       const marshal = new Marshal();
@@ -58393,20 +58796,20 @@ void main() {
       marshal.writeFloat(hdrBackgroundSaturation);
       marshal.writeFloat(backgroundBlur);
       marshal.writeRGBA(backgroundColor);
-      const returnMarshal = await this._messenger.sendRPCWithReturn(marshal);
+      const returnMarshal = await this._socket.sendRPCWithReturn(marshal);
       const ret = returnMarshal.readBoolean();
       return ret;
     }
     RPCTriggerRenderDocCapture() {
       const marshal = new Marshal();
       marshal.writeString("RPCTriggerRenderDocCapture");
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
     RPCUnloadVim(componentHandle) {
       const marshal = new Marshal();
       marshal.writeString("RPCUnloadVim");
       marshal.writeUInt(componentHandle);
-      this._messenger.sendRPC(marshal);
+      this._socket.sendRPC(marshal);
     }
   }
   class Validation {
@@ -58755,6 +59158,12 @@ void main() {
     RPCLockIblRotation(lock) {
       this.rpc.RPCLockIblRotation(lock);
     }
+    RPCGetSceneAABB() {
+      return this.safeCall(
+        () => this.rpc.RPCGetSceneAABB(),
+        void 0
+      );
+    }
     /*******************************************************************************
      * NODE VISIBILITY METHODS
      * Methods for controlling node visibility, including show/hide, ghosting,
@@ -58885,6 +59294,19 @@ void main() {
       if (!Validation.isComponentHandle(componentHandle)) return;
       this.rpc.RPCDestroyText(componentHandle);
     }
+    /*******************************************************************************
+     * SECTION BOX METHODS
+     * Methods for controlling section box visibility and position.
+     ******************************************************************************/
+    RPCSetSectionBox(state) {
+      this.rpc.RPCSetSectionBox(state);
+    }
+    async RPCGetSectionBox() {
+      return await this.safeCall(
+        () => this.rpc.RPCGetSectionBox(),
+        void 0
+      );
+    }
     /*******************************************************************************
      * CAMERA AND VIEW METHODS
      * Methods for controlling camera position, movement, framing, and view settings.
@@ -58910,6 +59332,12 @@ void main() {
       blendTime = Validation.clamp01(blendTime);
       this.rpc.RPCSetCameraPosition(segment, blendTime);
     }
+    async RPCGetBoundingBoxAll(componentHandle) {
+      return await this.safeCall(
+        () => this.rpc.RPCGetBoundingBoxAll(componentHandle),
+        void 0
+      );
+    }
     /**
      * Calculates the bounding box for specified nodes in a component.
      * Large node arrays are automatically processed in batches for better performance.
@@ -59503,9 +59931,6 @@ void main() {
      * Starts logging the stream metrics.
      */
     startLoggging() {
-      this._id = setInterval(() => {
-        this.logMetrics();
-      }, 5e3);
     }
     /**
      * Stops logging the stream metrics.
@@ -59617,6 +60042,8 @@ Averrage Date/Second ${avgDataRatePS} kb
        */
       __publicField(this, "onVideoFrame", () => {
       });
+      __publicField(this, "onCameraPose", () => {
+      });
       __publicField(this, "_state", { status: "disconnected" });
       __publicField(this, "_onStatusUpdate", new distExports.SimpleEventDispatcher());
       __publicField(this, "_connectPromise", new ResolvedPromise(void 0));
@@ -59674,7 +60101,7 @@ Averrage Date/Second ${avgDataRatePS} kb
         return Promise.reject(new Error(`Invalid WebSocket URL: ${url}`));
       }
       if (this._socket) {
-        if (this._socket.url === url) {
+        if (this._connectionSettings.url === url) {
           return this._connectPromise.promise;
         } else {
           this._clearSocket();
@@ -59761,6 +60188,10 @@ Averrage Date/Second ${avgDataRatePS} kb
           this.handleRPCResponse(msg.dataBuffer);
           return;
         case 254:
+          const m = new ReadMarshal(msg.dataBuffer);
+          if (this.onCameraPose) {
+            this.onCameraPose(m.readSegment());
+          }
           return;
         case 0:
         case 1:
@@ -59774,8 +60205,7 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @param buffer - The ArrayBuffer containing the response data.
      */
     handleRPCResponse(buffer) {
-      const m = new Marshal();
-      m.writeData(buffer);
+      const m = new ReadMarshal(buffer);
       const callId = m.readUInt();
       const pendingRPC = this._pendingRPCs.get(callId);
       if (pendingRPC !== void 0) {
@@ -60478,12 +60908,12 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @throws Error if 'all' is passed, as this feature is not supported yet.
      */
     async getBoundingBox(nodes) {
-      if (nodes === "all") {
-        throw new Error("Feature not supported yet.");
-      }
       if (!this.connected || nodes.length === 0) {
         return Promise.resolve(void 0);
       }
+      if (nodes === "all") {
+        return await this._rpc.RPCGetBoundingBoxAll(this._handle);
+      }
       return await this._rpc.RPCGetBoundingBox(this._handle, nodes);
     }
     /**
@@ -60945,7 +61375,7 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     /**
      * Restores the camera to its last tracked position
-     * @param blendTime - Duration of the camera animation in seconds
+     * @param blendTime - Duration of the camera animation in seconds 
      */
     restoreLastPosition(blendTime = this._defaultBlendTime) {
       var _a2;
@@ -60958,29 +61388,10 @@ Averrage Date/Second ${avgDataRatePS} kb
      * Handles camera initialization when connection is established
      */
     onConnect() {
-      this.startTracking();
       this.restoreLastPosition();
     }
-    /**
-     * Starts tracking camera position at regular intervals
-     */
-    startTracking() {
-      clearInterval(this._interval);
-      this._interval = setInterval(() => this.update(), 1e3);
-    }
-    /**
-     * Stops tracking camera position
-     */
-    stopTracking() {
-      clearInterval(this._interval);
-      this._interval = void 0;
-    }
-    /**
-     * Updates the stored camera position
-     * @private
-     */
-    async update() {
-      this._lastPosition = await this._rpc.RPCGetCameraPosition();
+    onCameraPose(pose) {
+      this._lastPosition = pose;
     }
     /**
      * Pauses or resumes rendering
@@ -61421,6 +61832,9 @@ Averrage Date/Second ${avgDataRatePS} kb
       this._updateLighting = true;
       this.requestSettingsUpdate();
     }
+    getBoundingBox() {
+      return this._rpc.RPCGetSceneAABB();
+    }
     /**
      * Requests an update to be performed on the next animation frame.
      * Multiple setting changes will be batched into a single update.
@@ -61452,6 +61866,103 @@ Averrage Date/Second ${avgDataRatePS} kb
       }
     }
   }
+  class SectionBox {
+    constructor(rpc) {
+      __publicField(this, "_enabled", false);
+      __publicField(this, "_visible", true);
+      __publicField(this, "_interactible", true);
+      __publicField(this, "_clip", true);
+      __publicField(this, "_box", new Box3());
+      __publicField(this, "_rpc");
+      __publicField(this, "_interval");
+      __publicField(this, "_animationFrame");
+      // Signals
+      __publicField(this, "_onUpdate", new distExports$1.SignalDispatcher());
+      this._rpc = rpc;
+    }
+    get onUpdate() {
+      return this._onUpdate.asEvent();
+    }
+    get needUpdate() {
+      return this._animationFrame > 0;
+    }
+    async onConnect() {
+      this.push();
+      this._interval = setInterval(() => this.pull(), 1e3);
+    }
+    scheduleUpdate() {
+      if (this._animationFrame) return;
+      this._animationFrame = requestAnimationFrame(() => {
+        this._animationFrame = void 0;
+        this.push();
+      });
+    }
+    async pull() {
+      if (this.needUpdate) return;
+      const state = await this._rpc.RPCGetSectionBox();
+      let changed = false;
+      if (state.enabled !== this._enabled || state.visible !== this._visible || state.interactible !== this._interactible || state.clip !== this._clip || state.box !== this._box) {
+        changed = true;
+      }
+      this._enabled = state.enabled;
+      this._visible = state.visible;
+      this._interactible = state.interactible;
+      this._clip = state.clip;
+      this._box = state.box;
+      if (changed) {
+        this._onUpdate.dispatch();
+      }
+    }
+    async push() {
+      await this._rpc.RPCSetSectionBox({
+        enabled: this._enabled,
+        visible: this._visible,
+        interactible: this._interactible,
+        clip: this._clip,
+        box: this._box
+      });
+    }
+    get enabled() {
+      return this._enabled;
+    }
+    set enabled(value) {
+      this._enabled = value;
+      this.scheduleUpdate();
+    }
+    get visible() {
+      return this._visible;
+    }
+    set visible(value) {
+      this._visible = value;
+      this.scheduleUpdate();
+    }
+    get interactible() {
+      return this._interactible;
+    }
+    set interactible(value) {
+      this._interactible = value;
+      this.scheduleUpdate();
+    }
+    get clip() {
+      return this._clip;
+    }
+    set clip(value) {
+      this._clip = value;
+      this.scheduleUpdate();
+    }
+    fitBox(box) {
+      this._box = box;
+      this.scheduleUpdate();
+    }
+    getBox() {
+      return this._box;
+    }
+    dispose() {
+      clearInterval(this._interval);
+      cancelAnimationFrame(this._animationFrame);
+      this._onUpdate.clear();
+    }
+  }
   const INVALID_HANDLE = 4294967295;
   class Viewer {
     /**
@@ -61479,6 +61990,10 @@ Averrage Date/Second ${avgDataRatePS} kb
        * API to create, manage, and destroy colors.
        */
       __publicField(this, "colors");
+      /**
+       * The section box API for controlling the section box.
+       */
+      __publicField(this, "sectionBox");
       this._logger = logger ?? defaultLogger;
       this._socketClient = new SocketClient(this._logger, () => this.validateConnection());
       this.rpc = new RpcSafeClient(new RpcClient(this._socketClient));
@@ -61491,7 +62006,9 @@ Averrage Date/Second ${avgDataRatePS} kb
       this.colors = new ColorManager(this.rpc);
       this._camera = new Camera(this.rpc);
       this._input = new Inputs(canvas, this.rpc, this._selection, this._camera, this._renderer);
+      this.sectionBox = new SectionBox(this.rpc);
       this._socketClient.onVideoFrame = (msg) => this._decoder.enqueue(msg);
+      this._socketClient.onCameraPose = (pose) => this._camera.onCameraPose(pose);
       this._socketClient.onStatusUpdate.subscribe((state) => {
         if (state.status === "disconnected") {
           this.onDisconnect();
@@ -61576,6 +62093,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       this._input.onConnect();
       this._camera.onConnect();
       this._vims.getAll().forEach((vim) => vim.connect());
+      this.sectionBox.onConnect();
       this._viewport.update();
       this._decoder.start();
     }
@@ -61613,7 +62131,6 @@ Averrage Date/Second ${avgDataRatePS} kb
      * Cleans up resources and stops tracking.
      */
     onDisconnect() {
-      this._camera.stopTracking();
       this._decoder.stop();
       this._decoder.clear();
       this.colors.clear();
@@ -61680,6 +62197,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       this._viewport.dispose();
       this._decoder.dispose();
       this._input.dispose();
+      this.sectionBox.dispose();
       this._canvas.remove();
       window.onbeforeunload = null;
     }
@@ -75719,7 +76237,7 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     if (state.status === "connecting") {
       if (modal.current === void 0 || modal.current.type === "loading") {
-        modal.loading({ message: "Initializing..." });
+        modal.loading({ message: "Connecting to VIM Ultra server..." });
       }
     }
     if (state.status === "error") {