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

package/dist/browser/index.mjs

@@ -263,6 +263,10 @@ var _Caching, Caching;
 var init_Caching = __esm({
   "src/cache/Caching.ts"() {
     _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();
       }
@@ -298,6 +302,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();
         }
@@ -309,6 +314,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();
@@ -320,6 +326,7 @@ var init_Caching = __esm({
         };
       }
     };
+    _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();
@@ -1208,118 +1215,6 @@ var init_Materials = __esm({
   }
 });
 
-// src/model/Model.ts
-function isDoubleArray(obj) {
-  return Array.isArray(obj) && obj.length === 2;
-}
-function isTripleArray(obj) {
-  return Array.isArray(obj) && obj.length === 3;
-}
-function isQuadArray(obj) {
-  return Array.isArray(obj) && obj.length === 4;
-}
-var ITEM_GENERATED, BUILTIN_GENERATED, BUILTIN_ENTITY, DEFAULT_ELEMENTS;
-var init_Model = __esm({
-  "src/model/Model.ts"() {
-    ITEM_GENERATED = "item/generated";
-    BUILTIN_GENERATED = "builtin/generated";
-    BUILTIN_ENTITY = "builtin/entity";
-    DEFAULT_ELEMENTS = [];
-  }
-});
-
-// ../../node_modules/ts-deepmerge/dist/index.js
-var require_dist = __commonJS({
-  "../../node_modules/ts-deepmerge/dist/index.js"(exports) {
-    "use strict";
-    var __assign = exports && exports.__assign || function() {
-      __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-          s = arguments[i];
-          for (var p11 in s) if (Object.prototype.hasOwnProperty.call(s, p11))
-            t[p11] = s[p11];
-        }
-        return t;
-      };
-      return __assign.apply(this, arguments);
-    };
-    var __read = exports && exports.__read || function(o, n) {
-      var m = typeof Symbol === "function" && o[Symbol.iterator];
-      if (!m) return o;
-      var i = m.call(o), r, ar = [], e;
-      try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-      } catch (error) {
-        e = { error };
-      } finally {
-        try {
-          if (r && !r.done && (m = i["return"])) m.call(i);
-        } finally {
-          if (e) throw e.error;
-        }
-      }
-      return ar;
-    };
-    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
-      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
-        }
-      }
-      return to.concat(ar || Array.prototype.slice.call(from));
-    };
-    Object.defineProperty(exports, "__esModule", { value: true });
-    var isObject = function(obj) {
-      if (typeof obj === "object" && obj !== null) {
-        if (typeof Object.getPrototypeOf === "function") {
-          var prototype = Object.getPrototypeOf(obj);
-          return prototype === Object.prototype || prototype === null;
-        }
-        return Object.prototype.toString.call(obj) === "[object Object]";
-      }
-      return false;
-    };
-    var PROTECTED_KEYS = ["__proto__"];
-    var merge10 = function() {
-      var objects = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        objects[_i] = arguments[_i];
-      }
-      return objects.reduce(function(result, current) {
-        Object.keys(current).forEach(function(key) {
-          if (PROTECTED_KEYS.includes(key)) {
-            return;
-          }
-          if (Array.isArray(result[key]) && Array.isArray(current[key])) {
-            result[key] = merge10.options.mergeArrays ? Array.from(new Set(result[key].concat(current[key]))) : current[key];
-          } else if (isObject(result[key]) && isObject(current[key])) {
-            result[key] = merge10(result[key], current[key]);
-          } else {
-            result[key] = current[key];
-          }
-        });
-        return result;
-      }, {});
-    };
-    var defaultOptions = {
-      mergeArrays: true
-    };
-    merge10.options = defaultOptions;
-    merge10.withOptions = function(options) {
-      var objects = [];
-      for (var _i = 1; _i < arguments.length; _i++) {
-        objects[_i - 1] = arguments[_i];
-      }
-      merge10.options = __assign({ mergeArrays: true }, options);
-      var result = merge10.apply(void 0, __spreadArray([], __read(objects), false));
-      merge10.options = defaultOptions;
-      return result;
-    };
-    exports.default = merge10;
-  }
-});
-
 // src/assets/AssetKey.ts
 function isResourceLocation(value) {
   return typeof value === "string" && /^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(value);
@@ -1422,17 +1317,306 @@ var init_AssetKey = __esm({
         if (this.type) {
           p11.push(this.type);
         }
-        p11.push(this.path);
-        return p11.join("/");
+        p11.push(this.path);
+        return p11.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"() {
+    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_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 i = 0; i < 3; i++) {
+        const difference = (left[i] ?? 0) - (right[i] ?? 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 versions = index.map((entry) => ({ name: entry.name, number: release(entry.name) })).filter((entry) => !!entry.number).sort((left, right) => compare(left.number, right.number));
+          const sameLine = versions.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] ?? versions.filter((entry) => compare(entry.number, requested) <= 0).pop() ?? versions[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_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;
+}
+function isTripleArray(obj) {
+  return Array.isArray(obj) && obj.length === 3;
+}
+function isQuadArray(obj) {
+  return Array.isArray(obj) && obj.length === 4;
+}
+var ITEM_GENERATED, BUILTIN_GENERATED, BUILTIN_ENTITY, DEFAULT_ELEMENTS;
+var init_Model = __esm({
+  "src/model/Model.ts"() {
+    ITEM_GENERATED = "item/generated";
+    BUILTIN_GENERATED = "builtin/generated";
+    BUILTIN_ENTITY = "builtin/entity";
+    DEFAULT_ELEMENTS = [];
+  }
+});
+
+// ../../node_modules/ts-deepmerge/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/ts-deepmerge/dist/index.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p11 in s) if (Object.prototype.hasOwnProperty.call(s, p11))
+            t[p11] = s[p11];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    var __read = exports && exports.__read || function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var isObject = function(obj) {
+      if (typeof obj === "object" && obj !== null) {
+        if (typeof Object.getPrototypeOf === "function") {
+          var prototype = Object.getPrototypeOf(obj);
+          return prototype === Object.prototype || prototype === null;
+        }
+        return Object.prototype.toString.call(obj) === "[object Object]";
       }
-      toNamespacedString() {
-        return this.namespace + ":" + this.getFullPath();
+      return false;
+    };
+    var PROTECTED_KEYS = ["__proto__"];
+    var merge10 = function() {
+      var objects = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        objects[_i] = arguments[_i];
       }
-      /** Returns a cache identifier that includes the explicit root or {@link AssetLoader.ROOT}. */
-      serialize() {
-        return this.toString();
+      return objects.reduce(function(result, current) {
+        Object.keys(current).forEach(function(key) {
+          if (PROTECTED_KEYS.includes(key)) {
+            return;
+          }
+          if (Array.isArray(result[key]) && Array.isArray(current[key])) {
+            result[key] = merge10.options.mergeArrays ? Array.from(new Set(result[key].concat(current[key]))) : current[key];
+          } else if (isObject(result[key]) && isObject(current[key])) {
+            result[key] = merge10(result[key], current[key]);
+          } else {
+            result[key] = current[key];
+          }
+        });
+        return result;
+      }, {});
+    };
+    var defaultOptions = {
+      mergeArrays: true
+    };
+    merge10.options = defaultOptions;
+    merge10.withOptions = function(options) {
+      var objects = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        objects[_i - 1] = arguments[_i];
       }
+      merge10.options = __assign({ mergeArrays: true }, options);
+      var result = merge10.apply(void 0, __spreadArray([], __read(objects), false));
+      merge10.options = defaultOptions;
+      return result;
     };
+    exports.default = merge10;
   }
 });
 
@@ -1558,147 +1742,6 @@ var init_ModelMerger = __esm({
   }
 });
 
-// src/assets/source/parser/AssetParsers.ts
-var AssetParser;
-var init_AssetParsers = __esm({
-  "src/assets/source/parser/AssetParsers.ts"() {
-    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_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 i = 0; i < 3; i++) {
-        const difference = (left[i] ?? 0) - (right[i] ?? 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 versions = index.map((entry) => ({ name: entry.name, number: release(entry.name) })).filter((entry) => !!entry.number).sort((left, right) => compare(left.number, right.number));
-          const sameLine = versions.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] ?? versions.filter((entry) => compare(entry.number, requested) <= 0).pop() ?? versions[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({
@@ -2021,6 +2064,7 @@ var init_ItemTints = __esm({
 var Models;
 var init_Models = __esm({
   "src/assets/Models.ts"() {
+    init_Renames();
     init_Caching();
     init_ModelMerger();
     init_AssetLoader();
@@ -2350,6 +2394,11 @@ var init_Models = __esm({
           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 () => {
@@ -2383,6 +2432,7 @@ var init_BlockStates = __esm({
     init_AssetKey();
     init_PersistentCache();
     init_AssetParsers();
+    init_Renames();
     init_MineRenderData();
     BlockStates = class {
       static get PERSISTENT_CACHE() {
@@ -2423,6 +2473,9 @@ var init_BlockStates = __esm({
         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, (k) => {
           return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
@@ -7984,6 +8037,7 @@ var Fonts = class {
 init_MineRenderData();
 init_ModelTextures();
 init_Models();
+init_Renames();
 init_source();
 
 // src/cache/index.ts
@@ -17298,18 +17352,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 ?? (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);
@@ -17352,10 +17411,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,
@@ -17369,11 +17428,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);
@@ -17389,6 +17450,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
@@ -17408,6 +17470,7 @@ var SectionModels = class {
 };
 
 // src/world/_entities/WorldEntities.ts
+init_Renames();
 init_Entities();
 init_EntityObject();
 
@@ -17567,8 +17630,10 @@ var WorldEntities = class {
         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) {
@@ -17583,7 +17648,7 @@ var WorldEntities = class {
           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 (error) {
           console.warn(`Could not draw saved entity ${placement.key.toNamespacedString()}, skipping it`, error);
@@ -17615,6 +17680,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 = {};
@@ -17678,12 +17869,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;
@@ -17724,6 +17920,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 ?? (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));
@@ -17959,6 +18214,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()]);
     }
   }
@@ -17975,11 +18233,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 });
     }
@@ -17990,6 +18251,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);
     }
@@ -18024,6 +18286,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();
@@ -18142,8 +18406,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 () => {
@@ -18160,7 +18430,8 @@ var MineRenderWorld = class {
             await this.updateCulling([]);
           }
         },
-        this.ambientLight
+        this.ambientLight,
+        () => this.biomeBlend
       );
       this._chunks.set(key, chunk);
     }
@@ -18279,9 +18550,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))) {
@@ -18296,7 +18568,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");
     }
   }
@@ -18406,6 +18678,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;
@@ -18422,9 +18695,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];
       }
@@ -18545,7 +18818,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 ?? (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);
@@ -18572,6 +18849,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
@@ -18716,7 +18994,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;
@@ -18725,6 +19003,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();
@@ -18734,6 +19013,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;
@@ -18832,10 +19112,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);
@@ -18850,10 +19140,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);
@@ -18893,6 +19205,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,
@@ -18912,6 +19238,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) {
@@ -18949,7 +19279,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, {
@@ -18968,7 +19298,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;
@@ -18979,7 +19313,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);
@@ -19026,7 +19363,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 });
@@ -19110,12 +19447,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) {
@@ -19163,7 +19523,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)) {
@@ -19333,6 +19697,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)
     )) : [];
@@ -19646,6 +20011,7 @@ export {
   PackMetadata,
   PersistentCache,
   PlayerHeadTextures,
+  Renames,
   Renderer,
   RequestError,
   Requests,