minerender 2.1.0-alpha.86 → 2.1.0-alpha.88

package/dist/browser/index.js

@@ -191,6 +191,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;
 }
@@ -18688,6 +18705,7 @@ var index_browser_exports = {};
 __export(index_browser_exports, {
   AXES: () => AXES,
   AnvilParser: () => AnvilParser,
+  AnvilWorldSource: () => AnvilWorldSource,
   ArchiveAssetSource: () => ArchiveAssetSource,
   AssetKey: () => AssetKey,
   AssetLoadError: () => AssetLoadError,
@@ -18777,6 +18795,7 @@ __export(index_browser_exports, {
   SchematicParser: () => SchematicParser,
   SectionMesh: () => SectionMesh,
   SectionModels: () => SectionModels,
+  SectionWorker: () => SectionWorker,
   SkinImage: () => SkinImage,
   SkinObject: () => SkinObject,
   SkinPart: () => SkinPart,
@@ -18791,6 +18810,7 @@ __export(index_browser_exports, {
   TintColors: () => TintColors,
   UVMapper: () => UVMapper,
   VideoExporter: () => VideoExporter,
+  WorldStreamer: () => WorldStreamer,
   WrappedImage: () => WrappedImage,
   addBox3WireframeToObject: () => addBox3WireframeToObject,
   addWireframeToMesh: () => addWireframeToMesh,
@@ -18800,6 +18820,7 @@ __export(index_browser_exports, {
   axisToVec3: () => axisToVec3,
   base64decode: () => base64decode,
   base64encode: () => base64encode,
+  buildSectionGeometry: () => buildSectionGeometry,
   capeTextureSizes: () => capeTextureSizes,
   captureException: () => captureException,
   changeEvent: () => changeEvent,
@@ -18852,6 +18873,7 @@ __export(index_browser_exports, {
   sampleEntityAnimation: () => sampleEntityAnimation,
   sampleEntityKeyframes: () => sampleEntityKeyframes,
   sampleFluid: () => sampleFluid,
+  sectionGeometryTransferables: () => sectionGeometryTransferables,
   serializeBoxGeometryKey: () => serializeBoxGeometryKey,
   serializeImageKey: () => serializeImageKey,
   serializeMaterialKey: () => serializeMaterialKey,
@@ -18869,7 +18891,8 @@ __export(index_browser_exports, {
   toDegrees: () => toDegrees,
   toRadians: () => toRadians,
   toTrianglesDrawMode: () => toTrianglesDrawMode,
-  trimCanvas: () => trimCanvas
+  trimCanvas: () => trimCanvas,
+  yieldToEventLoop: () => yieldToEventLoop
 });
 module.exports = __toCommonJS(index_browser_exports);
 
@@ -18954,6 +18977,7 @@ function probeImageSize(data) {
 }
 
 // src/env/browser/BrowserEnv.ts
+var import_meta = {};
 var BrowserEnv = class {
   constructor() {
     this.name = "browser";
@@ -18981,6 +19005,14 @@ var BrowserEnv = class {
       version: version2
     }));
   }
+  createWorker(name) {
+    if (name !== "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 env = new BrowserEnv();
@@ -28634,6 +28666,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);
@@ -28661,10 +28703,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];
@@ -28701,9 +28743,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 };
@@ -28883,19 +28930,150 @@ 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;
   }
 };
 
+// src/world/AnvilWorldSource.ts
+init_MineRenderError();
+async function abortable2(promise, signal) {
+  if (!signal) return promise;
+  let abort;
+  const cancelled = new Promise((_, reject) => {
+    abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+  try {
+    return await Promise.race([promise, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+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 [name, value] of Object.entries({ maxCachedRegions: this.maxCachedRegions, maxCachedBytes: this.maxCachedBytes })) {
+      if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name} must be a nonnegative safe integer`);
+    }
+  }
+  /** Decodes one column at absolute chunk coordinates. Aborting a caller leaves other shared readers active. */
+  async getChunk(x, z, signal) {
+    if (!Number.isSafeInteger(x) || !Number.isSafeInteger(z)) {
+      throw new RangeError("Chunk column coordinates must be safe integers");
+    }
+    const regionX = Math.floor(x / 32), regionZ = Math.floor(z / 32);
+    const data = await this.getRegion(regionX, regionZ, signal);
+    signal?.throwIfAborted();
+    if (!data) return void 0;
+    const chunk = await abortable2(AnvilParser.parseChunk(data, x - regionX * 32, z - regionZ * 32), signal);
+    signal?.throwIfAborted();
+    if (chunk && (chunk.x !== x || chunk.z !== z)) {
+      throw new MineRenderError(`Anvil chunk coordinates ${chunk.x},${chunk.z} do not match requested column ${x},${z}`);
+    }
+    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(x, z, signal) {
+    signal?.throwIfAborted();
+    const key = `${x},${z}`;
+    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(x, z, 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 release = () => {
+        if (finished) return false;
+        finished = true;
+        signal?.removeEventListener("abort", abort);
+        read.waiters--;
+        return true;
+      };
+      const abort = () => {
+        if (!release()) 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", abort, { once: true });
+      read.promise.then(
+        (data) => {
+          if (release()) resolve(data);
+        },
+        (error) => {
+          if (release()) reject(error);
+        }
+      );
+      if (signal?.aborted) abort();
+    });
+  }
+  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/Chunk.ts
 var import_three42 = require("three");
 init_BlockStates();
@@ -28904,7 +29082,7 @@ init_AssetKey();
 // src/world/MineRenderWorld.ts
 var import_three40 = require("three");
 init_Model();
-init_BatchedExecutor();
+init_util();
 init_AssetKey();
 init_BlockStates();
 init_CubeFace();
@@ -29049,7 +29227,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) {
@@ -29066,8 +29244,10 @@ var MineRenderWorld = class {
     };
     const place = (block) => this.placeBlock(new import_three40.Vector3(...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);
     }
@@ -29076,6 +29256,23 @@ var MineRenderWorld = class {
       for (const block of multiblock.blocks) await place(block);
       return;
     }
+    if (!executor) {
+      const groups2 = /* @__PURE__ */ new Map();
+      const position = new import_three40.Vector3();
+      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(",");
@@ -29084,19 +29281,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);
-          })
-        ));
-        const failure = results.find((result) => result.status === "rejected");
-        if (failure?.status === "rejected") throw failure.reason;
+    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 ?? (positions = blocks.map(({ index }) => new import_three40.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) queue.stop();
     }
   }
   /** Replaces one chunk column's blocks. Entity NBT remains available on the parsed chunk. */
@@ -29104,7 +29316,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 import_three40.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);
@@ -29119,6 +29348,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()]);
     }
@@ -29159,19 +29389,23 @@ var MineRenderWorld = class {
     this.sectionModels?.clear();
   }
   updateCulling(positions) {
+    const neighbor = new import_three40.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 import_three40.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 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 import_three40.Vector3(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);
           }
         }
       }
@@ -29179,39 +29413,38 @@ var MineRenderWorld = class {
     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((x, y, z) => {
-                const neighbor = pos.clone().add(new import_three40.Vector3(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 import_three40.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((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;
@@ -29273,7 +29506,228 @@ init_Model();
 // src/world/SectionMesh.ts
 var import_three41 = require("three");
 init_CanvasCompat();
+init_CubeFace();
 init_Materials();
+
+// 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"));
+  }
+  /** 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;
+  }
+};
+_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 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 import_three41.Group {
   constructor() {
     super(...arguments);
@@ -29281,86 +29735,31 @@ var SectionMesh = class _SectionMesh extends import_three41.Group {
   }
   /** 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 = createCanvas(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 import_three41.BufferGeometry();
-      geometry.setAttribute("position", new import_three41.Float32BufferAttribute(positions, 3));
-      geometry.setAttribute("normal", new import_three41.Float32BufferAttribute(normals, 3));
-      geometry.setAttribute("uv", new import_three41.Float32BufferAttribute(uvs, 2));
-      geometry.setAttribute("uvBounds", new import_three41.Float32BufferAttribute(uvBounds, 4));
-      geometry.setAttribute("color", new import_three41.Float32BufferAttribute(colors, 3));
-      geometry.setIndex(indices);
+      geometry.setAttribute("position", new import_three41.Float32BufferAttribute(page.positions.buffer, 3));
+      geometry.setAttribute("normal", new import_three41.Float32BufferAttribute(page.normals.buffer, 3));
+      geometry.setAttribute("uv", new import_three41.Float32BufferAttribute(page.uvs.buffer, 2));
+      geometry.setAttribute("uvBounds", new import_three41.Float32BufferAttribute(page.uvBounds.buffer, 4));
+      geometry.setAttribute("color", new import_three41.Float32BufferAttribute(page.colors.buffer, 3));
+      geometry.setIndex(new import_three41.Uint32BufferAttribute(page.indices.buffer, 1));
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const material = Materials.createShadedCanvasMaterial(canvas, false, false, true);
@@ -29394,7 +29793,9 @@ var Chunk = class _Chunk {
     this.renderedBlocks = /* @__PURE__ */ new Map();
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
+    this.blockPosition = new import_three42.Vector3();
     this.meshDirty = false;
+    this.meshGeneration = 0;
     this.scene = scene;
     this.x = x;
     this.y = y;
@@ -29407,7 +29808,7 @@ var Chunk = class _Chunk {
     if (isTripleArray(posOrX)) {
       return this.getBlockAt(new import_three42.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);
   }
@@ -29431,48 +29832,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 import_three42.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 (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));
@@ -29493,15 +29927,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) {
@@ -29512,12 +29955,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) {
@@ -29525,7 +29973,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) {
@@ -29534,6 +29981,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;
@@ -29570,4 +30018,178 @@ var Chunk = class _Chunk {
     );
   }
 };
+
+// src/world/WorldStreamer.ts
+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(x, z) {
+    if (this.disposed) throw new Error("WorldStreamer is disposed");
+    if (![x, z].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 !== x || this.center.z !== z) {
+      this.center = { x, z };
+      this.desired = [];
+      for (let dz = -this.loadRadius; dz <= this.loadRadius; dz++) {
+        for (let dx = -this.loadRadius; dx <= this.loadRadius; dx++) {
+          this.desired.push({ x: x + dx, z: z + dz });
+        }
+      }
+      this.desired.sort((a, b) => (a.x - x) ** 2 + (a.z - z) ** 2 - (b.x - x) ** 2 - (b.z - z) ** 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 (error) {
+          failed = true;
+          failure ?? (failure = error);
+        }
+      }
+      this.missing.clear();
+      this.failed.clear();
+      if (failed) throw failure;
+    }).catch((error) => {
+      this.disposal = void 0;
+      throw error;
+    }));
+  }
+  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 (error) {
+          if (!controller.signal.aborted && !this.disposed && this.within(position, this.loadRadius)) {
+            this.failed.set(this.key(position), { ...position, error });
+          }
+          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 (error) {
+          try {
+            await this.unload(position);
+          } catch (cleanupError) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            try {
+              Object.defineProperty(failure, "cause", { value: cleanupError, configurable: true });
+            } catch {
+              throw Object.assign(new Error(failure.message), { cause: cleanupError });
+            }
+            throw failure;
+          }
+          throw error;
+        }
+      }
+    } 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}`;
+  }
+};
 //# sourceMappingURL=index.js.map