minerender 2.1.0-alpha.121 → 2.1.0-alpha.123

package/dist/node/index.js

@@ -12633,6 +12633,10 @@ var BlockObject = class _BlockObject extends SceneObject {
   get blockEntities() {
     return this._entities;
   }
+  /** Model placements drawn for this block, including its fluid surface. */
+  get models() {
+    return this._models;
+  }
   /** Sets visibility for this block's model instances and block entities. */
   setVisible(visible) {
     this.visible = visible;
@@ -17386,12 +17390,12 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-var import_three44 = require("three");
+var import_three47 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three42 = require("three");
+var import_three45 = require("three");
 init_Model();
 init_util();
 init_AssetKey();
@@ -17656,11 +17660,74 @@ function resolveSavedEntity(entity) {
 
 // src/world/_entities/WorldEntities.ts
 init_BannerPatterns();
+var import_three44 = require("three");
+
+// src/world/_picking/Picking.ts
+var import_three42 = require("three");
+init_three();
+function pickableMeshes(root, scene, raycaster) {
+  const result = [];
+  let attached = false;
+  for (let parent = root; parent; parent = parent.parent) {
+    if (!parent.visible) return result;
+    if (parent === scene) attached = true;
+  }
+  if (!attached) return result;
+  root.updateWorldMatrix(true, true);
+  root.traverseVisible((object4) => {
+    if (isMesh(object4) && raycaster.layers.test(object4.layers)) result.push(object4);
+  });
+  return result;
+}
+function visibleHits(raycaster, meshes) {
+  return raycaster.intersectObjects(meshes, false).filter((hit) => {
+    if (!hit.face) return false;
+    const mesh = hit.object;
+    const material = Array.isArray(mesh.material) ? mesh.material[hit.face.materialIndex] : mesh.material;
+    return material?.visible;
+  });
+}
+function hitNormal(hit) {
+  const mesh = hit.object;
+  const matrix = mesh.matrixWorld.clone();
+  if (isInstancedMesh(mesh) && hit.instanceId !== void 0) {
+    const instance = new import_three42.Matrix4();
+    mesh.getMatrixAt(hit.instanceId, instance);
+    matrix.multiply(instance);
+  }
+  return hit.face.normal.clone().applyNormalMatrix(new import_three42.Matrix3().getNormalMatrix(matrix));
+}
+
+// src/world/_entities/WorldEntities.ts
 var WorldEntities = class {
   constructor(scene) {
     this.scene = scene;
     this.columns = /* @__PURE__ */ new Map();
   }
+  /** Finds the nearest visible triangle belonging to an entity owned by this world. */
+  raycast(raycaster) {
+    const owners = /* @__PURE__ */ new Map();
+    for (const column of this.columns.values()) {
+      for (const [object4, placement] of column) {
+        for (const mesh of pickableMeshes(object4, this.scene, raycaster)) {
+          owners.set(mesh, { object: object4, ...placement });
+        }
+      }
+    }
+    for (const hit of visibleHits(raycaster, [...owners.keys()])) {
+      const mesh = hit.object;
+      const owner = owners.get(mesh);
+      return {
+        type: owner.type,
+        position: new import_three44.Vector3(...owner.position),
+        object: owner.object,
+        point: hit.point.clone(),
+        normal: hitNormal(hit),
+        distance: hit.distance
+      };
+    }
+    return void 0;
+  }
   /** Captures column ownership before asynchronous block or asset loading starts. */
   prepare(entities = [], column) {
     const placements = entities.flatMap((entity) => {
@@ -17669,7 +17736,7 @@ var WorldEntities = class {
       const position = [...entity.position];
       const key = column?.join(",") ?? `${Math.floor(position[0] / 16)},${Math.floor(position[2] / 16)}`;
       let owner = this.columns.get(key);
-      if (!owner) this.columns.set(key, owner = /* @__PURE__ */ new Set());
+      if (!owner) this.columns.set(key, owner = /* @__PURE__ */ new Map());
       return [{ ...resolved, position, column: key, owner }];
     });
     return async () => {
@@ -17695,7 +17762,7 @@ var WorldEntities = class {
           object4.rotation.y = placement.yaw;
           await object4.init();
           if (!current()) return;
-          placement.owner.add(object4);
+          placement.owner.set(object4, { type: placement.key.toNamespacedString(), position: placement.position });
           this.scene.add(object4);
         } catch (error) {
           console.warn(`Could not draw saved entity ${placement.key.toNamespacedString()}, skipping it`, error);
@@ -17710,7 +17777,7 @@ var WorldEntities = class {
     const objects = this.columns.get(key);
     this.columns.delete(key);
     if (!objects) return;
-    for (const object4 of objects) {
+    for (const object4 of objects.keys()) {
       object4.removeFromScene();
       object4.dispose();
     }
@@ -17771,6 +17838,21 @@ var MineRenderWorld = class {
     if (options.sectionMeshing) this.sectionModels = new SectionModels(options.maxAtlasSize);
     if (options.renderEntities) this.entities = new WorldEntities(scene);
   }
+  /**
+   * Returns the nearest visible block geometry hit, respecting the raycaster's layers and near/far range.
+   * Includes fluids and block entities; texture alpha does not change triangle intersections.
+   */
+  raycast(raycaster) {
+    return Chunk.raycast(this._chunks.values(), raycaster);
+  }
+  /**
+   * Returns the nearest visible mob geometry hit when renderEntities is enabled.
+   * Respects layers and near/far; compare its distance with raycast() to account for blocks.
+   * Texture alpha does not change triangle intersections.
+   */
+  raycastEntities(raycaster) {
+    return this.entities?.raycast(raycaster);
+  }
   /** Whether neighboring opaque cubes shade block-face corners. Defaults to false. */
   get ambientOcclusion() {
     return this._ambientOcclusion;
@@ -17791,25 +17873,25 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three42.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three45.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three42.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three45.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_three42.Vector3(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three42.Vector3(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new import_three45.Vector3(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three45.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;
     return this.biomes.get(`${cx}_${cz}`)?.get(cy)?.[Math.floor(lx / 4) + Math.floor(lz / 4) * 4 + Math.floor(ly / 4) * 16];
   }
   getLightAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getLightAt(new import_three42.Vector3(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getLightAt(new import_three42.Vector3(...posOrX));
+    if (typeof posOrX === "number") return this.getLightAt(new import_three45.Vector3(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getLightAt(new import_three45.Vector3(...posOrX));
     this.validatePosBounds(posOrX);
     const { x, y: py, z: pz } = posOrX;
     const cx = Math.floor(x / 16), cy = Math.floor(py / 16), cz = Math.floor(pz / 16);
@@ -17827,10 +17909,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three42.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three45.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three42.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three45.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -17841,10 +17923,10 @@ var MineRenderWorld = class {
   }
   async setBlockVisibleAt(posOrX, yOrVisible, z, visible) {
     if (typeof posOrX === "number") {
-      return this.setBlockVisibleAt(new import_three42.Vector3(posOrX, yOrVisible, z), visible);
+      return this.setBlockVisibleAt(new import_three45.Vector3(posOrX, yOrVisible, z), visible);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockVisibleAt(new import_three42.Vector3(...posOrX), yOrVisible);
+      return this.setBlockVisibleAt(new import_three45.Vector3(...posOrX), yOrVisible);
     }
     this.validatePosBounds(posOrX);
     await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
@@ -17870,7 +17952,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_three42.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three45.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     const types = /* @__PURE__ */ new Set();
     for (const block of multiblock.blocks) {
@@ -17886,7 +17968,7 @@ var MineRenderWorld = class {
     }
     if (!executor) {
       const groups2 = /* @__PURE__ */ new Map();
-      const position = new import_three42.Vector3();
+      const position = new import_three45.Vector3();
       for (const block of multiblock.blocks) {
         const [x, y, z] = block.position;
         this.validatePosBounds(position.set(x, y, z));
@@ -17926,7 +18008,7 @@ var MineRenderWorld = class {
       try {
         positions = await chunk.placeBlocks(blocks);
       } finally {
-        positions ??= blocks.map(({ index }) => new import_three42.Vector3(
+        positions ??= blocks.map(({ index }) => new import_three45.Vector3(
           chunk.x * 16 + index % 16,
           chunk.y * 16 + Math.floor(index / 256),
           chunk.z * 16 + Math.floor(index / 16) % 16
@@ -17978,7 +18060,7 @@ var MineRenderWorld = class {
       }
       for (const section of chunk.sections) {
         if (section.biomes) {
-          const position = new import_three42.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new import_three45.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)) {
@@ -17994,7 +18076,7 @@ var MineRenderWorld = class {
       for (const section of chunk.sections) {
         if (!executor) {
           if (!occupiedSections.has(section.y)) continue;
-          const position = new import_three42.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new import_three45.Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const target = this.getOrCreateChunkAt(position);
           try {
@@ -18098,7 +18180,7 @@ var MineRenderWorld = class {
     this.sectionModels?.clear();
   }
   updateCulling(positions) {
-    const neighbor = new import_three42.Vector3();
+    const neighbor = new import_three45.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}`);
@@ -18229,7 +18311,7 @@ var MineRenderWorld = class {
   }
   /** Converts block coordinates to scene units by multiplying each component by 16. */
   static worldToScenePosition(pos) {
-    return new import_three42.Vector3(
+    return new import_three45.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
@@ -18237,7 +18319,7 @@ var MineRenderWorld = class {
   }
   /** Converts scene units to block coordinates without rounding to an integer block. */
   static sceneToWorldPosition(pos) {
-    return new import_three42.Vector3(
+    return new import_three45.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -18260,7 +18342,7 @@ var MineRenderWorld = class {
 init_Model();
 
 // src/world/SectionMesh.ts
-var import_three43 = require("three");
+var import_three46 = require("three");
 init_CanvasCompat();
 init_Materials();
 
@@ -18445,6 +18527,7 @@ function buildSectionGeometry(input) {
     const positions = new Float32Array(faces * 12), normals = new Float32Array(faces * 12);
     const uvs = new Float32Array(faces * 8), uvBounds = new Float32Array(faces * 16), colors = new Float32Array(faces * 12);
     const outputIndices = new Uint32Array(faces * 6);
+    const blockIndices = new Uint16Array(faces);
     let vertex = 0, indexOffset = 0;
     for (const entry of page.entries) {
       const template = templateData[templates[entry]];
@@ -18459,6 +18542,7 @@ function buildSectionGeometry(input) {
       const ambientMask = ambientOcclusion && template.ambientOcclusion !== false ? sectionAmbientOcclusionMask(ambientOcclusion, lightIndex) : 0;
       for (let quad = 0; quad < template.quads; quad++) {
         if (cullMasks[entry] & template.cullFaces[quad]) continue;
+        blockIndices[indexOffset / 6] = indices[entry];
         if (ambientMask) quadAmbientOcclusion(template.positions, template.normals, quad, ambientMask, cornerBrightness2);
         const brightness = light ? lightBrightness(light[lightIndex + LIGHT_SAMPLE_OFFSETS[quadLightIndex(template.positions, template.normals, quad)]], ambientLight) : 1;
         const start = vertex;
@@ -18491,6 +18575,7 @@ function buildSectionGeometry(input) {
       const mapV = (v) => 1 - (placement.y + (1 - v) * atlas.height) / page.height;
       const lightIndex = (y + 1) * 324 + (z + 1) * 18 + x + 1;
       for (let quad = 0; quad < quads.sprites.length; quad++) {
+        blockIndices[indexOffset / 6] = x + z * 16 + y * 256;
         const rect = quads.sprites[quad] === 0 ? data.still : data.flow;
         const brightness = light ? lightBrightness(fluidLightLevel(
           light[lightIndex],
@@ -18521,11 +18606,11 @@ function buildSectionGeometry(input) {
         indexOffset += 6;
       }
     }
-    return { layer: page.layer, width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, indices: outputIndices };
+    return { layer: page.layer, width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, indices: outputIndices, blockIndices };
   });
 }
 function sectionGeometryTransferables(pages) {
-  return pages.flatMap((page) => [page.positions.buffer, page.normals.buffer, page.uvs.buffer, page.uvBounds.buffer, page.colors.buffer, page.indices.buffer]);
+  return pages.flatMap((page) => [page.positions.buffer, page.normals.buffer, page.uvs.buffer, page.uvBounds.buffer, page.colors.buffer, page.indices.buffer, page.blockIndices.buffer]);
 }
 
 // src/world/SectionWorker.ts
@@ -18583,7 +18668,7 @@ var SectionWorker = class _SectionWorker {
 
 // src/world/SectionMesh.ts
 var templateCache = /* @__PURE__ */ new WeakMap();
-var WATER_TINT = new import_three43.Color(4159204).toArray();
+var WATER_TINT = new import_three46.Color(4159204).toArray();
 function toInput(entries, maxAtlasSize, fluids, lighting) {
   if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
   const atlases = [];
@@ -18680,10 +18765,16 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
   }
   return { input, atlases };
 }
-var SectionMesh = class _SectionMesh extends import_three43.Group {
+var SectionMesh = class _SectionMesh extends import_three46.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
+    this.blockIndices = /* @__PURE__ */ new Map();
+  }
+  /** Returns the owning section cell for a triangle hit on this mesh's merged geometry. */
+  getBlockIndex(hit) {
+    if (hit.faceIndex === void 0 || hit.faceIndex === null) return void 0;
+    return this.blockIndices.get(hit.object)?.[Math.floor(hit.faceIndex / 2)];
   }
   /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
   static build(entries, maxAtlasSize = 2048, fluids, lighting) {
@@ -18705,27 +18796,28 @@ var SectionMesh = class _SectionMesh extends import_three43.Group {
       for (const { atlas, x, y } of page.placements) {
         context.drawImage(atlases[atlas].image.canvas, x, y);
       }
-      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));
+      const geometry = new import_three46.BufferGeometry();
+      geometry.setAttribute("position", new import_three46.Float32BufferAttribute(page.positions.buffer, 3));
+      geometry.setAttribute("normal", new import_three46.Float32BufferAttribute(page.normals.buffer, 3));
+      geometry.setAttribute("uv", new import_three46.Float32BufferAttribute(page.uvs.buffer, 2));
+      geometry.setAttribute("uvBounds", new import_three46.Float32BufferAttribute(page.uvBounds.buffer, 4));
+      geometry.setAttribute("color", new import_three46.Float32BufferAttribute(page.colors.buffer, 3));
+      geometry.setIndex(new import_three46.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_three43.FrontSide;
+      material.side = import_three46.FrontSide;
       if (page.layer === 2) {
-        material.side = import_three43.DoubleSide;
+        material.side = import_three46.DoubleSide;
         material.forceSinglePass = true;
         material.depthWrite = !material.transparent;
       }
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new import_three43.Mesh(geometry, material);
+      const mesh = new import_three46.Mesh(geometry, material);
       section.add(mesh);
+      section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
       for (const { atlas: id, x, y } of page.placements) {
         const atlas = atlases[id];
@@ -18751,6 +18843,7 @@ var SectionMesh = class _SectionMesh extends import_three43.Group {
       mesh.material.dispose();
       texture?.dispose();
     }
+    this.blockIndices.clear();
     this.removeFromParent();
     super.dispose();
   }
@@ -18760,7 +18853,8 @@ var SectionMesh = class _SectionMesh extends import_three43.Group {
 init_FluidGeometry();
 init_FluidQuads();
 init_CubeFace();
-var WATER_TINT2 = new import_three44.Color(4159204).toArray();
+init_InstanceReference();
+var WATER_TINT2 = new import_three47.Color(4159204).toArray();
 var Chunk = class _Chunk {
   constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
     this.onBlocksChanged = onBlocksChanged;
@@ -18773,10 +18867,11 @@ var Chunk = class _Chunk {
     this.ambientLight = ambientLight;
     this.data = new ChunkData();
     this.renderedBlocks = /* @__PURE__ */ new Map();
+    this.objectBlocks = /* @__PURE__ */ new Set();
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
     this.fluidCells = new Uint8Array(4096);
-    this.blockPosition = new import_three44.Vector3();
+    this.blockPosition = new import_three47.Vector3();
     this.meshDirty = false;
     this.meshGeneration = 0;
     this.scene = scene;
@@ -18784,20 +18879,84 @@ var Chunk = class _Chunk {
     this.y = y;
     this.z = z;
   }
+  /** Finds the nearest owned block hit across sections, testing each shared mesh once. */
+  static raycast(chunks, raycaster) {
+    const roots = /* @__PURE__ */ new Map();
+    const targets = /* @__PURE__ */ new Map();
+    const meshes = (root, scene) => {
+      const cached2 = roots.get(root);
+      if (cached2) return cached2;
+      const result = pickableMeshes(root, scene, raycaster);
+      roots.set(root, result);
+      return result;
+    };
+    const add = (root, owner, reference) => {
+      for (const mesh of meshes(root, owner.chunk.scene)) {
+        if (reference && reference.instanceable.getInstanceReference(mesh, reference.index) !== reference) continue;
+        let entry = targets.get(mesh);
+        if (!entry) targets.set(mesh, entry = { owners: /* @__PURE__ */ new Map() });
+        entry.owners.set(reference?.index, owner);
+      }
+    };
+    for (const chunk of chunks) {
+      for (const index of chunk.objectBlocks) {
+        const block = chunk.renderedBlocks.get(index).object;
+        if (!block || !block.visible || chunk.hiddenBlocks.has(index)) continue;
+        const owner = { chunk, index };
+        for (const model of block.models) {
+          if (isInstanceReference(model)) {
+            if (model.instanceable.isInstanceActive(model.index, model)) add(model.instanceable, owner, model);
+          } else {
+            add(model, owner);
+          }
+        }
+        for (const entity of block.blockEntities) add(entity, owner);
+      }
+      if (chunk.sectionMesh) {
+        for (const mesh of meshes(chunk.sectionMesh, chunk.scene)) {
+          targets.set(mesh, { owners: /* @__PURE__ */ new Map(), section: { chunk, mesh: chunk.sectionMesh } });
+        }
+      }
+    }
+    for (const hit of visibleHits(raycaster, [...targets.keys()])) {
+      const mesh = hit.object;
+      const entry = targets.get(mesh);
+      let owner = entry.owners.get(hit.instanceId) ?? entry.owners.get(void 0);
+      if (entry.section) {
+        const index = entry.section.mesh.getBlockIndex(hit);
+        if (index !== void 0) owner = { chunk: entry.section.chunk, index };
+      }
+      if (!owner || owner.chunk.hiddenBlocks.has(owner.index)) continue;
+      const info = owner.chunk.renderedBlocks.get(owner.index);
+      if (!info) continue;
+      return {
+        position: new import_three47.Vector3(
+          owner.chunk.x * 16 + owner.index % 16,
+          owner.chunk.y * 16 + Math.floor(owner.index / 256),
+          owner.chunk.z * 16 + Math.floor(owner.index / 16) % 16
+        ),
+        block: info.block,
+        point: hit.point.clone(),
+        normal: hitNormal(hit),
+        distance: hit.distance
+      };
+    }
+    return void 0;
+  }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three44.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three47.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three44.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three47.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);
     return this.renderedBlocks.get(index);
   }
   getBiomeAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getBiomeAt(new import_three44.Vector3(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three44.Vector3(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new import_three47.Vector3(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new import_three47.Vector3(...posOrX));
     const pos = this.worldPosToChunkPos(posOrX);
     _Chunk.chunkPosToBlockIndex(pos);
     return this.biomeAt ? this.biomeAt(posOrX.x, posOrX.y, posOrX.z) : this.biomes?.[Math.floor(pos.x / 4) + Math.floor(pos.z / 4) * 4 + Math.floor(pos.y / 4) * 16];
@@ -18840,17 +18999,17 @@ var Chunk = class _Chunk {
         this.hiddenBlocks.add(index);
         this.renderedBlocks.get(index)?.object?.setVisible(false);
       }
-      const positions = blocks.map(({ index }) => new import_three44.Vector3(...this.positionAt(index)));
+      const positions = blocks.map(({ index }) => new import_three47.Vector3(...this.positionAt(index)));
       if (this.onBlocksChanged) await this.onBlocksChanged(positions);
       else await this.rebuildSectionMesh();
     }
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three44.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three47.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three44.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three47.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -18904,7 +19063,8 @@ var Chunk = class _Chunk {
       if (this.fluidCells[index]) this.meshDirty = true;
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
-      const worldPos = new import_three44.Vector3(
+      this.objectBlocks.delete(index);
+      const worldPos = new import_three47.Vector3(
         this.x * 16 + index % 16,
         this.y * 16 + Math.floor(index / 256),
         this.z * 16 + Math.floor(index / 16) % 16
@@ -18946,6 +19106,7 @@ var Chunk = class _Chunk {
         this.renderedBlocks.set(index, { get block() {
           return readBlock();
         }, object: object4 });
+        if (object4) this.objectBlocks.add(index);
       } catch (error) {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
@@ -18964,6 +19125,7 @@ var Chunk = class _Chunk {
     this.fluidCells.fill(0);
     this.waterTints = void 0;
     this.renderedBlocks.clear();
+    this.objectBlocks.clear();
     this.hiddenBlocks.clear();
     this.meshDirty = true;
     this.data.copyFrom(data);
@@ -19013,6 +19175,7 @@ var Chunk = class _Chunk {
         this.renderedBlocks.set(index, { get block() {
           return readBlock();
         }, object: void 0 });
+        this.objectBlocks.delete(index);
       } catch (error) {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
@@ -19032,16 +19195,18 @@ var Chunk = class _Chunk {
           biome,
           biomePosition: this.biomePosition(index, blockState3, this.data.stateAt(this.data.idAt(index)))
         });
-        object4.setPosition(new import_three44.Vector3(
+        object4.setPosition(new import_three47.Vector3(
           this.x * 256 + index % 16 * 16,
           this.y * 256 + Math.floor(index / 256) * 16,
           this.z * 256 + Math.floor(index / 16) % 16 * 16
         ));
         this.renderedBlocks.get(index).object = object4;
+        this.objectBlocks.add(index);
       } catch (error) {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
         this.renderedBlocks.delete(index);
+        this.objectBlocks.delete(index);
         object4?.removeFromScene();
         if (!failed) failure = error;
         failed = true;
@@ -19122,7 +19287,7 @@ var Chunk = class _Chunk {
         context.prepared = await prepare(async () => await available() ? BlockTints.getBiomeColor(blockState3?.key, biome, position) : void 0);
         if (fluid?.kind === "water" && await available()) {
           const color2 = await Biomes.getColor(biome, "water", blockState3?.key);
-          if (color2 !== void 0 && color2 !== 4159204) context.waterTint = new import_three44.Color(color2).toArray();
+          if (color2 !== void 0 && color2 !== 4159204) context.waterTint = new import_three47.Color(color2).toArray();
         }
       }
       for (const index of indices2) contexts.set(index, context);
@@ -19293,7 +19458,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_three44.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three47.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();
@@ -19302,6 +19467,7 @@ var Chunk = class _Chunk {
     this.sectionMesh = void 0;
     this.meshDirty = false;
     this.renderedBlocks.clear();
+    this.objectBlocks.clear();
     this.hiddenBlocks.clear();
     this.fluidCells.fill(0);
     this.waterTints = void 0;
@@ -19328,14 +19494,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three44.Vector3(
+    return new import_three47.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three44.Vector3(
+    return new import_three47.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z