vim-web 0.3.43 → 0.3.44-dev.0

package/dist/vim-web.js

@@ -47148,6 +47148,154 @@ let Vim$1 = class Vim {
     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 i = 0; i < geometries.length; ++i) {
+    const geometry = geometries[i];
+    let attributesCount = 0;
+    if (isIndexed !== (geometry.index !== null)) {
+      console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + i + ". 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 " + i + '. 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 " + i + ". 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 " + i + ". .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 " + i + ".  .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 " + i + ". The geometry must have either an index or a position attribute");
+        return null;
+      }
+      mergedGeometry.addGroup(offset, count, i);
+      offset += count;
+    }
+  }
+  if (isIndexed) {
+    let indexOffset = 0;
+    const mergedIndex = [];
+    for (let i = 0; i < geometries.length; ++i) {
+      const index2 = geometries[i].index;
+      for (let j = 0; j < index2.count; ++j) {
+        mergedIndex.push(index2.getX(j) + indexOffset);
+      }
+      indexOffset += geometries[i].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 i = 0; i < numMorphTargets; ++i) {
+      const morphAttributesToMerge = [];
+      for (let j = 0; j < morphAttributes[name].length; ++j) {
+        morphAttributesToMerge.push(morphAttributes[name][j][i]);
+      }
+      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 i = 0; i < attributes.length; ++i) {
+    const attribute = attributes[i];
+    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 i = 0; i < attributes.length; ++i) {
+    const attribute = attributes[i];
+    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) {
@@ -50104,7 +50252,7 @@ const defaultViewerSettings = {
     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,
@@ -50428,18 +50576,18 @@ class CameraMovement {
   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);
@@ -50647,12 +50795,30 @@ class CameraMovementSnap extends CameraMovement {
     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;
@@ -50663,17 +50829,14 @@ class CameraMovementSnap extends CameraMovement {
   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;
   }
 }
@@ -50722,6 +50885,8 @@ let Camera$1 = class Camera2 {
     __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()
     );
@@ -50782,7 +50947,7 @@ let Camera$1 = class Camera2 {
   }
   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();
     }
@@ -54869,8 +55034,314 @@ class Measure {
     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,
@@ -54926,7 +55397,7 @@ class BoxOutline extends LineSegments {
     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);
@@ -54955,305 +55426,169 @@ class BoxOutline extends LineSegments {
     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");
@@ -55261,21 +55596,13 @@ class SectionBox {
     __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;
     };
@@ -55290,37 +55617,61 @@ class SectionBox {
     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;
@@ -55332,71 +55683,79 @@ class SectionBox {
     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");
@@ -55428,7 +55787,7 @@ class Gizmos {
     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,
@@ -57661,17 +58020,16 @@ function isWebSocketUrl(input) {
 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) {
@@ -57680,21 +58038,162 @@ class Marshal {
       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();
@@ -57714,74 +58213,33 @@ class Marshal {
     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();
@@ -57794,12 +58252,6 @@ class Marshal {
       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();
@@ -57808,38 +58260,17 @@ class Marshal {
       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 Vector22(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 Vector32(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();
@@ -57852,14 +58283,6 @@ class Marshal {
       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();
@@ -57867,91 +58290,55 @@ class Marshal {
     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 Box32(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 Box32(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 = [];
@@ -57986,17 +58373,17 @@ const materialHandles = [
   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();
@@ -58004,18 +58391,18 @@ class RpcClient {
     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();
@@ -58023,7 +58410,7 @@ class RpcClient {
     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;
   }
@@ -58033,7 +58420,7 @@ class RpcClient {
     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;
   }
@@ -58041,25 +58428,19 @@ class RpcClient {
     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;
   }
@@ -58068,7 +58449,7 @@ class RpcClient {
     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;
   }
@@ -58078,7 +58459,7 @@ class RpcClient {
     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;
   }
@@ -58087,14 +58468,14 @@ class RpcClient {
     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;
   }
@@ -58103,36 +58484,58 @@ class RpcClient {
     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;
   }
@@ -58141,65 +58544,65 @@ class RpcClient {
     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;
   }
@@ -58208,7 +58611,7 @@ class RpcClient {
     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;
   }
@@ -58216,7 +58619,7 @@ class RpcClient {
     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();
@@ -58224,33 +58627,33 @@ class RpcClient {
     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();
@@ -58260,19 +58663,19 @@ class RpcClient {
     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;
   }
@@ -58282,39 +58685,39 @@ class RpcClient {
     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();
@@ -58325,7 +58728,7 @@ class RpcClient {
     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();
@@ -58333,26 +58736,26 @@ class RpcClient {
     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();
@@ -58360,13 +58763,13 @@ class RpcClient {
     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();
@@ -58377,20 +58780,20 @@ class RpcClient {
     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 {
@@ -58869,6 +59272,19 @@ class RpcSafeClient {
     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.
@@ -58894,6 +59310,12 @@ class RpcSafeClient {
     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.
@@ -59487,9 +59909,6 @@ class StreamLogger {
    * Starts logging the stream metrics.
    */
   startLoggging() {
-    this._id = setInterval(() => {
-      this.logMetrics();
-    }, 5e3);
   }
   /**
    * Stops logging the stream metrics.
@@ -59601,6 +60020,8 @@ class SocketClient {
      */
     __publicField(this, "onVideoFrame", () => {
     });
+    __publicField(this, "onCameraPose", () => {
+    });
     __publicField(this, "_state", { status: "disconnected" });
     __publicField(this, "_onStatusUpdate", new distExports.SimpleEventDispatcher());
     __publicField(this, "_connectPromise", new ResolvedPromise(void 0));
@@ -59658,7 +60079,7 @@ class SocketClient {
       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();
@@ -59745,6 +60166,10 @@ class SocketClient {
         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:
@@ -59758,8 +60183,7 @@ class SocketClient {
    * @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) {
@@ -60462,12 +60886,12 @@ class Vim2 {
    * @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);
   }
   /**
@@ -60929,7 +61353,7 @@ class Camera3 {
   }
   /**
    * 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;
@@ -60942,29 +61366,10 @@ class Camera3 {
    * 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
@@ -61436,6 +61841,103 @@ class Renderer2 {
     }
   }
 }
+class SectionBox2 {
+  constructor(rpc) {
+    __publicField(this, "_enabled", false);
+    __publicField(this, "_visible", true);
+    __publicField(this, "_interactible", true);
+    __publicField(this, "_clip", true);
+    __publicField(this, "_box", new Box32());
+    __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 Viewer2 {
   /**
@@ -61463,6 +61965,10 @@ class Viewer2 {
      * 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));
@@ -61475,7 +61981,9 @@ class Viewer2 {
     this.colors = new ColorManager(this.rpc);
     this._camera = new Camera3(this.rpc);
     this._input = new Inputs(canvas, this.rpc, this._selection, this._camera, this._renderer);
+    this.sectionBox = new SectionBox2(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();
@@ -61560,6 +62068,7 @@ class Viewer2 {
     this._input.onConnect();
     this._camera.onConnect();
     this._vims.getAll().forEach((vim) => vim.connect());
+    this.sectionBox.onConnect();
     this._viewport.update();
     this._decoder.start();
   }
@@ -61597,7 +62106,6 @@ class Viewer2 {
    * Cleans up resources and stops tracking.
    */
   onDisconnect() {
-    this._camera.stopTracking();
     this._decoder.stop();
     this._decoder.clear();
     this.colors.clear();
@@ -61664,6 +62172,7 @@ class Viewer2 {
     this._viewport.dispose();
     this._decoder.dispose();
     this._input.dispose();
+    this.sectionBox.dispose();
     this._canvas.remove();
     window.onbeforeunload = null;
   }
@@ -75703,7 +76212,7 @@ function updateModal(modal, state) {
   }
   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") {