minerender 2.1.0-alpha.127 → 2.1.0-alpha.129

package/dist/bundle.js

@@ -41476,6 +41476,10 @@ void main() {
       init_esm2();
       init_esm();
       _Caching = class _Caching {
+        /** Changes when shared assets are cleared, so derived caches can discard their old values. */
+        static get generation() {
+          return this._generation;
+        }
         static createAssetCache() {
           return Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
         }
@@ -41511,6 +41515,7 @@ void main() {
         }
         /** 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();
           }
@@ -41522,6 +41527,7 @@ void main() {
          * 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();
@@ -41533,6 +41539,7 @@ void main() {
           };
         }
       };
+      _Caching._generation = 0;
       _Caching.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
       _Caching.imageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
       _Caching.canvasImageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
@@ -42813,6 +42820,311 @@ void main() {
     }
   });
 
+  // src/assets/AssetKey.ts
+  function isResourceLocation(value) {
+    return typeof value === "string" && /^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(value);
+  }
+  function isBasicAssetKey(obj) {
+    return obj !== null && typeof obj === "object" && typeof obj.namespace === "string" && typeof obj.path === "string";
+  }
+  function isAssetKey(obj) {
+    return isBasicAssetKey(obj) && obj.isAssetKey === true;
+  }
+  var BasicAssetKey, AssetKey;
+  var init_AssetKey = __esm({
+    "src/assets/AssetKey.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_Assets();
+      init_AssetLoader();
+      BasicAssetKey = class {
+        constructor(namespaceOrKey, path) {
+          if (path) {
+            this.namespace = namespaceOrKey;
+            this.path = path;
+          } else {
+            this.namespace = namespaceOrKey.namespace;
+            this.path = namespaceOrKey.path;
+          }
+        }
+        toNamespacedString() {
+          return this.namespace + ":" + this.path;
+        }
+        toString() {
+          return this.toNamespacedString();
+        }
+        serialize() {
+          return this.toString();
+        }
+      };
+      AssetKey = class _AssetKey extends BasicAssetKey {
+        /**
+         * Creates a key from separate path components. Use {@link parse} for a combined reference.
+         *
+         * @param assetType - Asset directory, such as `models`, `textures`, or `blockstates`.
+         * @param type - Subdirectory, such as `block` or `item`.
+         * @param rootType - Top-level directory, usually `assets` or `data`.
+         * @param root - Base URL override for hosted asset sources.
+         */
+        constructor(namespace, path, assetType, type, rootType = "assets", extension = ".json", root) {
+          super(namespace, path);
+          this.namespace = namespace;
+          this.path = path;
+          this.assetType = assetType;
+          this.type = type;
+          this.rootType = rootType;
+          this.extension = extension;
+          this.root = root;
+          this.isAssetKey = true;
+        }
+        /**
+         * Parses an asset reference such as `minecraft:block/stone`.
+         * A missing namespace defaults to the origin's namespace or `minecraft`.
+         *
+         * @param assetType - Asset category, such as `models` or `textures`.
+         * @param str - Path with an optional namespace and file extension.
+         * @param origin - Supplies the asset root, default namespace, and non-texture extension.
+         * @returns A key with the matching extension removed from its path. Textures use `.png`;
+         * other assets use the origin's extension or `.json`.
+         */
+        static parse(assetType, str, origin) {
+          let namespace = origin?.namespace || DEFAULT_NAMESPACE;
+          if (str.includes(":")) {
+            let split2 = str.split(":");
+            namespace = split2[0];
+            str = split2[1];
+          }
+          let split = str.split("/");
+          let type = void 0;
+          if (split.length > 1) {
+            type = split[0];
+            split.shift();
+          }
+          let path = split.join("/");
+          const extension = assetType === "textures" ? ".png" : origin?.extension ?? ".json";
+          if (extension && path.endsWith(extension)) {
+            path = path.slice(0, -extension.length);
+          }
+          return new _AssetKey(namespace, path, assetType, type, "assets", extension, origin?.root);
+        }
+        toString() {
+          let a4 = [
+            this.root ?? AssetLoader.ROOT,
+            this.rootType ?? "__rootType__",
+            this.assetType ?? "__assetType__",
+            this.type ?? "__type__",
+            this.namespace,
+            this.path
+          ];
+          return a4.join("/");
+        }
+        /** Joins the type subdirectory and path without adding a namespace or file extension. */
+        getFullPath() {
+          let p14 = [];
+          if (this.type) {
+            p14.push(this.type);
+          }
+          p14.push(this.path);
+          return p14.join("/");
+        }
+        toNamespacedString() {
+          return this.namespace + ":" + this.getFullPath();
+        }
+        /** Returns a cache identifier that includes the explicit root or {@link AssetLoader.ROOT}. */
+        serialize() {
+          return this.toString();
+        }
+      };
+    }
+  });
+
+  // src/assets/source/parser/AssetParsers.ts
+  var AssetParser;
+  var init_AssetParsers = __esm({
+    "src/assets/source/parser/AssetParsers.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      AssetParser = /* @__PURE__ */ ((AssetParser2) => {
+        AssetParser2["MODEL"] = "model";
+        AssetParser2["BLOCKSTATE"] = "blockstate";
+        AssetParser2["META"] = "meta";
+        AssetParser2["NBT"] = "nbt";
+        AssetParser2["IMAGE"] = "image";
+        AssetParser2["LIST"] = "list";
+        AssetParser2["JSON"] = "json";
+        return AssetParser2;
+      })(AssetParser || {});
+    }
+  });
+
+  // src/assets/MineRenderData.ts
+  var object, release, compare, MineRenderData;
+  var init_MineRenderData = __esm({
+    "src/assets/MineRenderData.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_AssetKey();
+      init_AssetLoader();
+      init_AssetParsers();
+      init_Caching();
+      object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+      release = (value) => /^\d+\.\d+(?:\.\d+)?$/.test(value) ? value.split(".").map(Number) : void 0;
+      compare = (left, right) => {
+        for (let i4 = 0; i4 < 3; i4++) {
+          const difference = (left[i4] ?? 0) - (right[i4] ?? 0);
+          if (difference) return difference;
+        }
+        return 0;
+      };
+      MineRenderData = class {
+        /** Loads one registry. Missing files and invalid data reject the request. */
+        static async get(dataset, root) {
+          root = root?.replace(/\/+$/, "");
+          const scope = AssetLoader.persistentScope;
+          const defaultRoot = AssetLoader.ROOT;
+          const resolved = await this.resolve(root);
+          const entry = resolved.manifest.datasets[dataset];
+          if (!entry) throw new Error(`MineRender ${dataset} data is unavailable for ${resolved.version}: ${resolved.manifest.unavailable[dataset] ?? "not listed in the manifest"}`);
+          const file = entry.file;
+          const requestRoot = resolved.root === (root ?? defaultRoot).replace(/\/+$/, "") ? root : resolved.root;
+          return await this.cached(`${requestRoot === void 0 ? "sources" : "explicit"}:${resolved.root}/${file}:${entry.sha256}`, scope, defaultRoot, async () => {
+            const data = await this.load(file.slice(0, -5), requestRoot);
+            if (!this.validDataset(dataset, data)) throw new Error(`Invalid MineRender ${dataset} data at ${resolved.root}/minerender-data/${file}`);
+            return data;
+          });
+        }
+        /**
+         * Uses the exact version when published. Otherwise, selects the nearest patch in the same
+         * release line (older on ties), then the latest earlier release or the oldest published release.
+         * Unpublished snapshots reject.
+         */
+        static async resolve(root) {
+          const requestRoot = root?.replace(/\/+$/, "");
+          const defaultRoot = AssetLoader.ROOT;
+          root = (root ?? defaultRoot).replace(/\/+$/, "");
+          const scope = AssetLoader.persistentScope;
+          return this.cached(`resolve:${requestRoot === void 0 ? "sources" : "explicit"}:${root}`, scope, defaultRoot, async () => {
+            const requestedVersion = root.slice(root.lastIndexOf("/") + 1);
+            let manifest = await this.manifest(root, requestRoot !== void 0 && release(requestedVersion) ? requestedVersion : void 0, requestRoot);
+            if (manifest) return { requestedVersion, version: manifest.minecraftVersion, root, manifest };
+            const requested = release(requestedVersion);
+            if (!requested) {
+              throw new Error(`No MineRender data is published for ${requestedVersion}; automatic fallback requires a release`);
+            }
+            const base = root.slice(0, root.lastIndexOf("/"));
+            const index = await this.cached(`versions:${base}`, scope, defaultRoot, async () => {
+              const value = await this.load("versions", base);
+              if (!object(value) || !Array.isArray(value.versions) || !value.versions.every((entry) => object(entry) && typeof entry.name === "string")) {
+                throw new Error(`Invalid MineRender version index at ${base}/minerender-data/versions.json`);
+              }
+              return value.versions;
+            });
+            const versions2 = index.map((entry) => ({ name: entry.name, number: release(entry.name) })).filter((entry) => !!entry.number).sort((left, right) => compare(left.number, right.number));
+            const sameLine = versions2.filter((entry) => entry.number[0] === requested[0] && entry.number[1] === requested[1]);
+            const selected = sameLine.sort((left, right) => Math.abs((left.number[2] ?? 0) - (requested[2] ?? 0)) - Math.abs((right.number[2] ?? 0) - (requested[2] ?? 0)) || compare(left.number, right.number))[0] ?? versions2.filter((entry) => compare(entry.number, requested) <= 0).pop() ?? versions2[0];
+            if (!selected) throw new Error(`No compatible MineRender data is published for ${requestedVersion}`);
+            const resolvedRoot = `${base}/${selected.name}`;
+            manifest = await this.manifest(resolvedRoot, selected.name, resolvedRoot);
+            if (!manifest) throw new Error(`Missing MineRender manifest for published version ${selected.name}`);
+            return { requestedVersion, version: selected.name, root: resolvedRoot, manifest };
+          });
+        }
+        static async manifest(root, expectedVersion, requestRoot) {
+          const data = await this.load("manifest", requestRoot);
+          if (data === void 0) return void 0;
+          if (!object(data) || data.schemaVersion !== 1 || typeof data.minecraftVersion !== "string" || !Number.isInteger(data.dataVersion) || !object(data.unavailable) || !Object.values(data.unavailable).every((value) => typeof value === "string") || !object(data.datasets) || !Object.values(data.datasets).every((entry) => {
+            return object(entry) && typeof entry.file === "string" && /^[a-z0-9][a-z0-9._-]*\.json$/.test(entry.file) && typeof entry.sha256 === "string" && /^[0-9a-f]{64}$/.test(entry.sha256);
+          }) || expectedVersion !== void 0 && data.minecraftVersion !== expectedVersion) {
+            throw new Error(`Invalid MineRender manifest at ${root}/minerender-data/manifest.json`);
+          }
+          return data;
+        }
+        static load(file, root) {
+          const key = new AssetKey("minerender-data", file, void 0, void 0, void 0, ".json", root);
+          key.rootType = void 0;
+          return AssetLoader.get(key, "json" /* JSON */);
+        }
+        static async cached(key, scope, defaultRoot, loader) {
+          const checkSources = () => {
+            if (AssetLoader.persistentScope !== scope || AssetLoader.ROOT !== defaultRoot) throw new Error("Asset sources changed while loading MineRender data; retry the request");
+          };
+          checkSources();
+          return await Caching.mineRenderDataCache.get(scope ? `${scope}
+${key}` : key, async () => {
+            const value = await loader();
+            checkSources();
+            return value;
+          });
+        }
+        static validDataset(dataset, data) {
+          if (!object(data)) return false;
+          if (dataset === "potionColors") return object(data.effects) && Object.values(data.effects).every(Number.isInteger) && object(data.potions) && Object.values(data.potions).every((effects) => Array.isArray(effects) && effects.every((effect) => object(effect) && typeof effect.id === "string" && Number.isInteger(effect.amplifier)));
+          if (dataset === "renames") return data.format === "data-fixer-renames" && Number.isInteger(data.baseDataVersion) && ["blocks", "items", "entities"].every((kind) => object(data[kind]) && Object.values(data[kind]).every((entry) => object(entry) && typeof entry.registered === "boolean" && Array.isArray(entry.ranges) && entry.ranges.length > 0 && entry.ranges.every((range) => object(range) && Number.isInteger(range.before) && typeof range.to === "string")));
+          if (dataset === "legacyBlocks") return object(data.blocks) && Object.values(data.blocks).every((value) => typeof value === "string");
+          if (dataset === "blockCulling") return Array.isArray(data.profiles) && data.profiles.every((profile) => object(profile) && typeof profile.type === "string") && object(data.blocks) && Object.values(data.blocks).every((index) => Number.isInteger(index) && index >= 0 && index < data.profiles.length) && (data.groups === void 0 || object(data.groups) && Object.values(data.groups).every((group) => Array.isArray(group) && group.every((type) => typeof type === "string")));
+          return Object.values(data).every((value) => {
+            if (!object(value)) return false;
+            switch (dataset) {
+              case "itemDefaults":
+                return true;
+              case "blockStates":
+                return Object.values(value).every((property) => object(property) && "default" in property && Array.isArray(property.values));
+              case "blockTints":
+                return ["constant", "grass", "stem", "redstone"].includes(value.source) && (value.source !== "constant" || Number.isInteger(value.color)) && (value.biome === void 0 || ["grass", "foliage", "dry_foliage", "water"].includes(value.biome));
+              case "fluids":
+                return ["water", "lava"].includes(value.kind) && typeof value.renderModel === "boolean" && (value.levelProperty === void 0 || typeof value.levelProperty === "string");
+              case "dyes":
+                return [value.id, value.textureDiffuseColor, value.fireworkColor, value.textColor].every(Number.isInteger);
+              default:
+                return false;
+            }
+          });
+        }
+      };
+    }
+  });
+
+  // src/assets/Renames.ts
+  var Renames;
+  var init_Renames = __esm({
+    "src/assets/Renames.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_AssetKey();
+      init_MineRenderData();
+      Renames = class {
+        /** Loads the selected version's rename table, or `undefined` when its published data has none. */
+        static async get(root) {
+          const resolved = await MineRenderData.resolve(root);
+          return resolved.manifest.datasets.renames ? MineRenderData.get("renames", root) : void 0;
+        }
+        /**
+         * Returns the ID that replaced `id`, or `undefined` when `id` keeps its meaning.
+         * Without a data version, an ID that the selected version still registers keeps its meaning.
+         */
+        static async resolve(kind, id, dataVersion, root) {
+          const data = await this.get(root);
+          if (!data || !Object.prototype.hasOwnProperty.call(data[kind], id)) return void 0;
+          const entry = data[kind][id];
+          if (dataVersion === void 0) return entry.registered ? void 0 : entry.ranges[entry.ranges.length - 1].to;
+          if (dataVersion < data.baseDataVersion) return void 0;
+          return entry.ranges.find((range) => dataVersion < range.before)?.to;
+        }
+        /** Returns a copy of `key` for the replacement ID, or `undefined` when the ID keeps its meaning. */
+        static async key(kind, key) {
+          const renamed = await this.resolve(kind, `${key.namespace}:${key.path}`, void 0, key.root);
+          if (!renamed) return void 0;
+          const [namespace, path] = renamed.split(":");
+          return new AssetKey(namespace, path, key.assetType, key.type, key.rootType, key.extension, key.root);
+        }
+      };
+    }
+  });
+
   // src/model/Model.ts
   function isDoubleArray(obj) {
     return Array.isArray(obj) && obj.length === 2;
@@ -42931,125 +43243,6 @@ void main() {
     }
   });
 
-  // src/assets/AssetKey.ts
-  function isResourceLocation(value) {
-    return typeof value === "string" && /^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(value);
-  }
-  function isBasicAssetKey(obj) {
-    return obj !== null && typeof obj === "object" && typeof obj.namespace === "string" && typeof obj.path === "string";
-  }
-  function isAssetKey(obj) {
-    return isBasicAssetKey(obj) && obj.isAssetKey === true;
-  }
-  var BasicAssetKey, AssetKey;
-  var init_AssetKey = __esm({
-    "src/assets/AssetKey.ts"() {
-      init_dirname();
-      init_buffer2();
-      init_process2();
-      init_Assets();
-      init_AssetLoader();
-      BasicAssetKey = class {
-        constructor(namespaceOrKey, path) {
-          if (path) {
-            this.namespace = namespaceOrKey;
-            this.path = path;
-          } else {
-            this.namespace = namespaceOrKey.namespace;
-            this.path = namespaceOrKey.path;
-          }
-        }
-        toNamespacedString() {
-          return this.namespace + ":" + this.path;
-        }
-        toString() {
-          return this.toNamespacedString();
-        }
-        serialize() {
-          return this.toString();
-        }
-      };
-      AssetKey = class _AssetKey extends BasicAssetKey {
-        /**
-         * Creates a key from separate path components. Use {@link parse} for a combined reference.
-         *
-         * @param assetType - Asset directory, such as `models`, `textures`, or `blockstates`.
-         * @param type - Subdirectory, such as `block` or `item`.
-         * @param rootType - Top-level directory, usually `assets` or `data`.
-         * @param root - Base URL override for hosted asset sources.
-         */
-        constructor(namespace, path, assetType, type, rootType = "assets", extension = ".json", root) {
-          super(namespace, path);
-          this.namespace = namespace;
-          this.path = path;
-          this.assetType = assetType;
-          this.type = type;
-          this.rootType = rootType;
-          this.extension = extension;
-          this.root = root;
-          this.isAssetKey = true;
-        }
-        /**
-         * Parses an asset reference such as `minecraft:block/stone`.
-         * A missing namespace defaults to the origin's namespace or `minecraft`.
-         *
-         * @param assetType - Asset category, such as `models` or `textures`.
-         * @param str - Path with an optional namespace and file extension.
-         * @param origin - Supplies the asset root, default namespace, and non-texture extension.
-         * @returns A key with the matching extension removed from its path. Textures use `.png`;
-         * other assets use the origin's extension or `.json`.
-         */
-        static parse(assetType, str, origin) {
-          let namespace = origin?.namespace || DEFAULT_NAMESPACE;
-          if (str.includes(":")) {
-            let split2 = str.split(":");
-            namespace = split2[0];
-            str = split2[1];
-          }
-          let split = str.split("/");
-          let type = void 0;
-          if (split.length > 1) {
-            type = split[0];
-            split.shift();
-          }
-          let path = split.join("/");
-          const extension = assetType === "textures" ? ".png" : origin?.extension ?? ".json";
-          if (extension && path.endsWith(extension)) {
-            path = path.slice(0, -extension.length);
-          }
-          return new _AssetKey(namespace, path, assetType, type, "assets", extension, origin?.root);
-        }
-        toString() {
-          let a4 = [
-            this.root ?? AssetLoader.ROOT,
-            this.rootType ?? "__rootType__",
-            this.assetType ?? "__assetType__",
-            this.type ?? "__type__",
-            this.namespace,
-            this.path
-          ];
-          return a4.join("/");
-        }
-        /** Joins the type subdirectory and path without adding a namespace or file extension. */
-        getFullPath() {
-          let p14 = [];
-          if (this.type) {
-            p14.push(this.type);
-          }
-          p14.push(this.path);
-          return p14.join("/");
-        }
-        toNamespacedString() {
-          return this.namespace + ":" + this.getFullPath();
-        }
-        /** Returns a cache identifier that includes the explicit root or {@link AssetLoader.ROOT}. */
-        serialize() {
-          return this.toString();
-        }
-      };
-    }
-  });
-
   // src/model/DisplayPosition.ts
   var DisplayPosition, DISPLAY_POSITIONS;
   var init_DisplayPosition = __esm({
@@ -43181,153 +43374,6 @@ void main() {
     }
   });
 
-  // src/assets/source/parser/AssetParsers.ts
-  var AssetParser;
-  var init_AssetParsers = __esm({
-    "src/assets/source/parser/AssetParsers.ts"() {
-      init_dirname();
-      init_buffer2();
-      init_process2();
-      AssetParser = /* @__PURE__ */ ((AssetParser2) => {
-        AssetParser2["MODEL"] = "model";
-        AssetParser2["BLOCKSTATE"] = "blockstate";
-        AssetParser2["META"] = "meta";
-        AssetParser2["NBT"] = "nbt";
-        AssetParser2["IMAGE"] = "image";
-        AssetParser2["LIST"] = "list";
-        AssetParser2["JSON"] = "json";
-        return AssetParser2;
-      })(AssetParser || {});
-    }
-  });
-
-  // src/assets/MineRenderData.ts
-  var object, release, compare, MineRenderData;
-  var init_MineRenderData = __esm({
-    "src/assets/MineRenderData.ts"() {
-      init_dirname();
-      init_buffer2();
-      init_process2();
-      init_AssetKey();
-      init_AssetLoader();
-      init_AssetParsers();
-      init_Caching();
-      object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-      release = (value) => /^\d+\.\d+(?:\.\d+)?$/.test(value) ? value.split(".").map(Number) : void 0;
-      compare = (left, right) => {
-        for (let i4 = 0; i4 < 3; i4++) {
-          const difference = (left[i4] ?? 0) - (right[i4] ?? 0);
-          if (difference) return difference;
-        }
-        return 0;
-      };
-      MineRenderData = class {
-        /** Loads one registry. Missing files and invalid data reject the request. */
-        static async get(dataset, root) {
-          root = root?.replace(/\/+$/, "");
-          const scope = AssetLoader.persistentScope;
-          const defaultRoot = AssetLoader.ROOT;
-          const resolved = await this.resolve(root);
-          const entry = resolved.manifest.datasets[dataset];
-          if (!entry) throw new Error(`MineRender ${dataset} data is unavailable for ${resolved.version}: ${resolved.manifest.unavailable[dataset] ?? "not listed in the manifest"}`);
-          const file = entry.file;
-          const requestRoot = resolved.root === (root ?? defaultRoot).replace(/\/+$/, "") ? root : resolved.root;
-          return await this.cached(`${requestRoot === void 0 ? "sources" : "explicit"}:${resolved.root}/${file}:${entry.sha256}`, scope, defaultRoot, async () => {
-            const data = await this.load(file.slice(0, -5), requestRoot);
-            if (!this.validDataset(dataset, data)) throw new Error(`Invalid MineRender ${dataset} data at ${resolved.root}/minerender-data/${file}`);
-            return data;
-          });
-        }
-        /**
-         * Uses the exact version when published. Otherwise, selects the nearest patch in the same
-         * release line (older on ties), then the latest earlier release or the oldest published release.
-         * Unpublished snapshots reject.
-         */
-        static async resolve(root) {
-          const requestRoot = root?.replace(/\/+$/, "");
-          const defaultRoot = AssetLoader.ROOT;
-          root = (root ?? defaultRoot).replace(/\/+$/, "");
-          const scope = AssetLoader.persistentScope;
-          return this.cached(`resolve:${requestRoot === void 0 ? "sources" : "explicit"}:${root}`, scope, defaultRoot, async () => {
-            const requestedVersion = root.slice(root.lastIndexOf("/") + 1);
-            let manifest = await this.manifest(root, requestRoot !== void 0 && release(requestedVersion) ? requestedVersion : void 0, requestRoot);
-            if (manifest) return { requestedVersion, version: manifest.minecraftVersion, root, manifest };
-            const requested = release(requestedVersion);
-            if (!requested) {
-              throw new Error(`No MineRender data is published for ${requestedVersion}; automatic fallback requires a release`);
-            }
-            const base = root.slice(0, root.lastIndexOf("/"));
-            const index = await this.cached(`versions:${base}`, scope, defaultRoot, async () => {
-              const value = await this.load("versions", base);
-              if (!object(value) || !Array.isArray(value.versions) || !value.versions.every((entry) => object(entry) && typeof entry.name === "string")) {
-                throw new Error(`Invalid MineRender version index at ${base}/minerender-data/versions.json`);
-              }
-              return value.versions;
-            });
-            const versions2 = index.map((entry) => ({ name: entry.name, number: release(entry.name) })).filter((entry) => !!entry.number).sort((left, right) => compare(left.number, right.number));
-            const sameLine = versions2.filter((entry) => entry.number[0] === requested[0] && entry.number[1] === requested[1]);
-            const selected = sameLine.sort((left, right) => Math.abs((left.number[2] ?? 0) - (requested[2] ?? 0)) - Math.abs((right.number[2] ?? 0) - (requested[2] ?? 0)) || compare(left.number, right.number))[0] ?? versions2.filter((entry) => compare(entry.number, requested) <= 0).pop() ?? versions2[0];
-            if (!selected) throw new Error(`No compatible MineRender data is published for ${requestedVersion}`);
-            const resolvedRoot = `${base}/${selected.name}`;
-            manifest = await this.manifest(resolvedRoot, selected.name, resolvedRoot);
-            if (!manifest) throw new Error(`Missing MineRender manifest for published version ${selected.name}`);
-            return { requestedVersion, version: selected.name, root: resolvedRoot, manifest };
-          });
-        }
-        static async manifest(root, expectedVersion, requestRoot) {
-          const data = await this.load("manifest", requestRoot);
-          if (data === void 0) return void 0;
-          if (!object(data) || data.schemaVersion !== 1 || typeof data.minecraftVersion !== "string" || !Number.isInteger(data.dataVersion) || !object(data.unavailable) || !Object.values(data.unavailable).every((value) => typeof value === "string") || !object(data.datasets) || !Object.values(data.datasets).every((entry) => {
-            return object(entry) && typeof entry.file === "string" && /^[a-z0-9][a-z0-9._-]*\.json$/.test(entry.file) && typeof entry.sha256 === "string" && /^[0-9a-f]{64}$/.test(entry.sha256);
-          }) || expectedVersion !== void 0 && data.minecraftVersion !== expectedVersion) {
-            throw new Error(`Invalid MineRender manifest at ${root}/minerender-data/manifest.json`);
-          }
-          return data;
-        }
-        static load(file, root) {
-          const key = new AssetKey("minerender-data", file, void 0, void 0, void 0, ".json", root);
-          key.rootType = void 0;
-          return AssetLoader.get(key, "json" /* JSON */);
-        }
-        static async cached(key, scope, defaultRoot, loader) {
-          const checkSources = () => {
-            if (AssetLoader.persistentScope !== scope || AssetLoader.ROOT !== defaultRoot) throw new Error("Asset sources changed while loading MineRender data; retry the request");
-          };
-          checkSources();
-          return await Caching.mineRenderDataCache.get(scope ? `${scope}
-${key}` : key, async () => {
-            const value = await loader();
-            checkSources();
-            return value;
-          });
-        }
-        static validDataset(dataset, data) {
-          if (!object(data)) return false;
-          if (dataset === "potionColors") return object(data.effects) && Object.values(data.effects).every(Number.isInteger) && object(data.potions) && Object.values(data.potions).every((effects) => Array.isArray(effects) && effects.every((effect) => object(effect) && typeof effect.id === "string" && Number.isInteger(effect.amplifier)));
-          if (dataset === "legacyBlocks") return object(data.blocks) && Object.values(data.blocks).every((value) => typeof value === "string");
-          if (dataset === "blockCulling") return Array.isArray(data.profiles) && data.profiles.every((profile) => object(profile) && typeof profile.type === "string") && object(data.blocks) && Object.values(data.blocks).every((index) => Number.isInteger(index) && index >= 0 && index < data.profiles.length) && (data.groups === void 0 || object(data.groups) && Object.values(data.groups).every((group) => Array.isArray(group) && group.every((type) => typeof type === "string")));
-          return Object.values(data).every((value) => {
-            if (!object(value)) return false;
-            switch (dataset) {
-              case "itemDefaults":
-                return true;
-              case "blockStates":
-                return Object.values(value).every((property) => object(property) && "default" in property && Array.isArray(property.values));
-              case "blockTints":
-                return ["constant", "grass", "stem", "redstone"].includes(value.source) && (value.source !== "constant" || Number.isInteger(value.color)) && (value.biome === void 0 || ["grass", "foliage", "dry_foliage", "water"].includes(value.biome));
-              case "fluids":
-                return ["water", "lava"].includes(value.kind) && typeof value.renderModel === "boolean" && (value.levelProperty === void 0 || typeof value.levelProperty === "string");
-              case "dyes":
-                return [value.id, value.textureDiffuseColor, value.fireworkColor, value.textColor].every(Number.isInteger);
-              default:
-                return false;
-            }
-          });
-        }
-      };
-    }
-  });
-
   // src/assets/BannerPatterns.ts
   var DYE_COLORS, BannerPatterns;
   var init_BannerPatterns = __esm({
@@ -43668,6 +43714,7 @@ ${key}` : key, async () => {
       init_dirname();
       init_buffer2();
       init_process2();
+      init_Renames();
       init_Caching();
       init_ModelMerger();
       init_AssetLoader();
@@ -43997,6 +44044,11 @@ ${key}` : key, async () => {
             key.extension = ".json";
           }
           const preview = this.snapshotContext(key, context);
+          if (key.type === "item") {
+            const renamed = await Renames.key("items", key);
+            const replacement = renamed && await this.getMerged(renamed, preview);
+            if (replacement) return replacement;
+          }
           const dataKey = await this.applyDefaults(key, preview);
           const keyStr = AssetLoader.persistentKey(key.serialize() + (key.type === "item" ? this.contextKey(preview) + dataKey : ""));
           const model = await Caching.mergedModelCache.get(keyStr, async () => {
@@ -44033,6 +44085,7 @@ ${key}` : key, async () => {
       init_AssetKey();
       init_PersistentCache();
       init_AssetParsers();
+      init_Renames();
       init_MineRenderData();
       BlockStates = class {
         static get PERSISTENT_CACHE() {
@@ -44073,6 +44126,9 @@ ${key}` : key, async () => {
           if (!key.extension) {
             key.extension = ".json";
           }
+          const renamed = await Renames.key("blocks", key);
+          const replacement = renamed && await this.get(renamed);
+          if (replacement) return replacement;
           const keyStr = key.serialize();
           return Caching.blockStateCache.get(keyStr, (k4) => {
             return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
@@ -95450,6 +95506,7 @@ ${shader.fragmentShader}`.replace(
     PackMetadata: () => PackMetadata,
     PersistentCache: () => PersistentCache,
     PlayerHeadTextures: () => PlayerHeadTextures,
+    Renames: () => Renames,
     Renderer: () => Renderer,
     RequestError: () => RequestError,
     Requests: () => Requests,
@@ -96144,6 +96201,7 @@ ${shader.fragmentShader}`.replace(
   init_MineRenderData();
   init_ModelTextures();
   init_Models();
+  init_Renames();
   init_source();
 
   // src/bedrock/index.ts
@@ -107683,18 +107741,23 @@ gl_FragDepth=readDepth(vUv);
         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 color3;
       const resolveColor = typeof biomeColor === "function" ? () => color3 ?? (color3 = 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);
@@ -107737,10 +107800,10 @@ gl_FragDepth=readDepth(vUv);
       }
       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,
@@ -107754,11 +107817,13 @@ gl_FragDepth=readDepth(vUv);
         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((name2) => name2 === data.cullface);
             if (local < 0) {
               cullFaces.push(0);
@@ -107774,6 +107839,7 @@ gl_FragDepth=readDepth(vUv);
           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
@@ -107796,6 +107862,7 @@ gl_FragDepth=readDepth(vUv);
   init_dirname();
   init_buffer2();
   init_process2();
+  init_Renames();
   init_Entities();
   init_EntityObject();
 
@@ -107961,8 +108028,10 @@ gl_FragDepth=readDepth(vUv);
           try {
             if (!current()) return;
             const models = await Entities.getEntityList();
-            if (!models.includes(placement.key.path) || !current()) return;
-            const model = await Entities.getEntity(placement.key, placement.texture, { when: placement.when });
+            const renamed = models.includes(placement.key.path) ? void 0 : await Renames.key("entities", placement.key);
+            const key = renamed && models.includes(renamed.path) ? renamed : placement.key;
+            if (!models.includes(key.path) || !current()) return;
+            const model = await Entities.getEntity(key, placement.texture, { when: placement.when });
             if (!model || !current()) return;
             let tints = placement.tints;
             if (placement.woolDye) {
@@ -107977,7 +108046,7 @@ gl_FragDepth=readDepth(vUv);
             object4.rotation.y = placement.yaw;
             await object4.init();
             if (!current()) return;
-            placement.owner.set(object4, { type: placement.key.toNamespacedString(), position: placement.position });
+            placement.owner.set(object4, { type: key.toNamespacedString(), position: placement.position });
             this.scene.add(object4);
           } catch (error2) {
             console.warn(`Could not draw saved entity ${placement.key.toNamespacedString()}, skipping it`, error2);
@@ -108009,6 +108078,135 @@ gl_FragDepth=readDepth(vUv);
   // src/world/MineRenderWorld.ts
   init_FluidQuads();
 
+  // src/world/_biomes/BiomeBlend.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  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(x4, z4) {
+      for (const [key, tile] of this.tiles) {
+        if (Math.abs(tile.x - x4) <= 1 && Math.abs(tile.z - z4) <= 1) this.tiles.delete(key);
+      }
+    }
+    async getColor(kind, origin, position) {
+      const [x4, y5, z4] = position;
+      const biome = this.biomeAt(x4, y5, z4);
+      if (biome === void 0) return void 0;
+      if (this.generation !== Caching.generation) {
+        this.clear();
+        this.generation = Caching.generation;
+      }
+      const tileX = Math.floor(x4 / 16), tileZ = Math.floor(z4 / 16), quartY = Math.floor(y5 / 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;
+        }, (error2) => {
+          if (this.tiles.get(key)?.colors === colors) this.tiles.delete(key);
+          throw error2;
+        });
+        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 color3 = result.colors[(z4 - tileZ * 16) * 16 + x4 - tileX * 16];
+      return color3 === -1 ? void 0 : color3;
+    }
+    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 z4 = 0; z4 < quartSize; z4++) {
+        for (let x4 = 0; x4 < quartSize; x4++) {
+          const id = this.biomeAt((quartX + x4) * 4, quartY * 4, (quartZ + z4) * 4);
+          ids[z4 * quartSize + x4] = 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, color3]) => {
+        try {
+          return [id, await color3];
+        } catch (error2) {
+          failures.set(id, error2);
+          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 z4 = 0; z4 < size; z4++) {
+        const row = [0, 0, 0, 0];
+        for (let x4 = 0; x4 < size; x4++) {
+          const id = ids[(Math.floor((startZ + z4) / 4) - quartZ) * quartSize + Math.floor((startX + x4) / 4) - quartX];
+          const value = id === void 0 ? void 0 : loaded.get(id);
+          const color3 = value?.swamp ? swampGrassColor(startX + x4, startZ + z4) : value?.color;
+          if (color3 !== void 0) {
+            samples[z4 * size + x4] = color3;
+            row[0] += color3 >> 16 & 255;
+            row[1] += color3 >> 8 & 255;
+            row[2] += color3 & 255;
+            row[3]++;
+          }
+          for (let channel = 0; channel < 4; channel++) {
+            sums[channel][(z4 + 1) * stride + x4 + 1] = sums[channel][z4 * stride + x4 + 1] + row[channel];
+          }
+        }
+      }
+      const colors = new Int32Array(256).fill(-1), width = radius * 2 + 1;
+      for (let z4 = 0; z4 < 16; z4++) {
+        for (let x4 = 0; x4 < 16; x4++) {
+          if (samples[(z4 + radius) * size + x4 + radius] === -1) continue;
+          const topLeft = z4 * stride + x4, topRight = topLeft + width;
+          const bottomLeft = (z4 + width) * stride + x4, bottomRight = bottomLeft + width;
+          const sum = (values) => values[bottomRight] - values[bottomLeft] - values[topRight] + values[topLeft];
+          const count = sum(sums[3]);
+          if (count) colors[z4 * 16 + x4] = 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
   init_dirname();
   init_buffer2();
@@ -108078,12 +108276,17 @@ gl_FragDepth=readDepth(vUv);
       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((x4, y5, z4) => this.getBiomeAt(x4, y5, z4), this._biomeBlendRadius);
       this.scene = scene;
       this.savedLighting = options.savedLighting ?? false;
       this.ambientLight = options.ambientLight ?? 0;
@@ -108124,6 +108327,65 @@ gl_FragDepth=readDepth(vUv);
       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((x4, y5, z4) => this.getBiomeAt(x4, y5, z4), 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(x4, z4, y5, includeColumn = true) {
+      const queued = [];
+      if (!this.biomeBlend) return queued;
+      this.biomeBlend.invalidateColumn(x4, z4);
+      for (const chunk of this._chunks.values()) {
+        if (Math.abs(chunk.x - x4) > 1 || Math.abs(chunk.z - z4) > 1 || !includeColumn && chunk.x === x4 && chunk.z === z4 || y5 !== void 0 && chunk.y !== y5 && chunk.y !== y5 + 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 === x4 && column.z === z4)) columns.push({ x: x4, z: z4 });
+      }
+      return queued;
+    }
+    async refreshBiomes() {
+      if (this.biomeRefreshing) await this.biomeRefreshing;
+      if (!this.pendingBiomes.size) return /* @__PURE__ */ new Map();
+      return this.biomeRefreshing ?? (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 (error2) {
+              failures.set(chunk, error2);
+              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, y5, z4) {
       if (typeof posOrX == "number") {
         return this.getBlockAt(new Vector3(posOrX, y5, z4));
@@ -108359,6 +108621,9 @@ gl_FragDepth=readDepth(vUv);
         }
         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()]);
       }
     }
@@ -108375,11 +108640,14 @@ gl_FragDepth=readDepth(vUv);
       try {
         await this.clearChunkColumn(x4, z4);
       } 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(x4, z4) {
       this.biomes.delete(`${x4}_${z4}`);
+      this.markBiomesChanged(x4, z4, void 0, false);
       if (this.savedLighting) {
         for (const y5 of this.light.get(`${x4}_${z4}`)?.keys() ?? []) this.markSectionChanged({ x: x4, y: y5, z: z4 });
       }
@@ -108390,6 +108658,7 @@ gl_FragDepth=readDepth(vUv);
       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);
       }
@@ -108424,6 +108693,8 @@ gl_FragDepth=readDepth(vUv);
       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();
@@ -108542,8 +108813,14 @@ gl_FragDepth=readDepth(vUv);
               column?.delete(y5);
               if (!column?.size) this.biomes.delete(columnKey);
             }
-            await chunk.refreshBiomes();
-            await this._chunks.get(`${x4}_${y5 + 1}_${z4}`)?.refreshBiomes();
+            if (this.biomeBlend) {
+              const queued = this.markBiomesChanged(x4, z4, y5);
+              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(`${x4}_${y5 + 1}_${z4}`)?.refreshBiomes();
+            }
           },
           this.savedLighting ? (x5, y6, z5) => this.lightLevelAt(x5, y6, z5) : void 0,
           async () => {
@@ -108560,7 +108837,8 @@ gl_FragDepth=readDepth(vUv);
               await this.updateCulling([]);
             }
           },
-          this.ambientLight
+          this.ambientLight,
+          () => this.biomeBlend
         );
         this._chunks.set(key, chunk);
       }
@@ -108691,9 +108969,10 @@ gl_FragDepth=readDepth(vUv);
 
   // 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))) {
@@ -108708,7 +108987,7 @@ gl_FragDepth=readDepth(vUv);
     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");
       }
     }
@@ -108818,6 +109097,7 @@ gl_FragDepth=readDepth(vUv);
           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 = vertex2;
           for (let corner = 0; corner < 4; corner++, vertex2++) {
             const source = quad * 4 + corner;
@@ -108834,9 +109114,9 @@ gl_FragDepth=readDepth(vUv);
             uvBounds[vertex2 * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
             uvBounds[vertex2 * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
             const factor = brightness * (ambientMask ? cornerBrightness2[corner] : 1);
-            colors[vertex2 * 3] = template.colors[source * 3] * factor;
-            colors[vertex2 * 3 + 1] = template.colors[source * 3 + 1] * factor;
-            colors[vertex2 * 3 + 2] = template.colors[source * 3 + 2] * factor;
+            colors[vertex2 * 3] = (tint === void 0 ? template.colors[source * 3] : biomeTints[tint]) * factor;
+            colors[vertex2 * 3 + 1] = (tint === void 0 ? template.colors[source * 3 + 1] : biomeTints[tint + 1]) * factor;
+            colors[vertex2 * 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];
         }
@@ -108960,7 +109240,11 @@ gl_FragDepth=readDepth(vUv);
       ...lighting
     };
     for (let i4 = 0; i4 < entries.length; i4++) {
-      const { index, template, cullMask } = entries[i4];
+      const { index, template, cullMask, biomeTint } = entries[i4];
+      if (biomeTint) {
+        input.biomeTints ?? (input.biomeTints = new Float32Array(entries.length * 3).fill(NaN));
+        input.biomeTints.set(biomeTint, i4 * 3);
+      }
       let id = templateIds.get(template);
       if (id === void 0) {
         let atlas = atlasIds.get(template.atlas);
@@ -108987,6 +109271,7 @@ gl_FragDepth=readDepth(vUv);
             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
@@ -109131,7 +109416,7 @@ gl_FragDepth=readDepth(vUv);
   init_InstanceReference();
   var WATER_TINT2 = new Color(4159204).toArray();
   var Chunk = class _Chunk {
-    constructor(scene, x4, y5, z4, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
+    constructor(scene, x4, y5, z4, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0, biomeBlend) {
       this.onBlocksChanged = onBlocksChanged;
       this.sectionModels = sectionModels;
       this.neighborCell = neighborCell;
@@ -109140,6 +109425,7 @@ gl_FragDepth=readDepth(vUv);
       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();
@@ -109149,6 +109435,7 @@ gl_FragDepth=readDepth(vUv);
       this.blockPosition = new Vector3();
       this.meshDirty = false;
       this.meshGeneration = 0;
+      this.blockChanges = /* @__PURE__ */ new Set();
       this.scene = scene;
       this.x = x4;
       this.y = y5;
@@ -109247,10 +109534,20 @@ gl_FragDepth=readDepth(vUv);
       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 [x4, , z4] = this.positionAt(index), radius = blend.radius;
+          if (!columns.some((column) => x4 >= column.x * 16 - radius && x4 <= column.x * 16 + 15 + radius && z4 >= column.z * 16 - radius && z4 <= column.z * 16 + 15 + radius)) continue;
+        }
         const block = this.data.get(index);
         const stateKey = ChunkData.paletteKey(block);
         let matches = affected.get(stateKey);
@@ -109265,10 +109562,32 @@ gl_FragDepth=readDepth(vUv);
         }
         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);
@@ -109308,6 +109627,20 @@ gl_FragDepth=readDepth(vUv);
     }
     /** 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,
@@ -109327,6 +109660,10 @@ gl_FragDepth=readDepth(vUv);
       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, i4) => [key, settled[i4]]));
+      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) {
@@ -109364,7 +109701,7 @@ gl_FragDepth=readDepth(vUv);
           }
           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, {
@@ -109383,7 +109720,11 @@ gl_FragDepth=readDepth(vUv);
           }, object: object4 });
           if (object4) this.objectBlocks.add(index);
         } catch (error2) {
-          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 = error2;
@@ -109394,7 +109735,10 @@ gl_FragDepth=readDepth(vUv);
       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);
@@ -109441,7 +109785,7 @@ gl_FragDepth=readDepth(vUv);
           ];
           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 });
@@ -109525,12 +109869,35 @@ gl_FragDepth=readDepth(vUv);
     }
     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 = (color3) => perBlock || fluid?.renderModel === false ? void 0 : this.sectionModels.prepareState(blockState3, stored.properties, color3);
       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 color3 = await biomeColor(source);
+              if (color3 !== void 0) context.tint = new Color(color3).toArray();
+            }
+            if (fluid?.kind === "water") {
+              const color3 = await biomeColor("water");
+              if (color3 !== void 0 && color3 !== 4159204) context.waterTint = new Color(color3).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) {
@@ -109578,7 +109945,11 @@ gl_FragDepth=readDepth(vUv);
       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)) {
@@ -109748,6 +110119,7 @@ gl_FragDepth=readDepth(vUv);
     }
     /** 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 Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
       )) : [];