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

package/dist/browser/esm/world/WorldStreamer.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/world/WorldStreamer.ts"],"sourcesContent":["import type { AnvilChunk } from \"./AnvilParser\";\nimport type { MineRenderWorld } from \"./MineRenderWorld\";\nimport type { WorldChunkSource } from \"./WorldChunkSource\";\n\nexport interface WorldStreamerOptions {\n    /** Loads a square of chunk columns around the center. Integer from 0 to 32; defaults to 2. */\n    loadRadius?: number;\n    /** Retains loaded columns within this radius. Defaults to loadRadius + 1, capped at 32. */\n    unloadRadius?: number;\n}\n\ninterface ChunkPosition {\n    x: number;\n    z: number;\n}\n\n/**\n * Loads nearby chunk columns in distance order and unloads distant columns.\n * Updates coalesce to the latest center and serialize world mutations. Use a dedicated world:\n * the streamer replaces columns it loads, and callers must await disposal before editing that world.\n * The source remains caller-owned. Lighting, biome tint, and LOD are not added by streaming.\n */\nexport class WorldStreamer {\n    private readonly loadRadius: number;\n    private readonly unloadRadius: number;\n    private readonly loaded = new Map<string, ChunkPosition>();\n    private readonly owned = new Map<string, ChunkPosition>();\n    private readonly missing = new Map<string, ChunkPosition>();\n    private readonly failed = new Map<string, ChunkPosition & { error: unknown }>();\n    private desired: ChunkPosition[] = [];\n    private center?: ChunkPosition;\n    private loading?: { position: ChunkPosition; controller: AbortController };\n    private running?: Promise<void>;\n    private disposal?: Promise<void>;\n    private disposed = false;\n\n    constructor(\n        private readonly world: Pick<MineRenderWorld<boolean>, \"placeChunk\" | \"unloadChunkColumn\">,\n        private readonly source: WorldChunkSource,\n        options: WorldStreamerOptions = {}\n    ) {\n        this.loadRadius = options.loadRadius ?? 2;\n        this.unloadRadius = options.unloadRadius ?? Math.min(32, this.loadRadius + 1);\n        if (![this.loadRadius, this.unloadRadius].every(value => Number.isInteger(value) && value >= 0 && value <= 32)\n            || this.unloadRadius < this.loadRadius) {\n            throw new RangeError(\"Chunk radii must be integers from 0 to 32, with unloadRadius at least loadRadius\");\n        }\n    }\n\n    /** Returns absolute coordinates of successfully placed columns, including retained columns. */\n    public get loadedChunks(): readonly { x: number; z: number }[] {\n        return [...this.loaded.values()].map(position => ({ ...position }));\n    }\n\n    /** Returns source failures retained within the unload radius. Failed columns do not block other loads. */\n    public get failedChunks(): readonly { x: number; z: number; error: unknown }[] {\n        return [...this.failed.values()].map(failure => ({ ...failure }));\n    }\n\n    /** Counts desired columns still waiting for a source read or placement, including the active column. */\n    public get pendingChunks(): number {\n        return this.desired.filter(position => this.needsLoad(position)).length;\n    }\n\n    /**\n     * Updates the center in absolute chunk coordinates. Repeated calls share the active drain.\n     * Source failures are recorded in failedChunks; other columns continue loading. Missing and failed\n     * columns are remembered within the retention radius. Call retryFailedChunks to retry source failures.\n     * Placement and unload failures reject the drain; call update again to retry those operations.\n     * Reads outside the latest load radius receive an abort signal; placement finishes before unloading.\n     * Sources should represent an unchanged world during streaming.\n     */\n    public async update(x: number, z: number): Promise<void> {\n        if (this.disposed) throw new Error(\"WorldStreamer is disposed\");\n        if (![x, z].every(value => Number.isSafeInteger(value)\n            && Number.isSafeInteger(value - this.unloadRadius) && Number.isSafeInteger(value + this.unloadRadius))) {\n            throw new RangeError(\"Chunk coordinates must be safe integers within the streaming radius\");\n        }\n        if (!this.center || this.center.x !== x || this.center.z !== z) {\n            this.center = { x, z };\n            this.desired = [];\n            for (let dz = -this.loadRadius; dz <= this.loadRadius; dz++) {\n                for (let dx = -this.loadRadius; dx <= this.loadRadius; dx++) {\n                    this.desired.push({ x: x + dx, z: z + dz });\n                }\n            }\n            this.desired.sort((a, b) => (a.x - x) ** 2 + (a.z - z) ** 2 - (b.x - x) ** 2 - (b.z - z) ** 2);\n            if (this.loading && !this.within(this.loading.position, this.loadRadius)) {\n                this.loading.controller.abort();\n            }\n        }\n        return this.running ??= Promise.resolve().then(() => this.drain());\n    }\n\n    /** Updates from a camera or view-center position in scene units. One chunk spans 256 scene units. */\n    public async updatePosition(position: { x: number; z: number }): Promise<void> {\n        if (![position.x, position.z].every(Number.isFinite)) throw new RangeError(\"Scene coordinates must be finite\");\n        return this.update(Math.floor(position.x / 256), Math.floor(position.z / 256));\n    }\n\n    /** Forgets recorded source failures and retries desired columns at the latest center. */\n    public async retryFailedChunks(): Promise<void> {\n        if (this.disposed) throw new Error(\"WorldStreamer is disposed\");\n        this.failed.clear();\n        if (this.center) await this.update(this.center.x, this.center.z);\n    }\n\n    /** Aborts source reads, waits for active work, then unloads owned columns. The world and source remain caller-owned. */\n    public dispose(): Promise<void> {\n        this.disposed = true;\n        this.desired = [];\n        this.center = undefined;\n        this.loading?.controller.abort();\n        return this.disposal ??= Promise.resolve().then(async () => {\n            await this.running?.catch(() => undefined);\n            let failure: unknown;\n            let failed = false;\n            for (const position of this.owned.values()) {\n                try {\n                    await this.unload(position);\n                } catch (error) {\n                    failed = true;\n                    failure ??= error;\n                }\n            }\n            this.missing.clear();\n            this.failed.clear();\n            if (failed) throw failure;\n        }).catch(error => {\n            this.disposal = undefined;\n            throw error;\n        });\n    }\n\n    private async drain(): Promise<void> {\n        try {\n            while (!this.disposed) {\n                for (const [key, position] of this.missing) {\n                    if (!this.within(position, this.unloadRadius)) this.missing.delete(key);\n                }\n                for (const [key, position] of this.failed) {\n                    if (!this.within(position, this.unloadRadius)) this.failed.delete(key);\n                }\n                // Failed placements remain owned until cleanup succeeds, even inside the retained area.\n                const obsolete = [...this.owned.values()].find(position =>\n                    !this.loaded.has(this.key(position)) || !this.within(position, this.unloadRadius));\n                if (obsolete) {\n                    await this.unload(obsolete);\n                    continue;\n                }\n                const position = this.desired.find(position => this.needsLoad(position));\n                if (!position) return;\n                let chunk: AnvilChunk | undefined;\n                const controller = new AbortController();\n                this.loading = { position, controller };\n                try {\n                    chunk = await this.source.getChunk(position.x, position.z, controller.signal);\n                    if (chunk) this.validateChunk(chunk, position);\n                } catch (error) {\n                    if (!controller.signal.aborted && !this.disposed && this.within(position, this.loadRadius)) {\n                        this.failed.set(this.key(position), { ...position, error });\n                    }\n                    continue;\n                } finally {\n                    this.loading = undefined;\n                }\n                if (controller.signal.aborted || this.disposed || !this.within(position, this.loadRadius)) continue;\n                if (!chunk) {\n                    this.missing.set(this.key(position), position);\n                    continue;\n                }\n                this.owned.set(this.key(position), position);\n                try {\n                    await this.world.placeChunk(chunk);\n                    this.loaded.set(this.key(position), position);\n                } catch (error) {\n                    try {\n                        await this.unload(position);\n                    } catch (cleanupError) {\n                        const failure = error instanceof Error ? error : new Error(String(error));\n                        try {\n                            Object.defineProperty(failure, \"cause\", { value: cleanupError, configurable: true });\n                        } catch {\n                            throw Object.assign(new Error(failure.message), { cause: cleanupError });\n                        }\n                        throw failure;\n                    }\n                    throw error;\n                }\n            }\n        } finally {\n            this.running = undefined;\n        }\n    }\n\n    private needsLoad(position: ChunkPosition): boolean {\n        const key = this.key(position);\n        return !this.loaded.has(key) && !this.missing.has(key) && !this.failed.has(key);\n    }\n\n    private async unload(position: ChunkPosition): Promise<void> {\n        await this.world.unloadChunkColumn(position.x, position.z);\n        this.owned.delete(this.key(position));\n        this.loaded.delete(this.key(position));\n    }\n\n    private validateChunk(chunk: AnvilChunk, position: ChunkPosition): void {\n        if (chunk.x !== position.x || chunk.z !== position.z) {\n            throw new Error(`World source returned chunk ${chunk.x},${chunk.z} for ${position.x},${position.z}`);\n        }\n    }\n\n    private within(position: ChunkPosition, radius: number): boolean {\n        return !!this.center && Math.abs(position.x - this.center.x) <= radius && Math.abs(position.z - this.center.z) <= radius;\n    }\n\n    private key(position: ChunkPosition): string {\n        return `${position.x},${position.z}`;\n    }\n}\n"],"mappings":"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","names":["position"]}
+{"version":3,"sources":["../../../../src/world/WorldStreamer.ts"],"sourcesContent":["import type { AnvilChunk } from \"./AnvilParser\";\nimport type { MineRenderWorld } from \"./MineRenderWorld\";\nimport type { WorldChunkSource } from \"./WorldChunkSource\";\n\nexport interface WorldStreamerOptions {\n    /** Loads a square of chunk columns around the center. Integer from 0 to 32; defaults to 2. */\n    loadRadius?: number;\n    /** Retains loaded columns within this radius. Defaults to loadRadius + 1, capped at 32. */\n    unloadRadius?: number;\n}\n\ninterface ChunkPosition {\n    x: number;\n    z: number;\n}\n\n/**\n * Loads nearby chunk columns in distance order and unloads distant columns.\n * Updates coalesce to the latest center and serialize world mutations. Use a dedicated world:\n * the streamer replaces columns it loads, and callers must await disposal before editing that world.\n * The source remains caller-owned. Lighting, biome tint, and LOD are not added by streaming.\n */\nexport class WorldStreamer {\n    private readonly loadRadius: number;\n    private readonly unloadRadius: number;\n    private readonly loaded = new Map<string, ChunkPosition>();\n    private readonly owned = new Map<string, ChunkPosition>();\n    private readonly missing = new Map<string, ChunkPosition>();\n    private readonly failed = new Map<string, ChunkPosition & { error: unknown }>();\n    private desired: ChunkPosition[] = [];\n    private center?: ChunkPosition;\n    private loading?: { position: ChunkPosition; controller: AbortController };\n    private running?: Promise<void>;\n    private disposal?: Promise<void>;\n    private disposed = false;\n\n    constructor(\n        private readonly world: Pick<MineRenderWorld<boolean>, \"placeChunk\" | \"unloadChunkColumns\">,\n        private readonly source: WorldChunkSource,\n        options: WorldStreamerOptions = {}\n    ) {\n        this.loadRadius = options.loadRadius ?? 2;\n        this.unloadRadius = options.unloadRadius ?? Math.min(32, this.loadRadius + 1);\n        if (![this.loadRadius, this.unloadRadius].every(value => Number.isInteger(value) && value >= 0 && value <= 32)\n            || this.unloadRadius < this.loadRadius) {\n            throw new RangeError(\"Chunk radii must be integers from 0 to 32, with unloadRadius at least loadRadius\");\n        }\n    }\n\n    /** Returns absolute coordinates of successfully placed columns, including retained columns. */\n    public get loadedChunks(): readonly { x: number; z: number }[] {\n        return [...this.loaded.values()].map(position => ({ ...position }));\n    }\n\n    /** Returns source failures retained within the unload radius. Failed columns do not block other loads. */\n    public get failedChunks(): readonly { x: number; z: number; error: unknown }[] {\n        return [...this.failed.values()].map(failure => ({ ...failure }));\n    }\n\n    /** Counts desired columns still waiting for a source read or placement, including the active column. */\n    public get pendingChunks(): number {\n        return this.desired.filter(position => this.needsLoad(position)).length;\n    }\n\n    /**\n     * Updates the center in absolute chunk coordinates. Repeated calls share the active drain.\n     * Source failures are recorded in failedChunks; other columns continue loading. Missing and failed\n     * columns are remembered within the retention radius. Call retryFailedChunks to retry source failures.\n     * Placement and unload failures reject the drain; call update again to retry those operations.\n     * Reads outside the latest load radius receive an abort signal; placement finishes before unloading.\n     * Sources should represent an unchanged world during streaming.\n     */\n    public async update(x: number, z: number): Promise<void> {\n        if (this.disposed) throw new Error(\"WorldStreamer is disposed\");\n        if (![x, z].every(value => Number.isSafeInteger(value)\n            && Number.isSafeInteger(value - this.unloadRadius) && Number.isSafeInteger(value + this.unloadRadius))) {\n            throw new RangeError(\"Chunk coordinates must be safe integers within the streaming radius\");\n        }\n        if (!this.center || this.center.x !== x || this.center.z !== z) {\n            this.center = { x, z };\n            this.desired = [];\n            for (let dz = -this.loadRadius; dz <= this.loadRadius; dz++) {\n                for (let dx = -this.loadRadius; dx <= this.loadRadius; dx++) {\n                    this.desired.push({ x: x + dx, z: z + dz });\n                }\n            }\n            this.desired.sort((a, b) => (a.x - x) ** 2 + (a.z - z) ** 2 - (b.x - x) ** 2 - (b.z - z) ** 2);\n            if (this.loading && !this.within(this.loading.position, this.loadRadius)) {\n                this.loading.controller.abort();\n            }\n        }\n        return this.running ??= Promise.resolve().then(() => this.drain());\n    }\n\n    /** Updates from a camera or view-center position in scene units. One chunk spans 256 scene units. */\n    public async updatePosition(position: { x: number; z: number }): Promise<void> {\n        if (![position.x, position.z].every(Number.isFinite)) throw new RangeError(\"Scene coordinates must be finite\");\n        return this.update(Math.floor(position.x / 256), Math.floor(position.z / 256));\n    }\n\n    /** Forgets recorded source failures and retries desired columns at the latest center. */\n    public async retryFailedChunks(): Promise<void> {\n        if (this.disposed) throw new Error(\"WorldStreamer is disposed\");\n        this.failed.clear();\n        if (this.center) await this.update(this.center.x, this.center.z);\n    }\n\n    /** Aborts source reads, waits for active work, then unloads owned columns. The world and source remain caller-owned. */\n    public dispose(): Promise<void> {\n        this.disposed = true;\n        this.desired = [];\n        this.center = undefined;\n        this.loading?.controller.abort();\n        return this.disposal ??= Promise.resolve().then(async () => {\n            await this.running?.catch(() => undefined);\n            try {\n                await this.unloadMany([...this.owned.values()]);\n            } finally {\n                this.missing.clear();\n                this.failed.clear();\n            }\n        }).catch(error => {\n            this.disposal = undefined;\n            throw error;\n        });\n    }\n\n    private async drain(): Promise<void> {\n        try {\n            while (!this.disposed) {\n                for (const [key, position] of this.missing) {\n                    if (!this.within(position, this.unloadRadius)) this.missing.delete(key);\n                }\n                for (const [key, position] of this.failed) {\n                    if (!this.within(position, this.unloadRadius)) this.failed.delete(key);\n                }\n                // Failed placements remain owned until cleanup succeeds, even inside the retained area.\n                const obsolete = [...this.owned.values()].filter(position =>\n                    !this.loaded.has(this.key(position)) || !this.within(position, this.unloadRadius));\n                if (obsolete.length) {\n                    await this.unloadMany(obsolete);\n                    continue;\n                }\n                const position = this.desired.find(position => this.needsLoad(position));\n                if (!position) return;\n                let chunk: AnvilChunk | undefined;\n                const controller = new AbortController();\n                this.loading = { position, controller };\n                try {\n                    chunk = await this.source.getChunk(position.x, position.z, controller.signal);\n                    if (chunk) this.validateChunk(chunk, position);\n                } catch (error) {\n                    if (!controller.signal.aborted && !this.disposed && this.within(position, this.loadRadius)) {\n                        this.failed.set(this.key(position), { ...position, error });\n                    }\n                    continue;\n                } finally {\n                    this.loading = undefined;\n                }\n                if (controller.signal.aborted || this.disposed || !this.within(position, this.loadRadius)) continue;\n                if (!chunk) {\n                    this.missing.set(this.key(position), position);\n                    continue;\n                }\n                this.owned.set(this.key(position), position);\n                try {\n                    await this.world.placeChunk(chunk);\n                    this.loaded.set(this.key(position), position);\n                } catch (error) {\n                    try {\n                        await this.unloadMany([position]);\n                    } catch (cleanupError) {\n                        const failure = error instanceof Error ? error : new Error(String(error));\n                        try {\n                            Object.defineProperty(failure, \"cause\", { value: cleanupError, configurable: true });\n                        } catch {\n                            throw Object.assign(new Error(failure.message), { cause: cleanupError });\n                        }\n                        throw failure;\n                    }\n                    throw error;\n                }\n            }\n        } finally {\n            this.running = undefined;\n        }\n    }\n\n    private needsLoad(position: ChunkPosition): boolean {\n        const key = this.key(position);\n        return !this.loaded.has(key) && !this.missing.has(key) && !this.failed.has(key);\n    }\n\n    private async unloadMany(positions: readonly ChunkPosition[]): Promise<void> {\n        if (!positions.length) return;\n        try {\n            await this.world.unloadChunkColumns(positions.map(({ x, z }) => ({ x, z })));\n        } catch (error) {\n            // A rejected batch may have removed any subset; retry every owner before reloading it.\n            for (const position of positions) this.loaded.delete(this.key(position));\n            throw error;\n        }\n        for (const position of positions) {\n            this.owned.delete(this.key(position));\n            this.loaded.delete(this.key(position));\n        }\n    }\n\n    private validateChunk(chunk: AnvilChunk, position: ChunkPosition): void {\n        if (chunk.x !== position.x || chunk.z !== position.z) {\n            throw new Error(`World source returned chunk ${chunk.x},${chunk.z} for ${position.x},${position.z}`);\n        }\n    }\n\n    private within(position: ChunkPosition, radius: number): boolean {\n        return !!this.center && Math.abs(position.x - this.center.x) <= radius && Math.abs(position.z - this.center.z) <= radius;\n    }\n\n    private key(position: ChunkPosition): string {\n        return `${position.x},${position.z}`;\n    }\n}\n"],"mappings":"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","names":["position"]}

package/dist/browser/index.d.ts

@@ -4066,7 +4066,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>>;
@@ -4078,11 +4078,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.
@@ -4093,7 +4096,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;
@@ -4258,6 +4261,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. */
@@ -4335,7 +4346,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;
@@ -4369,7 +4380,7 @@ declare class WorldStreamer {
     dispose(): Promise<void>;
     private drain;
     private needsLoad;
-    private unload;
+    private unloadMany;
     private validateChunk;
     private within;
     private key;

package/dist/browser/index.js

@@ -18686,8 +18686,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 ?? (this.biomeRefreshing = Promise.resolve().then(async () => {
       const failures = /* @__PURE__ */ new Map();
@@ -18699,7 +18705,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);
@@ -18961,15 +18967,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) log19.warn("Failed to refresh biome colors", failures.values().next().value);
       await this.updateCulling([]);
     }
@@ -19032,7 +19058,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);
@@ -19054,58 +19080,72 @@ var MineRenderWorld = class {
         }
       }
     }
+    if (defer) return Promise.resolve();
     return this.culling ?? (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;
@@ -19122,7 +19162,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);
@@ -19856,11 +19896,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();
@@ -19917,7 +19960,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();
     }
   }
@@ -20571,19 +20614,12 @@ var WorldStreamer = class {
     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);
-        }
+      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;
@@ -20598,9 +20634,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));
@@ -20630,7 +20666,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 {
@@ -20651,10 +20687,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) {