minerender 2.1.0-alpha.137 → 2.1.0-alpha.138

package/dist/node/index.d.mts

@@ -4068,7 +4068,7 @@ declare class Chunk<SectionMeshing extends boolean = false> {
     private ambientOcclusionCells?;
     private readonly blockChanges;
     private biomeChange?;
-    constructor(scene: MineRenderScene, x: number, y: number, z: number, onBlocksChanged?: ((positions: Vector3[]) => Promise<void>) | undefined, sectionModels?: SectionModels | undefined, neighborCell?: ((x: number, y: number, z: number) => number) | undefined, biomeAt?: ((x: number, y: number, z: number) => Maybe<string>) | undefined, onBiomesChanged?: ((biomes?: readonly string[]) => Promise<void>) | undefined, lightAt?: ((x: number, y: number, z: number) => number) | undefined, onLightCleared?: (() => Promise<void>) | undefined, ambientLight?: number, biomeBlend?: (() => BiomeBlend | undefined) | undefined);
+    constructor(scene: MineRenderScene, x: number, y: number, z: number, onBlocksChanged?: ((positions: Vector3[], deferCulling?: boolean) => Promise<void>) | undefined, sectionModels?: SectionModels | undefined, neighborCell?: ((x: number, y: number, z: number) => number) | undefined, biomeAt?: ((x: number, y: number, z: number) => Maybe<string>) | undefined, onBiomesChanged?: ((biomes?: readonly string[]) => Promise<void>) | undefined, lightAt?: ((x: number, y: number, z: number) => number) | undefined, onLightCleared?: (() => Promise<void>) | undefined, ambientLight?: number, biomeBlend?: (() => BiomeBlend | undefined) | undefined);
     /** Finds the nearest owned block hit across sections, testing each shared mesh once. */
     static raycast<SectionMeshing extends boolean>(chunks: Iterable<Chunk<SectionMeshing>>, raycaster: Raycaster): WorldBlockIntersection | undefined;
     getBlockAt(x: number, y: number, z: number): Maybe<BlockInfo<SectionMeshing>>;
@@ -4080,11 +4080,14 @@ declare class Chunk<SectionMeshing extends boolean = false> {
     getBiomeAt(pos: TripleArray): Maybe<string>;
     /** Copies 64 biome IDs in x + z * 4 + y * 16 order and refreshes placed blocks. Omit the array to clear biome data. */
     setBiomes(biomes?: readonly string[]): Promise<void>;
-    /** Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects. */
+    /**
+     * Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects.
+     * The owning world can defer neighbor culling until all affected chunks are refreshed.
+     */
     refreshBiomes(columns?: readonly {
         x: number;
         z: number;
-    }[]): Promise<void>;
+    }[], deferCulling?: boolean): Promise<void>;
     private refreshBiomeBlocks;
     /**
      * Places a block at integer world block coordinates. Pass `undefined` to remove it.
@@ -4095,7 +4098,7 @@ declare class Chunk<SectionMeshing extends boolean = false> {
     /**
      * Places a block at integer chunk-local coordinates from 0 to 15.
      */
-    setBlockInChunkAt(pos: Vector3, block?: Block, worldPos?: Vector3, onBlocksChanged?: ((positions: Vector3[]) => Promise<void>) | undefined): Promise<Maybe<BlockInfo<SectionMeshing>>>;
+    setBlockInChunkAt(pos: Vector3, block?: Block, worldPos?: Vector3, onBlocksChanged?: ((positions: Vector3[], deferCulling?: boolean) => Promise<void>) | undefined): Promise<Maybe<BlockInfo<SectionMeshing>>>;
     /** Places cells in input order and returns changed world positions without refreshing neighbors. */
     placeBlocks(blocks: readonly {
         index: number;
@@ -4260,6 +4263,14 @@ declare class MineRenderWorld<SectionMeshing extends boolean = false> {
      * Coordinates match AnvilChunk.x/z, not block positions. Missing columns are ignored.
      */
     unloadChunkColumn(x: number, z: number): Promise<void>;
+    /**
+     * Removes chunk columns together and refreshes surviving neighbors once.
+     * Coordinates are absolute chunk columns. Duplicate and missing columns are ignored.
+     */
+    unloadChunkColumns(positions: readonly {
+        x: number;
+        z: number;
+    }[]): Promise<void>;
     private clearChunkColumn;
     private markSectionChanged;
     /** Removes all chunks and releases their blocks, section meshes, and owned entities. */
@@ -4337,7 +4348,7 @@ declare class WorldStreamer {
     private running?;
     private disposal?;
     private disposed;
-    constructor(world: Pick<MineRenderWorld<boolean>, "placeChunk" | "unloadChunkColumn">, source: WorldChunkSource, options?: WorldStreamerOptions);
+    constructor(world: Pick<MineRenderWorld<boolean>, "placeChunk" | "unloadChunkColumns">, source: WorldChunkSource, options?: WorldStreamerOptions);
     /** Returns absolute coordinates of successfully placed columns, including retained columns. */
     get loadedChunks(): readonly {
         x: number;
@@ -4371,7 +4382,7 @@ declare class WorldStreamer {
     dispose(): Promise<void>;
     private drain;
     private needsLoad;
-    private unload;
+    private unloadMany;
     private validateChunk;
     private within;
     private key;

package/dist/node/index.d.ts

@@ -4068,7 +4068,7 @@ declare class Chunk<SectionMeshing extends boolean = false> {
     private ambientOcclusionCells?;
     private readonly blockChanges;
     private biomeChange?;
-    constructor(scene: MineRenderScene, x: number, y: number, z: number, onBlocksChanged?: ((positions: Vector3[]) => Promise<void>) | undefined, sectionModels?: SectionModels | undefined, neighborCell?: ((x: number, y: number, z: number) => number) | undefined, biomeAt?: ((x: number, y: number, z: number) => Maybe<string>) | undefined, onBiomesChanged?: ((biomes?: readonly string[]) => Promise<void>) | undefined, lightAt?: ((x: number, y: number, z: number) => number) | undefined, onLightCleared?: (() => Promise<void>) | undefined, ambientLight?: number, biomeBlend?: (() => BiomeBlend | undefined) | undefined);
+    constructor(scene: MineRenderScene, x: number, y: number, z: number, onBlocksChanged?: ((positions: Vector3[], deferCulling?: boolean) => Promise<void>) | undefined, sectionModels?: SectionModels | undefined, neighborCell?: ((x: number, y: number, z: number) => number) | undefined, biomeAt?: ((x: number, y: number, z: number) => Maybe<string>) | undefined, onBiomesChanged?: ((biomes?: readonly string[]) => Promise<void>) | undefined, lightAt?: ((x: number, y: number, z: number) => number) | undefined, onLightCleared?: (() => Promise<void>) | undefined, ambientLight?: number, biomeBlend?: (() => BiomeBlend | undefined) | undefined);
     /** Finds the nearest owned block hit across sections, testing each shared mesh once. */
     static raycast<SectionMeshing extends boolean>(chunks: Iterable<Chunk<SectionMeshing>>, raycaster: Raycaster): WorldBlockIntersection | undefined;
     getBlockAt(x: number, y: number, z: number): Maybe<BlockInfo<SectionMeshing>>;
@@ -4080,11 +4080,14 @@ declare class Chunk<SectionMeshing extends boolean = false> {
     getBiomeAt(pos: TripleArray): Maybe<string>;
     /** Copies 64 biome IDs in x + z * 4 + y * 16 order and refreshes placed blocks. Omit the array to clear biome data. */
     setBiomes(biomes?: readonly string[]): Promise<void>;
-    /** Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects. */
+    /**
+     * Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects.
+     * The owning world can defer neighbor culling until all affected chunks are refreshed.
+     */
     refreshBiomes(columns?: readonly {
         x: number;
         z: number;
-    }[]): Promise<void>;
+    }[], deferCulling?: boolean): Promise<void>;
     private refreshBiomeBlocks;
     /**
      * Places a block at integer world block coordinates. Pass `undefined` to remove it.
@@ -4095,7 +4098,7 @@ declare class Chunk<SectionMeshing extends boolean = false> {
     /**
      * Places a block at integer chunk-local coordinates from 0 to 15.
      */
-    setBlockInChunkAt(pos: Vector3, block?: Block, worldPos?: Vector3, onBlocksChanged?: ((positions: Vector3[]) => Promise<void>) | undefined): Promise<Maybe<BlockInfo<SectionMeshing>>>;
+    setBlockInChunkAt(pos: Vector3, block?: Block, worldPos?: Vector3, onBlocksChanged?: ((positions: Vector3[], deferCulling?: boolean) => Promise<void>) | undefined): Promise<Maybe<BlockInfo<SectionMeshing>>>;
     /** Places cells in input order and returns changed world positions without refreshing neighbors. */
     placeBlocks(blocks: readonly {
         index: number;
@@ -4260,6 +4263,14 @@ declare class MineRenderWorld<SectionMeshing extends boolean = false> {
      * Coordinates match AnvilChunk.x/z, not block positions. Missing columns are ignored.
      */
     unloadChunkColumn(x: number, z: number): Promise<void>;
+    /**
+     * Removes chunk columns together and refreshes surviving neighbors once.
+     * Coordinates are absolute chunk columns. Duplicate and missing columns are ignored.
+     */
+    unloadChunkColumns(positions: readonly {
+        x: number;
+        z: number;
+    }[]): Promise<void>;
     private clearChunkColumn;
     private markSectionChanged;
     /** Removes all chunks and releases their blocks, section meshes, and owned entities. */
@@ -4337,7 +4348,7 @@ declare class WorldStreamer {
     private running?;
     private disposal?;
     private disposed;
-    constructor(world: Pick<MineRenderWorld<boolean>, "placeChunk" | "unloadChunkColumn">, source: WorldChunkSource, options?: WorldStreamerOptions);
+    constructor(world: Pick<MineRenderWorld<boolean>, "placeChunk" | "unloadChunkColumns">, source: WorldChunkSource, options?: WorldStreamerOptions);
     /** Returns absolute coordinates of successfully placed columns, including retained columns. */
     get loadedChunks(): readonly {
         x: number;
@@ -4371,7 +4382,7 @@ declare class WorldStreamer {
     dispose(): Promise<void>;
     private drain;
     private needsLoad;
-    private unload;
+    private unloadMany;
     private validateChunk;
     private within;
     private key;

package/dist/node/index.js

@@ -18711,8 +18711,14 @@ var MineRenderWorld = class {
     }
     return queued;
   }
-  async refreshBiomes() {
-    if (this.biomeRefreshing) await this.biomeRefreshing;
+  async refreshBiomes(deferCulling = false) {
+    if (this.biomeRefreshing) {
+      await this.biomeRefreshing;
+      if (!deferCulling) {
+        if (this.pendingCulling.size) await this.updateCulling([]);
+        else await this.culling;
+      }
+    }
     if (!this.pendingBiomes.size) return /* @__PURE__ */ new Map();
     return this.biomeRefreshing ??= Promise.resolve().then(async () => {
       const failures = /* @__PURE__ */ new Map();
@@ -18724,7 +18730,7 @@ var MineRenderWorld = class {
           this.pendingBiomes.delete(chunk);
           if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) !== chunk) continue;
           try {
-            await chunk.refreshBiomes(columns);
+            await chunk.refreshBiomes(columns, deferCulling);
           } catch (error) {
             failures.set(chunk, error);
             if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) === chunk) this.pendingBiomes.set(chunk, void 0);
@@ -18986,15 +18992,35 @@ var MineRenderWorld = class {
    * Coordinates match AnvilChunk.x/z, not block positions. Missing columns are ignored.
    */
   async unloadChunkColumn(x, z) {
-    if (!Number.isInteger(x) || !Number.isInteger(z)) {
-      throw new RangeError("Chunk column coordinates must be integers");
+    return this.unloadChunkColumns([{ x, z }]);
+  }
+  /**
+   * Removes chunk columns together and refreshes surviving neighbors once.
+   * Coordinates are absolute chunk columns. Duplicate and missing columns are ignored.
+   */
+  async unloadChunkColumns(positions) {
+    const columns = /* @__PURE__ */ new Map();
+    for (const position of positions) {
+      const { x, z } = position ?? {};
+      if (!Number.isInteger(x) || !Number.isInteger(z)) {
+        throw new RangeError("Chunk column coordinates must be integers");
+      }
+      columns.set(`${x}_${z}`, { x, z });
     }
-    this.entities?.clearColumn(x, z);
+    if (!columns.size) return;
     await this.culling;
+    let sliceStart = performance.now();
     try {
-      await this.clearChunkColumn(x, z);
+      for (const { x, z } of columns.values()) {
+        this.entities?.clearColumn(x, z);
+        await this.clearChunkColumn(x, z);
+        if (performance.now() - sliceStart > 8) {
+          await yieldToEventLoop();
+          sliceStart = performance.now();
+        }
+      }
     } finally {
-      const failures = await this.refreshBiomes();
+      const failures = await this.refreshBiomes(true);
       if (failures.size) log18.warn("Failed to refresh biome colors", failures.values().next().value);
       await this.updateCulling([]);
     }
@@ -19057,7 +19083,7 @@ var MineRenderWorld = class {
     }
     this.sectionModels?.clear();
   }
-  updateCulling(positions) {
+  updateCulling(positions, defer = false) {
     const neighbor = new import_three45.Vector3();
     for (const pos of positions) {
       const cx = Math.floor(pos.x / 16), cy = Math.floor(pos.y / 16), cz = Math.floor(pos.z / 16);
@@ -19079,58 +19105,72 @@ var MineRenderWorld = class {
         }
       }
     }
+    if (defer) return Promise.resolve();
     return this.culling ??= Promise.resolve().then(async () => {
       let sliceStart = performance.now();
       try {
         const culling = await loadBlockCulling();
         while (this.pendingCulling.size) {
-          const batch = [...this.pendingCulling];
+          const batch = new Map(this.pendingCulling);
           this.pendingCulling.clear();
-          for (const [chunk, indices] of batch) {
-            const neighbors = CUBE_FACE_OFFSETS.map(([x, y, z]) => this._chunks.get(`${chunk.x + x}_${chunk.y + y}_${chunk.z + z}`));
-            const neighborAt = (x, y, z) => {
-              const lx = x - chunk.x * 16, ly = y - chunk.y * 16, lz = z - chunk.z * 16;
-              const section = neighbors[lx >= 16 ? 0 : lx < 0 ? 1 : ly >= 16 ? 2 : ly < 0 ? 3 : lz >= 16 ? 4 : 5];
-              return [section, (ly & 15) * 256 + (lz & 15) * 16 + (lx & 15)];
-            };
-            const masks = chunk.updateCullMasks(indices === "all" ? void 0 : indices, (x, y, z) => {
-              const [section, i] = neighborAt(x, y, z);
-              return section?.isOccludingIndex(i) ?? false;
-            }, culling, (x, y, z) => {
-              const [section, i] = neighborAt(x, y, z);
-              return section?.visibleBlockIndex(i);
-            });
-            const fluidIndices = indices === "all" ? function* () {
-              for (let index = 0; index < 4096; index++) yield index;
-            }() : indices;
-            for (const index of fluidIndices) {
-              if (!chunk.fluidByteIndex(index) || !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 byte = section?.fluidByteIndex(neighborIndex) ?? 0;
-                  return {
-                    fluid: fluidKindOf(byte),
-                    level: byte & 15,
-                    solid: section?.isOccludingIndex(neighborIndex) ?? false
-                  };
-                });
+          try {
+            for (const [chunk, indices] of batch) {
+              const neighbors = CUBE_FACE_OFFSETS.map(([x, y, z]) => this._chunks.get(`${chunk.x + x}_${chunk.y + y}_${chunk.z + z}`));
+              const neighborAt = (x, y, z) => {
+                const lx = x - chunk.x * 16, ly = y - chunk.y * 16, lz = z - chunk.z * 16;
+                const section = neighbors[lx >= 16 ? 0 : lx < 0 ? 1 : ly >= 16 ? 2 : ly < 0 ? 3 : lz >= 16 ? 4 : 5];
+                return [section, (ly & 15) * 256 + (lz & 15) * 16 + (lx & 15)];
+              };
+              const masks = chunk.updateCullMasks(indices === "all" ? void 0 : indices, (x, y, z) => {
+                const [section, i] = neighborAt(x, y, z);
+                return section?.isOccludingIndex(i) ?? false;
+              }, culling, (x, y, z) => {
+                const [section, i] = neighborAt(x, y, z);
+                return section?.visibleBlockIndex(i);
+              });
+              const fluidIndices = indices === "all" ? function* () {
+                for (let index = 0; index < 4096; index++) yield index;
+              }() : indices;
+              for (const index of fluidIndices) {
+                if (!chunk.fluidByteIndex(index) || !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 byte = section?.fluidByteIndex(neighborIndex) ?? 0;
+                    return {
+                      fluid: fluidKindOf(byte),
+                      level: byte & 15,
+                      solid: section?.isOccludingIndex(neighborIndex) ?? false
+                    };
+                  });
+                }
+              }
+              for (const [index, mask] of masks) await chunk.setCullMaskIndex(index, mask);
+              await chunk.refreshLight(indices === "all" ? void 0 : indices);
+              chunk.refreshAmbientOcclusion(this._ambientOcclusion);
+              if ((this._ambientOcclusion || this.ambientOcclusionPending) && performance.now() - sliceStart > 8) {
+                await yieldToEventLoop();
+                sliceStart = performance.now();
               }
             }
-            for (const [index, mask] of masks) await chunk.setCullMaskIndex(index, mask);
-            await chunk.refreshLight(indices === "all" ? void 0 : indices);
-            chunk.refreshAmbientOcclusion(this._ambientOcclusion);
-            if ((this._ambientOcclusion || this.ambientOcclusionPending) && performance.now() - sliceStart > 8) {
-              await yieldToEventLoop();
-              sliceStart = performance.now();
+            const builds = await Promise.allSettled([...batch.keys()].map(async (chunk) => {
+              await chunk.rebuildSectionMesh();
+              batch.delete(chunk);
+            }));
+            const failure = builds.find((result) => result.status === "rejected");
+            if (failure?.status === "rejected") throw failure.reason;
+          } catch (error) {
+            for (const [chunk, indices] of batch) {
+              const pending = this.pendingCulling.get(chunk);
+              this.pendingCulling.set(chunk, indices === "all" || pending === "all" ? "all" : /* @__PURE__ */ new Set([...indices, ...pending ?? []]));
             }
+            throw error;
           }
-          await Promise.all(batch.map(([chunk]) => chunk.rebuildSectionMesh()));
         }
       } finally {
         this.culling = void 0;
@@ -19147,7 +19187,7 @@ var MineRenderWorld = class {
         x,
         y,
         z,
-        (positions) => this.updateCulling(positions),
+        (positions, defer) => this.updateCulling(positions, defer),
         this.sectionModels,
         (x2, y2, z2) => {
           const cx = Math.floor(x2 / 16), cy = Math.floor(y2 / 16), cz = Math.floor(z2 / 16);
@@ -19882,11 +19922,14 @@ var Chunk = class _Chunk {
     this.biomes = copy;
     return this.refreshBiomes();
   }
-  /** Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects. */
-  refreshBiomes(columns) {
-    return this.changeBlocks(() => this.refreshBiomeBlocks(columns), true);
+  /**
+   * Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects.
+   * The owning world can defer neighbor culling until all affected chunks are refreshed.
+   */
+  refreshBiomes(columns, deferCulling = false) {
+    return this.changeBlocks(() => this.refreshBiomeBlocks(columns, deferCulling), true);
   }
-  async refreshBiomeBlocks(columns) {
+  async refreshBiomeBlocks(columns, deferCulling = false) {
     const blend = columns && this.biomeBlend?.();
     const ownColumn = columns?.some((column) => column.x === this.x && column.z === this.z);
     const affected = /* @__PURE__ */ new Map();
@@ -19943,7 +19986,7 @@ var Chunk = class _Chunk {
         this.renderedBlocks.get(index)?.object?.setVisible(false);
       }
       const positions = blocks.map(({ index }) => new import_three47.Vector3(...this.positionAt(index)));
-      if (this.onBlocksChanged) await this.onBlocksChanged(positions);
+      if (this.onBlocksChanged) await this.onBlocksChanged(positions, deferCulling);
       else await this.rebuildSectionMesh();
     }
   }
@@ -20597,19 +20640,12 @@ var WorldStreamer = class {
     this.loading?.controller.abort();
     return 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 ??= error;
-        }
+      try {
+        await this.unloadMany([...this.owned.values()]);
+      } finally {
+        this.missing.clear();
+        this.failed.clear();
       }
-      this.missing.clear();
-      this.failed.clear();
-      if (failed) throw failure;
     }).catch((error) => {
       this.disposal = void 0;
       throw error;
@@ -20624,9 +20660,9 @@ var WorldStreamer = class {
         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);
+        const obsolete = [...this.owned.values()].filter((position2) => !this.loaded.has(this.key(position2)) || !this.within(position2, this.unloadRadius));
+        if (obsolete.length) {
+          await this.unloadMany(obsolete);
           continue;
         }
         const position = this.desired.find((position2) => this.needsLoad(position2));
@@ -20656,7 +20692,7 @@ var WorldStreamer = class {
           this.loaded.set(this.key(position), position);
         } catch (error) {
           try {
-            await this.unload(position);
+            await this.unloadMany([position]);
           } catch (cleanupError) {
             const failure = error instanceof Error ? error : new Error(String(error));
             try {
@@ -20677,10 +20713,18 @@ var WorldStreamer = class {
     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));
+  async unloadMany(positions) {
+    if (!positions.length) return;
+    try {
+      await this.world.unloadChunkColumns(positions.map(({ x, z }) => ({ x, z })));
+    } catch (error) {
+      for (const position of positions) this.loaded.delete(this.key(position));
+      throw error;
+    }
+    for (const position of positions) {
+      this.owned.delete(this.key(position));
+      this.loaded.delete(this.key(position));
+    }
   }
   validateChunk(chunk, position) {
     if (chunk.x !== position.x || chunk.z !== position.z) {