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

package/dist/node/index.mjs

@@ -192,6 +192,23 @@ async function sleep(timeout) {
     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;
 }
@@ -28557,6 +28574,16 @@ init_NBTHelper();
 
 // src/world/ChunkData.ts
 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);
@@ -28584,10 +28611,10 @@ var ChunkData = class _ChunkData {
     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((name) => [name, block.properties[name]]));
       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];
@@ -28624,9 +28651,14 @@ var ChunkData = class _ChunkData {
   }
   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((name) => [name, block.properties[name]]));
+    return JSON.stringify([blockKey(block.type).toNamespacedString(), properties]);
+  }
   static copyBlock(state, nbt) {
     const block = { type: state.type };
     if (state.properties) block.properties = { ...state.properties };
@@ -28806,14 +28838,17 @@ var AnvilParser = class {
     const perLong = Math.floor(64 / bits);
     const expected = padded ? Math.ceil(4096 / perLong) : Math.ceil(4096 * bits / 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(bits)) - 1n;
+    const words = tag.value.map(([high, low]) => [high >>> 0, low >>> 0]);
+    const mask = (1 << bits) - 1;
     for (let index = 0; index < 4096; index++) {
-      const word = padded ? Math.floor(index / perLong) : Math.floor(index * bits / 64);
-      const shift = padded ? index % perLong * bits : index * bits % 64;
-      let value = words[word] >> BigInt(shift);
-      if (!padded && shift + bits > 64) value |= words[word + 1] << BigInt(64 - shift);
-      indices[index] = Number(value & mask);
+      const bitPos = index * bits;
+      const word = padded ? Math.floor(index / perLong) : bitPos >>> 6;
+      const shift = padded ? index % perLong * bits : bitPos & 63;
+      const [high, low] = words[word];
+      let value = shift < 32 ? low >>> shift : high >>> shift - 32;
+      if (shift < 32 && shift + bits > 32) value += high * 2 ** (32 - shift);
+      if (!padded && shift + bits > 64) value += words[word + 1][1] * 2 ** (64 - shift);
+      indices[index] = value & mask;
     }
     return indices;
   }
@@ -28954,8 +28989,8 @@ init_AssetKey();
 
 // src/world/MineRenderWorld.ts
 init_Model();
+init_util();
 import { Vector3 as Vector316 } from "three";
-init_BatchedExecutor();
 init_AssetKey();
 init_BlockStates();
 init_CubeFace();
@@ -29100,7 +29135,7 @@ var MineRenderWorld = class {
    * 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) {
@@ -29117,8 +29152,10 @@ var MineRenderWorld = class {
     };
     const place = (block) => this.placeBlock(new Vector316(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
+    const types = /* @__PURE__ */ new Set();
     for (const block of multiblock.blocks) {
-      if (Chunk.isAir(block)) continue;
+      if (Chunk.isAir(block) || types.has(block.type)) continue;
+      types.add(block.type);
       const key = AssetKey.parse("blockstates", block.type);
       keys.set(key.serialize(), key);
     }
@@ -29127,6 +29164,23 @@ var MineRenderWorld = class {
       for (const block of multiblock.blocks) await place(block);
       return;
     }
+    if (!executor) {
+      const groups2 = /* @__PURE__ */ new Map();
+      const position = new Vector316();
+      for (const block of multiblock.blocks) {
+        const [x, y, z] = block.position;
+        this.validatePosBounds(position.set(x, y, z));
+        const cx = Math.floor(x / 16), cy = Math.floor(y / 16), cz = Math.floor(z / 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: (y - cy * 16) * 256 + (z - cz * 16) * 16 + x - 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(",");
@@ -29135,19 +29189,34 @@ var MineRenderWorld = class {
       else positions.set(key, [block]);
     }
     const groups = [...positions.values()];
-    const queue = executor ?? new BatchedExecutor();
-    try {
-      for (let i = 0; i < groups.length; i += queue.batch) {
-        const results = await Promise.allSettled(groups.slice(i, i + queue.batch).map(
-          (blocks) => queue.submit(async () => {
-            for (const block of blocks) await place(block);
-          })
+    for (let i = 0; i < groups.length; i += executor.batch) {
+      const results = await Promise.allSettled(groups.slice(i, i + 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 ??= blocks.map(({ index }) => new Vector316(
+          chunk.x * 16 + index % 16,
+          chunk.y * 16 + Math.floor(index / 256),
+          chunk.z * 16 + Math.floor(index / 16) % 16
         ));
-        const failure = results.find((result) => result.status === "rejected");
-        if (failure?.status === "rejected") throw failure.reason;
+        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) queue.stop();
     }
   }
   /** Replaces one chunk column's blocks. Entity NBT remains available on the parsed chunk. */
@@ -29155,7 +29224,24 @@ var MineRenderWorld = class {
     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 Vector316(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);
@@ -29170,6 +29256,7 @@ var MineRenderWorld = class {
         }
         await this.placeBlocks({ size: [16, 16, 16], blocks }, true, executor, changes);
       }
+      if (!executor) await this.placeChunkGroups(groups, changes);
     } finally {
       await this.updateCulling([...changes.values()]);
     }
@@ -29210,19 +29297,23 @@ var MineRenderWorld = class {
     this.sectionModels?.clear();
   }
   updateCulling(positions) {
+    const neighbor = new Vector316();
     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 Vector316(...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 y = -1; y <= 1; y++) {
         for (let z = -1; z <= 1; z++) {
           for (let x = -1; x <= 1; x++) {
-            const neighbor = pos.clone().add(new Vector316(x, y, z));
-            if (this.getBlockAt(neighbor)?.object?.fluidKind) {
-              this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
-            }
+            const nx = lx + x, ny = ly + y, nz = lz + z;
+            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(x) + Math.abs(y) + Math.abs(z) > 1 && !section.getBlockAt(neighbor.set(pos.x + x, pos.y + y, pos.z + z))?.object?.fluidKind) continue;
+            if (!pending) this.pendingCulling.set(section, pending = /* @__PURE__ */ new Set());
+            pending.add(index);
           }
         }
       }
@@ -29230,39 +29321,38 @@ var MineRenderWorld = class {
     return 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((x, y, z) => {
-                const neighbor = pos.clone().add(new Vector316(x, y, z));
-                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 Vector316(...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((x, y, z) => {
+                  const nx = lx + x, ny = ly + y, nz = lz + z;
+                  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 + x, wy + y, wz + z))?.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;
@@ -29323,8 +29413,230 @@ init_Model();
 
 // src/world/SectionMesh.ts
 init_CanvasCompat();
+init_CubeFace();
 init_Materials();
-import { BufferGeometry as BufferGeometry8, Float32BufferAttribute as Float32BufferAttribute8, Group as Group3, Mesh as Mesh9 } from "three";
+import { BufferGeometry as BufferGeometry8, Float32BufferAttribute as Float32BufferAttribute8, Group as Group3, Mesh as Mesh9, Uint32BufferAttribute } from "three";
+
+// src/world/SectionGeometry.ts
+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((a, b) => atlases[b].height - atlases[a].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 i = 0; i < pages.length; i++) {
+      const page2 = pages[i];
+      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 = i;
+      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 vertex = 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 = (u) => (placement.x + u * atlas.width) / page.width;
+      const mapV = (v) => 1 - (placement.y + (1 - v) * 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 = vertex;
+        for (let corner = 0; corner < 4; corner++, vertex++) {
+          const source = face * 4 + corner;
+          positions[vertex * 3] = template.positions[source * 3] + offsetX;
+          positions[vertex * 3 + 1] = template.positions[source * 3 + 1] + offsetY;
+          positions[vertex * 3 + 2] = template.positions[source * 3 + 2] + offsetZ;
+          normals[vertex * 3] = template.normals[source * 3];
+          normals[vertex * 3 + 1] = template.normals[source * 3 + 1];
+          normals[vertex * 3 + 2] = template.normals[source * 3 + 2];
+          uvs[vertex * 2] = mapU(template.uvs[source * 2]);
+          uvs[vertex * 2 + 1] = mapV(template.uvs[source * 2 + 1]);
+          uvBounds[vertex * 4] = mapU(template.uvBounds[source * 4]);
+          uvBounds[vertex * 4 + 1] = mapV(template.uvBounds[source * 4 + 1]);
+          uvBounds[vertex * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
+          uvBounds[vertex * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
+          colors[vertex * 3] = template.colors[source * 3];
+          colors[vertex * 3 + 1] = template.colors[source * 3 + 1];
+          colors[vertex * 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_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"));
+  }
+  static {
+    this.initialized = false;
+  }
+  /** 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 error = new Error(message);
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+    this.worker?.terminate();
+    this.worker = void 0;
+    _SectionWorker.instance = void 0;
+  }
+};
+
+// 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 i = 0; i < entries.length; i++) {
+    const { index, template, cullMask } = entries[i];
+    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 color2 = template.geometry.getAttribute("color");
+        for (let vertex = 0; vertex < CUBE_FACES.length * 4; vertex++) {
+          data.positions.set([position.getX(vertex), position.getY(vertex), position.getZ(vertex)], vertex * 3);
+          data.normals.set([normal.getX(vertex), normal.getY(vertex), normal.getZ(vertex)], vertex * 3);
+          data.uvs.set([uv.getX(vertex), uv.getY(vertex)], vertex * 2);
+          data.uvBounds.set([
+            bounds?.getX(vertex) ?? 0,
+            bounds?.getY(vertex) ?? 0,
+            bounds?.getZ(vertex) ?? 1,
+            bounds?.getW(vertex) ?? 1
+          ], vertex * 4);
+          data.colors.set([color2?.getX(vertex) ?? 1, color2?.getY(vertex) ?? 1, color2?.getZ(vertex) ?? 1], vertex * 3);
+        }
+        const indices = template.geometry.getIndex();
+        for (let i2 = 0; i2 < data.indices.length; i2++) data.indices[i2] = indices.getX(i2);
+        templateCache.set(template, data);
+      }
+      id = input.templateData.length;
+      templateIds.set(template, id);
+      input.templateData.push({ ...data, atlas });
+    }
+    input.indices[i] = index;
+    input.templates[i] = id;
+    input.cullMasks[i] = cullMask;
+  }
+  return { input, atlases };
+}
 var SectionMesh = class _SectionMesh extends Group3 {
   constructor() {
     super(...arguments);
@@ -29332,86 +29644,31 @@ var SectionMesh = class _SectionMesh extends Group3 {
   }
   /** 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((a, b) => b.image.height - a.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 = createCanvas2(page.width, page.height);
       const context = canvas.getContext("2d");
       for (const { atlas, x, y } of page.placements) {
-        context.drawImage(atlas.image.canvas, x, y);
-      }
-      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 color2 = template.geometry.getAttribute("color");
-        const sourceIndices = template.geometry.getIndex();
-        const placement = locations.get(template.atlas).placement;
-        const mapU = (u) => (placement.x + u * template.atlas.image.width) / page.width;
-        const mapV = (v) => 1 - (placement.y + (1 - v) * 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 vertex = face * 4 + corner;
-            positions.push(position.getX(vertex) + offsetX, position.getY(vertex) + offsetY, position.getZ(vertex) + offsetZ);
-            normals.push(normal.getX(vertex), normal.getY(vertex), normal.getZ(vertex));
-            uvs.push(mapU(uv.getX(vertex)), mapV(uv.getY(vertex)));
-            uvBounds.push(
-              mapU(bounds?.getX(vertex) ?? 0),
-              mapV(bounds?.getY(vertex) ?? 0),
-              mapU(bounds?.getZ(vertex) ?? 1),
-              mapV(bounds?.getW(vertex) ?? 1)
-            );
-            colors.push(color2?.getX(vertex) ?? 1, color2?.getY(vertex) ?? 1, color2?.getZ(vertex) ?? 1);
-          }
-          for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
-        }
+        context.drawImage(atlases[atlas].image.canvas, x, y);
       }
       const geometry = new BufferGeometry8();
-      geometry.setAttribute("position", new Float32BufferAttribute8(positions, 3));
-      geometry.setAttribute("normal", new Float32BufferAttribute8(normals, 3));
-      geometry.setAttribute("uv", new Float32BufferAttribute8(uvs, 2));
-      geometry.setAttribute("uvBounds", new Float32BufferAttribute8(uvBounds, 4));
-      geometry.setAttribute("color", new Float32BufferAttribute8(colors, 3));
-      geometry.setIndex(indices);
+      geometry.setAttribute("position", new Float32BufferAttribute8(page.positions.buffer, 3));
+      geometry.setAttribute("normal", new Float32BufferAttribute8(page.normals.buffer, 3));
+      geometry.setAttribute("uv", new Float32BufferAttribute8(page.uvs.buffer, 2));
+      geometry.setAttribute("uvBounds", new Float32BufferAttribute8(page.uvBounds.buffer, 4));
+      geometry.setAttribute("color", new Float32BufferAttribute8(page.colors.buffer, 3));
+      geometry.setIndex(new Uint32BufferAttribute(page.indices.buffer, 1));
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const material = Materials.createShadedCanvasMaterial(canvas, false, false, true);
@@ -29445,7 +29702,9 @@ var Chunk = class _Chunk {
     this.renderedBlocks = /* @__PURE__ */ new Map();
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
+    this.blockPosition = new Vector317();
     this.meshDirty = false;
+    this.meshGeneration = 0;
     this.scene = scene;
     this.x = x;
     this.y = y;
@@ -29458,7 +29717,7 @@ var Chunk = class _Chunk {
     if (isTripleArray(posOrX)) {
       return this.getBlockAt(new Vector317(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);
   }
@@ -29482,48 +29741,81 @@ var Chunk = class _Chunk {
       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 (error) {
-      this.data.set(index, void 0);
-      object3?.removeFromScene();
-      throw error;
+      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 Vector317(
+        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 (error) {
+        this.data.set(index, void 0);
+        object3?.removeFromScene();
+        if (!failed) failure = error;
+        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));
@@ -29544,15 +29836,24 @@ var Chunk = class _Chunk {
     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) {
@@ -29563,12 +29864,17 @@ var Chunk = class _Chunk {
       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) {
@@ -29576,7 +29882,6 @@ var Chunk = class _Chunk {
       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) {
@@ -29585,6 +29890,7 @@ var Chunk = class _Chunk {
     ));
     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;
@@ -29888,6 +30194,7 @@ export {
   SchematicParser,
   SectionMesh,
   SectionModels,
+  SectionWorker,
   SkinImage,
   SkinObject,
   SkinPart,
@@ -29912,6 +30219,7 @@ export {
   axisToVec3,
   base64decode,
   base64encode,
+  buildSectionGeometry,
   capeTextureSizes,
   captureException,
   changeEvent,
@@ -29963,6 +30271,7 @@ export {
   sampleEntityAnimation,
   sampleEntityKeyframes,
   sampleFluid,
+  sectionGeometryTransferables,
   serializeBoxGeometryKey,
   serializeImageKey,
   serializeMaterialKey,
@@ -29980,6 +30289,7 @@ export {
   toDegrees,
   toRadians,
   toTrianglesDrawMode,
-  trimCanvas
+  trimCanvas,
+  yieldToEventLoop
 };
 //# sourceMappingURL=index.mjs.map