minerender 2.1.0-alpha.86 → 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 });
@@ -106478,6 +106495,7 @@ ${shader.fragmentShader}`.replace(
   __export(index_browser_exports, {
     AXES: () => AXES,
     AnvilParser: () => AnvilParser,
+    AnvilWorldSource: () => AnvilWorldSource,
     ArchiveAssetSource: () => ArchiveAssetSource,
     AssetKey: () => AssetKey,
     AssetLoadError: () => AssetLoadError,
@@ -106567,6 +106585,7 @@ ${shader.fragmentShader}`.replace(
     SchematicParser: () => SchematicParser,
     SectionMesh: () => SectionMesh,
     SectionModels: () => SectionModels,
+    SectionWorker: () => SectionWorker,
     SkinImage: () => SkinImage,
     SkinObject: () => SkinObject,
     SkinPart: () => SkinPart,
@@ -106581,6 +106600,7 @@ ${shader.fragmentShader}`.replace(
     TintColors: () => TintColors,
     UVMapper: () => UVMapper,
     VideoExporter: () => VideoExporter,
+    WorldStreamer: () => WorldStreamer,
     WrappedImage: () => WrappedImage,
     addBox3WireframeToObject: () => addBox3WireframeToObject,
     addWireframeToMesh: () => addWireframeToMesh,
@@ -106590,6 +106610,7 @@ ${shader.fragmentShader}`.replace(
     axisToVec3: () => axisToVec3,
     base64decode: () => base64decode,
     base64encode: () => base64encode,
+    buildSectionGeometry: () => buildSectionGeometry,
     capeTextureSizes: () => capeTextureSizes,
     captureException: () => captureException,
     changeEvent: () => changeEvent,
@@ -106642,6 +106663,7 @@ ${shader.fragmentShader}`.replace(
     sampleEntityAnimation: () => sampleEntityAnimation,
     sampleEntityKeyframes: () => sampleEntityKeyframes,
     sampleFluid: () => sampleFluid,
+    sectionGeometryTransferables: () => sectionGeometryTransferables,
     serializeBoxGeometryKey: () => serializeBoxGeometryKey,
     serializeImageKey: () => serializeImageKey,
     serializeMaterialKey: () => serializeMaterialKey,
@@ -106659,7 +106681,8 @@ ${shader.fragmentShader}`.replace(
     toDegrees: () => toDegrees,
     toRadians: () => toRadians,
     toTrianglesDrawMode: () => toTrianglesDrawMode,
-    trimCanvas: () => trimCanvas
+    trimCanvas: () => trimCanvas,
+    yieldToEventLoop: () => yieldToEventLoop
   });
   init_dirname();
   init_buffer2();
@@ -106760,6 +106783,7 @@ ${shader.fragmentShader}`.replace(
   }
 
   // src/env/browser/BrowserEnv.ts
+  var import_meta = {};
   var BrowserEnv = class {
     constructor() {
       this.name = "browser";
@@ -106787,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();
@@ -118753,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);
@@ -118780,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];
@@ -118820,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 };
@@ -119002,19 +119049,153 @@ 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;
     }
   };
 
+  // src/world/AnvilWorldSource.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_MineRenderError();
+  async function abortable2(promise, signal) {
+    if (!signal) return promise;
+    let abort2;
+    const cancelled = new Promise((_4, reject) => {
+      abort2 = () => reject(signal.reason);
+      signal.addEventListener("abort", abort2, { once: true });
+      if (signal.aborted) abort2();
+    });
+    try {
+      return await Promise.race([promise, cancelled]);
+    } finally {
+      signal.removeEventListener("abort", abort2);
+    }
+  }
+  var AnvilWorldSource = class {
+    constructor(readRegion, options = {}) {
+      this.readRegion = readRegion;
+      this.regions = /* @__PURE__ */ new Map();
+      this.pending = /* @__PURE__ */ new Map();
+      this.cachedBytes = 0;
+      this.maxCachedRegions = options.maxCachedRegions ?? 4;
+      this.maxCachedBytes = options.maxCachedBytes ?? 64 * 1024 * 1024;
+      for (const [name2, value] of Object.entries({ maxCachedRegions: this.maxCachedRegions, maxCachedBytes: this.maxCachedBytes })) {
+        if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name2} must be a nonnegative safe integer`);
+      }
+    }
+    /** Decodes one column at absolute chunk coordinates. Aborting a caller leaves other shared readers active. */
+    async getChunk(x4, z4, signal) {
+      if (!Number.isSafeInteger(x4) || !Number.isSafeInteger(z4)) {
+        throw new RangeError("Chunk column coordinates must be safe integers");
+      }
+      const regionX = Math.floor(x4 / 32), regionZ = Math.floor(z4 / 32);
+      const data = await this.getRegion(regionX, regionZ, signal);
+      signal?.throwIfAborted();
+      if (!data) return void 0;
+      const chunk = await abortable2(AnvilParser.parseChunk(data, x4 - regionX * 32, z4 - regionZ * 32), signal);
+      signal?.throwIfAborted();
+      if (chunk && (chunk.x !== x4 || chunk.z !== z4)) {
+        throw new MineRenderError(`Anvil chunk coordinates ${chunk.x},${chunk.z} do not match requested column ${x4},${z4}`);
+      }
+      return chunk;
+    }
+    /** Releases cached regions. Reads already in progress finish without repopulating this cache. */
+    clearCache() {
+      this.regions.clear();
+      this.pending.clear();
+      this.cachedBytes = 0;
+    }
+    getRegion(x4, z4, signal) {
+      signal?.throwIfAborted();
+      const key = `${x4},${z4}`;
+      const cached2 = this.regions.get(key);
+      if (cached2) {
+        this.regions.delete(key);
+        this.regions.set(key, cached2);
+        return Promise.resolve(cached2.data);
+      }
+      let loading = this.pending.get(key);
+      if (!loading) {
+        const controller = new AbortController();
+        loading = {
+          controller,
+          waiters: 0,
+          settled: false,
+          promise: Promise.resolve().then(() => {
+            controller.signal.throwIfAborted();
+            return this.readRegion(x4, z4, controller.signal);
+          }).then((data) => {
+            controller.signal.throwIfAborted();
+            let bytes = data instanceof Uint8Array ? data : data === void 0 ? void 0 : new Uint8Array(data);
+            if (bytes && bytes.byteLength !== bytes.buffer.byteLength) bytes = new Uint8Array(bytes);
+            if (bytes) AnvilParser.getChunkList(bytes);
+            loading.settled = true;
+            if (this.pending.get(key) === loading) this.cacheRegion(key, bytes);
+            return bytes;
+          }).finally(() => {
+            loading.settled = true;
+            if (this.pending.get(key) === loading) this.pending.delete(key);
+          })
+        };
+        this.pending.set(key, loading);
+      }
+      const read = loading;
+      read.waiters++;
+      return new Promise((resolve, reject) => {
+        let finished = false;
+        const release2 = () => {
+          if (finished) return false;
+          finished = true;
+          signal?.removeEventListener("abort", abort2);
+          read.waiters--;
+          return true;
+        };
+        const abort2 = () => {
+          if (!release2()) return;
+          if (!read.waiters && !read.settled) {
+            if (this.pending.get(key) === read) this.pending.delete(key);
+            read.controller.abort(signal.reason);
+          }
+          reject(signal.reason);
+        };
+        signal?.addEventListener("abort", abort2, { once: true });
+        read.promise.then(
+          (data) => {
+            if (release2()) resolve(data);
+          },
+          (error2) => {
+            if (release2()) reject(error2);
+          }
+        );
+        if (signal?.aborted) abort2();
+      });
+    }
+    cacheRegion(key, data) {
+      const size = data?.byteLength ?? 0;
+      if (!this.maxCachedRegions || size > this.maxCachedBytes) return;
+      this.regions.set(key, { data, size });
+      this.cachedBytes += size;
+      while (this.regions.size > this.maxCachedRegions || this.cachedBytes > this.maxCachedBytes) {
+        const oldest = this.regions.keys().next().value;
+        this.cachedBytes -= this.regions.get(oldest).size;
+        this.regions.delete(oldest);
+      }
+    }
+  };
+
   // src/world/BlockInfo.ts
   init_dirname();
   init_buffer2();
@@ -119034,7 +119215,7 @@ gl_FragDepth=readDepth(vUv);
   init_process2();
   init_three_module();
   init_Model();
-  init_BatchedExecutor();
+  init_util();
   init_AssetKey();
   init_BlockStates();
   init_CubeFace();
@@ -119182,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) {
@@ -119199,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);
       }
@@ -119209,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(",");
@@ -119217,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. */
@@ -119237,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);
@@ -119252,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()]);
       }
@@ -119292,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);
             }
           }
         }
@@ -119312,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;
@@ -119409,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);
@@ -119417,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);
@@ -119530,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;
@@ -119543,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);
     }
@@ -119567,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));
@@ -119629,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) {
@@ -119648,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) {
@@ -119661,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) {
@@ -119670,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;
@@ -119706,6 +120163,188 @@ gl_FragDepth=readDepth(vUv);
       );
     }
   };
+
+  // src/world/WorldChunkSource.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
+  // src/world/WorldStreamer.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var WorldStreamer = class {
+    constructor(world, source, options = {}) {
+      this.world = world;
+      this.source = source;
+      this.loaded = /* @__PURE__ */ new Map();
+      this.owned = /* @__PURE__ */ new Map();
+      this.missing = /* @__PURE__ */ new Map();
+      this.failed = /* @__PURE__ */ new Map();
+      this.desired = [];
+      this.disposed = false;
+      this.loadRadius = options.loadRadius ?? 2;
+      this.unloadRadius = options.unloadRadius ?? Math.min(32, this.loadRadius + 1);
+      if (![this.loadRadius, this.unloadRadius].every((value) => Number.isInteger(value) && value >= 0 && value <= 32) || this.unloadRadius < this.loadRadius) {
+        throw new RangeError("Chunk radii must be integers from 0 to 32, with unloadRadius at least loadRadius");
+      }
+    }
+    /** Returns absolute coordinates of successfully placed columns, including retained columns. */
+    get loadedChunks() {
+      return [...this.loaded.values()].map((position) => ({ ...position }));
+    }
+    /** Returns source failures retained within the unload radius. Failed columns do not block other loads. */
+    get failedChunks() {
+      return [...this.failed.values()].map((failure) => ({ ...failure }));
+    }
+    /** Counts desired columns still waiting for a source read or placement, including the active column. */
+    get pendingChunks() {
+      return this.desired.filter((position) => this.needsLoad(position)).length;
+    }
+    /**
+     * Updates the center in absolute chunk coordinates. Repeated calls share the active drain.
+     * Source failures are recorded in failedChunks; other columns continue loading. Missing and failed
+     * columns are remembered within the retention radius. Call retryFailedChunks to retry source failures.
+     * Placement and unload failures reject the drain; call update again to retry those operations.
+     * Reads outside the latest load radius receive an abort signal; placement finishes before unloading.
+     * Sources should represent an unchanged world during streaming.
+     */
+    async update(x4, z4) {
+      if (this.disposed) throw new Error("WorldStreamer is disposed");
+      if (![x4, z4].every((value) => Number.isSafeInteger(value) && Number.isSafeInteger(value - this.unloadRadius) && Number.isSafeInteger(value + this.unloadRadius))) {
+        throw new RangeError("Chunk coordinates must be safe integers within the streaming radius");
+      }
+      if (!this.center || this.center.x !== x4 || this.center.z !== z4) {
+        this.center = { x: x4, z: z4 };
+        this.desired = [];
+        for (let dz = -this.loadRadius; dz <= this.loadRadius; dz++) {
+          for (let dx = -this.loadRadius; dx <= this.loadRadius; dx++) {
+            this.desired.push({ x: x4 + dx, z: z4 + dz });
+          }
+        }
+        this.desired.sort((a4, b4) => (a4.x - x4) ** 2 + (a4.z - z4) ** 2 - (b4.x - x4) ** 2 - (b4.z - z4) ** 2);
+        if (this.loading && !this.within(this.loading.position, this.loadRadius)) {
+          this.loading.controller.abort();
+        }
+      }
+      return this.running ?? (this.running = Promise.resolve().then(() => this.drain()));
+    }
+    /** Updates from a camera or view-center position in scene units. One chunk spans 256 scene units. */
+    async updatePosition(position) {
+      if (![position.x, position.z].every(Number.isFinite)) throw new RangeError("Scene coordinates must be finite");
+      return this.update(Math.floor(position.x / 256), Math.floor(position.z / 256));
+    }
+    /** Forgets recorded source failures and retries desired columns at the latest center. */
+    async retryFailedChunks() {
+      if (this.disposed) throw new Error("WorldStreamer is disposed");
+      this.failed.clear();
+      if (this.center) await this.update(this.center.x, this.center.z);
+    }
+    /** Aborts source reads, waits for active work, then unloads owned columns. The world and source remain caller-owned. */
+    dispose() {
+      this.disposed = true;
+      this.desired = [];
+      this.center = void 0;
+      this.loading?.controller.abort();
+      return this.disposal ?? (this.disposal = Promise.resolve().then(async () => {
+        await this.running?.catch(() => void 0);
+        let failure;
+        let failed = false;
+        for (const position of this.owned.values()) {
+          try {
+            await this.unload(position);
+          } catch (error2) {
+            failed = true;
+            failure ?? (failure = error2);
+          }
+        }
+        this.missing.clear();
+        this.failed.clear();
+        if (failed) throw failure;
+      }).catch((error2) => {
+        this.disposal = void 0;
+        throw error2;
+      }));
+    }
+    async drain() {
+      try {
+        while (!this.disposed) {
+          for (const [key, position2] of this.missing) {
+            if (!this.within(position2, this.unloadRadius)) this.missing.delete(key);
+          }
+          for (const [key, position2] of this.failed) {
+            if (!this.within(position2, this.unloadRadius)) this.failed.delete(key);
+          }
+          const obsolete = [...this.owned.values()].find((position2) => !this.loaded.has(this.key(position2)) || !this.within(position2, this.unloadRadius));
+          if (obsolete) {
+            await this.unload(obsolete);
+            continue;
+          }
+          const position = this.desired.find((position2) => this.needsLoad(position2));
+          if (!position) return;
+          let chunk;
+          const controller = new AbortController();
+          this.loading = { position, controller };
+          try {
+            chunk = await this.source.getChunk(position.x, position.z, controller.signal);
+            if (chunk) this.validateChunk(chunk, position);
+          } catch (error2) {
+            if (!controller.signal.aborted && !this.disposed && this.within(position, this.loadRadius)) {
+              this.failed.set(this.key(position), { ...position, error: error2 });
+            }
+            continue;
+          } finally {
+            this.loading = void 0;
+          }
+          if (controller.signal.aborted || this.disposed || !this.within(position, this.loadRadius)) continue;
+          if (!chunk) {
+            this.missing.set(this.key(position), position);
+            continue;
+          }
+          this.owned.set(this.key(position), position);
+          try {
+            await this.world.placeChunk(chunk);
+            this.loaded.set(this.key(position), position);
+          } catch (error2) {
+            try {
+              await this.unload(position);
+            } catch (cleanupError) {
+              const failure = error2 instanceof Error ? error2 : new Error(String(error2));
+              try {
+                Object.defineProperty(failure, "cause", { value: cleanupError, configurable: true });
+              } catch {
+                throw Object.assign(new Error(failure.message), { cause: cleanupError });
+              }
+              throw failure;
+            }
+            throw error2;
+          }
+        }
+      } finally {
+        this.running = void 0;
+      }
+    }
+    needsLoad(position) {
+      const key = this.key(position);
+      return !this.loaded.has(key) && !this.missing.has(key) && !this.failed.has(key);
+    }
+    async unload(position) {
+      await this.world.unloadChunkColumn(position.x, position.z);
+      this.owned.delete(this.key(position));
+      this.loaded.delete(this.key(position));
+    }
+    validateChunk(chunk, position) {
+      if (chunk.x !== position.x || chunk.z !== position.z) {
+        throw new Error(`World source returned chunk ${chunk.x},${chunk.z} for ${position.x},${position.z}`);
+      }
+    }
+    within(position, radius) {
+      return !!this.center && Math.abs(position.x - this.center.x) <= radius && Math.abs(position.z - this.center.z) <= radius;
+    }
+    key(position) {
+      return `${position.x},${position.z}`;
+    }
+  };
   return __toCommonJS(index_browser_exports);
 })();
 /*! Bundled license information: