minerender 2.1.0-alpha.114 → 2.1.0-alpha.115

package/dist/browser/index.js

@@ -7549,6 +7549,7 @@ __export(index_browser_exports, {
   EntityObject: () => EntityObject,
   Env: () => Env,
   FluidModelObject: () => FluidModelObject,
+  FlyControls: () => FlyControls,
   Fonts: () => Fonts,
   GUI_CONTAINER_LAYOUTS: () => GUI_CONTAINER_LAYOUTS,
   Geometries: () => Geometries,
@@ -7651,6 +7652,7 @@ __export(index_browser_exports, {
   isDisposable: () => isDisposable,
   isDoubleArray: () => isDoubleArray,
   isEntityObject: () => isEntityObject,
+  isFlyControls: () => isFlyControls,
   isGuiObject: () => isGuiObject,
   isInstanceManager: () => isInstanceManager,
   isInstanceReference: () => isInstanceReference,
@@ -13267,8 +13269,323 @@ init_ModelObject();
 // src/index.ts
 init_nbt();
 
-// src/renderer/MineRenderScene.ts
+// src/renderer/FlyControls.ts
 var import_three35 = require("three");
+var VANILLA_FLY_SPEED = 10.89;
+var PITCH_LIMIT = Math.PI / 2;
+var MOVE_EPSILON = 1e-6;
+var _euler = new import_three35.Euler(0, 0, 0, "YXZ");
+var _forward = new import_three35.Vector3();
+var _right = new import_three35.Vector3();
+var _targetVelocity = new import_three35.Vector3();
+var FlyControls = class extends import_three35.Controls {
+  constructor(camera, domElement) {
+    super(camera, domElement ?? null);
+    this.isFlyControls = true;
+    /** Horizontal and vertical speed in scene units per second; vanilla creative flight by default. */
+    this.movementSpeed = 16 * VANILLA_FLY_SPEED;
+    /** Speed multiplier while the sprint key is held. */
+    this.sprintMultiplier = 2;
+    /** Radians per pixel of pointer movement. */
+    this.lookSpeed = 2e-3;
+    /** Smooth acceleration and deceleration, approximating vanilla flight momentum. */
+    this.enableDamping = true;
+    /** Portion of the remaining velocity change applied per 60 Hz frame (0–1) when damping is enabled. */
+    this.dampingFactor = 0.25;
+    /** Capture the pointer on click so the mouse turns the camera without dragging; dragging works regardless. */
+    this.pointerLock = true;
+    /** Scroll the wheel to change `movementSpeed` within `speedRange`. */
+    this.enableWheelSpeed = true;
+    /** Minimum and maximum `movementSpeed` reachable with the wheel. */
+    this.speedRange = [16, 16 * 500];
+    /** Touch joystick travel in CSS pixels for full speed. */
+    this.joystickRadius = 64;
+    /** Key bindings by `KeyboardEvent.code`. */
+    this.keys = {
+      forward: ["KeyW", "ArrowUp"],
+      back: ["KeyS", "ArrowDown"],
+      left: ["KeyA", "ArrowLeft"],
+      right: ["KeyD", "ArrowRight"],
+      up: ["Space"],
+      down: ["ShiftLeft", "ShiftRight"],
+      sprint: ["ControlLeft", "ControlRight"]
+    };
+    this._pressed = /* @__PURE__ */ new Set();
+    this._velocity = new import_three35.Vector3();
+    this._lastPosition = new import_three35.Vector3();
+    this._lastQuaternion = new import_three35.Quaternion();
+    this._position0 = new import_three35.Vector3();
+    this._quaternion0 = new import_three35.Quaternion();
+    this._dragMoved = false;
+    this._locked = false;
+    this._onKeyDown = (event) => this.handleKey(event, true);
+    this._onKeyUp = (event) => this.handleKey(event, false);
+    this._onPointerDown = (event) => this.handlePointerDown(event);
+    this._onPointerMove = (event) => this.handlePointerMove(event);
+    this._onPointerUp = (event) => this.handlePointerUp(event);
+    this._onPointerLockChange = () => this.handlePointerLockChange();
+    this._onContextMenu = (event) => event.preventDefault();
+    this._onWheel = (event) => this.handleWheel(event);
+    this._onBlur = () => this.releaseKeys();
+    this._lastPosition.copy(camera.position);
+    this._lastQuaternion.copy(camera.quaternion);
+    this.saveState();
+    if (domElement) this.connect(domElement);
+  }
+  connect(element) {
+    super.connect(element);
+    const document2 = element.ownerDocument;
+    document2.addEventListener("keydown", this._onKeyDown);
+    document2.addEventListener("keyup", this._onKeyUp);
+    document2.addEventListener("pointerlockchange", this._onPointerLockChange);
+    document2.defaultView?.addEventListener("blur", this._onBlur);
+    element.addEventListener("pointerdown", this._onPointerDown);
+    element.addEventListener("pointermove", this._onPointerMove);
+    element.addEventListener("pointerup", this._onPointerUp);
+    element.addEventListener("pointercancel", this._onPointerUp);
+    element.addEventListener("contextmenu", this._onContextMenu);
+    element.addEventListener("wheel", this._onWheel, { passive: false });
+    element.addEventListener("blur", this._onBlur);
+    element.style.touchAction = "none";
+    if (element.tabIndex < 0) element.tabIndex = 0;
+  }
+  disconnect() {
+    const element = this.domElement;
+    if (!element) return;
+    const document2 = element.ownerDocument;
+    document2.removeEventListener("keydown", this._onKeyDown);
+    document2.removeEventListener("keyup", this._onKeyUp);
+    document2.removeEventListener("pointerlockchange", this._onPointerLockChange);
+    document2.defaultView?.removeEventListener("blur", this._onBlur);
+    element.removeEventListener("pointerdown", this._onPointerDown);
+    element.removeEventListener("pointermove", this._onPointerMove);
+    element.removeEventListener("pointerup", this._onPointerUp);
+    element.removeEventListener("pointercancel", this._onPointerUp);
+    element.removeEventListener("contextmenu", this._onContextMenu);
+    element.removeEventListener("wheel", this._onWheel);
+    element.removeEventListener("blur", this._onBlur);
+    element.style.touchAction = "auto";
+    this.unlock();
+    this._locked = false;
+    this.releaseKeys();
+    this._dragPointer = void 0;
+    this._joystick = void 0;
+  }
+  dispose() {
+    this.disconnect();
+  }
+  /** Whether mouse look currently owns the pointer. */
+  get locked() {
+    return this._locked;
+  }
+  /** Requests pointer capture; browsers only allow this from a user gesture. */
+  lock() {
+    const element = this.domElement;
+    if (!element || this._locked || typeof element.requestPointerLock !== "function") return;
+    try {
+      const result = element.requestPointerLock();
+      if (result instanceof Promise) result.catch(() => void 0);
+    } catch {
+    }
+  }
+  /** Releases a captured pointer. */
+  unlock() {
+    const document2 = this.domElement?.ownerDocument;
+    if (document2?.pointerLockElement && document2.pointerLockElement === this.domElement) {
+      document2.exitPointerLock();
+    }
+  }
+  /** Stores the camera pose that {@link reset} restores. */
+  saveState() {
+    this._position0.copy(this.object.position);
+    this._quaternion0.copy(this.object.quaternion);
+  }
+  /** Restores the saved camera pose and stops movement. */
+  reset() {
+    this.object.position.copy(this._position0);
+    this.object.quaternion.copy(this._quaternion0);
+    this._velocity.set(0, 0, 0);
+    this.notifyChange();
+  }
+  /** Horizontal yaw in radians, where zero looks toward -Z. */
+  get yaw() {
+    return _euler.setFromQuaternion(this.object.quaternion).y;
+  }
+  /** Vertical pitch in radians, positive looking up. */
+  get pitch() {
+    return _euler.setFromQuaternion(this.object.quaternion).x;
+  }
+  /** Turns the camera; pitch is clamped to straight up and down. */
+  setRotation(yaw, pitch) {
+    _euler.set(import_three35.MathUtils.clamp(pitch, -PITCH_LIMIT, PITCH_LIMIT), yaw, 0);
+    this.object.quaternion.setFromEuler(_euler);
+    this.notifyChange();
+  }
+  /** Points the camera at a position without rolling it. */
+  lookAt(target) {
+    _forward.copy(target).sub(this.object.position);
+    if (_forward.lengthSq() < MOVE_EPSILON) return;
+    _forward.normalize();
+    this.setRotation(Math.atan2(-_forward.x, -_forward.z), Math.asin(import_three35.MathUtils.clamp(_forward.y, -1, 1)));
+  }
+  /** Whether an action's key is held. */
+  isPressed(action) {
+    return this._pressed.has(action);
+  }
+  /**
+   * Advances movement by `delta` seconds (measured since the previous call when omitted)
+   * and dispatches `change` when the camera moved.
+   */
+  update(delta) {
+    if (delta === void 0) {
+      const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+      delta = this._lastTime === void 0 ? 0 : (now - this._lastTime) / 1e3;
+      this._lastTime = now;
+    }
+    if (!this.enabled) {
+      this._velocity.set(0, 0, 0);
+      return;
+    }
+    if (delta > 0) this.move(delta);
+    this.notifyChange();
+  }
+  move(delta) {
+    const camera = this.object;
+    let forward = (this._pressed.has("forward") ? 1 : 0) - (this._pressed.has("back") ? 1 : 0);
+    let strafe = (this._pressed.has("right") ? 1 : 0) - (this._pressed.has("left") ? 1 : 0);
+    const climb = (this._pressed.has("up") ? 1 : 0) - (this._pressed.has("down") ? 1 : 0);
+    const joystick = this._joystick;
+    if (joystick) {
+      const radius = Math.max(this.joystickRadius, 1);
+      forward = import_three35.MathUtils.clamp(forward + (joystick.originY - joystick.y) / radius, -1, 1);
+      strafe = import_three35.MathUtils.clamp(strafe + (joystick.x - joystick.originX) / radius, -1, 1);
+    }
+    _euler.setFromQuaternion(camera.quaternion);
+    const yaw = _euler.y;
+    _forward.set(-Math.sin(yaw), 0, -Math.cos(yaw));
+    _right.set(Math.cos(yaw), 0, -Math.sin(yaw));
+    _targetVelocity.set(0, 0, 0);
+    if (forward || strafe || climb) {
+      _targetVelocity.addScaledVector(_forward, forward).addScaledVector(_right, strafe);
+      if (_targetVelocity.lengthSq() > 1) _targetVelocity.normalize();
+      _targetVelocity.y = climb;
+      const speed = this.movementSpeed * (this._pressed.has("sprint") ? this.sprintMultiplier : 1);
+      _targetVelocity.multiplyScalar(speed);
+    }
+    if (this.enableDamping) {
+      const blend = 1 - Math.pow(1 - import_three35.MathUtils.clamp(this.dampingFactor, 0, 1), delta * 60);
+      this._velocity.lerp(_targetVelocity, blend);
+      if (_targetVelocity.lengthSq() === 0 && this._velocity.lengthSq() < MOVE_EPSILON) this._velocity.set(0, 0, 0);
+    } else {
+      this._velocity.copy(_targetVelocity);
+    }
+    camera.position.addScaledVector(this._velocity, delta);
+  }
+  notifyChange() {
+    const camera = this.object;
+    if (this._lastPosition.distanceToSquared(camera.position) > MOVE_EPSILON || 8 * (1 - this._lastQuaternion.dot(camera.quaternion)) > MOVE_EPSILON) {
+      this._lastPosition.copy(camera.position);
+      this._lastQuaternion.copy(camera.quaternion);
+      this.dispatchEvent({ type: "change" });
+    }
+  }
+  releaseKeys() {
+    this._pressed.clear();
+  }
+  handleKey(event, down) {
+    const action = this.actionFor(event.code);
+    if (!action) return;
+    const ownsInput = this.enabled && (this._locked || event.target === this.domElement);
+    if (down && !ownsInput) return;
+    const pressed = this._pressed.has(action);
+    if (down) this._pressed.add(action);
+    else this._pressed.delete(action);
+    if (ownsInput || this.enabled && pressed) event.preventDefault();
+  }
+  actionFor(code) {
+    for (const action in this.keys) {
+      if (this.keys[action].includes(code)) return action;
+    }
+    return void 0;
+  }
+  handlePointerDown(event) {
+    const element = this.domElement;
+    if (!this.enabled || !element) return;
+    element.focus?.({ preventScroll: true });
+    if (this._locked) return;
+    if (event.pointerType === "touch" && !this._joystick && this.onJoystickSide(event)) {
+      this._joystick = { id: event.pointerId, originX: event.clientX, originY: event.clientY, x: event.clientX, y: event.clientY };
+      element.setPointerCapture?.(event.pointerId);
+      return;
+    }
+    if (this._dragPointer !== void 0) return;
+    if (event.pointerType === "mouse" && event.button !== 0 && event.button !== 2) return;
+    this._dragPointer = event.pointerId;
+    this._dragMoved = false;
+    element.setPointerCapture?.(event.pointerId);
+  }
+  onJoystickSide(event) {
+    const rect = this.domElement?.getBoundingClientRect?.();
+    return !!rect && event.clientX < rect.left + rect.width / 2;
+  }
+  handlePointerMove(event) {
+    if (!this.enabled) return;
+    const joystick = this._joystick;
+    if (joystick && event.pointerId === joystick.id) {
+      joystick.x = event.clientX;
+      joystick.y = event.clientY;
+      return;
+    }
+    if (!this._locked && event.pointerId !== this._dragPointer) return;
+    const dx = event.movementX ?? 0;
+    const dy = event.movementY ?? 0;
+    if (!dx && !dy) return;
+    this._dragMoved = true;
+    this.turn(dx, dy);
+  }
+  handlePointerUp(event) {
+    if (this._joystick?.id === event.pointerId) {
+      this._joystick = void 0;
+      this.domElement?.releasePointerCapture?.(event.pointerId);
+      return;
+    }
+    if (event.pointerId !== this._dragPointer) return;
+    this._dragPointer = void 0;
+    this.domElement?.releasePointerCapture?.(event.pointerId);
+    if (this.enabled && this.pointerLock && !this._dragMoved && event.pointerType === "mouse" && event.button === 0) {
+      this.lock();
+    }
+  }
+  handleWheel(event) {
+    if (!this.enabled || !this.enableWheelSpeed) return;
+    event.preventDefault();
+    const steps = event.deltaMode === 0 ? event.deltaY / 100 : event.deltaY;
+    const [min, max] = this.speedRange;
+    this.movementSpeed = import_three35.MathUtils.clamp(this.movementSpeed * Math.pow(1.15, -steps), Math.min(min, max), Math.max(min, max));
+  }
+  handlePointerLockChange() {
+    const document2 = this.domElement?.ownerDocument;
+    const locked = !!document2 && document2.pointerLockElement === this.domElement;
+    if (locked === this._locked) return;
+    this._locked = locked;
+    if (!locked) this.releaseKeys();
+    this.dispatchEvent({ type: locked ? "lock" : "unlock" });
+  }
+  turn(dx, dy) {
+    _euler.setFromQuaternion(this.object.quaternion);
+    _euler.y -= dx * this.lookSpeed;
+    _euler.x = import_three35.MathUtils.clamp(_euler.x - dy * this.lookSpeed, -PITCH_LIMIT, PITCH_LIMIT);
+    _euler.z = 0;
+    this.object.quaternion.setFromEuler(_euler);
+    this.notifyChange();
+  }
+};
+function isFlyControls(obj) {
+  return obj?.isFlyControls === true;
+}
+
+// src/renderer/MineRenderScene.ts
+var import_three36 = require("three");
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
 init_ModelObject();
@@ -14178,7 +14495,7 @@ var SkinObject = class extends SceneObject {
 // src/renderer/MineRenderScene.ts
 init_EntityObject();
 init_ItemTints();
-var _MineRenderScene = class _MineRenderScene extends import_three35.Scene {
+var _MineRenderScene = class _MineRenderScene extends import_three36.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -14333,7 +14650,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three37 = require("three");
+var import_three38 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
@@ -14342,11 +14659,11 @@ init_Model();
 init_three();
 
 // src/three/OrbitControls.js
-var import_three36 = require("three");
+var import_three37 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three36.EventDispatcher {
+var OrbitControls = class extends import_three37.EventDispatcher {
   constructor(object4, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -14355,7 +14672,7 @@ var OrbitControls = class extends import_three36.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three36.Vector3();
+    this.target = new import_three37.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -14377,8 +14694,8 @@ var OrbitControls = class extends import_three36.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three36.MOUSE.ROTATE, MIDDLE: import_three36.MOUSE.DOLLY, RIGHT: import_three36.MOUSE.PAN };
-    this.touches = { ONE: import_three36.TOUCH.ROTATE, TWO: import_three36.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three37.MOUSE.ROTATE, MIDDLE: import_three37.MOUSE.DOLLY, RIGHT: import_three37.MOUSE.PAN };
+    this.touches = { ONE: import_three37.TOUCH.ROTATE, TWO: import_three37.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -14407,11 +14724,11 @@ var OrbitControls = class extends import_three36.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three36.Vector3();
-      const quat = new import_three36.Quaternion().setFromUnitVectors(object4.up, new import_three36.Vector3(0, 1, 0));
+      const offset = new import_three37.Vector3();
+      const quat = new import_three37.Quaternion().setFromUnitVectors(object4.up, new import_three37.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three36.Vector3();
-      const lastQuaternion = new import_three36.Quaternion();
+      const lastPosition = new import_three37.Vector3();
+      const lastQuaternion = new import_three37.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -14497,20 +14814,20 @@ var OrbitControls = class extends import_three36.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three36.Spherical();
-    const sphericalDelta = new import_three36.Spherical();
+    const spherical = new import_three37.Spherical();
+    const sphericalDelta = new import_three37.Spherical();
     let scale = 1;
-    const panOffset = new import_three36.Vector3();
+    const panOffset = new import_three37.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three36.Vector2();
-    const rotateEnd = new import_three36.Vector2();
-    const rotateDelta = new import_three36.Vector2();
-    const panStart = new import_three36.Vector2();
-    const panEnd = new import_three36.Vector2();
-    const panDelta = new import_three36.Vector2();
-    const dollyStart = new import_three36.Vector2();
-    const dollyEnd = new import_three36.Vector2();
-    const dollyDelta = new import_three36.Vector2();
+    const rotateStart = new import_three37.Vector2();
+    const rotateEnd = new import_three37.Vector2();
+    const rotateDelta = new import_three37.Vector2();
+    const panStart = new import_three37.Vector2();
+    const panEnd = new import_three37.Vector2();
+    const panDelta = new import_three37.Vector2();
+    const dollyStart = new import_three37.Vector2();
+    const dollyEnd = new import_three37.Vector2();
+    const dollyDelta = new import_three37.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -14526,7 +14843,7 @@ var OrbitControls = class extends import_three36.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three36.Vector3();
+      const v = new import_three37.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -14534,7 +14851,7 @@ var OrbitControls = class extends import_three36.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three36.Vector3();
+      const v = new import_three37.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -14547,7 +14864,7 @@ var OrbitControls = class extends import_three36.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three36.Vector3();
+      const offset = new import_three37.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -14796,12 +15113,12 @@ var OrbitControls = class extends import_three36.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three36.MOUSE.DOLLY:
+        case import_three37.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three36.MOUSE.ROTATE:
+        case import_three37.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -14812,7 +15129,7 @@ var OrbitControls = class extends import_three36.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three36.MOUSE.PAN:
+        case import_three37.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -14868,12 +15185,12 @@ var OrbitControls = class extends import_three36.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three36.TOUCH.ROTATE:
+            case import_three37.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three36.TOUCH.PAN:
+            case import_three37.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -14884,12 +15201,12 @@ var OrbitControls = class extends import_three36.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three36.TOUCH.DOLLY_PAN:
+            case import_three37.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three36.TOUCH.DOLLY_ROTATE:
+            case import_three37.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -14956,7 +15273,7 @@ var OrbitControls = class extends import_three36.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three36.Vector2();
+        position = new import_three37.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -14976,10 +15293,10 @@ var MapControls = class extends OrbitControls {
   constructor(object4, domElement) {
     super(object4, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three36.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three36.MOUSE.ROTATE;
-    this.touches.ONE = import_three36.TOUCH.PAN;
-    this.touches.TWO = import_three36.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three37.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three37.MOUSE.ROTATE;
+    this.touches.ONE = import_three37.TOUCH.PAN;
+    this.touches.TWO = import_three37.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -15050,14 +15367,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three37.PerspectiveCamera(
+        return new import_three38.PerspectiveCamera(
           this.options.camera.perspective.fov,
           this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
           this.options.camera.near,
           this.options.camera.far
         );
       case "orthographic":
-        return new import_three37.OrthographicCamera(
+        return new import_three38.OrthographicCamera(
           this.options.camera.orthographic.left ?? this.viewWidth / -2,
           this.options.camera.orthographic.right ?? this.viewWidth / 2,
           this.options.camera.orthographic.top ?? this.viewHeight / 2,
@@ -15073,7 +15390,7 @@ var _Renderer = class _Renderer {
     }
     const pixelRatio = this.options.render.pixelRatio ?? 1;
     this._surface?.resize?.(Math.floor(this.viewWidth * pixelRatio), Math.floor(this.viewHeight * pixelRatio));
-    const renderer = new import_three37.WebGLRenderer({
+    const renderer = new import_three38.WebGLRenderer({
       canvas: this._surface?.canvas,
       context: this._surface?.context,
       antialias: this.options.render.antialias,
@@ -15083,8 +15400,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three37.PCFShadowMap;
-    renderer.outputColorSpace = import_three37.SRGBColorSpace;
+    renderer.shadowMap.type = import_three38.PCFShadowMap;
+    renderer.outputColorSpace = import_three38.SRGBColorSpace;
     if (this._surface) {
       renderer.setDrawingBufferSize(this.viewWidth, this.viewHeight, pixelRatio);
     } else {
@@ -15102,20 +15419,77 @@ var _Renderer = class _Renderer {
   }
   createControls() {
     if (!this.options.controls?.enabled) return void 0;
-    const position = this.camera.position.clone();
-    const controls = new OrbitControls(this.camera, this.renderer.domElement);
-    this.camera.position.copy(position);
+    return this.createControlsFor(this.options.controls.mode ?? "orbit", this.initialTarget());
+  }
+  initialTarget() {
     const target = this.options.camera.lookingAt;
-    if (isVector3(target)) {
+    if (isVector3(target)) return target.clone();
+    if (isTripleArray(target)) return new import_three38.Vector3(target[0], target[1], target[2]);
+    return new import_three38.Vector3();
+  }
+  createControlsFor(mode, target) {
+    let controls;
+    if (mode === "fly") {
+      controls = new FlyControls(this.camera, this.renderer.domElement);
+      controls.lookAt(target);
+      controls.saveState();
+    } else {
+      const position = this.camera.position.clone();
+      controls = new OrbitControls(this.camera, this.renderer.domElement);
+      this.camera.position.copy(position);
       controls.target.copy(target);
-    } else if (isTripleArray(target)) {
-      controls.target.set(target[0], target[1], target[2]);
+      controls.update();
+      controls.saveState();
     }
-    controls.update();
-    controls.saveState();
+    this._controlsTime = void 0;
     this.registerEventDispatcher(controls);
     return controls;
   }
+  /**
+   * Replaces renderer-owned controls with the selected mode, keeping the camera where it is.
+   * Switching to orbit controls targets the point the camera looks at, at the previous orbit distance.
+   * Returns the new controls, or undefined when controls were disabled at construction or after disposal.
+   */
+  setControlsMode(mode) {
+    const current = this._controls;
+    if (this._disposed || !current) return void 0;
+    if (this.controlsMode === mode) return current;
+    let target;
+    if (isFlyControls(current)) {
+      const distance = this._orbitDistance ?? (this.camera.position.distanceTo(this.initialTarget()) || 1);
+      target = new import_three38.Vector3(0, 0, -distance).applyQuaternion(this.camera.quaternion).add(this.camera.position);
+    } else {
+      target = current.target.clone();
+      this._orbitDistance = this.camera.position.distanceTo(target);
+    }
+    const enabled = current.enabled;
+    this.disposeControls(current);
+    this._controls = this.createControlsFor(mode, target);
+    this._controls.enabled = enabled;
+    this.dirty = true;
+    return this._controls;
+  }
+  disposeControls(controls) {
+    this._controls = void 0;
+    this.unregisterEventDispatcher(controls);
+    controls.enabled = false;
+    controls.dispose();
+  }
+  /** Advances owned controls; without a frame time, flight movement does not progress. */
+  updateControls(time) {
+    const controls = this._controls;
+    if (!controls?.enabled) {
+      this._controlsTime = void 0;
+      return;
+    }
+    if (!isFlyControls(controls)) {
+      controls.update();
+      return;
+    }
+    const previous = this._controlsTime;
+    if (time !== void 0) this._controlsTime = time;
+    controls.update(time === void 0 || previous === void 0 ? 0 : (time - previous) / 1e3);
+  }
   //</editor-fold>
   init() {
     if (this._disposed) return;
@@ -15123,20 +15497,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three37.GridHelper(128, 16);
+      const gridHelper = new import_three38.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three37.GridHelper(128, 16);
+      const gridHelper2 = new import_three38.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three37.GridHelper(128, 16);
+      const gridHelper3 = new import_three38.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper3);
       gridHelper3.rotation.z = 90 * (Math.PI / 180);
       this.scene.add(gridHelper3);
     }
     if (this.options.debug.axes) {
-      const axesHelper = new import_three37.AxesHelper(64);
+      const axesHelper = new import_three38.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -15192,6 +15566,12 @@ var _Renderer = class _Renderer {
     events.add(changeEvent2);
     dispatcher.addEventListener(changeEvent2, this._changeListener);
   }
+  unregisterEventDispatcher(dispatcher) {
+    const events = this._eventDispatchers.get(dispatcher);
+    if (!events) return;
+    for (const event of events) dispatcher.removeEventListener(event, this._changeListener);
+    this._eventDispatchers.delete(dispatcher);
+  }
   /** Updates the camera and canvas size. Width and height are in CSS pixels. */
   resize(width, height) {
     if (this._disposed) return;
@@ -15268,6 +15648,7 @@ var _Renderer = class _Renderer {
       this.renderer.setAnimationLoop(null);
     }
     this._nextFrameTime = void 0;
+    this._controlsTime = void 0;
     for (const subscription of this._frameCallbacks.values()) subscription.previous = void 0;
   }
   /**
@@ -15297,10 +15678,7 @@ var _Renderer = class _Renderer {
     }
     this._element = void 0;
     if (this._controls) {
-      const controls = this._controls;
-      this._controls = void 0;
-      controls.enabled = false;
-      controls.dispose();
+      this.disposeControls(this._controls);
     }
     this.scene.clear();
     for (const helper of this._debugHelpers) {
@@ -15317,9 +15695,7 @@ var _Renderer = class _Renderer {
   }
   animate(t = performance.now()) {
     if (!this._running) return;
-    if (this._controls?.enabled) {
-      this._controls.update();
-    }
+    this.updateControls(t);
     if (!this._running) return;
     if (!this.dirty && !this.options.render.renderAlways && !this._frameCallbacks.size && !this._videoExporter) return;
     const interval = this._frameInterval;
@@ -15356,7 +15732,7 @@ var _Renderer = class _Renderer {
   /** Draws a fresh frame without starting the animation loop or invoking frame callbacks. */
   renderOnce() {
     if (this._disposed) throw new Error("Cannot render a disposed renderer");
-    if (this._controls?.enabled) this._controls.update();
+    this.updateControls();
     this.drawFrame();
   }
   /**
@@ -15386,7 +15762,7 @@ var _Renderer = class _Renderer {
       try {
         if (!wasRunning) this.start();
         this._videoExporter = exporter;
-        if (this._controls?.enabled) this._controls.update();
+        this.updateControls();
         this.drawFrame();
       } catch (error) {
         exporter.cancel(error);
@@ -15437,6 +15813,19 @@ var _Renderer = class _Renderer {
   get controls() {
     return this._controls;
   }
+  /** Renderer-owned OrbitControls, or undefined in fly mode or without controls. */
+  get orbitControls() {
+    return this._controls && !isFlyControls(this._controls) ? this._controls : void 0;
+  }
+  /** Renderer-owned {@link FlyControls}, or undefined in orbit mode or without controls. */
+  get flyControls() {
+    return isFlyControls(this._controls) ? this._controls : void 0;
+  }
+  /** The active renderer-owned controls mode, or undefined without controls. */
+  get controlsMode() {
+    if (!this._controls) return void 0;
+    return isFlyControls(this._controls) ? "fly" : "orbit";
+  }
   ///
 };
 _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
@@ -15454,8 +15843,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three37.Vector3(50, 50, 50),
-    lookingAt: new import_three37.Vector3(0, 0, 0)
+    position: new import_three38.Vector3(50, 50, 50),
+    lookingAt: new import_three38.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -15470,7 +15859,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
     enabled: true
   },
   controls: {
-    enabled: false
+    enabled: false,
+    mode: "orbit"
   },
   debug: {
     grid: false,
@@ -15724,7 +16114,7 @@ function parseSceneDocument(value) {
 }
 
 // src/scene/SceneDocumentLoader.ts
-var import_three39 = require("three");
+var import_three40 = require("three");
 init_AssetKey();
 init_AssetLoader();
 init_BlockStates();
@@ -15785,7 +16175,7 @@ var SceneDocumentLoader = class {
     if (definition.minecraftVersion !== void 0 && definition.minecraftVersion !== AssetLoader.version) {
       throw new Error(`Scene requires Minecraft ${definition.minecraftVersion}; call AssetLoader.setVersion("${definition.minecraftVersion}") before loading it`);
     }
-    const root = new import_three39.Group();
+    const root = new import_three40.Group();
     root.name = "MineRender scene document";
     const objects = [];
     let disposed = false;
@@ -15825,7 +16215,7 @@ var SceneDocumentLoader = class {
     return this.loadValidatedObject(scene, definition, parent);
   }
   static async loadValidatedObject(scene, definition, parent) {
-    const root = new import_three39.Group();
+    const root = new import_three40.Group();
     root.name = definition.name ?? definition.id;
     root.userData.sceneObjectId = definition.id;
     root.position.fromArray(definition.position ?? [0, 0, 0]);
@@ -16703,12 +17093,12 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-var import_three43 = require("three");
+var import_three44 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three41 = require("three");
+var import_three42 = require("three");
 init_Model();
 init_util();
 init_AssetKey();
@@ -16716,7 +17106,7 @@ init_BlockStates();
 init_CubeFace();
 
 // src/world/SectionModels.ts
-var import_three40 = require("three");
+var import_three41 = require("three");
 init_AssetKey();
 init_Models();
 init_CubeFace();
@@ -16740,7 +17130,7 @@ function cached(map, key, load) {
 }
 function compactQuads(geometry, keep) {
   const quads = keep.flatMap((kept, index) => kept ? [index] : []);
-  const compact = new import_three40.BufferGeometry();
+  const compact = new import_three41.BufferGeometry();
   for (const [name, size] of Object.entries({ position: 3, normal: 3, uv: 2, uvBounds: 4, color: 3 })) {
     const source2 = geometry.getAttribute(name);
     const defaults = name === "uvBounds" ? [0, 0, 1, 1] : name === "color" ? [1, 1, 1] : void 0;
@@ -16752,7 +17142,7 @@ function compactQuads(geometry, keep) {
         }
       }
     }
-    compact.setAttribute(name, new import_three40.BufferAttribute(values, size));
+    compact.setAttribute(name, new import_three41.BufferAttribute(values, size));
   }
   const source = geometry.getIndex();
   const indices = [];
@@ -16826,7 +17216,7 @@ var SectionModels = class {
           });
           await object4.init();
           let geometry = object4.children[0].geometry;
-          geometry.applyMatrix4(new import_three40.Matrix4().makeRotationFromEuler(rotation));
+          geometry.applyMatrix4(new import_three41.Matrix4().makeRotationFromEuler(rotation));
           object4.clear();
           const keep = [];
           const cullFaces = [];
@@ -16840,7 +17230,7 @@ var SectionModels = class {
                 cullFaces.push(0);
                 continue;
               }
-              const normal = new import_three40.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+              const normal = new import_three41.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
               const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
               cullFaces.push(world < 0 ? 0 : 1 << world);
             }
@@ -17036,17 +17426,17 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three41.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three42.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three41.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three42.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   getBiomeAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getBiomeAt(new import_three41.Vector3(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three41.Vector3(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new import_three42.Vector3(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three42.Vector3(...posOrX));
     this.validatePosBounds(posOrX);
     const cx = Math.floor(posOrX.x / 16), cy = Math.floor(posOrX.y / 16), cz = Math.floor(posOrX.z / 16);
     const lx = posOrX.x - cx * 16, ly = posOrX.y - cy * 16, lz = posOrX.z - cz * 16;
@@ -17054,10 +17444,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three41.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three42.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three41.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three42.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -17068,10 +17458,10 @@ var MineRenderWorld = class {
   }
   async setBlockVisibleAt(posOrX, yOrVisible, z, visible) {
     if (typeof posOrX === "number") {
-      return this.setBlockVisibleAt(new import_three41.Vector3(posOrX, yOrVisible, z), visible);
+      return this.setBlockVisibleAt(new import_three42.Vector3(posOrX, yOrVisible, z), visible);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockVisibleAt(new import_three41.Vector3(...posOrX), yOrVisible);
+      return this.setBlockVisibleAt(new import_three42.Vector3(...posOrX), yOrVisible);
     }
     this.validatePosBounds(posOrX);
     await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
@@ -17097,7 +17487,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new import_three41.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three42.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     const types = /* @__PURE__ */ new Set();
     for (const block of multiblock.blocks) {
@@ -17113,7 +17503,7 @@ var MineRenderWorld = class {
     }
     if (!executor) {
       const groups2 = /* @__PURE__ */ new Map();
-      const position = new import_three41.Vector3();
+      const position = new import_three42.Vector3();
       for (const block of multiblock.blocks) {
         const [x, y, z] = block.position;
         this.validatePosBounds(position.set(x, y, z));
@@ -17153,7 +17543,7 @@ var MineRenderWorld = class {
       try {
         positions = await chunk.placeBlocks(blocks);
       } finally {
-        positions ?? (positions = blocks.map(({ index }) => new import_three41.Vector3(
+        positions ?? (positions = blocks.map(({ index }) => new import_three42.Vector3(
           chunk.x * 16 + index % 16,
           chunk.y * 16 + Math.floor(index / 256),
           chunk.z * 16 + Math.floor(index / 16) % 16
@@ -17192,7 +17582,7 @@ var MineRenderWorld = class {
       let sliceStart = performance.now();
       for (const section of chunk.sections) {
         if (section.biomes) {
-          const position = new import_three41.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new import_three42.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const copy = [...section.biomes];
           if (copy.length !== 64 || !copy.every((id) => typeof id === "string" && id.length > 0)) {
@@ -17205,7 +17595,7 @@ var MineRenderWorld = class {
         }
         if (!executor) {
           if (!occupiedSections.has(section.y)) continue;
-          const position = new import_three41.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new import_three42.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const target = this.getOrCreateChunkAt(position);
           try {
@@ -17299,7 +17689,7 @@ var MineRenderWorld = class {
     this.sectionModels?.clear();
   }
   updateCulling(positions) {
-    const neighbor = new import_three41.Vector3();
+    const neighbor = new import_three42.Vector3();
     for (const pos of positions) {
       const cx = Math.floor(pos.x / 16), cy = Math.floor(pos.y / 16), cz = Math.floor(pos.z / 16);
       const chunk = this._chunks.get(`${cx}_${cy}_${cz}`);
@@ -17391,7 +17781,7 @@ var MineRenderWorld = class {
   }
   /** Converts block coordinates to scene units by multiplying each component by 16. */
   static worldToScenePosition(pos) {
-    return new import_three41.Vector3(
+    return new import_three42.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
@@ -17399,7 +17789,7 @@ var MineRenderWorld = class {
   }
   /** Converts scene units to block coordinates without rounding to an integer block. */
   static sceneToWorldPosition(pos) {
-    return new import_three41.Vector3(
+    return new import_three42.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -17422,7 +17812,7 @@ var MineRenderWorld = class {
 init_Model();
 
 // src/world/SectionMesh.ts
-var import_three42 = require("three");
+var import_three43 = require("three");
 init_CanvasCompat();
 init_Materials();
 
@@ -17650,7 +18040,7 @@ var SectionWorker = _SectionWorker;
 
 // src/world/SectionMesh.ts
 var templateCache = /* @__PURE__ */ new WeakMap();
-var WATER_TINT = new import_three42.Color(4159204).toArray();
+var WATER_TINT = new import_three43.Color(4159204).toArray();
 function toInput(entries, maxAtlasSize, fluids) {
   if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
   const atlases = [];
@@ -17745,7 +18135,7 @@ function toInput(entries, maxAtlasSize, fluids) {
   }
   return { input, atlases };
 }
-var SectionMesh = class _SectionMesh extends import_three42.Group {
+var SectionMesh = class _SectionMesh extends import_three43.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -17770,26 +18160,26 @@ var SectionMesh = class _SectionMesh extends import_three42.Group {
       for (const { atlas, x, y } of page.placements) {
         context.drawImage(atlases[atlas].image.canvas, x, y);
       }
-      const geometry = new import_three42.BufferGeometry();
-      geometry.setAttribute("position", new import_three42.Float32BufferAttribute(page.positions.buffer, 3));
-      geometry.setAttribute("normal", new import_three42.Float32BufferAttribute(page.normals.buffer, 3));
-      geometry.setAttribute("uv", new import_three42.Float32BufferAttribute(page.uvs.buffer, 2));
-      geometry.setAttribute("uvBounds", new import_three42.Float32BufferAttribute(page.uvBounds.buffer, 4));
-      geometry.setAttribute("color", new import_three42.Float32BufferAttribute(page.colors.buffer, 3));
-      geometry.setIndex(new import_three42.Uint32BufferAttribute(page.indices.buffer, 1));
+      const geometry = new import_three43.BufferGeometry();
+      geometry.setAttribute("position", new import_three43.Float32BufferAttribute(page.positions.buffer, 3));
+      geometry.setAttribute("normal", new import_three43.Float32BufferAttribute(page.normals.buffer, 3));
+      geometry.setAttribute("uv", new import_three43.Float32BufferAttribute(page.uvs.buffer, 2));
+      geometry.setAttribute("uvBounds", new import_three43.Float32BufferAttribute(page.uvBounds.buffer, 4));
+      geometry.setAttribute("color", new import_three43.Float32BufferAttribute(page.colors.buffer, 3));
+      geometry.setIndex(new import_three43.Uint32BufferAttribute(page.indices.buffer, 1));
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const transparent = page.layer === 2 ? atlases[page.placements[0].atlas].hasTranslucency : page.layer === 1;
       const material = Materials.createShadedCanvasMaterial(canvas, transparent, false, true);
-      material.side = import_three42.FrontSide;
+      material.side = import_three43.FrontSide;
       if (page.layer === 2) {
-        material.side = import_three42.DoubleSide;
+        material.side = import_three43.DoubleSide;
         material.forceSinglePass = true;
         material.depthWrite = !material.transparent;
       }
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new import_three42.Mesh(geometry, material);
+      const mesh = new import_three43.Mesh(geometry, material);
       section.add(mesh);
       const unsubscribe = [];
       for (const { atlas: id, x, y } of page.placements) {
@@ -17835,7 +18225,7 @@ var Chunk = class _Chunk {
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
     this.fluidCells = new Uint8Array(4096);
-    this.blockPosition = new import_three43.Vector3();
+    this.blockPosition = new import_three44.Vector3();
     this.meshDirty = false;
     this.meshGeneration = 0;
     this.scene = scene;
@@ -17845,10 +18235,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three43.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three44.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three43.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three44.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.blockPosition.set(posOrX.x - this.x * 16, posOrX.y - this.y * 16, posOrX.z - this.z * 16);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -17856,10 +18246,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three43.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three44.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three43.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three44.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -17912,7 +18302,7 @@ var Chunk = class _Chunk {
       if (this.fluidCells[index]) this.meshDirty = true;
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
-      const worldPos = new import_three43.Vector3(
+      const worldPos = new import_three44.Vector3(
         this.x * 16 + index % 16,
         this.y * 16 + Math.floor(index / 256),
         this.z * 16 + Math.floor(index / 16) % 16
@@ -18037,7 +18427,7 @@ var Chunk = class _Chunk {
             this.z * 16 + Math.floor(index / 16) % 16
           ]
         });
-        object4.setPosition(new import_three43.Vector3(
+        object4.setPosition(new import_three44.Vector3(
           this.x * 256 + index % 16 * 16,
           this.y * 256 + Math.floor(index / 256) * 16,
           this.z * 256 + Math.floor(index / 16) % 16 * 16
@@ -18188,7 +18578,7 @@ var Chunk = class _Chunk {
   /** Removes stored blocks and render objects. Set `notify` to false to skip the owning world's update. */
   async clear(notify = true) {
     const positions = notify && this.onBlocksChanged ? [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three43.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three44.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     )) : [];
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -18216,14 +18606,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three43.Vector3(
+    return new import_three44.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three43.Vector3(
+    return new import_three44.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z