minerender 2.1.0-alpha.87 → 2.1.0-alpha.89

package/dist/bundle.js

@@ -21996,8 +21996,8 @@ var MineRender = (() => {
         }
       }
     }
-    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer2) {
-      if (integer2 === true) {
+    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer3) {
+      if (integer3 === true) {
         gl.vertexAttribIPointer(index, size, type, stride, offset);
       } else {
         gl.vertexAttribPointer(index, size, type, normalized, stride, offset);
@@ -22024,7 +22024,7 @@ var MineRender = (() => {
             const buffer2 = attribute.buffer;
             const type = attribute.type;
             const bytesPerElement = attribute.bytesPerElement;
-            const integer2 = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType;
+            const integer3 = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType;
             if (geometryAttribute.isInterleavedBufferAttribute) {
               const data = geometryAttribute.data;
               const stride = data.stride;
@@ -22050,7 +22050,7 @@ var MineRender = (() => {
                   normalized,
                   stride * bytesPerElement,
                   (offset + size / programAttribute.locationSize * i4) * bytesPerElement,
-                  integer2
+                  integer3
                 );
               }
             } else {
@@ -22075,7 +22075,7 @@ var MineRender = (() => {
                   normalized,
                   size * bytesPerElement,
                   size / programAttribute.locationSize * i4 * bytesPerElement,
-                  integer2
+                  integer3
                 );
               }
             }
@@ -39810,6 +39810,23 @@ void main() {
       setTimeout(() => resolve(), timeout);
     });
   }
+  function yieldToEventLoop() {
+    const scheduler = globalThis.scheduler;
+    if (scheduler?.yield) return scheduler.yield();
+    return new Promise((resolve) => {
+      if (typeof MessageChannel !== "undefined") {
+        const channel = new MessageChannel();
+        channel.port1.onmessage = () => {
+          channel.port1.close();
+          channel.port2.close();
+          resolve();
+        };
+        channel.port2.postMessage(void 0);
+      } else {
+        setTimeout(resolve, 0);
+      }
+    });
+  }
   function clampRotationDegrees(deg) {
     return deg % 360;
   }
@@ -99623,7 +99640,7 @@ return ${compiler2.callType("value", tagType)}
   });
 
   // ../../node_modules/@zip.js/zip.js/lib/zip-fs.js
-  var import_meta, baseURL;
+  var import_meta2, baseURL;
   var init_zip_fs = __esm({
     "../../node_modules/@zip.js/zip.js/lib/zip-fs.js"() {
       init_dirname();
@@ -99638,9 +99655,9 @@ return ${compiler2.callType("value", tagType)}
       init_zip_reader();
       init_zip_writer();
       init_zip_fs_core();
-      import_meta = {};
+      import_meta2 = {};
       try {
-        baseURL = import_meta.url;
+        baseURL = import_meta2.url;
       } catch (_4) {
       }
       configure({ baseURL });
@@ -106568,12 +106585,14 @@ ${shader.fragmentShader}`.replace(
     SchematicParser: () => SchematicParser,
     SectionMesh: () => SectionMesh,
     SectionModels: () => SectionModels,
+    SectionWorker: () => SectionWorker,
     SkinImage: () => SkinImage,
     SkinObject: () => SkinObject,
     SkinPart: () => SkinPart,
     SkinTextures: () => SkinTextures,
     Skins: () => Skins,
     SpecialItems: () => SpecialItems,
+    SpongeSchematicParser: () => SpongeSchematicParser,
     StructureParser: () => StructureParser,
     TextureAtlas: () => TextureAtlas,
     TextureLoader: () => TextureLoader2,
@@ -106592,6 +106611,7 @@ ${shader.fragmentShader}`.replace(
     axisToVec3: () => axisToVec3,
     base64decode: () => base64decode,
     base64encode: () => base64encode,
+    buildSectionGeometry: () => buildSectionGeometry,
     capeTextureSizes: () => capeTextureSizes,
     captureException: () => captureException,
     changeEvent: () => changeEvent,
@@ -106644,6 +106664,7 @@ ${shader.fragmentShader}`.replace(
     sampleEntityAnimation: () => sampleEntityAnimation,
     sampleEntityKeyframes: () => sampleEntityKeyframes,
     sampleFluid: () => sampleFluid,
+    sectionGeometryTransferables: () => sectionGeometryTransferables,
     serializeBoxGeometryKey: () => serializeBoxGeometryKey,
     serializeImageKey: () => serializeImageKey,
     serializeMaterialKey: () => serializeMaterialKey,
@@ -106661,7 +106682,8 @@ ${shader.fragmentShader}`.replace(
     toDegrees: () => toDegrees,
     toRadians: () => toRadians,
     toTrianglesDrawMode: () => toTrianglesDrawMode,
-    trimCanvas: () => trimCanvas
+    trimCanvas: () => trimCanvas,
+    yieldToEventLoop: () => yieldToEventLoop
   });
   init_dirname();
   init_buffer2();
@@ -106762,6 +106784,7 @@ ${shader.fragmentShader}`.replace(
   }
 
   // src/env/browser/BrowserEnv.ts
+  var import_meta = {};
   var BrowserEnv = class {
     constructor() {
       this.name = "browser";
@@ -106789,6 +106812,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();
@@ -111337,46 +111368,46 @@ property list uchar int vertex_index
   }
   var BlockStateResolver = class {
     /** Loads vanilla property defaults, falling back to preview values inferred from the blockstate file. */
-    static async defaults(blockState) {
-      const defaults = blockState.key ? await BlockStates.getDefaultState(blockState.key) : void 0;
+    static async defaults(blockState2) {
+      const defaults = blockState2.key ? await BlockStates.getDefaultState(blockState2.key) : void 0;
       const state = {};
       if (defaults && Object.keys(defaults).length > 0) {
         for (const key in defaults) state[key] = defaults[key].default;
-      } else if (blockState.variants) {
-        const variant = Object.keys(blockState.variants)[0];
+      } else if (blockState2.variants) {
+        const variant = Object.keys(blockState2.variants)[0];
         if (variant) {
           for (const property of variant.split(",")) {
             const [key, value] = property.split("=");
             state[key] = value;
           }
         }
-      } else if (blockState.multipart) {
-        const condition = blockState.multipart.map((part) => part.when).find((when) => when !== void 0 && Object.values(when).every((value) => typeof value === "string"));
+      } else if (blockState2.multipart) {
+        const condition = blockState2.multipart.map((part) => part.when).find((when) => when !== void 0 && Object.values(when).every((value) => typeof value === "string"));
         for (const [key, value] of Object.entries(condition ?? {})) state[key] = value.split("|")[0];
       }
       return state;
     }
     /** Selects matching models. Supply `choose` to control selection within each alternatives array. */
-    static select(blockState, state, choose = this.choose) {
-      return this.matching(blockState, state).map(choose);
+    static select(blockState2, state, choose = this.choose) {
+      return this.matching(blockState2, state).map(choose);
     }
     /** Returns matching model groups before choosing weighted alternatives. */
-    static matching(blockState, state) {
+    static matching(blockState2, state) {
       const out = [];
-      if (blockState.variants) {
-        if (Object.keys(blockState.variants).length === 1 && "" in blockState.variants) {
-          out.push(blockState.variants[""]);
+      if (blockState2.variants) {
+        if (Object.keys(blockState2.variants).length === 1 && "" in blockState2.variants) {
+          out.push(blockState2.variants[""]);
         } else {
-          for (const variantKey in blockState.variants) {
+          for (const variantKey in blockState2.variants) {
             const matches = variantKey.split(",").every((property) => {
               const [key, value] = property.split("=");
               return `${state[key]}` === `${value}`;
             });
-            if (matches) out.push(blockState.variants[variantKey]);
+            if (matches) out.push(blockState2.variants[variantKey]);
           }
         }
-      } else if (blockState.multipart) {
-        for (const part of blockState.multipart) {
+      } else if (blockState2.multipart) {
+        for (const part of blockState2.multipart) {
           if (part.apply && (!part.when || matchesCondition(part.when, state))) {
             out.push(part.apply);
           }
@@ -111515,9 +111546,9 @@ property list uchar int vertex_index
   init_FluidGeometry();
   init_Entities();
   var _BlockObject = class _BlockObject extends SceneObject {
-    constructor(blockState, options) {
+    constructor(blockState2, options) {
       super(options);
-      this.blockState = blockState;
+      this.blockState = blockState2;
       this.isBlockObject = true;
       this._previousState = {};
       this._state = {};
@@ -113712,6 +113743,160 @@ property list uchar int vertex_index
     throw new MineRenderError(`Schematic ${name2} must be a compound list`);
   }
 
+  // src/model/multiblock/SpongeSchematicParser.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_MineRenderError();
+  var SpongeSchematicParser = class {
+    /**
+     * Parses decoded NBT with a local block palette, omitting air blocks.
+     * Applies Offset to block and entity positions; size remains the source dimensions.
+     * Biomes and metadata are not imported, and DataVersion does not trigger migration.
+     */
+    static async parse(nbt) {
+      const tags = nbt.value.Schematic === void 0 ? nbt.value : compound(nbt.value.Schematic, "Schematic");
+      const version3 = integer2(tags.Version, "Version");
+      if (version3 !== 2 && version3 !== 3) {
+        throw new MineRenderError(`Unsupported Sponge schematic version ${version3}; expected 2 or 3`);
+      }
+      const dataVersion = integer2(tags.DataVersion, "DataVersion");
+      const size = ["Width", "Height", "Length"].map((name2) => {
+        const tag = tags[name2];
+        if (tag?.type !== "short" || !Number.isInteger(tag.value) || tag.value < -32768 || tag.value > 65535 || tag.value === 0) {
+          throw new MineRenderError(`Sponge schematic ${name2} must be a positive unsigned short`);
+        }
+        return tag.value & 65535;
+      });
+      const offset = tags.Offset === void 0 ? [0, 0, 0] : intPosition(tags.Offset, "Offset");
+      const blocks = [];
+      const container = version3 === 2 ? tags : tags.Blocks === void 0 ? void 0 : compound(tags.Blocks, "Blocks");
+      if (container) {
+        const paletteTag = container.Palette;
+        if (!paletteTag) throw new MineRenderError("Sponge schematic requires a local Palette; global block IDs are not supported");
+        const palette = /* @__PURE__ */ new Map();
+        const paletteMax = version3 === 2 && tags.PaletteMax !== void 0 ? integer2(tags.PaletteMax, "PaletteMax") : void 0;
+        if (paletteMax !== void 0 && paletteMax <= 0) throw new MineRenderError("Sponge schematic PaletteMax must be positive");
+        for (const [state, tag] of Object.entries(compound(paletteTag, "Palette"))) {
+          const id = integer2(tag, "Palette index");
+          if (id < 0 || palette.has(id) || paletteMax !== void 0 && id >= paletteMax) {
+            throw new MineRenderError(`Invalid or duplicate Sponge schematic palette index ${id}`);
+          }
+          palette.set(id, blockState(state));
+        }
+        const [width, height, length] = size;
+        const volume = width * height * length;
+        const data = container[version3 === 2 ? "BlockData" : "Data"];
+        if (data?.type !== "byteArray" || !Array.isArray(data.value) || data.value.length < volume) {
+          throw new MineRenderError(`Sponge schematic block data must contain ${volume} varints`);
+        }
+        const blockEntities = /* @__PURE__ */ new Map();
+        for (const entity of compoundList2(container, "BlockEntities")) {
+          const pos = intPosition(entity.Pos, "BlockEntities Pos");
+          if (pos.some((value2, axis) => value2 < 0 || value2 >= size[axis])) {
+            throw new MineRenderError("Sponge schematic block entity position is outside its dimensions");
+          }
+          const index = pos[0] + pos[2] * width + pos[1] * width * length;
+          if (blockEntities.has(index)) throw new MineRenderError(`Duplicate Sponge schematic block entity at index ${index}`);
+          const value = entityData(entity, version3);
+          for (const [axis, name2] of ["x", "y", "z"].entries()) {
+            value[name2] = { type: "int", value: pos[axis] + offset[axis] };
+          }
+          blockEntities.set(index, { type: "compound", value });
+        }
+        let cursor = 0;
+        for (let index = 0; index < volume; index++) {
+          let id = 0;
+          for (let shift = 0; ; shift += 7) {
+            const byte = data.value[cursor++];
+            if (!Number.isInteger(byte) || byte < -128 || byte > 255) {
+              throw new MineRenderError(`Invalid or truncated Sponge schematic varint at index ${index}`);
+            }
+            const unsigned = byte & 255;
+            if (shift === 28 && unsigned > 7) {
+              throw new MineRenderError(`Sponge schematic varint exceeds a nonnegative int at index ${index}`);
+            }
+            id += (unsigned & 127) * 2 ** shift;
+            if ((unsigned & 128) === 0) break;
+          }
+          const state = palette.get(id);
+          if (!state) throw new MineRenderError(`Sponge schematic palette index ${id} does not exist`);
+          if (["minecraft:air", "minecraft:cave_air", "minecraft:void_air"].includes(state.type)) continue;
+          blocks.push({
+            type: state.type,
+            properties: { ...state.properties },
+            position: [
+              index % width + offset[0],
+              Math.floor(index / (width * length)) + offset[1],
+              Math.floor(index / width) % length + offset[2]
+            ],
+            nbt: blockEntities.get(index)
+          });
+        }
+        if (cursor !== data.value.length) throw new MineRenderError("Sponge schematic block data has trailing bytes");
+      }
+      const entities = compoundList2(tags, "Entities").map((entity) => {
+        const pos = entity.Pos;
+        if (pos?.type !== "list" || pos.value.type !== "double" || pos.value.value.length !== 3 || !pos.value.value.every(Number.isFinite)) {
+          throw new MineRenderError("Sponge schematic entity Pos must contain three doubles");
+        }
+        const position = pos.value.value.map((value2, axis) => value2 + offset[axis]);
+        const value = entityData(entity, version3);
+        value.Pos = { type: "list", value: { type: "double", value: [...position] } };
+        return { position, nbt: { type: "compound", value } };
+      });
+      return { size, blocks, entities, dataVersion };
+    }
+  };
+  function integer2(tag, name2) {
+    if (tag?.type !== "int" || !Number.isInteger(tag.value) || tag.value < -2147483648 || tag.value > 2147483647) {
+      throw new MineRenderError(`Sponge schematic ${name2} must be an int`);
+    }
+    return tag.value;
+  }
+  function compound(tag, name2) {
+    if (tag?.type !== "compound" || !tag.value || typeof tag.value !== "object" || Array.isArray(tag.value)) {
+      throw new MineRenderError(`Sponge schematic ${name2} must be a compound`);
+    }
+    return tag.value;
+  }
+  function intPosition(tag, name2) {
+    if (tag?.type !== "intArray" || !Array.isArray(tag.value) || tag.value.length !== 3 || !tag.value.every((value) => Number.isInteger(value) && value >= -2147483648 && value <= 2147483647)) {
+      throw new MineRenderError(`Sponge schematic ${name2} must contain three ints`);
+    }
+    return [...tag.value];
+  }
+  function compoundList2(tags, name2) {
+    const tag = tags[name2];
+    if (tag === void 0) return [];
+    if (tag.type === "list" && Array.isArray(tag.value.value)) {
+      if (tag.value.value.length === 0) return [];
+      if (tag.value.type === "compound") return tag.value.value;
+    }
+    throw new MineRenderError(`Sponge schematic ${name2} must be a compound list`);
+  }
+  function blockState(state) {
+    const match = /^((?:[a-z0-9_.-]+:)?[a-z0-9_./-]+)(?:\[([^\[\]]*)\])?$/.exec(state);
+    if (!match) throw new MineRenderError(`Invalid Sponge schematic block state ${state}`);
+    const properties = {};
+    if (match[2]) {
+      for (const entry of match[2].split(",")) {
+        const pair = /^([a-z0-9_]+)=([^\s=,\[\]]+)$/.exec(entry);
+        if (!pair || Object.prototype.hasOwnProperty.call(properties, pair[1])) throw new MineRenderError(`Invalid Sponge schematic block state ${state}`);
+        Object.defineProperty(properties, pair[1], { value: pair[2], enumerable: true, writable: true, configurable: true });
+      }
+    }
+    return { type: match[1].includes(":") ? match[1] : `minecraft:${match[1]}`, properties };
+  }
+  function entityData(entity, version3) {
+    const id = entity.Id;
+    if (id?.type !== "string" || !id.value) throw new MineRenderError("Sponge schematic entity Id must be a nonempty string");
+    const { Id, Pos, ...extra } = entity;
+    const value = version3 === 2 ? extra : entity.Data === void 0 ? {} : { ...compound(entity.Data, "entity Data") };
+    value.id = { type: "string", value: id.value.includes(":") ? id.value : `minecraft:${id.value}` };
+    return value;
+  }
+
   // src/model/multiblock/StructureParser.ts
   init_dirname();
   init_buffer2();
@@ -114971,8 +115156,8 @@ property list uchar int vertex_index
      * Set `options.initialState` to choose block properties such as `facing` or `axis`.
      * Use the returned object's `setPosition` method to move all of its model parts.
      */
-    async addBlock(blockState, options, parent = this) {
-      return this.addSceneObject(blockState, () => new BlockObject(blockState, options), options, parent);
+    async addBlock(blockState2, options, parent = this) {
+      return this.addSceneObject(blockState2, () => new BlockObject(blockState2, options), options, parent);
     }
     /**
      * Loads a skin and adds an initialized player model.
@@ -118755,6 +118940,16 @@ gl_FragDepth=readDepth(vUv);
   init_buffer2();
   init_process2();
   init_AssetKey();
+  var blockKeys = /* @__PURE__ */ new Map();
+  function blockKey(type) {
+    let key = blockKeys.get(type);
+    if (!key) {
+      key = AssetKey.parse("blockstates", type);
+      if (blockKeys.size >= 4096) blockKeys.clear();
+      blockKeys.set(type, key);
+    }
+    return key;
+  }
   var ChunkData = class _ChunkData {
     constructor() {
       this.indices = new Uint16Array(4096);
@@ -118782,10 +118977,10 @@ gl_FragDepth=readDepth(vUv);
       let key;
       let nbt;
       if (block && !_ChunkData.isAir(block)) {
-        const type = AssetKey.parse("blockstates", block.type).toNamespacedString();
+        const type = blockKey(block.type).toNamespacedString();
         const properties = Object.fromEntries(Object.keys(block.properties ?? {}).sort().map((name2) => [name2, block.properties[name2]]));
         state = Object.freeze(Object.keys(properties).length ? { type, properties: Object.freeze(properties) } : { type });
-        key = JSON.stringify([type, properties]);
+        key = _ChunkData.paletteKey(block);
         if (block.nbt !== void 0) nbt = structuredClone(block.nbt);
       }
       const previousId = this.indices[index];
@@ -118822,9 +119017,14 @@ gl_FragDepth=readDepth(vUv);
     }
     static isAir(block) {
       if (typeof block === "undefined" || typeof block.type === "undefined") return true;
-      const key = AssetKey.parse("blockstates", block.type);
+      const key = blockKey(block.type);
       return key.namespace === "minecraft" && !key.type && ["air", "cave_air", "void_air"].includes(key.path);
     }
+    /** Identifies a normalized block type and its sorted properties, excluding per-cell NBT. */
+    static paletteKey(block) {
+      const properties = Object.fromEntries(Object.keys(block.properties ?? {}).sort().map((name2) => [name2, block.properties[name2]]));
+      return JSON.stringify([blockKey(block.type).toNamespacedString(), properties]);
+    }
     static copyBlock(state, nbt) {
       const block = { type: state.type };
       if (state.properties) block.properties = { ...state.properties };
@@ -119004,14 +119204,17 @@ gl_FragDepth=readDepth(vUv);
       const perLong = Math.floor(64 / bits2);
       const expected = padded ? Math.ceil(4096 / perLong) : Math.ceil(4096 * bits2 / 64);
       if (tag.value.length !== expected) throw new MineRenderError(`Invalid Anvil block-state array length: expected ${expected}`);
-      const words = tag.value.map(([high, low]) => BigInt(high >>> 0) << 32n | BigInt(low >>> 0));
-      const mask = (1n << BigInt(bits2)) - 1n;
+      const words = tag.value.map(([high, low]) => [high >>> 0, low >>> 0]);
+      const mask = (1 << bits2) - 1;
       for (let index = 0; index < 4096; index++) {
-        const word = padded ? Math.floor(index / perLong) : Math.floor(index * bits2 / 64);
-        const shift = padded ? index % perLong * bits2 : index * bits2 % 64;
-        let value = words[word] >> BigInt(shift);
-        if (!padded && shift + bits2 > 64) value |= words[word + 1] << BigInt(64 - shift);
-        indices[index] = Number(value & mask);
+        const bitPos = index * bits2;
+        const word = padded ? Math.floor(index / perLong) : bitPos >>> 6;
+        const shift = padded ? index % perLong * bits2 : bitPos & 63;
+        const [high, low] = words[word];
+        let value = shift < 32 ? low >>> shift : high >>> shift - 32;
+        if (shift < 32 && shift + bits2 > 32) value += high * 2 ** (32 - shift);
+        if (!padded && shift + bits2 > 64) value += words[word + 1][1] * 2 ** (64 - shift);
+        indices[index] = value & mask;
       }
       return indices;
     }
@@ -119167,7 +119370,7 @@ gl_FragDepth=readDepth(vUv);
   init_process2();
   init_three_module();
   init_Model();
-  init_BatchedExecutor();
+  init_util();
   init_AssetKey();
   init_BlockStates();
   init_CubeFace();
@@ -119207,18 +119410,18 @@ gl_FragDepth=readDepth(vUv);
       if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("maxAtlasSize must be a positive integer");
     }
     /** Returns a cube template, or `undefined` when the block requires an individual render object. */
-    async get(blockState, properties = {}) {
-      if (!blockState.variants || blockState.multipart) return void 0;
-      let states = this.states.get(blockState);
-      if (!states) this.states.set(blockState, states = /* @__PURE__ */ new Map());
+    async get(blockState2, properties = {}) {
+      if (!blockState2.variants || blockState2.multipart) return void 0;
+      let states = this.states.get(blockState2);
+      if (!states) this.states.set(blockState2, states = /* @__PURE__ */ new Map());
       const key = JSON.stringify(Object.entries(properties).sort(([a4], [b4]) => a4.localeCompare(b4)));
-      const prepared = await cached(states, key, () => this.prepare(blockState, properties));
+      const prepared = await cached(states, key, () => this.prepare(blockState2, properties));
       if (!prepared) return void 0;
       return prepared.templates.get(BlockStateResolver.choose(prepared.variants));
     }
-    async prepare(blockState, properties) {
-      const state = { ...await BlockStateResolver.defaults(blockState), ...properties };
-      const groups = BlockStateResolver.matching(blockState, state);
+    async prepare(blockState2, properties) {
+      const state = { ...await BlockStateResolver.defaults(blockState2), ...properties };
+      const groups = BlockStateResolver.matching(blockState2, state);
       if (groups.length !== 1) return void 0;
       const variants = groups[0];
       const choices = Array.isArray(variants) ? variants : [variants];
@@ -119230,7 +119433,7 @@ gl_FragDepth=readDepth(vUv);
         const atlas = await UVMapper.getAtlas(model);
         const rotation = BlockStateResolver.rotation(variant);
         if (!atlas || atlas.hasAnimation || !ModelCulling.isOpaqueFullCube(atlas) || atlas.image.width > this.maxAtlasSize || atlas.image.height > this.maxAtlasSize || ModelCulling.toLocalMask(63, rotation) !== 63) return void 0;
-        const tints = await BlockTints.get(blockState.key, state, model);
+        const tints = await BlockTints.get(blockState2.key, state, model);
         let models = this.models.get(model);
         if (!models) this.models.set(model, models = /* @__PURE__ */ new Map());
         const key = JSON.stringify([rotation.x, rotation.y, rotation.z, variant.uvlock, tints]);
@@ -119315,7 +119518,7 @@ gl_FragDepth=readDepth(vUv);
      * Places a structure's blocks at their stored positions, then refreshes neighboring faces.
      * Entity NBT is retained by the structure but is not rendered.
      *
-     * @param useBatches - Uses bounded batches by default. Set to `false` for sequential placement.
+     * @param useBatches - Yields between chunks by default. Set to `false` for sequential placement.
      * @param executor - Optional queue for batched placement. The caller remains responsible for stopping it.
      */
     async placeMultiBlock(multiblock, useBatches = true, executor) {
@@ -119332,8 +119535,10 @@ gl_FragDepth=readDepth(vUv);
       };
       const place = (block) => this.placeBlock(new Vector3(...block.position), block, collect);
       const keys = /* @__PURE__ */ new Map();
+      const types2 = /* @__PURE__ */ new Set();
       for (const block of multiblock.blocks) {
-        if (Chunk.isAir(block)) continue;
+        if (Chunk.isAir(block) || types2.has(block.type)) continue;
+        types2.add(block.type);
         const key = AssetKey.parse("blockstates", block.type);
         keys.set(key.serialize(), key);
       }
@@ -119342,6 +119547,23 @@ gl_FragDepth=readDepth(vUv);
         for (const block of multiblock.blocks) await place(block);
         return;
       }
+      if (!executor) {
+        const groups2 = /* @__PURE__ */ new Map();
+        const position = new Vector3();
+        for (const block of multiblock.blocks) {
+          const [x4, y5, z4] = block.position;
+          this.validatePosBounds(position.set(x4, y5, z4));
+          const cx = Math.floor(x4 / 16), cy = Math.floor(y5 / 16), cz = Math.floor(z4 / 16);
+          const key = `${cx}_${cy}_${cz}`;
+          const chunk = this._chunks.get(key) ?? (Chunk.isAir(block) ? void 0 : this.getOrCreateChunkAt(position));
+          if (!chunk) continue;
+          let group = groups2.get(chunk);
+          if (!group) groups2.set(chunk, group = []);
+          group.push({ index: (y5 - cy * 16) * 256 + (z4 - cz * 16) * 16 + x4 - cx * 16, block });
+        }
+        await this.placeChunkGroups(groups2, changes);
+        return;
+      }
       const positions = /* @__PURE__ */ new Map();
       for (const block of multiblock.blocks) {
         const key = block.position.join(",");
@@ -119350,19 +119572,34 @@ gl_FragDepth=readDepth(vUv);
         else positions.set(key, [block]);
       }
       const groups = [...positions.values()];
-      const queue2 = executor ?? new BatchedExecutor();
-      try {
-        for (let i4 = 0; i4 < groups.length; i4 += queue2.batch) {
-          const results = await Promise.allSettled(groups.slice(i4, i4 + queue2.batch).map(
-            (blocks) => queue2.submit(async () => {
-              for (const block of blocks) await place(block);
-            })
-          ));
-          const failure = results.find((result) => result.status === "rejected");
-          if (failure?.status === "rejected") throw failure.reason;
+      for (let i4 = 0; i4 < groups.length; i4 += executor.batch) {
+        const results = await Promise.allSettled(groups.slice(i4, i4 + executor.batch).map(
+          (blocks) => executor.submit(async () => {
+            for (const block of blocks) await place(block);
+          })
+        ));
+        const failure = results.find((result) => result.status === "rejected");
+        if (failure?.status === "rejected") throw failure.reason;
+      }
+    }
+    async placeChunkGroups(groups, changes) {
+      let sliceStart = performance.now();
+      for (const [chunk, blocks] of groups) {
+        let positions;
+        try {
+          positions = await chunk.placeBlocks(blocks);
+        } finally {
+          positions ?? (positions = blocks.map(({ index }) => new Vector3(
+            chunk.x * 16 + index % 16,
+            chunk.y * 16 + Math.floor(index / 256),
+            chunk.z * 16 + Math.floor(index / 16) % 16
+          )));
+          for (const pos of positions) changes.set(`${pos.x},${pos.y},${pos.z}`, pos);
+        }
+        if (performance.now() - sliceStart > 8) {
+          await yieldToEventLoop();
+          sliceStart = performance.now();
         }
-      } finally {
-        if (!executor) queue2.stop();
       }
     }
     /** Replaces one chunk column's blocks. Entity NBT remains available on the parsed chunk. */
@@ -119370,7 +119607,24 @@ gl_FragDepth=readDepth(vUv);
       const changes = /* @__PURE__ */ new Map();
       try {
         await this.clearChunkColumn(chunk.x, chunk.z, changes);
+        const groups = /* @__PURE__ */ new Map();
         for (const section of chunk.sections) {
+          if (!executor) {
+            const blocks2 = [];
+            for (let index = 0; index < 4096; index++) {
+              const block = section.data.get(index);
+              if (block) blocks2.push({ index, block });
+            }
+            if (blocks2.length) {
+              const position = new Vector3(chunk.x * 16, section.y * 16, chunk.z * 16);
+              this.validatePosBounds(position);
+              const target = this.getOrCreateChunkAt(position);
+              const previous = groups.get(target);
+              if (previous) previous.push(...blocks2);
+              else groups.set(target, blocks2);
+            }
+            continue;
+          }
           const blocks = [];
           for (let index = 0; index < 4096; index++) {
             const block = section.data.get(index);
@@ -119385,6 +119639,7 @@ gl_FragDepth=readDepth(vUv);
           }
           await this.placeBlocks({ size: [16, 16, 16], blocks }, true, executor, changes);
         }
+        if (!executor) await this.placeChunkGroups(groups, changes);
       } finally {
         await this.updateCulling([...changes.values()]);
       }
@@ -119425,19 +119680,23 @@ gl_FragDepth=readDepth(vUv);
       this.sectionModels?.clear();
     }
     updateCulling(positions) {
+      const neighbor = new Vector3();
       for (const pos of positions) {
-        this.pendingCulling.set(pos.toArray().join(","), pos.clone());
-        for (const offset of CUBE_FACE_OFFSETS) {
-          const neighbor = pos.clone().add(new Vector3(...offset));
-          this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
-        }
+        const cx = Math.floor(pos.x / 16), cy = Math.floor(pos.y / 16), cz = Math.floor(pos.z / 16);
+        const chunk = this._chunks.get(`${cx}_${cy}_${cz}`);
+        const lx = pos.x - cx * 16, ly = pos.y - cy * 16, lz = pos.z - cz * 16;
         for (let y5 = -1; y5 <= 1; y5++) {
           for (let z4 = -1; z4 <= 1; z4++) {
             for (let x4 = -1; x4 <= 1; x4++) {
-              const neighbor = pos.clone().add(new Vector3(x4, y5, z4));
-              if (this.getBlockAt(neighbor)?.object?.fluidKind) {
-                this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
-              }
+              const nx = lx + x4, ny = ly + y5, nz = lz + z4;
+              const section = nx >= 0 && nx < 16 && ny >= 0 && ny < 16 && nz >= 0 && nz < 16 ? chunk : this._chunks.get(`${cx + Math.floor(nx / 16)}_${cy + Math.floor(ny / 16)}_${cz + Math.floor(nz / 16)}`);
+              if (!section) continue;
+              const index = (ny & 15) * 256 + (nz & 15) * 16 + (nx & 15);
+              let pending = this.pendingCulling.get(section);
+              if (pending?.has(index)) continue;
+              if (Math.abs(x4) + Math.abs(y5) + Math.abs(z4) > 1 && !section.getBlockAt(neighbor.set(pos.x + x4, pos.y + y5, pos.z + z4))?.object?.fluidKind) continue;
+              if (!pending) this.pendingCulling.set(section, pending = /* @__PURE__ */ new Set());
+              pending.add(index);
             }
           }
         }
@@ -119445,39 +119704,38 @@ gl_FragDepth=readDepth(vUv);
       return this.culling ?? (this.culling = Promise.resolve().then(async () => {
         try {
           while (this.pendingCulling.size) {
-            const batch = [...this.pendingCulling.values()];
+            const batch = [...this.pendingCulling];
             this.pendingCulling.clear();
-            const changed = /* @__PURE__ */ new Set();
-            for (const pos of batch) {
-              const chunk = this.getChunkAt(pos);
-              if (!chunk) continue;
-              changed.add(chunk);
-              const block = chunk.getBlockAt(pos);
-              if (!block || !chunk.isBlockVisibleAt(pos)) {
-                continue;
-              }
-              if (block.object?.fluidKind) {
-                await block.object.updateFluid((x4, y5, z4) => {
-                  const neighbor = pos.clone().add(new Vector3(x4, y5, z4));
-                  const section = this.getChunkAt(neighbor);
-                  const object3 = section?.isBlockVisibleAt(neighbor) ? section.getBlockAt(neighbor)?.object : void 0;
-                  return {
-                    fluid: object3?.fluidKind,
-                    level: object3?.fluidLevel,
-                    solid: section?.isOccludingAt(neighbor) ?? false
-                  };
-                });
-              }
-              let mask = 0;
-              for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-                const neighbor = pos.clone().add(new Vector3(...offset));
-                if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
-                  mask |= 1 << face;
+            for (const [chunk, indices] of batch) {
+              for (const index of indices) {
+                if (!chunk.isBlockVisibleIndex(index)) continue;
+                const lx = index % 16, ly = Math.floor(index / 256), lz = Math.floor(index / 16) % 16;
+                const wx = chunk.x * 16 + lx, wy = chunk.y * 16 + ly, wz = chunk.z * 16 + lz;
+                const block = chunk.getBlockAt(neighbor.set(wx, wy, wz));
+                if (block.object?.fluidKind) {
+                  await block.object.updateFluid((x4, y5, z4) => {
+                    const nx = lx + x4, ny = ly + y5, nz = lz + z4;
+                    const section = nx >= 0 && nx < 16 && ny >= 0 && ny < 16 && nz >= 0 && nz < 16 ? chunk : this._chunks.get(`${chunk.x + Math.floor(nx / 16)}_${chunk.y + Math.floor(ny / 16)}_${chunk.z + Math.floor(nz / 16)}`);
+                    const neighborIndex = (ny & 15) * 256 + (nz & 15) * 16 + (nx & 15);
+                    const object3 = section?.isBlockVisibleIndex(neighborIndex) ? section.getBlockAt(neighbor.set(wx + x4, wy + y5, wz + z4))?.object : void 0;
+                    return {
+                      fluid: object3?.fluidKind,
+                      level: object3?.fluidLevel,
+                      solid: section?.isOccludingIndex(neighborIndex) ?? false
+                    };
+                  });
+                }
+                let mask = 0;
+                for (let face = 0; face < CUBE_FACE_OFFSETS.length; face++) {
+                  const offset = CUBE_FACE_OFFSETS[face];
+                  const nx = lx + offset[0], ny = ly + offset[1], nz = lz + offset[2];
+                  const section = nx >= 0 && nx < 16 && ny >= 0 && ny < 16 && nz >= 0 && nz < 16 ? chunk : this._chunks.get(`${chunk.x + Math.floor(nx / 16)}_${chunk.y + Math.floor(ny / 16)}_${chunk.z + Math.floor(nz / 16)}`);
+                  if (section?.isOccludingIndex((ny & 15) * 256 + (nz & 15) * 16 + (nx & 15))) mask |= 1 << face;
                 }
+                await chunk.setCullMaskIndex(index, mask);
               }
-              await chunk.setCullMaskAt(pos, mask);
             }
-            for (const chunk of changed) chunk.rebuildSectionMesh();
+            await Promise.all(batch.map(([chunk]) => chunk.rebuildSectionMesh()));
           }
         } finally {
           this.culling = void 0;
@@ -119542,7 +119800,234 @@ gl_FragDepth=readDepth(vUv);
   init_process2();
   init_three_module();
   init_CanvasCompat();
+  init_CubeFace();
   init_Materials();
+
+  // src/world/SectionGeometry.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_CubeFace();
+  function buildSectionGeometry(input) {
+    const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize } = input;
+    if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
+    if (count > indices.length || count > templates.length || count > cullMasks.length) throw new RangeError("Section entry count exceeds its arrays");
+    const visible = [];
+    const visibleAtlases = /* @__PURE__ */ new Set();
+    for (let entry = 0; entry < count; entry++) {
+      const template = templateData[templates[entry]];
+      if (!template.cullFaces.some((direction) => !(cullMasks[entry] & direction))) continue;
+      visible.push(entry);
+      visibleAtlases.add(template.atlas);
+    }
+    const pages = [];
+    const locations = /* @__PURE__ */ new Map();
+    for (const atlas of [...visibleAtlases].sort((a4, b4) => atlases[b4].height - atlases[a4].height)) {
+      const { width, height } = atlases[atlas];
+      if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
+      let selected = -1;
+      for (let i4 = 0; i4 < pages.length; i4++) {
+        const page2 = pages[i4];
+        const nextRow = page2.x + width > maxAtlasSize;
+        if ((nextRow ? page2.y + page2.rowHeight : page2.y) + height > maxAtlasSize) continue;
+        if (nextRow) {
+          page2.y += page2.rowHeight;
+          page2.x = 0;
+          page2.rowHeight = 0;
+        }
+        selected = i4;
+        break;
+      }
+      if (selected < 0) {
+        selected = pages.length;
+        pages.push({ placements: [], entries: [], x: 0, y: 0, rowHeight: 0, width: 0, height: 0 });
+      }
+      const page = pages[selected];
+      page.placements.push({ atlas, x: page.x, y: page.y });
+      locations.set(atlas, { page: selected, x: page.x, y: page.y });
+      page.x += width;
+      page.rowHeight = Math.max(page.rowHeight, height);
+      page.width = Math.max(page.width, page.x);
+      page.height = Math.max(page.height, page.y + height);
+    }
+    for (const entry of visible) pages[locations.get(templateData[templates[entry]].atlas).page].entries.push(entry);
+    return pages.map((page) => {
+      let faces = 0;
+      for (const entry of page.entries) {
+        const template = templateData[templates[entry]];
+        for (let face = 0; face < CUBE_FACES.length; face++) {
+          if (!(cullMasks[entry] & template.cullFaces[face])) faces++;
+        }
+      }
+      const positions = new Float32Array(faces * 12), normals = new Float32Array(faces * 12);
+      const uvs = new Float32Array(faces * 8), uvBounds = new Float32Array(faces * 16), colors = new Float32Array(faces * 12);
+      const outputIndices = new Uint32Array(faces * 6);
+      let vertex2 = 0, indexOffset = 0;
+      for (const entry of page.entries) {
+        const template = templateData[templates[entry]];
+        const atlas = atlases[template.atlas];
+        const placement = locations.get(template.atlas);
+        const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
+        const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
+        const offsetX = indices[entry] % 16 * 16;
+        const offsetY = Math.floor(indices[entry] / 256) * 16;
+        const offsetZ = Math.floor(indices[entry] / 16) % 16 * 16;
+        for (let face = 0; face < CUBE_FACES.length; face++) {
+          if (cullMasks[entry] & template.cullFaces[face]) continue;
+          const start = vertex2;
+          for (let corner = 0; corner < 4; corner++, vertex2++) {
+            const source = face * 4 + corner;
+            positions[vertex2 * 3] = template.positions[source * 3] + offsetX;
+            positions[vertex2 * 3 + 1] = template.positions[source * 3 + 1] + offsetY;
+            positions[vertex2 * 3 + 2] = template.positions[source * 3 + 2] + offsetZ;
+            normals[vertex2 * 3] = template.normals[source * 3];
+            normals[vertex2 * 3 + 1] = template.normals[source * 3 + 1];
+            normals[vertex2 * 3 + 2] = template.normals[source * 3 + 2];
+            uvs[vertex2 * 2] = mapU(template.uvs[source * 2]);
+            uvs[vertex2 * 2 + 1] = mapV(template.uvs[source * 2 + 1]);
+            uvBounds[vertex2 * 4] = mapU(template.uvBounds[source * 4]);
+            uvBounds[vertex2 * 4 + 1] = mapV(template.uvBounds[source * 4 + 1]);
+            uvBounds[vertex2 * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
+            uvBounds[vertex2 * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
+            colors[vertex2 * 3] = template.colors[source * 3];
+            colors[vertex2 * 3 + 1] = template.colors[source * 3 + 1];
+            colors[vertex2 * 3 + 2] = template.colors[source * 3 + 2];
+          }
+          for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[face * 6 + corner] - face * 4;
+        }
+      }
+      return { width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, indices: outputIndices };
+    });
+  }
+  function sectionGeometryTransferables(pages) {
+    return pages.flatMap((page) => [page.positions.buffer, page.normals.buffer, page.uvs.buffer, page.uvBounds.buffer, page.colors.buffer, page.indices.buffer]);
+  }
+
+  // src/world/SectionWorker.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_Env();
+  var _SectionWorker = class _SectionWorker {
+    constructor(worker) {
+      this.worker = worker;
+      this.nextId = 0;
+      this.pending = /* @__PURE__ */ new Map();
+      worker.addEventListener("message", (event) => {
+        const reply = event.data;
+        const pending = this.pending.get(reply.id);
+        if (!pending) return;
+        this.pending.delete(reply.id);
+        if (reply.type === "pages") pending.resolve(reply.pages);
+        else pending.reject(new Error(reply.message));
+      });
+      worker.addEventListener("error", (event) => this.fail(event.message || "Section worker failed"));
+      worker.addEventListener("messageerror", () => this.fail("Section worker message could not be deserialized"));
+    }
+    /** The shared worker, or undefined when the environment has none or a previous worker failed. */
+    static shared() {
+      if (!this.initialized) {
+        this.initialized = true;
+        const worker = Env.provider.createWorker?.("section");
+        if (worker) this.instance = new _SectionWorker(worker);
+      }
+      return this.instance;
+    }
+    /** Builds geometry without transferring the input buffers away from the caller. */
+    build(input) {
+      if (!this.worker) return Promise.reject(new Error("Section worker terminated"));
+      return new Promise((resolve, reject) => {
+        const id = this.nextId++;
+        this.pending.set(id, { resolve, reject });
+        this.worker.postMessage({ id, type: "build", input });
+      });
+    }
+    /** Rejects pending builds, terminates the worker, and makes shared() return undefined. */
+    terminate() {
+      this.fail("Section worker terminated");
+    }
+    fail(message) {
+      const error2 = new Error(message);
+      for (const pending of this.pending.values()) pending.reject(error2);
+      this.pending.clear();
+      this.worker?.terminate();
+      this.worker = void 0;
+      _SectionWorker.instance = void 0;
+    }
+  };
+  _SectionWorker.initialized = false;
+  var SectionWorker = _SectionWorker;
+
+  // src/world/SectionMesh.ts
+  var templateCache = /* @__PURE__ */ new WeakMap();
+  function toInput(entries, maxAtlasSize) {
+    if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
+    const atlases = [];
+    const atlasIds = /* @__PURE__ */ new Map();
+    const templateIds = /* @__PURE__ */ new Map();
+    const input = {
+      count: entries.length,
+      indices: new Uint16Array(entries.length),
+      templates: new Uint16Array(entries.length),
+      cullMasks: new Uint8Array(entries.length),
+      templateData: [],
+      atlases: [],
+      maxAtlasSize
+    };
+    for (let i4 = 0; i4 < entries.length; i4++) {
+      const { index, template, cullMask } = entries[i4];
+      let id = templateIds.get(template);
+      if (id === void 0) {
+        let atlas = atlasIds.get(template.atlas);
+        if (atlas === void 0) {
+          atlas = atlases.length;
+          atlasIds.set(template.atlas, atlas);
+          atlases.push(template.atlas);
+          input.atlases.push({ width: template.atlas.image.width, height: template.atlas.image.height });
+        }
+        let data = templateCache.get(template);
+        if (!data) {
+          data = {
+            positions: new Float32Array(72),
+            normals: new Float32Array(72),
+            uvs: new Float32Array(48),
+            uvBounds: new Float32Array(96),
+            colors: new Float32Array(72),
+            indices: new Uint16Array(36),
+            cullFaces: new Uint8Array(template.cullFaces),
+            atlas: 0
+          };
+          const position = template.geometry.getAttribute("position");
+          const normal = template.geometry.getAttribute("normal");
+          const uv = template.geometry.getAttribute("uv");
+          const bounds = template.geometry.getAttribute("uvBounds");
+          const color3 = template.geometry.getAttribute("color");
+          for (let vertex2 = 0; vertex2 < CUBE_FACES.length * 4; vertex2++) {
+            data.positions.set([position.getX(vertex2), position.getY(vertex2), position.getZ(vertex2)], vertex2 * 3);
+            data.normals.set([normal.getX(vertex2), normal.getY(vertex2), normal.getZ(vertex2)], vertex2 * 3);
+            data.uvs.set([uv.getX(vertex2), uv.getY(vertex2)], vertex2 * 2);
+            data.uvBounds.set([
+              bounds?.getX(vertex2) ?? 0,
+              bounds?.getY(vertex2) ?? 0,
+              bounds?.getZ(vertex2) ?? 1,
+              bounds?.getW(vertex2) ?? 1
+            ], vertex2 * 4);
+            data.colors.set([color3?.getX(vertex2) ?? 1, color3?.getY(vertex2) ?? 1, color3?.getZ(vertex2) ?? 1], vertex2 * 3);
+          }
+          const indices = template.geometry.getIndex();
+          for (let i5 = 0; i5 < data.indices.length; i5++) data.indices[i5] = indices.getX(i5);
+          templateCache.set(template, data);
+        }
+        id = input.templateData.length;
+        templateIds.set(template, id);
+        input.templateData.push({ ...data, atlas });
+      }
+      input.indices[i4] = index;
+      input.templates[i4] = id;
+      input.cullMasks[i4] = cullMask;
+    }
+    return { input, atlases };
+  }
   var SectionMesh = class _SectionMesh extends Group {
     constructor() {
       super(...arguments);
@@ -119550,86 +120035,31 @@ gl_FragDepth=readDepth(vUv);
     }
     /** Builds section-local meshes from visible cube faces. `maxAtlasSize` limits each atlas dimension in pixels. */
     static build(entries, maxAtlasSize = 2048) {
-      if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
-      const visible = entries.filter((entry) => entry.template.cullFaces.some((direction) => !(entry.cullMask & direction)));
-      const atlases = [...new Set(visible.map((entry) => entry.template.atlas))].sort((a4, b4) => b4.image.height - a4.image.height);
-      const pages = [];
-      const locations = /* @__PURE__ */ new Map();
-      for (const atlas of atlases) {
-        const { width, height } = atlas.image;
-        if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
-        let selected;
-        for (const page of pages) {
-          const nextRow = page.x + width > maxAtlasSize;
-          if ((nextRow ? page.y + page.rowHeight : page.y) + height > maxAtlasSize) continue;
-          if (nextRow) {
-            page.y += page.rowHeight;
-            page.x = 0;
-            page.rowHeight = 0;
-          }
-          selected = page;
-          break;
-        }
-        if (!selected) {
-          selected = { placements: [], entries: [], x: 0, y: 0, rowHeight: 0, width: 0, height: 0 };
-          pages.push(selected);
-        }
-        const placement = { atlas, x: selected.x, y: selected.y };
-        selected.placements.push(placement);
-        selected.x += width;
-        selected.rowHeight = Math.max(selected.rowHeight, height);
-        selected.width = Math.max(selected.width, selected.x);
-        selected.height = Math.max(selected.height, selected.y + height);
-        locations.set(atlas, { page: selected, placement });
-      }
-      for (const entry of visible) locations.get(entry.template.atlas).page.entries.push(entry);
+      const { input, atlases } = toInput(entries, maxAtlasSize);
+      return this.fromPages(buildSectionGeometry(input), atlases);
+    }
+    /** Builds section-local meshes in a browser worker when available, with synchronous fallback. */
+    static async buildAsync(entries, maxAtlasSize = 2048) {
+      const { input, atlases } = toInput(entries, maxAtlasSize);
+      const worker = SectionWorker.shared();
+      const pages = worker ? await worker.build(input).catch(() => buildSectionGeometry(input)) : buildSectionGeometry(input);
+      return this.fromPages(pages, atlases);
+    }
+    static fromPages(pages, atlases) {
       const section = new _SectionMesh();
       for (const page of pages) {
         const canvas = createCanvas(page.width, page.height);
         const context = canvas.getContext("2d");
         for (const { atlas, x: x4, y: y5 } of page.placements) {
-          context.drawImage(atlas.image.canvas, x4, y5);
-        }
-        const positions = [], normals = [], uvs = [], uvBounds = [], colors = [], indices = [];
-        for (const { index, template, cullMask } of page.entries) {
-          const position = template.geometry.getAttribute("position");
-          const normal = template.geometry.getAttribute("normal");
-          const uv = template.geometry.getAttribute("uv");
-          const bounds = template.geometry.getAttribute("uvBounds");
-          const color3 = template.geometry.getAttribute("color");
-          const sourceIndices = template.geometry.getIndex();
-          const placement = locations.get(template.atlas).placement;
-          const mapU = (u4) => (placement.x + u4 * template.atlas.image.width) / page.width;
-          const mapV = (v5) => 1 - (placement.y + (1 - v5) * template.atlas.image.height) / page.height;
-          const offsetX = index % 16 * 16;
-          const offsetY = Math.floor(index / 256) * 16;
-          const offsetZ = Math.floor(index / 16) % 16 * 16;
-          for (let face = 0; face < 6; face++) {
-            if (cullMask & template.cullFaces[face]) continue;
-            const start = positions.length / 3;
-            for (let corner = 0; corner < 4; corner++) {
-              const vertex2 = face * 4 + corner;
-              positions.push(position.getX(vertex2) + offsetX, position.getY(vertex2) + offsetY, position.getZ(vertex2) + offsetZ);
-              normals.push(normal.getX(vertex2), normal.getY(vertex2), normal.getZ(vertex2));
-              uvs.push(mapU(uv.getX(vertex2)), mapV(uv.getY(vertex2)));
-              uvBounds.push(
-                mapU(bounds?.getX(vertex2) ?? 0),
-                mapV(bounds?.getY(vertex2) ?? 0),
-                mapU(bounds?.getZ(vertex2) ?? 1),
-                mapV(bounds?.getW(vertex2) ?? 1)
-              );
-              colors.push(color3?.getX(vertex2) ?? 1, color3?.getY(vertex2) ?? 1, color3?.getZ(vertex2) ?? 1);
-            }
-            for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
-          }
+          context.drawImage(atlases[atlas].image.canvas, x4, y5);
         }
         const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
-        geometry.setAttribute("normal", new Float32BufferAttribute(normals, 3));
-        geometry.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
-        geometry.setAttribute("uvBounds", new Float32BufferAttribute(uvBounds, 4));
-        geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
-        geometry.setIndex(indices);
+        geometry.setAttribute("position", new Float32BufferAttribute(page.positions.buffer, 3));
+        geometry.setAttribute("normal", new Float32BufferAttribute(page.normals.buffer, 3));
+        geometry.setAttribute("uv", new Float32BufferAttribute(page.uvs.buffer, 2));
+        geometry.setAttribute("uvBounds", new Float32BufferAttribute(page.uvBounds.buffer, 4));
+        geometry.setAttribute("color", new Float32BufferAttribute(page.colors.buffer, 3));
+        geometry.setIndex(new Uint32BufferAttribute(page.indices.buffer, 1));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         const material = Materials.createShadedCanvasMaterial(canvas, false, false, true);
@@ -119663,7 +120093,9 @@ gl_FragDepth=readDepth(vUv);
       this.renderedBlocks = /* @__PURE__ */ new Map();
       this.sectionBlocks = /* @__PURE__ */ new Map();
       this.hiddenBlocks = /* @__PURE__ */ new Set();
+      this.blockPosition = new Vector3();
       this.meshDirty = false;
+      this.meshGeneration = 0;
       this.scene = scene;
       this.x = x4;
       this.y = y5;
@@ -119676,7 +120108,7 @@ gl_FragDepth=readDepth(vUv);
       if (isTripleArray(posOrX)) {
         return this.getBlockAt(new Vector3(posOrX[0], posOrX[1], posOrX[2]));
       }
-      const pos = this.worldPosToChunkPos(posOrX);
+      const pos = this.blockPosition.set(posOrX.x - this.x * 16, posOrX.y - this.y * 16, posOrX.z - this.z * 16);
       const index = _Chunk.chunkPosToBlockIndex(pos);
       return this.renderedBlocks.get(index);
     }
@@ -119700,48 +120132,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 blockState2 = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
+          const perBlock = !blockState2 || !this.sectionModels || !!getFluidKind(blockState2.key, stored.properties) || !!(blockState2.key && BlockEntities.entry(await BlockEntities.getIndex(blockState2.key.root), blockState2.key.toNamespacedString()));
+          if (!perBlock) await this.sectionModels.get(blockState2, stored.properties);
+          return { blockState: blockState2, 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: blockState2, perBlock } = await resolutions.get(key);
+          if (!blockState2) {
+            this.data.set(index, void 0);
+            continue;
+          }
+          const template = perBlock ? void 0 : await this.sectionModels.get(blockState2, stored.properties);
+          if (template) {
+            this.sectionBlocks.set(index, { index, template, cullMask: 0 });
+            this.meshDirty = true;
+          } else {
+            object3 = await this.scene.addBlock(blockState2, {
+              mergeMeshes: true,
+              instanceMeshes: true,
+              maxInstanceCount: 2e3,
+              initialState: stored.properties
+            });
+            object3.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
+          }
+          this.renderedBlocks.set(index, { get block() {
+            return readBlock();
+          }, object: object3 });
+        } catch (error2) {
+          this.data.set(index, void 0);
+          object3?.removeFromScene();
+          if (!failed) failure = error2;
+          failed = true;
+        }
+      }
+      if (failed) throw failure;
+      return positions;
+    }
     /** Changes visibility at world block coordinates while preserving the block's data. */
     async setBlockVisibleAt(pos, visible) {
       const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
@@ -119762,15 +120227,24 @@ gl_FragDepth=readDepth(vUv);
       await this.onBlocksChanged?.([pos]);
     }
     isBlockVisibleAt(pos) {
-      const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+      return this.isBlockVisibleIndex(_Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos)));
+    }
+    /** Reports whether a cell has a visible render object or section entry. */
+    isBlockVisibleIndex(index) {
       return this.renderedBlocks.has(index) && !this.hiddenBlocks.has(index);
     }
     isOccludingAt(pos) {
-      const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+      return this.isOccludingIndex(_Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos)));
+    }
+    /** Reports whether a visible cell hides neighboring cube faces. */
+    isOccludingIndex(index) {
       return !this.hiddenBlocks.has(index) && (this.sectionBlocks.has(index) || (this.renderedBlocks.get(index)?.object?.isOccluding ?? false));
     }
     async setCullMaskAt(pos, mask) {
-      const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+      await this.setCullMaskIndex(_Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos)), mask);
+    }
+    /** Updates hidden faces for a cell's section entry or individual render object. */
+    async setCullMaskIndex(index, mask) {
       const entry = this.sectionBlocks.get(index);
       if (entry) {
         if (entry.cullMask !== mask) {
@@ -119781,12 +120255,17 @@ gl_FragDepth=readDepth(vUv);
         await this.renderedBlocks.get(index)?.object?.setCullMask(mask);
       }
     }
-    rebuildSectionMesh() {
+    /** Rebuilds visible section geometry and discards results superseded by another rebuild or clear. */
+    async rebuildSectionMesh() {
       if (!this.meshDirty) return;
-      const next = this.sectionBlocks.size ? SectionMesh.build(
-        [...this.sectionBlocks.values()].filter((entry) => !this.hiddenBlocks.has(entry.index)),
-        this.sectionModels.maxAtlasSize
-      ) : void 0;
+      this.meshDirty = false;
+      const generation = ++this.meshGeneration;
+      const entries = [...this.sectionBlocks.values()].filter((entry) => !this.hiddenBlocks.has(entry.index));
+      const next = entries.length ? await SectionMesh.buildAsync(entries, this.sectionModels.maxAtlasSize) : void 0;
+      if (generation !== this.meshGeneration) {
+        next?.dispose();
+        return;
+      }
       this.sectionMesh?.dispose();
       this.sectionMesh = next;
       if (next) {
@@ -119794,7 +120273,6 @@ gl_FragDepth=readDepth(vUv);
         this.scene.add(next);
       }
       this.scene.dirty = true;
-      this.meshDirty = false;
     }
     /** Removes stored blocks and their render objects, then notifies the owning world of changed positions. */
     async clear(onBlocksChanged = this.onBlocksChanged) {
@@ -119803,6 +120281,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;