minerender 2.1.0-alpha.87 → 2.1.0-alpha.88

package/dist/bundle.js

@@ -39810,6 +39810,23 @@ void main() {
       setTimeout(() => resolve(), timeout);
     });
   }
+  function yieldToEventLoop() {
+    const scheduler = globalThis.scheduler;
+    if (scheduler?.yield) return scheduler.yield();
+    return new Promise((resolve) => {
+      if (typeof MessageChannel !== "undefined") {
+        const channel = new MessageChannel();
+        channel.port1.onmessage = () => {
+          channel.port1.close();
+          channel.port2.close();
+          resolve();
+        };
+        channel.port2.postMessage(void 0);
+      } else {
+        setTimeout(resolve, 0);
+      }
+    });
+  }
   function clampRotationDegrees(deg) {
     return deg % 360;
   }
@@ -99623,7 +99640,7 @@ return ${compiler2.callType("value", tagType)}
   });
 
   // ../../node_modules/@zip.js/zip.js/lib/zip-fs.js
-  var import_meta, baseURL;
+  var import_meta2, baseURL;
   var init_zip_fs = __esm({
     "../../node_modules/@zip.js/zip.js/lib/zip-fs.js"() {
       init_dirname();
@@ -99638,9 +99655,9 @@ return ${compiler2.callType("value", tagType)}
       init_zip_reader();
       init_zip_writer();
       init_zip_fs_core();
-      import_meta = {};
+      import_meta2 = {};
       try {
-        baseURL = import_meta.url;
+        baseURL = import_meta2.url;
       } catch (_4) {
       }
       configure({ baseURL });
@@ -106568,6 +106585,7 @@ ${shader.fragmentShader}`.replace(
     SchematicParser: () => SchematicParser,
     SectionMesh: () => SectionMesh,
     SectionModels: () => SectionModels,
+    SectionWorker: () => SectionWorker,
     SkinImage: () => SkinImage,
     SkinObject: () => SkinObject,
     SkinPart: () => SkinPart,
@@ -106592,6 +106610,7 @@ ${shader.fragmentShader}`.replace(
     axisToVec3: () => axisToVec3,
     base64decode: () => base64decode,
     base64encode: () => base64encode,
+    buildSectionGeometry: () => buildSectionGeometry,
     capeTextureSizes: () => capeTextureSizes,
     captureException: () => captureException,
     changeEvent: () => changeEvent,
@@ -106644,6 +106663,7 @@ ${shader.fragmentShader}`.replace(
     sampleEntityAnimation: () => sampleEntityAnimation,
     sampleEntityKeyframes: () => sampleEntityKeyframes,
     sampleFluid: () => sampleFluid,
+    sectionGeometryTransferables: () => sectionGeometryTransferables,
     serializeBoxGeometryKey: () => serializeBoxGeometryKey,
     serializeImageKey: () => serializeImageKey,
     serializeMaterialKey: () => serializeMaterialKey,
@@ -106661,7 +106681,8 @@ ${shader.fragmentShader}`.replace(
     toDegrees: () => toDegrees,
     toRadians: () => toRadians,
     toTrianglesDrawMode: () => toTrianglesDrawMode,
-    trimCanvas: () => trimCanvas
+    trimCanvas: () => trimCanvas,
+    yieldToEventLoop: () => yieldToEventLoop
   });
   init_dirname();
   init_buffer2();
@@ -106762,6 +106783,7 @@ ${shader.fragmentShader}`.replace(
   }
 
   // src/env/browser/BrowserEnv.ts
+  var import_meta = {};
   var BrowserEnv = class {
     constructor() {
       this.name = "browser";
@@ -106789,6 +106811,14 @@ ${shader.fragmentShader}`.replace(
         version: version3
       }));
     }
+    createWorker(name2) {
+      if (name2 !== "section" || typeof Worker === "undefined") return void 0;
+      try {
+        return new Worker(new URL("./section.worker.mjs", import_meta.url), { type: "module" });
+      } catch {
+        return void 0;
+      }
+    }
   };
   function registerBrowserEnv() {
     const env3 = new BrowserEnv();
@@ -118755,6 +118785,16 @@ gl_FragDepth=readDepth(vUv);
   init_buffer2();
   init_process2();
   init_AssetKey();
+  var blockKeys = /* @__PURE__ */ new Map();
+  function blockKey(type) {
+    let key = blockKeys.get(type);
+    if (!key) {
+      key = AssetKey.parse("blockstates", type);
+      if (blockKeys.size >= 4096) blockKeys.clear();
+      blockKeys.set(type, key);
+    }
+    return key;
+  }
   var ChunkData = class _ChunkData {
     constructor() {
       this.indices = new Uint16Array(4096);
@@ -118782,10 +118822,10 @@ gl_FragDepth=readDepth(vUv);
       let key;
       let nbt;
       if (block && !_ChunkData.isAir(block)) {
-        const type = AssetKey.parse("blockstates", block.type).toNamespacedString();
+        const type = blockKey(block.type).toNamespacedString();
         const properties = Object.fromEntries(Object.keys(block.properties ?? {}).sort().map((name2) => [name2, block.properties[name2]]));
         state = Object.freeze(Object.keys(properties).length ? { type, properties: Object.freeze(properties) } : { type });
-        key = JSON.stringify([type, properties]);
+        key = _ChunkData.paletteKey(block);
         if (block.nbt !== void 0) nbt = structuredClone(block.nbt);
       }
       const previousId = this.indices[index];
@@ -118822,9 +118862,14 @@ gl_FragDepth=readDepth(vUv);
     }
     static isAir(block) {
       if (typeof block === "undefined" || typeof block.type === "undefined") return true;
-      const key = AssetKey.parse("blockstates", block.type);
+      const key = blockKey(block.type);
       return key.namespace === "minecraft" && !key.type && ["air", "cave_air", "void_air"].includes(key.path);
     }
+    /** Identifies a normalized block type and its sorted properties, excluding per-cell NBT. */
+    static paletteKey(block) {
+      const properties = Object.fromEntries(Object.keys(block.properties ?? {}).sort().map((name2) => [name2, block.properties[name2]]));
+      return JSON.stringify([blockKey(block.type).toNamespacedString(), properties]);
+    }
     static copyBlock(state, nbt) {
       const block = { type: state.type };
       if (state.properties) block.properties = { ...state.properties };
@@ -119004,14 +119049,17 @@ gl_FragDepth=readDepth(vUv);
       const perLong = Math.floor(64 / bits2);
       const expected = padded ? Math.ceil(4096 / perLong) : Math.ceil(4096 * bits2 / 64);
       if (tag.value.length !== expected) throw new MineRenderError(`Invalid Anvil block-state array length: expected ${expected}`);
-      const words = tag.value.map(([high, low]) => BigInt(high >>> 0) << 32n | BigInt(low >>> 0));
-      const mask = (1n << BigInt(bits2)) - 1n;
+      const words = tag.value.map(([high, low]) => [high >>> 0, low >>> 0]);
+      const mask = (1 << bits2) - 1;
       for (let index = 0; index < 4096; index++) {
-        const word = padded ? Math.floor(index / perLong) : Math.floor(index * bits2 / 64);
-        const shift = padded ? index % perLong * bits2 : index * bits2 % 64;
-        let value = words[word] >> BigInt(shift);
-        if (!padded && shift + bits2 > 64) value |= words[word + 1] << BigInt(64 - shift);
-        indices[index] = Number(value & mask);
+        const bitPos = index * bits2;
+        const word = padded ? Math.floor(index / perLong) : bitPos >>> 6;
+        const shift = padded ? index % perLong * bits2 : bitPos & 63;
+        const [high, low] = words[word];
+        let value = shift < 32 ? low >>> shift : high >>> shift - 32;
+        if (shift < 32 && shift + bits2 > 32) value += high * 2 ** (32 - shift);
+        if (!padded && shift + bits2 > 64) value += words[word + 1][1] * 2 ** (64 - shift);
+        indices[index] = value & mask;
       }
       return indices;
     }
@@ -119167,7 +119215,7 @@ gl_FragDepth=readDepth(vUv);
   init_process2();
   init_three_module();
   init_Model();
-  init_BatchedExecutor();
+  init_util();
   init_AssetKey();
   init_BlockStates();
   init_CubeFace();
@@ -119315,7 +119363,7 @@ gl_FragDepth=readDepth(vUv);
      * Places a structure's blocks at their stored positions, then refreshes neighboring faces.
      * Entity NBT is retained by the structure but is not rendered.
      *
-     * @param useBatches - Uses bounded batches by default. Set to `false` for sequential placement.
+     * @param useBatches - Yields between chunks by default. Set to `false` for sequential placement.
      * @param executor - Optional queue for batched placement. The caller remains responsible for stopping it.
      */
     async placeMultiBlock(multiblock, useBatches = true, executor) {
@@ -119332,8 +119380,10 @@ gl_FragDepth=readDepth(vUv);
       };
       const place = (block) => this.placeBlock(new Vector3(...block.position), block, collect);
       const keys = /* @__PURE__ */ new Map();
+      const types2 = /* @__PURE__ */ new Set();
       for (const block of multiblock.blocks) {
-        if (Chunk.isAir(block)) continue;
+        if (Chunk.isAir(block) || types2.has(block.type)) continue;
+        types2.add(block.type);
         const key = AssetKey.parse("blockstates", block.type);
         keys.set(key.serialize(), key);
       }
@@ -119342,6 +119392,23 @@ gl_FragDepth=readDepth(vUv);
         for (const block of multiblock.blocks) await place(block);
         return;
       }
+      if (!executor) {
+        const groups2 = /* @__PURE__ */ new Map();
+        const position = new Vector3();
+        for (const block of multiblock.blocks) {
+          const [x4, y5, z4] = block.position;
+          this.validatePosBounds(position.set(x4, y5, z4));
+          const cx = Math.floor(x4 / 16), cy = Math.floor(y5 / 16), cz = Math.floor(z4 / 16);
+          const key = `${cx}_${cy}_${cz}`;
+          const chunk = this._chunks.get(key) ?? (Chunk.isAir(block) ? void 0 : this.getOrCreateChunkAt(position));
+          if (!chunk) continue;
+          let group = groups2.get(chunk);
+          if (!group) groups2.set(chunk, group = []);
+          group.push({ index: (y5 - cy * 16) * 256 + (z4 - cz * 16) * 16 + x4 - cx * 16, block });
+        }
+        await this.placeChunkGroups(groups2, changes);
+        return;
+      }
       const positions = /* @__PURE__ */ new Map();
       for (const block of multiblock.blocks) {
         const key = block.position.join(",");
@@ -119350,19 +119417,34 @@ gl_FragDepth=readDepth(vUv);
         else positions.set(key, [block]);
       }
       const groups = [...positions.values()];
-      const queue2 = executor ?? new BatchedExecutor();
-      try {
-        for (let i4 = 0; i4 < groups.length; i4 += queue2.batch) {
-          const results = await Promise.allSettled(groups.slice(i4, i4 + queue2.batch).map(
-            (blocks) => queue2.submit(async () => {
-              for (const block of blocks) await place(block);
-            })
-          ));
-          const failure = results.find((result) => result.status === "rejected");
-          if (failure?.status === "rejected") throw failure.reason;
+      for (let i4 = 0; i4 < groups.length; i4 += executor.batch) {
+        const results = await Promise.allSettled(groups.slice(i4, i4 + executor.batch).map(
+          (blocks) => executor.submit(async () => {
+            for (const block of blocks) await place(block);
+          })
+        ));
+        const failure = results.find((result) => result.status === "rejected");
+        if (failure?.status === "rejected") throw failure.reason;
+      }
+    }
+    async placeChunkGroups(groups, changes) {
+      let sliceStart = performance.now();
+      for (const [chunk, blocks] of groups) {
+        let positions;
+        try {
+          positions = await chunk.placeBlocks(blocks);
+        } finally {
+          positions ?? (positions = blocks.map(({ index }) => new Vector3(
+            chunk.x * 16 + index % 16,
+            chunk.y * 16 + Math.floor(index / 256),
+            chunk.z * 16 + Math.floor(index / 16) % 16
+          )));
+          for (const pos of positions) changes.set(`${pos.x},${pos.y},${pos.z}`, pos);
+        }
+        if (performance.now() - sliceStart > 8) {
+          await yieldToEventLoop();
+          sliceStart = performance.now();
         }
-      } finally {
-        if (!executor) queue2.stop();
       }
     }
     /** Replaces one chunk column's blocks. Entity NBT remains available on the parsed chunk. */
@@ -119370,7 +119452,24 @@ gl_FragDepth=readDepth(vUv);
       const changes = /* @__PURE__ */ new Map();
       try {
         await this.clearChunkColumn(chunk.x, chunk.z, changes);
+        const groups = /* @__PURE__ */ new Map();
         for (const section of chunk.sections) {
+          if (!executor) {
+            const blocks2 = [];
+            for (let index = 0; index < 4096; index++) {
+              const block = section.data.get(index);
+              if (block) blocks2.push({ index, block });
+            }
+            if (blocks2.length) {
+              const position = new Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
+              this.validatePosBounds(position);
+              const target = this.getOrCreateChunkAt(position);
+              const previous = groups.get(target);
+              if (previous) previous.push(...blocks2);
+              else groups.set(target, blocks2);
+            }
+            continue;
+          }
           const blocks = [];
           for (let index = 0; index < 4096; index++) {
             const block = section.data.get(index);
@@ -119385,6 +119484,7 @@ gl_FragDepth=readDepth(vUv);
           }
           await this.placeBlocks({ size: [16, 16, 16], blocks }, true, executor, changes);
         }
+        if (!executor) await this.placeChunkGroups(groups, changes);
       } finally {
         await this.updateCulling([...changes.values()]);
       }
@@ -119425,19 +119525,23 @@ gl_FragDepth=readDepth(vUv);
       this.sectionModels?.clear();
     }
     updateCulling(positions) {
+      const neighbor = new Vector3();
       for (const pos of positions) {
-        this.pendingCulling.set(pos.toArray().join(","), pos.clone());
-        for (const offset of CUBE_FACE_OFFSETS) {
-          const neighbor = pos.clone().add(new Vector3(...offset));
-          this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
-        }
+        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}`);
+        const lx = pos.x - cx * 16, ly = pos.y - cy * 16, lz = pos.z - cz * 16;
         for (let y5 = -1; y5 <= 1; y5++) {
           for (let z4 = -1; z4 <= 1; z4++) {
             for (let x4 = -1; x4 <= 1; x4++) {
-              const neighbor = pos.clone().add(new Vector3(x4, y5, z4));
-              if (this.getBlockAt(neighbor)?.object?.fluidKind) {
-                this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
-              }
+              const nx = lx + x4, ny = ly + y5, nz = lz + z4;
+              const section = nx >= 0 && nx < 16 && ny >= 0 && ny < 16 && nz >= 0 && nz < 16 ? chunk : this._chunks.get(`${cx + Math.floor(nx / 16)}_${cy + Math.floor(ny / 16)}_${cz + Math.floor(nz / 16)}`);
+              if (!section) continue;
+              const index = (ny & 15) * 256 + (nz & 15) * 16 + (nx & 15);
+              let pending = this.pendingCulling.get(section);
+              if (pending?.has(index)) continue;
+              if (Math.abs(x4) + Math.abs(y5) + Math.abs(z4) > 1 && !section.getBlockAt(neighbor.set(pos.x + x4, pos.y + y5, pos.z + z4))?.object?.fluidKind) continue;
+              if (!pending) this.pendingCulling.set(section, pending = /* @__PURE__ */ new Set());
+              pending.add(index);
             }
           }
         }
@@ -119445,39 +119549,38 @@ gl_FragDepth=readDepth(vUv);
       return this.culling ?? (this.culling = Promise.resolve().then(async () => {
         try {
           while (this.pendingCulling.size) {
-            const batch = [...this.pendingCulling.values()];
+            const batch = [...this.pendingCulling];
             this.pendingCulling.clear();
-            const changed = /* @__PURE__ */ new Set();
-            for (const pos of batch) {
-              const chunk = this.getChunkAt(pos);
-              if (!chunk) continue;
-              changed.add(chunk);
-              const block = chunk.getBlockAt(pos);
-              if (!block || !chunk.isBlockVisibleAt(pos)) {
-                continue;
-              }
-              if (block.object?.fluidKind) {
-                await block.object.updateFluid((x4, y5, z4) => {
-                  const neighbor = pos.clone().add(new Vector3(x4, y5, z4));
-                  const section = this.getChunkAt(neighbor);
-                  const object3 = section?.isBlockVisibleAt(neighbor) ? section.getBlockAt(neighbor)?.object : void 0;
-                  return {
-                    fluid: object3?.fluidKind,
-                    level: object3?.fluidLevel,
-                    solid: section?.isOccludingAt(neighbor) ?? false
-                  };
-                });
-              }
-              let mask = 0;
-              for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-                const neighbor = pos.clone().add(new Vector3(...offset));
-                if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
-                  mask |= 1 << face;
+            for (const [chunk, indices] of batch) {
+              for (const index of indices) {
+                if (!chunk.isBlockVisibleIndex(index)) continue;
+                const lx = index % 16, ly = Math.floor(index / 256), lz = Math.floor(index / 16) % 16;
+                const wx = chunk.x * 16 + lx, wy = chunk.y * 16 + ly, wz = chunk.z * 16 + lz;
+                const block = chunk.getBlockAt(neighbor.set(wx, wy, wz));
+                if (block.object?.fluidKind) {
+                  await block.object.updateFluid((x4, y5, z4) => {
+                    const nx = lx + x4, ny = ly + y5, nz = lz + z4;
+                    const section = nx >= 0 && nx < 16 && ny >= 0 && ny < 16 && nz >= 0 && nz < 16 ? chunk : this._chunks.get(`${chunk.x + Math.floor(nx / 16)}_${chunk.y + Math.floor(ny / 16)}_${chunk.z + Math.floor(nz / 16)}`);
+                    const neighborIndex = (ny & 15) * 256 + (nz & 15) * 16 + (nx & 15);
+                    const object3 = section?.isBlockVisibleIndex(neighborIndex) ? section.getBlockAt(neighbor.set(wx + x4, wy + y5, wz + z4))?.object : void 0;
+                    return {
+                      fluid: object3?.fluidKind,
+                      level: object3?.fluidLevel,
+                      solid: section?.isOccludingIndex(neighborIndex) ?? false
+                    };
+                  });
+                }
+                let mask = 0;
+                for (let face = 0; face < CUBE_FACE_OFFSETS.length; face++) {
+                  const offset = CUBE_FACE_OFFSETS[face];
+                  const nx = lx + offset[0], ny = ly + offset[1], nz = lz + offset[2];
+                  const section = nx >= 0 && nx < 16 && ny >= 0 && ny < 16 && nz >= 0 && nz < 16 ? chunk : this._chunks.get(`${chunk.x + Math.floor(nx / 16)}_${chunk.y + Math.floor(ny / 16)}_${chunk.z + Math.floor(nz / 16)}`);
+                  if (section?.isOccludingIndex((ny & 15) * 256 + (nz & 15) * 16 + (nx & 15))) mask |= 1 << face;
                 }
+                await chunk.setCullMaskIndex(index, mask);
               }
-              await chunk.setCullMaskAt(pos, mask);
             }
-            for (const chunk of changed) chunk.rebuildSectionMesh();
+            await Promise.all(batch.map(([chunk]) => chunk.rebuildSectionMesh()));
           }
         } finally {
           this.culling = void 0;
@@ -119542,7 +119645,234 @@ gl_FragDepth=readDepth(vUv);
   init_process2();
   init_three_module();
   init_CanvasCompat();
+  init_CubeFace();
   init_Materials();
+
+  // src/world/SectionGeometry.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_CubeFace();
+  function buildSectionGeometry(input) {
+    const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize } = input;
+    if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
+    if (count > indices.length || count > templates.length || count > cullMasks.length) throw new RangeError("Section entry count exceeds its arrays");
+    const visible = [];
+    const visibleAtlases = /* @__PURE__ */ new Set();
+    for (let entry = 0; entry < count; entry++) {
+      const template = templateData[templates[entry]];
+      if (!template.cullFaces.some((direction) => !(cullMasks[entry] & direction))) continue;
+      visible.push(entry);
+      visibleAtlases.add(template.atlas);
+    }
+    const pages = [];
+    const locations = /* @__PURE__ */ new Map();
+    for (const atlas of [...visibleAtlases].sort((a4, b4) => atlases[b4].height - atlases[a4].height)) {
+      const { width, height } = atlases[atlas];
+      if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
+      let selected = -1;
+      for (let i4 = 0; i4 < pages.length; i4++) {
+        const page2 = pages[i4];
+        const nextRow = page2.x + width > maxAtlasSize;
+        if ((nextRow ? page2.y + page2.rowHeight : page2.y) + height > maxAtlasSize) continue;
+        if (nextRow) {
+          page2.y += page2.rowHeight;
+          page2.x = 0;
+          page2.rowHeight = 0;
+        }
+        selected = i4;
+        break;
+      }
+      if (selected < 0) {
+        selected = pages.length;
+        pages.push({ placements: [], entries: [], x: 0, y: 0, rowHeight: 0, width: 0, height: 0 });
+      }
+      const page = pages[selected];
+      page.placements.push({ atlas, x: page.x, y: page.y });
+      locations.set(atlas, { page: selected, x: page.x, y: page.y });
+      page.x += width;
+      page.rowHeight = Math.max(page.rowHeight, height);
+      page.width = Math.max(page.width, page.x);
+      page.height = Math.max(page.height, page.y + height);
+    }
+    for (const entry of visible) pages[locations.get(templateData[templates[entry]].atlas).page].entries.push(entry);
+    return pages.map((page) => {
+      let faces = 0;
+      for (const entry of page.entries) {
+        const template = templateData[templates[entry]];
+        for (let face = 0; face < CUBE_FACES.length; face++) {
+          if (!(cullMasks[entry] & template.cullFaces[face])) faces++;
+        }
+      }
+      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);
+      let vertex2 = 0, indexOffset = 0;
+      for (const entry of page.entries) {
+        const template = templateData[templates[entry]];
+        const atlas = atlases[template.atlas];
+        const placement = locations.get(template.atlas);
+        const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
+        const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
+        const offsetX = indices[entry] % 16 * 16;
+        const offsetY = Math.floor(indices[entry] / 256) * 16;
+        const offsetZ = Math.floor(indices[entry] / 16) % 16 * 16;
+        for (let face = 0; face < CUBE_FACES.length; face++) {
+          if (cullMasks[entry] & template.cullFaces[face]) continue;
+          const start = vertex2;
+          for (let corner = 0; corner < 4; corner++, vertex2++) {
+            const source = face * 4 + corner;
+            positions[vertex2 * 3] = template.positions[source * 3] + offsetX;
+            positions[vertex2 * 3 + 1] = template.positions[source * 3 + 1] + offsetY;
+            positions[vertex2 * 3 + 2] = template.positions[source * 3 + 2] + offsetZ;
+            normals[vertex2 * 3] = template.normals[source * 3];
+            normals[vertex2 * 3 + 1] = template.normals[source * 3 + 1];
+            normals[vertex2 * 3 + 2] = template.normals[source * 3 + 2];
+            uvs[vertex2 * 2] = mapU(template.uvs[source * 2]);
+            uvs[vertex2 * 2 + 1] = mapV(template.uvs[source * 2 + 1]);
+            uvBounds[vertex2 * 4] = mapU(template.uvBounds[source * 4]);
+            uvBounds[vertex2 * 4 + 1] = mapV(template.uvBounds[source * 4 + 1]);
+            uvBounds[vertex2 * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
+            uvBounds[vertex2 * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
+            colors[vertex2 * 3] = template.colors[source * 3];
+            colors[vertex2 * 3 + 1] = template.colors[source * 3 + 1];
+            colors[vertex2 * 3 + 2] = template.colors[source * 3 + 2];
+          }
+          for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[face * 6 + corner] - face * 4;
+        }
+      }
+      return { width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, indices: outputIndices };
+    });
+  }
+  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]);
+  }
+
+  // src/world/SectionWorker.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_Env();
+  var _SectionWorker = class _SectionWorker {
+    constructor(worker) {
+      this.worker = worker;
+      this.nextId = 0;
+      this.pending = /* @__PURE__ */ new Map();
+      worker.addEventListener("message", (event) => {
+        const reply = event.data;
+        const pending = this.pending.get(reply.id);
+        if (!pending) return;
+        this.pending.delete(reply.id);
+        if (reply.type === "pages") pending.resolve(reply.pages);
+        else pending.reject(new Error(reply.message));
+      });
+      worker.addEventListener("error", (event) => this.fail(event.message || "Section worker failed"));
+      worker.addEventListener("messageerror", () => this.fail("Section worker message could not be deserialized"));
+    }
+    /** The shared worker, or undefined when the environment has none or a previous worker failed. */
+    static shared() {
+      if (!this.initialized) {
+        this.initialized = true;
+        const worker = Env.provider.createWorker?.("section");
+        if (worker) this.instance = new _SectionWorker(worker);
+      }
+      return this.instance;
+    }
+    /** Builds geometry without transferring the input buffers away from the caller. */
+    build(input) {
+      if (!this.worker) return Promise.reject(new Error("Section worker terminated"));
+      return new Promise((resolve, reject) => {
+        const id = this.nextId++;
+        this.pending.set(id, { resolve, reject });
+        this.worker.postMessage({ id, type: "build", input });
+      });
+    }
+    /** Rejects pending builds, terminates the worker, and makes shared() return undefined. */
+    terminate() {
+      this.fail("Section worker terminated");
+    }
+    fail(message) {
+      const error2 = new Error(message);
+      for (const pending of this.pending.values()) pending.reject(error2);
+      this.pending.clear();
+      this.worker?.terminate();
+      this.worker = void 0;
+      _SectionWorker.instance = void 0;
+    }
+  };
+  _SectionWorker.initialized = false;
+  var SectionWorker = _SectionWorker;
+
+  // src/world/SectionMesh.ts
+  var templateCache = /* @__PURE__ */ new WeakMap();
+  function toInput(entries, maxAtlasSize) {
+    if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
+    const atlases = [];
+    const atlasIds = /* @__PURE__ */ new Map();
+    const templateIds = /* @__PURE__ */ new Map();
+    const input = {
+      count: entries.length,
+      indices: new Uint16Array(entries.length),
+      templates: new Uint16Array(entries.length),
+      cullMasks: new Uint8Array(entries.length),
+      templateData: [],
+      atlases: [],
+      maxAtlasSize
+    };
+    for (let i4 = 0; i4 < entries.length; i4++) {
+      const { index, template, cullMask } = entries[i4];
+      let id = templateIds.get(template);
+      if (id === void 0) {
+        let atlas = atlasIds.get(template.atlas);
+        if (atlas === void 0) {
+          atlas = atlases.length;
+          atlasIds.set(template.atlas, atlas);
+          atlases.push(template.atlas);
+          input.atlases.push({ width: template.atlas.image.width, height: template.atlas.image.height });
+        }
+        let data = templateCache.get(template);
+        if (!data) {
+          data = {
+            positions: new Float32Array(72),
+            normals: new Float32Array(72),
+            uvs: new Float32Array(48),
+            uvBounds: new Float32Array(96),
+            colors: new Float32Array(72),
+            indices: new Uint16Array(36),
+            cullFaces: new Uint8Array(template.cullFaces),
+            atlas: 0
+          };
+          const position = template.geometry.getAttribute("position");
+          const normal = template.geometry.getAttribute("normal");
+          const uv = template.geometry.getAttribute("uv");
+          const bounds = template.geometry.getAttribute("uvBounds");
+          const color3 = template.geometry.getAttribute("color");
+          for (let vertex2 = 0; vertex2 < CUBE_FACES.length * 4; vertex2++) {
+            data.positions.set([position.getX(vertex2), position.getY(vertex2), position.getZ(vertex2)], vertex2 * 3);
+            data.normals.set([normal.getX(vertex2), normal.getY(vertex2), normal.getZ(vertex2)], vertex2 * 3);
+            data.uvs.set([uv.getX(vertex2), uv.getY(vertex2)], vertex2 * 2);
+            data.uvBounds.set([
+              bounds?.getX(vertex2) ?? 0,
+              bounds?.getY(vertex2) ?? 0,
+              bounds?.getZ(vertex2) ?? 1,
+              bounds?.getW(vertex2) ?? 1
+            ], vertex2 * 4);
+            data.colors.set([color3?.getX(vertex2) ?? 1, color3?.getY(vertex2) ?? 1, color3?.getZ(vertex2) ?? 1], vertex2 * 3);
+          }
+          const indices = template.geometry.getIndex();
+          for (let i5 = 0; i5 < data.indices.length; i5++) data.indices[i5] = indices.getX(i5);
+          templateCache.set(template, data);
+        }
+        id = input.templateData.length;
+        templateIds.set(template, id);
+        input.templateData.push({ ...data, atlas });
+      }
+      input.indices[i4] = index;
+      input.templates[i4] = id;
+      input.cullMasks[i4] = cullMask;
+    }
+    return { input, atlases };
+  }
   var SectionMesh = class _SectionMesh extends Group {
     constructor() {
       super(...arguments);
@@ -119550,86 +119880,31 @@ gl_FragDepth=readDepth(vUv);
     }
     /** Builds section-local meshes from visible cube faces. `maxAtlasSize` limits each atlas dimension in pixels. */
     static build(entries, maxAtlasSize = 2048) {
-      if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
-      const visible = entries.filter((entry) => entry.template.cullFaces.some((direction) => !(entry.cullMask & direction)));
-      const atlases = [...new Set(visible.map((entry) => entry.template.atlas))].sort((a4, b4) => b4.image.height - a4.image.height);
-      const pages = [];
-      const locations = /* @__PURE__ */ new Map();
-      for (const atlas of atlases) {
-        const { width, height } = atlas.image;
-        if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
-        let selected;
-        for (const page of pages) {
-          const nextRow = page.x + width > maxAtlasSize;
-          if ((nextRow ? page.y + page.rowHeight : page.y) + height > maxAtlasSize) continue;
-          if (nextRow) {
-            page.y += page.rowHeight;
-            page.x = 0;
-            page.rowHeight = 0;
-          }
-          selected = page;
-          break;
-        }
-        if (!selected) {
-          selected = { placements: [], entries: [], x: 0, y: 0, rowHeight: 0, width: 0, height: 0 };
-          pages.push(selected);
-        }
-        const placement = { atlas, x: selected.x, y: selected.y };
-        selected.placements.push(placement);
-        selected.x += width;
-        selected.rowHeight = Math.max(selected.rowHeight, height);
-        selected.width = Math.max(selected.width, selected.x);
-        selected.height = Math.max(selected.height, selected.y + height);
-        locations.set(atlas, { page: selected, placement });
-      }
-      for (const entry of visible) locations.get(entry.template.atlas).page.entries.push(entry);
+      const { input, atlases } = toInput(entries, maxAtlasSize);
+      return this.fromPages(buildSectionGeometry(input), atlases);
+    }
+    /** Builds section-local meshes in a browser worker when available, with synchronous fallback. */
+    static async buildAsync(entries, maxAtlasSize = 2048) {
+      const { input, atlases } = toInput(entries, maxAtlasSize);
+      const worker = SectionWorker.shared();
+      const pages = worker ? await worker.build(input).catch(() => buildSectionGeometry(input)) : buildSectionGeometry(input);
+      return this.fromPages(pages, atlases);
+    }
+    static fromPages(pages, atlases) {
       const section = new _SectionMesh();
       for (const page of pages) {
         const canvas = createCanvas(page.width, page.height);
         const context = canvas.getContext("2d");
         for (const { atlas, x: x4, y: y5 } of page.placements) {
-          context.drawImage(atlas.image.canvas, x4, y5);
-        }
-        const positions = [], normals = [], uvs = [], uvBounds = [], colors = [], indices = [];
-        for (const { index, template, cullMask } of page.entries) {
-          const position = template.geometry.getAttribute("position");
-          const normal = template.geometry.getAttribute("normal");
-          const uv = template.geometry.getAttribute("uv");
-          const bounds = template.geometry.getAttribute("uvBounds");
-          const color3 = template.geometry.getAttribute("color");
-          const sourceIndices = template.geometry.getIndex();
-          const placement = locations.get(template.atlas).placement;
-          const mapU = (u4) => (placement.x + u4 * template.atlas.image.width) / page.width;
-          const mapV = (v5) => 1 - (placement.y + (1 - v5) * template.atlas.image.height) / page.height;
-          const offsetX = index % 16 * 16;
-          const offsetY = Math.floor(index / 256) * 16;
-          const offsetZ = Math.floor(index / 16) % 16 * 16;
-          for (let face = 0; face < 6; face++) {
-            if (cullMask & template.cullFaces[face]) continue;
-            const start = positions.length / 3;
-            for (let corner = 0; corner < 4; corner++) {
-              const vertex2 = face * 4 + corner;
-              positions.push(position.getX(vertex2) + offsetX, position.getY(vertex2) + offsetY, position.getZ(vertex2) + offsetZ);
-              normals.push(normal.getX(vertex2), normal.getY(vertex2), normal.getZ(vertex2));
-              uvs.push(mapU(uv.getX(vertex2)), mapV(uv.getY(vertex2)));
-              uvBounds.push(
-                mapU(bounds?.getX(vertex2) ?? 0),
-                mapV(bounds?.getY(vertex2) ?? 0),
-                mapU(bounds?.getZ(vertex2) ?? 1),
-                mapV(bounds?.getW(vertex2) ?? 1)
-              );
-              colors.push(color3?.getX(vertex2) ?? 1, color3?.getY(vertex2) ?? 1, color3?.getZ(vertex2) ?? 1);
-            }
-            for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
-          }
+          context.drawImage(atlases[atlas].image.canvas, x4, y5);
         }
         const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
-        geometry.setAttribute("normal", new Float32BufferAttribute(normals, 3));
-        geometry.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
-        geometry.setAttribute("uvBounds", new Float32BufferAttribute(uvBounds, 4));
-        geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
-        geometry.setIndex(indices);
+        geometry.setAttribute("position", new Float32BufferAttribute(page.positions.buffer, 3));
+        geometry.setAttribute("normal", new Float32BufferAttribute(page.normals.buffer, 3));
+        geometry.setAttribute("uv", new Float32BufferAttribute(page.uvs.buffer, 2));
+        geometry.setAttribute("uvBounds", new Float32BufferAttribute(page.uvBounds.buffer, 4));
+        geometry.setAttribute("color", new Float32BufferAttribute(page.colors.buffer, 3));
+        geometry.setIndex(new Uint32BufferAttribute(page.indices.buffer, 1));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         const material = Materials.createShadedCanvasMaterial(canvas, false, false, true);
@@ -119663,7 +119938,9 @@ gl_FragDepth=readDepth(vUv);
       this.renderedBlocks = /* @__PURE__ */ new Map();
       this.sectionBlocks = /* @__PURE__ */ new Map();
       this.hiddenBlocks = /* @__PURE__ */ new Set();
+      this.blockPosition = new Vector3();
       this.meshDirty = false;
+      this.meshGeneration = 0;
       this.scene = scene;
       this.x = x4;
       this.y = y5;
@@ -119676,7 +119953,7 @@ gl_FragDepth=readDepth(vUv);
       if (isTripleArray(posOrX)) {
         return this.getBlockAt(new Vector3(posOrX[0], posOrX[1], posOrX[2]));
       }
-      const pos = this.worldPosToChunkPos(posOrX);
+      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);
     }
@@ -119700,48 +119977,81 @@ gl_FragDepth=readDepth(vUv);
         worldPos = this.chunkPosToWorldPos(pos);
       }
       const index = _Chunk.chunkPosToBlockIndex(pos);
-      this.hiddenBlocks.delete(index);
-      this.data.set(index, block);
-      const readBlock = this.data.snapshot(index);
-      this.renderedBlocks.get(index)?.object?.removeFromScene();
-      if (this.sectionBlocks.delete(index)) this.meshDirty = true;
-      this.renderedBlocks.delete(index);
-      let object3;
       try {
-        if (!readBlock) return void 0;
-        const stored = readBlock();
-        const blockState = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
-        if (!blockState) {
-          this.data.set(index, void 0);
-          return void 0;
-        }
-        const perBlock = !this.sectionModels || getFluidKind(blockState.key, stored.properties) || blockState.key && BlockEntities.entry(await BlockEntities.getIndex(blockState.key.root), blockState.key.toNamespacedString());
-        const template = perBlock ? void 0 : await this.sectionModels.get(blockState, stored.properties);
-        if (template) {
-          this.sectionBlocks.set(index, { index, template, cullMask: 0 });
-          this.meshDirty = true;
-        } else {
-          object3 = await this.scene.addBlock(blockState, {
-            mergeMeshes: true,
-            instanceMeshes: true,
-            maxInstanceCount: 2e3,
-            initialState: stored.properties
-          });
-          object3.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
-        }
-        const info = { get block() {
-          return readBlock();
-        }, object: object3 };
-        this.renderedBlocks.set(index, info);
-        return info;
-      } catch (error2) {
-        this.data.set(index, void 0);
-        object3?.removeFromScene();
-        throw error2;
+        await this.placeBlocks([{ index, block }]);
+        return this.renderedBlocks.get(index);
       } finally {
         await onBlocksChanged?.([worldPos]);
       }
     }
+    /** Places cells in input order and returns changed world positions without refreshing neighbors. */
+    async placeBlocks(blocks) {
+      const resolutions = /* @__PURE__ */ new Map();
+      for (const { block } of blocks) {
+        if (!block || ChunkData.isAir(block)) continue;
+        const key = ChunkData.paletteKey(block);
+        if (resolutions.has(key)) continue;
+        const stored = { type: block.type, properties: block.properties ? { ...block.properties } : void 0 };
+        const resolved = (async () => {
+          const blockState = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
+          const perBlock = !blockState || !this.sectionModels || !!getFluidKind(blockState.key, stored.properties) || !!(blockState.key && BlockEntities.entry(await BlockEntities.getIndex(blockState.key.root), blockState.key.toNamespacedString()));
+          if (!perBlock) await this.sectionModels.get(blockState, stored.properties);
+          return { blockState, perBlock };
+        })();
+        resolutions.set(key, resolved);
+        void resolved.catch(() => void 0);
+      }
+      const positions = [];
+      let failed = false, failure;
+      for (const { index, block } of blocks) {
+        this.hiddenBlocks.delete(index);
+        this.data.set(index, block);
+        const readBlock = this.data.snapshot(index);
+        this.renderedBlocks.get(index)?.object?.removeFromScene();
+        if (this.sectionBlocks.delete(index)) this.meshDirty = true;
+        this.renderedBlocks.delete(index);
+        const worldPos = new Vector3(
+          this.x * 16 + index % 16,
+          this.y * 16 + Math.floor(index / 256),
+          this.z * 16 + Math.floor(index / 16) % 16
+        );
+        positions.push(worldPos);
+        let object3;
+        try {
+          if (!readBlock) continue;
+          const stored = readBlock();
+          const key = ChunkData.paletteKey(stored);
+          const { blockState, perBlock } = await resolutions.get(key);
+          if (!blockState) {
+            this.data.set(index, void 0);
+            continue;
+          }
+          const template = perBlock ? void 0 : await this.sectionModels.get(blockState, stored.properties);
+          if (template) {
+            this.sectionBlocks.set(index, { index, template, cullMask: 0 });
+            this.meshDirty = true;
+          } else {
+            object3 = await this.scene.addBlock(blockState, {
+              mergeMeshes: true,
+              instanceMeshes: true,
+              maxInstanceCount: 2e3,
+              initialState: stored.properties
+            });
+            object3.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
+          }
+          this.renderedBlocks.set(index, { get block() {
+            return readBlock();
+          }, object: object3 });
+        } catch (error2) {
+          this.data.set(index, void 0);
+          object3?.removeFromScene();
+          if (!failed) failure = error2;
+          failed = true;
+        }
+      }
+      if (failed) throw failure;
+      return positions;
+    }
     /** Changes visibility at world block coordinates while preserving the block's data. */
     async setBlockVisibleAt(pos, visible) {
       const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
@@ -119762,15 +120072,24 @@ gl_FragDepth=readDepth(vUv);
       await this.onBlocksChanged?.([pos]);
     }
     isBlockVisibleAt(pos) {
-      const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+      return this.isBlockVisibleIndex(_Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos)));
+    }
+    /** Reports whether a cell has a visible render object or section entry. */
+    isBlockVisibleIndex(index) {
       return this.renderedBlocks.has(index) && !this.hiddenBlocks.has(index);
     }
     isOccludingAt(pos) {
-      const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+      return this.isOccludingIndex(_Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos)));
+    }
+    /** Reports whether a visible cell hides neighboring cube faces. */
+    isOccludingIndex(index) {
       return !this.hiddenBlocks.has(index) && (this.sectionBlocks.has(index) || (this.renderedBlocks.get(index)?.object?.isOccluding ?? false));
     }
     async setCullMaskAt(pos, mask) {
-      const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+      await this.setCullMaskIndex(_Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos)), mask);
+    }
+    /** Updates hidden faces for a cell's section entry or individual render object. */
+    async setCullMaskIndex(index, mask) {
       const entry = this.sectionBlocks.get(index);
       if (entry) {
         if (entry.cullMask !== mask) {
@@ -119781,12 +120100,17 @@ gl_FragDepth=readDepth(vUv);
         await this.renderedBlocks.get(index)?.object?.setCullMask(mask);
       }
     }
-    rebuildSectionMesh() {
+    /** Rebuilds visible section geometry and discards results superseded by another rebuild or clear. */
+    async rebuildSectionMesh() {
       if (!this.meshDirty) return;
-      const next = this.sectionBlocks.size ? SectionMesh.build(
-        [...this.sectionBlocks.values()].filter((entry) => !this.hiddenBlocks.has(entry.index)),
-        this.sectionModels.maxAtlasSize
-      ) : void 0;
+      this.meshDirty = false;
+      const generation = ++this.meshGeneration;
+      const entries = [...this.sectionBlocks.values()].filter((entry) => !this.hiddenBlocks.has(entry.index));
+      const next = entries.length ? await SectionMesh.buildAsync(entries, this.sectionModels.maxAtlasSize) : void 0;
+      if (generation !== this.meshGeneration) {
+        next?.dispose();
+        return;
+      }
       this.sectionMesh?.dispose();
       this.sectionMesh = next;
       if (next) {
@@ -119794,7 +120118,6 @@ gl_FragDepth=readDepth(vUv);
         this.scene.add(next);
       }
       this.scene.dirty = true;
-      this.meshDirty = false;
     }
     /** Removes stored blocks and their render objects, then notifies the owning world of changed positions. */
     async clear(onBlocksChanged = this.onBlocksChanged) {
@@ -119803,6 +120126,7 @@ gl_FragDepth=readDepth(vUv);
       ));
       for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
       this.sectionBlocks.clear();
+      this.meshGeneration++;
       this.sectionMesh?.dispose();
       this.sectionMesh = void 0;
       this.meshDirty = false;