minerender 2.1.0-alpha.128 → 2.1.0-alpha.129

package/dist/node/index.mjs

@@ -251,6 +251,13 @@ var Caching;
 var init_Caching = __esm({
   "src/cache/Caching.ts"() {
     Caching = class _Caching {
+      static {
+        this._generation = 0;
+      }
+      /** Changes when shared assets are cleared, so derived caches can discard their old values. */
+      static get generation() {
+        return this._generation;
+      }
       static {
         this.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
       }
@@ -361,6 +368,7 @@ var init_Caching = __esm({
       }
       /** Invalidates in-memory entries so later lookups reload them. Persisted entries are retained. */
       static clear() {
+        this._generation++;
         for (const cache of this.all) {
           cache.invalidateAll();
         }
@@ -372,6 +380,7 @@ var init_Caching = __esm({
        * Use {@link shutdown} to also stop requests and the shared Ticker.
        */
       static end() {
+        this._generation++;
         for (const cache of this.all) {
           cache.invalidateAll();
           cache.end();
@@ -17381,18 +17390,23 @@ var SectionModels = class {
       return this.template(variant, choice, tints);
     }));
   }
-  /** Resolves section templates for one tint palette, with a synchronous weighted choice for each cell. */
-  async prepareState(blockState3, properties = {}, biomeColor) {
+  /** Resolves shared templates; dynamic biome tints are supplied on section placements instead of cached geometry. */
+  async prepareState(blockState3, properties = {}, biomeColor, dynamicBiomeTint = false) {
     const prepared = await this.state(blockState3, properties);
     if (!prepared) return void 0;
     let color2;
     const resolveColor = typeof biomeColor === "function" ? () => color2 ??= biomeColor() : biomeColor;
     const templates = /* @__PURE__ */ new Map();
+    const source = dynamicBiomeTint && await BlockTints.biomeSource(blockState3.key);
     await Promise.all([...prepared.choices].map(async ([variant, choice]) => {
       const tints = await BlockTints.get(blockState3.key, prepared.state, choice.model, void 0, resolveColor);
-      templates.set(variant, await this.template(variant, choice, tints));
+      const biomeTints = source ? await BlockTints.get(blockState3.key, prepared.state, choice.model, void 0, 16777215) : void 0;
+      templates.set(variant, await this.template(variant, choice, tints, biomeTints));
     }));
-    return { pick: (position) => prepared.groups.map((group) => templates.get(BlockStateResolver.choose(group, position))) };
+    return {
+      pick: (position) => prepared.groups.map((group) => templates.get(BlockStateResolver.choose(group, position))),
+      biomeTint: source ? [...templates.values()].some((template) => template.biomeTint?.some((value) => value === 1)) || void 0 : void 0
+    };
   }
   async state(blockState3, properties) {
     let states = this.states.get(blockState3);
@@ -17435,10 +17449,10 @@ var SectionModels = class {
     }
     return { state, groups, choices: prepared };
   }
-  async template(variant, { model, atlas, rotation }, tints) {
+  async template(variant, { model, atlas, rotation }, tints, biomeTints) {
     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]);
+    const key = JSON.stringify([rotation.x, rotation.y, rotation.z, variant.uvlock, tints, biomeTints]);
     return cached(models, key, async () => {
       const object4 = new SectionModel(model, {
         instanceMeshes: false,
@@ -17452,11 +17466,13 @@ var SectionModels = class {
       object4.clear();
       const keep = [];
       const cullFaces = [];
+      const biomeTint = biomeTints ? [] : void 0;
       for (const element of atlas.model.elements) {
         for (const face of CUBE_FACES) {
           const data = element.faces[face];
           keep.push(data !== void 0);
           if (!data) continue;
+          biomeTint?.push(Number(data.tintindex !== void 0 && biomeTints?.[data.tintindex] !== void 0));
           const local = CUBE_FACES.findIndex((name) => name === data.cullface);
           if (local < 0) {
             cullFaces.push(0);
@@ -17472,6 +17488,7 @@ var SectionModels = class {
         geometry,
         atlas,
         cullFaces: new Uint8Array(cullFaces),
+        biomeTint: biomeTint?.some(Boolean) ? new Uint8Array(biomeTint) : void 0,
         occludes: ModelCulling.isOpaqueFullCube(atlas) && ModelCulling.toLocalMask(63, rotation) === 63,
         layer: atlas.hasTranslucency ? 1 : 0,
         ambientOcclusion: model.ambientocclusion !== false
@@ -17701,6 +17718,132 @@ var WorldEntities = class {
 // src/world/MineRenderWorld.ts
 init_FluidQuads();
 
+// src/world/_biomes/BiomeBlend.ts
+init_AssetKey();
+init_AssetLoader();
+init_Caching();
+var MAX_TILES = 256;
+function validateBiomeBlendRadius(radius) {
+  if (!Number.isInteger(radius) || radius < 0 || radius > 7) {
+    throw new RangeError("biomeBlendRadius must be an integer from 0 to 7");
+  }
+}
+var BiomeBlend = class {
+  constructor(biomeAt, radius) {
+    this.biomeAt = biomeAt;
+    this.tiles = /* @__PURE__ */ new Map();
+    this.generation = Caching.generation;
+    validateBiomeBlendRadius(radius);
+    this._radius = radius;
+  }
+  get radius() {
+    return this._radius;
+  }
+  clear() {
+    this.tiles.clear();
+  }
+  invalidateColumn(x, z) {
+    for (const [key, tile] of this.tiles) {
+      if (Math.abs(tile.x - x) <= 1 && Math.abs(tile.z - z) <= 1) this.tiles.delete(key);
+    }
+  }
+  async getColor(kind, origin, position) {
+    const [x, y, z] = position;
+    const biome = this.biomeAt(x, y, z);
+    if (biome === void 0) return void 0;
+    if (this.generation !== Caching.generation) {
+      this.clear();
+      this.generation = Caching.generation;
+    }
+    const tileX = Math.floor(x / 16), tileZ = Math.floor(z / 16), quartY = Math.floor(y / 4);
+    const root = origin?.root ?? AssetLoader.ROOT;
+    const key = JSON.stringify([root, AssetLoader.persistentScope, kind, this._radius, tileX, quartY, tileZ]);
+    let tile = this.tiles.get(key);
+    if (tile) {
+      this.tiles.delete(key);
+      this.tiles.set(key, tile);
+    } else {
+      const snapshot = new AssetKey("minecraft", "", void 0, void 0, "assets", ".json", root);
+      const colors = this.buildTile(kind, snapshot, tileX, quartY, tileZ, this._radius).then((result2) => {
+        if (!result2.complete && this.tiles.get(key)?.colors === colors) this.tiles.delete(key);
+        return result2;
+      }, (error) => {
+        if (this.tiles.get(key)?.colors === colors) this.tiles.delete(key);
+        throw error;
+      });
+      tile = { x: tileX, z: tileZ, colors };
+      this.tiles.set(key, tile);
+      if (this.tiles.size > MAX_TILES) this.tiles.delete(this.tiles.keys().next().value);
+    }
+    const result = await tile.colors;
+    if (result.failures.has(biome)) throw result.failures.get(biome);
+    const color2 = result.colors[(z - tileZ * 16) * 16 + x - tileX * 16];
+    return color2 === -1 ? void 0 : color2;
+  }
+  async buildTile(kind, origin, tileX, quartY, tileZ, radius) {
+    const size = 16 + radius * 2, stride = size + 1;
+    const startX = tileX * 16 - radius, startZ = tileZ * 16 - radius;
+    const quartX = Math.floor(startX / 4), quartZ = Math.floor(startZ / 4);
+    const quartSize = Math.floor((startX + size - 1) / 4) - quartX + 1;
+    const ids = new Array(quartSize * quartSize);
+    const biomes = /* @__PURE__ */ new Map();
+    for (let z = 0; z < quartSize; z++) {
+      for (let x = 0; x < quartSize; x++) {
+        const id = this.biomeAt((quartX + x) * 4, quartY * 4, (quartZ + z) * 4);
+        ids[z * quartSize + x] = id;
+        if (id !== void 0 && !biomes.has(id)) {
+          biomes.set(id, (async () => {
+            const swamp = kind === "grass" && (await Biomes.get(id, origin))?.effects.grass_color_modifier === "swamp";
+            return { color: swamp ? void 0 : await Biomes.getColor(id, kind, origin), swamp };
+          })());
+        }
+      }
+    }
+    const failures = /* @__PURE__ */ new Map();
+    const loaded = new Map(await Promise.all([...biomes].map(async ([id, color2]) => {
+      try {
+        return [id, await color2];
+      } catch (error) {
+        failures.set(id, error);
+        return [id, { color: void 0, swamp: false }];
+      }
+    })));
+    const complete = [...loaded.values()].every((value) => value.swamp || value.color !== void 0);
+    const samples = new Int32Array(size * size).fill(-1);
+    const sums = Array.from({ length: 4 }, () => new Uint32Array(stride * stride));
+    for (let z = 0; z < size; z++) {
+      const row = [0, 0, 0, 0];
+      for (let x = 0; x < size; x++) {
+        const id = ids[(Math.floor((startZ + z) / 4) - quartZ) * quartSize + Math.floor((startX + x) / 4) - quartX];
+        const value = id === void 0 ? void 0 : loaded.get(id);
+        const color2 = value?.swamp ? swampGrassColor(startX + x, startZ + z) : value?.color;
+        if (color2 !== void 0) {
+          samples[z * size + x] = color2;
+          row[0] += color2 >> 16 & 255;
+          row[1] += color2 >> 8 & 255;
+          row[2] += color2 & 255;
+          row[3]++;
+        }
+        for (let channel = 0; channel < 4; channel++) {
+          sums[channel][(z + 1) * stride + x + 1] = sums[channel][z * stride + x + 1] + row[channel];
+        }
+      }
+    }
+    const colors = new Int32Array(256).fill(-1), width = radius * 2 + 1;
+    for (let z = 0; z < 16; z++) {
+      for (let x = 0; x < 16; x++) {
+        if (samples[(z + radius) * size + x + radius] === -1) continue;
+        const topLeft = z * stride + x, topRight = topLeft + width;
+        const bottomLeft = (z + width) * stride + x, bottomRight = bottomLeft + width;
+        const sum = (values) => values[bottomRight] - values[bottomLeft] - values[topRight] + values[topLeft];
+        const count = sum(sums[3]);
+        if (count) colors[z * 16 + x] = Math.floor(sum(sums[0]) / count) << 16 | Math.floor(sum(sums[1]) / count) << 8 | Math.floor(sum(sums[2]) / count);
+      }
+    }
+    return { colors, complete, failures };
+  }
+};
+
 // src/world/WorldLight.ts
 function copySectionLight(light) {
   const copy = {};
@@ -17764,12 +17907,17 @@ var MineRenderWorld = class {
     this.lightValidity = /* @__PURE__ */ new Map();
     this.highestSkySection = /* @__PURE__ */ new Map();
     this.ambientOcclusionPending = false;
+    this.pendingBiomes = /* @__PURE__ */ new Map();
     this.pendingCulling = /* @__PURE__ */ new Map();
     if (options.savedLighting && !options.sectionMeshing) throw new TypeError("savedLighting requires sectionMeshing");
     if (options.ambientOcclusion && !options.sectionMeshing) throw new TypeError("ambientOcclusion requires sectionMeshing");
     if (options.ambientLight !== void 0 && (!Number.isFinite(options.ambientLight) || options.ambientLight < 0 || options.ambientLight > 1)) {
       throw new RangeError("ambientLight must be a number from 0 to 1");
     }
+    this._biomeBlendRadius = options.biomeBlendRadius ?? 0;
+    validateBiomeBlendRadius(this._biomeBlendRadius);
+    if (this._biomeBlendRadius > 0 && !options.sectionMeshing) throw new TypeError("biomeBlendRadius requires sectionMeshing");
+    if (this._biomeBlendRadius) this.biomeBlend = new BiomeBlend((x, y, z) => this.getBiomeAt(x, y, z), this._biomeBlendRadius);
     this.scene = scene;
     this.savedLighting = options.savedLighting ?? false;
     this.ambientLight = options.ambientLight ?? 0;
@@ -17810,6 +17958,65 @@ var MineRenderWorld = class {
     await this.updateCulling([]);
     this.ambientOcclusionPending = false;
   }
+  /** Horizontal biome-color sampling radius, from 0 to 7 blocks. Zero disables blending. */
+  get biomeBlendRadius() {
+    return this._biomeBlendRadius;
+  }
+  /** Refreshes loaded grass, foliage, and water colors without reloading their source chunks. */
+  async setBiomeBlendRadius(radius) {
+    validateBiomeBlendRadius(radius);
+    if (radius > 0 && !this.sectionModels) throw new TypeError("biomeBlendRadius requires sectionMeshing");
+    if (radius !== this._biomeBlendRadius) {
+      this._biomeBlendRadius = radius;
+      this.biomeBlend?.clear();
+      this.biomeBlend = radius ? new BiomeBlend((x, y, z) => this.getBiomeAt(x, y, z), radius) : void 0;
+      for (const chunk of this._chunks.values()) this.pendingBiomes.set(chunk, void 0);
+    }
+    const failures = await this.refreshBiomes();
+    if (failures.size) throw failures.values().next().value;
+  }
+  markBiomesChanged(x, z, y, includeColumn = true) {
+    const queued = [];
+    if (!this.biomeBlend) return queued;
+    this.biomeBlend.invalidateColumn(x, z);
+    for (const chunk of this._chunks.values()) {
+      if (Math.abs(chunk.x - x) > 1 || Math.abs(chunk.z - z) > 1 || !includeColumn && chunk.x === x && chunk.z === z || y !== void 0 && chunk.y !== y && chunk.y !== y + 1) continue;
+      queued.push(chunk);
+      if (!this.pendingBiomes.has(chunk)) this.pendingBiomes.set(chunk, []);
+      const columns = this.pendingBiomes.get(chunk);
+      if (columns && !columns.some((column) => column.x === x && column.z === z)) columns.push({ x, z });
+    }
+    return queued;
+  }
+  async refreshBiomes() {
+    if (this.biomeRefreshing) await this.biomeRefreshing;
+    if (!this.pendingBiomes.size) return /* @__PURE__ */ new Map();
+    return this.biomeRefreshing ??= Promise.resolve().then(async () => {
+      const failures = /* @__PURE__ */ new Map();
+      const batch = [...this.pendingBiomes.keys()];
+      let sliceStart = performance.now();
+      try {
+        for (const chunk of batch) {
+          const columns = this.pendingBiomes.get(chunk);
+          this.pendingBiomes.delete(chunk);
+          if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) !== chunk) continue;
+          try {
+            await chunk.refreshBiomes(columns);
+          } catch (error) {
+            failures.set(chunk, error);
+            if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) === chunk) this.pendingBiomes.set(chunk, void 0);
+          }
+          if (performance.now() - sliceStart > 8) {
+            await yieldToEventLoop();
+            sliceStart = performance.now();
+          }
+        }
+        return failures;
+      } finally {
+        this.biomeRefreshing = void 0;
+      }
+    });
+  }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
       return this.getBlockAt(new Vector319(posOrX, y, z));
@@ -18045,6 +18252,9 @@ var MineRenderWorld = class {
       }
       await placeEntities?.();
     } finally {
+      this.markBiomesChanged(chunk.x, chunk.z, void 0, false);
+      const failures = await this.refreshBiomes();
+      if (failures.size) console.warn("Failed to refresh biome colors", failures.values().next().value);
       await this.updateCulling([...changes.values()]);
     }
   }
@@ -18061,11 +18271,14 @@ var MineRenderWorld = class {
     try {
       await this.clearChunkColumn(x, z);
     } finally {
+      const failures = await this.refreshBiomes();
+      if (failures.size) console.warn("Failed to refresh biome colors", failures.values().next().value);
       await this.updateCulling([]);
     }
   }
   async clearChunkColumn(x, z) {
     this.biomes.delete(`${x}_${z}`);
+    this.markBiomesChanged(x, z, void 0, false);
     if (this.savedLighting) {
       for (const y of this.light.get(`${x}_${z}`)?.keys() ?? []) this.markSectionChanged({ x, y, z });
     }
@@ -18076,6 +18289,7 @@ var MineRenderWorld = class {
     for (const [key, section] of previous) {
       this._chunks.delete(key);
       this.pendingCulling.delete(section);
+      this.pendingBiomes.delete(section);
       await section.clear(false);
       this.markSectionChanged(section);
     }
@@ -18110,6 +18324,8 @@ var MineRenderWorld = class {
     const chunks = [...this._chunks.values()];
     this._chunks.clear();
     this.biomes.clear();
+    this.biomeBlend?.clear();
+    this.pendingBiomes.clear();
     this.light.clear();
     this.lightValidity.clear();
     this.highestSkySection.clear();
@@ -18228,8 +18444,14 @@ var MineRenderWorld = class {
             column?.delete(y);
             if (!column?.size) this.biomes.delete(columnKey);
           }
-          await chunk.refreshBiomes();
-          await this._chunks.get(`${x}_${y + 1}_${z}`)?.refreshBiomes();
+          if (this.biomeBlend) {
+            const queued = this.markBiomesChanged(x, z, y);
+            const failures = await this.refreshBiomes();
+            for (const chunk2 of queued) if (failures.has(chunk2)) throw failures.get(chunk2);
+          } else {
+            await chunk.refreshBiomes();
+            await this._chunks.get(`${x}_${y + 1}_${z}`)?.refreshBiomes();
+          }
         },
         this.savedLighting ? (x2, y2, z2) => this.lightLevelAt(x2, y2, z2) : void 0,
         async () => {
@@ -18246,7 +18468,8 @@ var MineRenderWorld = class {
             await this.updateCulling([]);
           }
         },
-        this.ambientLight
+        this.ambientLight,
+        () => this.biomeBlend
       );
       this._chunks.set(key, chunk);
     }
@@ -18365,9 +18588,10 @@ var LIGHT_SAMPLE_OFFSETS = [0, 1, -1, 324, -324, 18, -18];
 
 // src/world/SectionGeometry.ts
 function buildSectionGeometry(input) {
-  const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion } = input;
+  const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion, biomeTints } = 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");
+  if (biomeTints && biomeTints.length !== count * 3) throw new RangeError("Section biome tints must contain RGB for each placement");
   if (fluids && fluids.cells.length !== 5832) throw new RangeError("Section fluid cells must cover an 18\xD718\xD718 neighborhood");
   if (fluids?.waterTints && fluids.waterTints.length !== 4096 * 3) throw new RangeError("Section water tints must contain RGB for 4096 cells");
   if (light && (light.length !== 5832 || light.some((level) => level > 15 && level !== 255))) {
@@ -18382,7 +18606,7 @@ function buildSectionGeometry(input) {
   const cornerBrightness2 = ambientOcclusion ? new Float32Array(4) : void 0;
   for (const template of templateData) {
     const { quads } = template;
-    if (template.positions.length !== quads * 12 || template.normals.length !== quads * 12 || template.uvs.length !== quads * 8 || template.uvBounds.length !== quads * 16 || template.colors.length !== quads * 12 || template.indices.length !== quads * 6 || template.cullFaces.length !== quads) {
+    if (template.positions.length !== quads * 12 || template.normals.length !== quads * 12 || template.uvs.length !== quads * 8 || template.uvBounds.length !== quads * 16 || template.colors.length !== quads * 12 || template.indices.length !== quads * 6 || template.cullFaces.length !== quads || template.biomeTint && template.biomeTint.length !== quads) {
       throw new RangeError("Section template arrays do not match its quad count");
     }
   }
@@ -18492,6 +18716,7 @@ function buildSectionGeometry(input) {
         blockIndices[indexOffset / 6] = indices[entry];
         if (ambientMask) quadAmbientOcclusion(template.positions, template.normals, quad, ambientMask, cornerBrightness2);
         const brightness = light ? lightBrightness(light[lightIndex + LIGHT_SAMPLE_OFFSETS[quadLightIndex(template.positions, template.normals, quad)]], ambientLight) : 1;
+        const tint = biomeTints && template.biomeTint?.[quad] && !Number.isNaN(biomeTints[entry * 3]) ? entry * 3 : void 0;
         const start = vertex;
         for (let corner = 0; corner < 4; corner++, vertex++) {
           const source = quad * 4 + corner;
@@ -18508,9 +18733,9 @@ function buildSectionGeometry(input) {
           uvBounds[vertex * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
           uvBounds[vertex * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
           const factor = brightness * (ambientMask ? cornerBrightness2[corner] : 1);
-          colors[vertex * 3] = template.colors[source * 3] * factor;
-          colors[vertex * 3 + 1] = template.colors[source * 3 + 1] * factor;
-          colors[vertex * 3 + 2] = template.colors[source * 3 + 2] * factor;
+          colors[vertex * 3] = (tint === void 0 ? template.colors[source * 3] : biomeTints[tint]) * factor;
+          colors[vertex * 3 + 1] = (tint === void 0 ? template.colors[source * 3 + 1] : biomeTints[tint + 1]) * factor;
+          colors[vertex * 3 + 2] = (tint === void 0 ? template.colors[source * 3 + 2] : biomeTints[tint + 2]) * factor;
         }
         for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[quad * 6 + corner];
       }
@@ -18632,7 +18857,11 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
     ...lighting
   };
   for (let i = 0; i < entries.length; i++) {
-    const { index, template, cullMask } = entries[i];
+    const { index, template, cullMask, biomeTint } = entries[i];
+    if (biomeTint) {
+      input.biomeTints ??= new Float32Array(entries.length * 3).fill(NaN);
+      input.biomeTints.set(biomeTint, i * 3);
+    }
     let id = templateIds.get(template);
     if (id === void 0) {
       let atlas = atlasIds.get(template.atlas);
@@ -18659,6 +18888,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
           colors: new Float32Array(quads * 12),
           indices: new Uint16Array(quads * 6),
           cullFaces: new Uint8Array(template.cullFaces),
+          biomeTint: template.biomeTint ? new Uint8Array(template.biomeTint) : void 0,
           atlas: 0,
           layer: template.layer,
           ambientOcclusion: template.ambientOcclusion
@@ -18803,7 +19033,7 @@ init_CubeFace();
 init_InstanceReference();
 var WATER_TINT2 = new Color13(4159204).toArray();
 var Chunk = class _Chunk {
-  constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
+  constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0, biomeBlend) {
     this.onBlocksChanged = onBlocksChanged;
     this.sectionModels = sectionModels;
     this.neighborCell = neighborCell;
@@ -18812,6 +19042,7 @@ var Chunk = class _Chunk {
     this.lightAt = lightAt;
     this.onLightCleared = onLightCleared;
     this.ambientLight = ambientLight;
+    this.biomeBlend = biomeBlend;
     this.data = new ChunkData();
     this.renderedBlocks = /* @__PURE__ */ new Map();
     this.objectBlocks = /* @__PURE__ */ new Set();
@@ -18821,6 +19052,7 @@ var Chunk = class _Chunk {
     this.blockPosition = new Vector320();
     this.meshDirty = false;
     this.meshGeneration = 0;
+    this.blockChanges = /* @__PURE__ */ new Set();
     this.scene = scene;
     this.x = x;
     this.y = y;
@@ -18919,10 +19151,20 @@ var Chunk = class _Chunk {
     return this.refreshBiomes();
   }
   /** Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects. */
-  async refreshBiomes() {
+  refreshBiomes(columns) {
+    return this.changeBlocks(() => this.refreshBiomeBlocks(columns), true);
+  }
+  async refreshBiomeBlocks(columns) {
+    const blend = columns && this.biomeBlend?.();
+    const ownColumn = columns?.some((column) => column.x === this.x && column.z === this.z);
     const affected = /* @__PURE__ */ new Map();
     const blocks = [];
     for (const index of this.renderedBlocks.keys()) {
+      if (blend) {
+        if (this.objectBlocks.has(index) && !ownColumn) continue;
+        const [x, , z] = this.positionAt(index), radius = blend.radius;
+        if (!columns.some((column) => x >= column.x * 16 - radius && x <= column.x * 16 + 15 + radius && z >= column.z * 16 - radius && z <= column.z * 16 + 15 + radius)) continue;
+      }
       const block = this.data.get(index);
       const stateKey = ChunkData.paletteKey(block);
       let matches = affected.get(stateKey);
@@ -18937,10 +19179,32 @@ var Chunk = class _Chunk {
       }
       if (await matches) blocks.push({ index, block });
     }
+    if (blend) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const entry of blocks) {
+        const key = ChunkData.paletteKey(entry.block);
+        let group = groups.get(key);
+        if (!group) groups.set(key, group = []);
+        group.push(entry);
+      }
+      blocks.length = 0;
+      const biomes = /* @__PURE__ */ new Map();
+      for (const group of groups.values()) {
+        const { contexts, fluid } = await this.resolveState(group[0].block, group.map((entry) => entry.index), biomes);
+        for (const entry of group) {
+          const context = contexts.get(entry.index);
+          const current = this.sectionBlocks.get(entry.index)?.[0]?.biomeTint;
+          const tint = context?.tint;
+          const tintChanged = !!current !== !!tint || tint?.some((value, channel) => value !== current?.[channel]);
+          const waterChanged = fluid?.kind === "water" && (context?.waterTint ?? WATER_TINT2).some((value, channel) => Math.fround(value) !== (this.waterTints?.[entry.index * 3 + channel] ?? Math.fround(WATER_TINT2[channel])));
+          if (this.objectBlocks.has(entry.index) || tintChanged || waterChanged) blocks.push(entry);
+        }
+      }
+    }
     if (!blocks.length) return;
     const hidden = new Set(this.hiddenBlocks);
     try {
-      await this.placeBlocks(blocks);
+      await this.replaceBlocks(blocks, true);
     } finally {
       for (const index of hidden) {
         this.hiddenBlocks.add(index);
@@ -18980,6 +19244,20 @@ var Chunk = class _Chunk {
   }
   /** Places cells in input order and returns changed world positions without refreshing neighbors. */
   async placeBlocks(blocks) {
+    return this.changeBlocks(() => this.replaceBlocks(blocks));
+  }
+  changeBlocks(change, refreshBiomes = false) {
+    const before = refreshBiomes ? Promise.allSettled(this.blockChanges) : this.biomeChange;
+    const result = before ? before.catch(() => void 0).then(change) : change();
+    const pending = result.finally(() => {
+      this.blockChanges.delete(pending);
+      if (this.biomeChange === pending) this.biomeChange = void 0;
+    });
+    this.blockChanges.add(pending);
+    if (refreshBiomes) this.biomeChange = pending;
+    return pending;
+  }
+  async replaceBlocks(blocks, preserveDataOnFailure = false) {
     const placements = blocks.map(({ index, block }) => ({
       index,
       key: block && !ChunkData.isAir(block) ? ChunkData.paletteKey(block) : void 0,
@@ -18999,6 +19277,10 @@ var Chunk = class _Chunk {
     const biomes = /* @__PURE__ */ new Map();
     const settled = await Promise.allSettled([...states.values()].map(({ stored, indices }) => this.resolveState(stored, indices, biomes)));
     const resolutions = new Map([...states.keys()].map((key, i) => [key, settled[i]]));
+    if (preserveDataOnFailure) {
+      const rejected = settled.find((result) => result.status === "rejected");
+      if (rejected?.status === "rejected") throw rejected.reason;
+    }
     const positions = [];
     let failed = false, failure;
     for (const { index, key, block } of placements) {
@@ -19036,7 +19318,7 @@ var Chunk = class _Chunk {
         }
         const templates = perBlock ? void 0 : fluid?.renderModel === false ? [] : (context?.prepared ?? prepared)?.pick(variantPosition);
         if (templates) {
-          this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0 })));
+          this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0, biomeTint: context?.tint })));
           this.meshDirty = true;
         } else {
           object4 = await this.scene.addBlock(blockState3, {
@@ -19055,7 +19337,11 @@ var Chunk = class _Chunk {
         }, object: object4 });
         if (object4) this.objectBlocks.add(index);
       } catch (error) {
-        this.data.assign(index, 0);
+        if (preserveDataOnFailure && readBlock) {
+          this.renderedBlocks.set(index, { get block() {
+            return readBlock();
+          }, object: void 0 });
+        } else this.data.assign(index, 0);
         this.fluidCells[index] = 0;
         object4?.removeFromScene();
         if (!failed) failure = error;
@@ -19066,7 +19352,10 @@ var Chunk = class _Chunk {
     return positions;
   }
   /** Replaces every cell from parsed section data. The caller refreshes neighbor culling. */
-  async placeSection(data) {
+  placeSection(data) {
+    return this.changeBlocks(() => this.replaceSection(data));
+  }
+  async replaceSection(data) {
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
     this.fluidCells.fill(0);
@@ -19113,7 +19402,7 @@ var Chunk = class _Chunk {
         ];
         const templates = perBlock ? void 0 : fluid?.renderModel === false ? [] : (context?.prepared ?? prepared)?.pick(variantPosition);
         if (templates) {
-          this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0 })));
+          this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0, biomeTint: context?.tint })));
           this.meshDirty = true;
         } else {
           perBlocks.push({ index, blockState: blockState3, biome: context?.biome });
@@ -19197,12 +19486,35 @@ var Chunk = class _Chunk {
   }
   async resolveState(stored, indices, biomes) {
     const blockState3 = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
-    const perBlock = !blockState3 || !this.sectionModels || !!(blockState3.key && BlockEntities.entry(await BlockEntities.getIndex(blockState3.key.root), blockState3.key.toNamespacedString()));
+    let perBlock = !blockState3 || !this.sectionModels || !!(blockState3.key && BlockEntities.entry(await BlockEntities.getIndex(blockState3.key.root), blockState3.key.toNamespacedString()));
     const fluid = await getBlockFluidState(blockState3?.key, stored.properties);
     const hasBiomes = this.getBiomeAt(this.x * 16, this.y * 16, this.z * 16) !== void 0 || this.biomeAt?.(this.x * 16, this.y * 16 - 1, this.z * 16) !== void 0;
     const source = hasBiomes && blockState3 ? await BlockTints.biomeSource(blockState3.key) : void 0;
     const prepare = (color2) => perBlock || fluid?.renderModel === false ? void 0 : this.sectionModels.prepareState(blockState3, stored.properties, color2);
     const contexts = /* @__PURE__ */ new Map();
+    const blend = this.biomeBlend?.();
+    if (blend && !perBlock && blockState3 && (source || fluid?.kind === "water")) {
+      const prepared2 = fluid?.renderModel === false ? void 0 : await this.sectionModels.prepareState(blockState3, stored.properties, void 0, true);
+      if (!prepared2 && fluid?.renderModel !== false) {
+        perBlock = true;
+      } else {
+        await Promise.all(indices.map(async (index) => {
+          const position = this.biomePosition(index, blockState3, stored);
+          const biomeColor = (kind) => blend.getColor(kind, blockState3.key, position);
+          const context = {};
+          if (source && prepared2?.biomeTint) {
+            const color2 = await biomeColor(source);
+            if (color2 !== void 0) context.tint = new Color13(color2).toArray();
+          }
+          if (fluid?.kind === "water") {
+            const color2 = await biomeColor("water");
+            if (color2 !== void 0 && color2 !== 4159204) context.waterTint = new Color13(color2).toArray();
+          }
+          contexts.set(index, context);
+        }));
+        return { blockState: blockState3, perBlock, fluid, prepared: prepared2, contexts, stored };
+      }
+    }
     const groups = /* @__PURE__ */ new Map();
     if (blockState3 && (source || fluid?.kind === "water")) {
       for (const index of indices) {
@@ -19250,7 +19562,11 @@ var Chunk = class _Chunk {
     this.waterTints.set(tint ?? WATER_TINT2, index * 3);
   }
   /** Changes visibility at world block coordinates while preserving the block's data. */
-  async setBlockVisibleAt(pos, visible) {
+  setBlockVisibleAt(pos, visible) {
+    const position = pos.clone();
+    return this.changeBlocks(() => this.setBlockVisibility(position, visible));
+  }
+  async setBlockVisibility(pos, visible) {
     const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
     const block = this.renderedBlocks.get(index);
     if (!block || visible === !this.hiddenBlocks.has(index)) {
@@ -19420,6 +19736,7 @@ var Chunk = class _Chunk {
   }
   /** Removes stored blocks and render objects. Set `notify` to false to skip the owning world's update. */
   async clear(notify = true) {
+    if (this.blockChanges.size) await Promise.allSettled(this.blockChanges);
     const positions = notify && this.onBlocksChanged ? [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
       new Vector320(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     )) : [];