minerender 2.1.0-alpha.140 → 2.1.0-alpha.142

package/dist/node/index.mjs

@@ -309,6 +309,9 @@ var init_Caching = __esm({
       static {
         this.blockEntityIndexCache = _Caching.createAssetCache();
       }
+      static {
+        this.entityDatasetVersionCache = _Caching.createAssetCache();
+      }
       static {
         this.unihexCache = _Caching.createAssetCache();
       }
@@ -353,6 +356,7 @@ var init_Caching = __esm({
           this.entityTextureCache,
           this.entityAnimationCache,
           this.blockEntityIndexCache,
+          this.entityDatasetVersionCache,
           this.fontCache,
           this.unihexCache,
           this.bannerPatternCache,
@@ -3331,23 +3335,39 @@ var init_MinecraftCubeTexture = __esm({
   }
 });
 
+// src/assets/_versions/DatasetVersions.ts
+var parseRelease, compare2, nearestRelease;
+var init_DatasetVersions = __esm({
+  "src/assets/_versions/DatasetVersions.ts"() {
+    parseRelease = (value) => /^\d+\.\d+(?:\.\d+)?$/.test(value) ? value.split(".").map(Number) : void 0;
+    compare2 = (left, right) => {
+      for (let i = 0; i < 3; i++) {
+        const difference = (left[i] ?? 0) - (right[i] ?? 0);
+        if (difference) return difference;
+      }
+      return 0;
+    };
+    nearestRelease = (requestedVersion, published) => {
+      const requested = parseRelease(requestedVersion);
+      if (!requested) return void 0;
+      const versions = published.map((name) => ({ name, number: parseRelease(name) })).filter((entry) => !!entry.number).sort((left, right) => compare2(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)) || compare2(left.number, right.number))[0] ?? versions.filter((entry) => compare2(entry.number, requested) <= 0).pop() ?? versions[0];
+      return selected?.name;
+    };
+  }
+});
+
 // src/assets/MineRenderData.ts
-var object2, release, compare2, MineRenderData;
+var object2, MineRenderData;
 var init_MineRenderData = __esm({
   "src/assets/MineRenderData.ts"() {
+    init_DatasetVersions();
     init_AssetKey();
     init_AssetLoader();
     init_AssetParsers();
     init_Caching();
     object2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-    release = (value) => /^\d+\.\d+(?:\.\d+)?$/.test(value) ? value.split(".").map(Number) : void 0;
-    compare2 = (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) {
@@ -3377,9 +3397,9 @@ var init_MineRenderData = __esm({
         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);
+          let manifest = await this.manifest(root, requestRoot !== void 0 && parseRelease(requestedVersion) ? requestedVersion : void 0, requestRoot);
           if (manifest) return { requestedVersion, version: manifest.minecraftVersion, root, manifest };
-          const requested = release(requestedVersion);
+          const requested = parseRelease(requestedVersion);
           if (!requested) {
             throw new Error(`No MineRender data is published for ${requestedVersion}; automatic fallback requires a release`);
           }
@@ -3391,14 +3411,12 @@ var init_MineRenderData = __esm({
             }
             return value.versions;
           });
-          const versions = index.map((entry) => ({ name: entry.name, number: release(entry.name) })).filter((entry) => !!entry.number).sort((left, right) => compare2(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)) || compare2(left.number, right.number))[0] ?? versions.filter((entry) => compare2(entry.number, requested) <= 0).pop() ?? versions[0];
+          const selected = nearestRelease(requestedVersion, index.map((entry) => entry.name));
           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 };
+          const resolvedRoot = `${base}/${selected}`;
+          manifest = await this.manifest(resolvedRoot, selected, resolvedRoot);
+          if (!manifest) throw new Error(`Missing MineRender manifest for published version ${selected}`);
+          return { requestedVersion, version: selected, root: resolvedRoot, manifest };
         });
       }
       static async manifest(root, expectedVersion, requestRoot) {
@@ -4520,118 +4538,12 @@ var init_Biomes = __esm({
   }
 });
 
-// src/assets/BlockEntities.ts
-import { Matrix4 as Matrix42 } from "three";
-var log9, BlockEntities;
-var init_BlockEntities = __esm({
-  "src/assets/BlockEntities.ts"() {
-    init_AssetKey();
-    init_AssetLoader();
-    init_source();
-    init_Caching();
-    init_log();
-    log9 = logger("BlockEntities");
-    BlockEntities = class {
-      /**
-       * Loads the block index of a version. Versions and sources without one yield an empty index, and so does
-       * a failed load: the index is optional, and blocks must not retry or fail with it one by one. The empty
-       * result is cached like any other; `Caching.clear()` or `AssetLoader.setVersion()` forces a new attempt.
-       */
-      static async getIndex(root) {
-        const key = new AssetKey("entity-models", "blocks", void 0, void 0, void 0, ".json", root);
-        key.rootType = void 0;
-        const index = await Caching.blockEntityIndexCache.get(key.serialize(), async () => {
-          try {
-            return await AssetLoader.get(key, "json" /* JSON */) ?? {};
-          } catch (error) {
-            log9.warn("Could not load the block entity index; block entities are drawn as plain block models", error);
-            return {};
-          }
-        });
-        return index ?? {};
-      }
-      /** The index entry of a block ID such as `minecraft:chest`. */
-      static entry(index, block) {
-        const entry = Object.prototype.hasOwnProperty.call(index, block) ? index[block] : void 0;
-        return Array.isArray(entry?.parts) ? entry : void 0;
-      }
-      /** Selects the parts and placement for a block ID such as `minecraft:chest`; undefined when nothing is drawn. */
-      static resolve(index, block, state = {}) {
-        const entry = this.entry(index, block);
-        if (!entry) return void 0;
-        const value = (property) => String(state[property]).toLowerCase();
-        const parts = entry.parts.filter((part) => Object.entries(part.when ?? {}).every(([property, values]) => String(values).split("|").includes(value(property))));
-        if (!parts.length) return void 0;
-        let rotation = 0;
-        if (entry.rotation) {
-          const selected = value(entry.rotation.property);
-          rotation = "degrees" in entry.rotation ? entry.rotation.degrees[selected] : Number(selected) * entry.rotation.step;
-          if (!Number.isFinite(rotation)) rotation = 0;
-        }
-        return { parts, rotation, translation: entry.translation ?? [0, 0, 0] };
-      }
-      /** Placement in block space (0..16 per axis), applied on top of the model's own transform. */
-      static matrix(resolved, matrix = new Matrix42()) {
-        return matrix.makeTranslation(8, 0, 8).multiply(new Matrix42().makeRotationY(resolved.rotation * Math.PI / 180)).multiply(new Matrix42().makeTranslation(resolved.translation[0] - 8, resolved.translation[1], resolved.translation[2] - 8));
-      }
-    };
-  }
-});
-
-// src/assets/DecoratedPots.ts
-var POTTERY_SHERDS, DecoratedPots;
-var init_DecoratedPots = __esm({
-  "src/assets/DecoratedPots.ts"() {
-    init_AssetKey();
-    POTTERY_SHERDS = Object.freeze([
-      "angler",
-      "archer",
-      "arms_up",
-      "blade",
-      "brewer",
-      "burn",
-      "danger",
-      "explorer",
-      "flow",
-      "friend",
-      "guster",
-      "heart",
-      "heartbreak",
-      "howl",
-      "miner",
-      "mourner",
-      "plenty",
-      "prize",
-      "scrape",
-      "sheaf",
-      "shelter",
-      "skull",
-      "snort"
-    ].map((pattern2) => `minecraft:${pattern2}_pottery_sherd`));
-    DecoratedPots = class {
-      /** Reads up to four item IDs in back, left, right, front order; missing and unmapped items use plain sides. */
-      static getSideTextures(value, root) {
-        const items = value === void 0 ? [] : value;
-        if (!Array.isArray(items) || items.length > 4) throw new Error("pot_decorations must be an array of at most four item IDs");
-        const textures = items.map((item) => {
-          if (!isResourceLocation(item)) throw new Error("Pot decorations must be item identifiers");
-          const id = item.includes(":") ? item : `minecraft:${item}`;
-          return POTTERY_SHERDS.includes(id) ? id.slice("minecraft:".length).replace(/_sherd$/, "_pattern") : "decorated_pot_side";
-        });
-        return Object.fromEntries(["back", "left", "right", "front"].map((side, index) => [
-          side,
-          new AssetKey("minecraft", `decorated_pot/${textures[index] ?? "decorated_pot_side"}`, "textures", "entity", "assets", ".png", root)
-        ]));
-      }
-    };
-  }
-});
-
 // src/assets/Entities.ts
 var Entities;
 var init_Entities = __esm({
   "src/assets/Entities.ts"() {
     init_AssetKey();
+    init_DatasetVersions();
     init_AssetLoader();
     init_source();
     init_Caching();
@@ -4639,11 +4551,36 @@ var init_Entities = __esm({
     init_MineRenderError();
     init_ModelTextures();
     Entities = class {
+      /**
+       * Resolves `root` (default: the active version). Uses the exact dataset when published or when the
+       * version is not a release; otherwise selects the nearest published release, like {@link MineRenderData.resolve}.
+       * Textures keep the requested root.
+       */
+      static async getDatasetRoot(root) {
+        const requestRoot = (root ?? AssetLoader.ROOT).replace(/\/+$/, "");
+        const requestedVersion = requestRoot.slice(requestRoot.lastIndexOf("/") + 1);
+        const base = requestRoot.slice(0, requestRoot.lastIndexOf("/"));
+        const selected = await Caching.entityDatasetVersionCache.get(root ?? `sources:${AssetLoader.ROOT}`, async () => {
+          const key = new AssetKey("entity-models", "version", void 0, void 0, void 0, ".json", root);
+          key.rootType = void 0;
+          if (!parseRelease(requestedVersion) || await AssetLoader.get(key, "json" /* JSON */) !== void 0) return requestedVersion;
+          const indexKey = new AssetKey("entity-models", "versions", void 0, void 0, void 0, ".json", base);
+          indexKey.rootType = void 0;
+          const index = await AssetLoader.get(indexKey, "json" /* JSON */);
+          if (index === void 0) return requestedVersion;
+          if (!index || typeof index !== "object" || Array.isArray(index) || !Array.isArray(index.versions) || !index.versions.every((entry) => entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.name === "string")) {
+            throw new MineRenderError(`Invalid entity model version index at ${base}/entity-models/versions.json`);
+          }
+          return nearestRelease(requestedVersion, index.versions.map((entry) => entry.name)) ?? requestedVersion;
+        });
+        return selected === requestedVersion ? root : `${base}/${selected}`;
+      }
       /** Lists model paths in the `minecraft` namespace, including subdirectories and excluding `.json`. */
       static async getEntityList() {
+        const root = await this.getDatasetRoot();
         const collect = async (path) => {
           const prefix2 = path ? `${path}/` : "";
-          const key = new AssetKey(DEFAULT_NAMESPACE, `${prefix2}_list`, void 0, void 0, "entity-models", ".json");
+          const key = new AssetKey(DEFAULT_NAMESPACE, `${prefix2}_list`, void 0, void 0, "entity-models", ".json", root);
           const list2 = await Caching.listAssetCache.get(key.serialize(), () => AssetLoader.get(key, "list" /* LIST */));
           if (!list2) return [];
           const files = list2.files.filter((file) => file.endsWith(".json") && file !== "_list.json").map((file) => `${prefix2}${file.slice(0, -5)}`);
@@ -4654,7 +4591,7 @@ var init_Entities = __esm({
       }
       static async getModelFile(modelKey) {
         const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json", isAssetKey(modelKey) ? modelKey.root : void 0);
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json", await this.getDatasetRoot(isAssetKey(modelKey) ? modelKey.root : void 0));
         return Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
       }
       /** Returns selectable geometry-layer names, or an empty list when the model is missing. */
@@ -4715,7 +4652,7 @@ var init_Entities = __esm({
        */
       static async getAnimations(modelKey) {
         const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
-        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json", isAssetKey(modelKey) ? modelKey.root : void 0);
+        const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json", await this.getDatasetRoot(isAssetKey(modelKey) ? modelKey.root : void 0));
         const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
         return file?.animations;
       }
@@ -4757,6 +4694,115 @@ var init_Entities = __esm({
   }
 });
 
+// src/assets/BlockEntities.ts
+import { Matrix4 as Matrix42 } from "three";
+var log9, BlockEntities;
+var init_BlockEntities = __esm({
+  "src/assets/BlockEntities.ts"() {
+    init_AssetKey();
+    init_Entities();
+    init_AssetLoader();
+    init_source();
+    init_Caching();
+    init_log();
+    log9 = logger("BlockEntities");
+    BlockEntities = class {
+      /**
+       * Loads the block index of a version. Versions and sources without one yield an empty index, and so does
+       * a failed load: the index is optional, and blocks must not retry or fail with it one by one. The empty
+       * result is cached like any other; `Caching.clear()` or `AssetLoader.setVersion()` forces a new attempt.
+       */
+      static async getIndex(root) {
+        const key = new AssetKey("entity-models", "blocks", void 0, void 0, void 0, ".json", root);
+        key.rootType = void 0;
+        const index = await Caching.blockEntityIndexCache.get(key.serialize(), async () => {
+          try {
+            key.root = await Entities.getDatasetRoot(root);
+            return await AssetLoader.get(key, "json" /* JSON */) ?? {};
+          } catch (error) {
+            log9.warn("Could not load the block entity index; block entities are drawn as plain block models", error);
+            return {};
+          }
+        });
+        return index ?? {};
+      }
+      /** The index entry of a block ID such as `minecraft:chest`. */
+      static entry(index, block) {
+        const entry = Object.prototype.hasOwnProperty.call(index, block) ? index[block] : void 0;
+        return Array.isArray(entry?.parts) ? entry : void 0;
+      }
+      /** Selects the parts and placement for a block ID such as `minecraft:chest`; undefined when nothing is drawn. */
+      static resolve(index, block, state = {}) {
+        const entry = this.entry(index, block);
+        if (!entry) return void 0;
+        const value = (property) => String(state[property]).toLowerCase();
+        const parts = entry.parts.filter((part) => Object.entries(part.when ?? {}).every(([property, values]) => String(values).split("|").includes(value(property))));
+        if (!parts.length) return void 0;
+        let rotation = 0;
+        if (entry.rotation) {
+          const selected = value(entry.rotation.property);
+          rotation = "degrees" in entry.rotation ? entry.rotation.degrees[selected] : Number(selected) * entry.rotation.step;
+          if (!Number.isFinite(rotation)) rotation = 0;
+        }
+        return { parts, rotation, translation: entry.translation ?? [0, 0, 0] };
+      }
+      /** Placement in block space (0..16 per axis), applied on top of the model's own transform. */
+      static matrix(resolved, matrix = new Matrix42()) {
+        return matrix.makeTranslation(8, 0, 8).multiply(new Matrix42().makeRotationY(resolved.rotation * Math.PI / 180)).multiply(new Matrix42().makeTranslation(resolved.translation[0] - 8, resolved.translation[1], resolved.translation[2] - 8));
+      }
+    };
+  }
+});
+
+// src/assets/DecoratedPots.ts
+var POTTERY_SHERDS, DecoratedPots;
+var init_DecoratedPots = __esm({
+  "src/assets/DecoratedPots.ts"() {
+    init_AssetKey();
+    POTTERY_SHERDS = Object.freeze([
+      "angler",
+      "archer",
+      "arms_up",
+      "blade",
+      "brewer",
+      "burn",
+      "danger",
+      "explorer",
+      "flow",
+      "friend",
+      "guster",
+      "heart",
+      "heartbreak",
+      "howl",
+      "miner",
+      "mourner",
+      "plenty",
+      "prize",
+      "scrape",
+      "sheaf",
+      "shelter",
+      "skull",
+      "snort"
+    ].map((pattern2) => `minecraft:${pattern2}_pottery_sherd`));
+    DecoratedPots = class {
+      /** Reads up to four item IDs in back, left, right, front order; missing and unmapped items use plain sides. */
+      static getSideTextures(value, root) {
+        const items = value === void 0 ? [] : value;
+        if (!Array.isArray(items) || items.length > 4) throw new Error("pot_decorations must be an array of at most four item IDs");
+        const textures = items.map((item) => {
+          if (!isResourceLocation(item)) throw new Error("Pot decorations must be item identifiers");
+          const id = item.includes(":") ? item : `minecraft:${item}`;
+          return POTTERY_SHERDS.includes(id) ? id.slice("minecraft:".length).replace(/_sherd$/, "_pattern") : "decorated_pot_side";
+        });
+        return Object.fromEntries(["back", "left", "right", "front"].map((side, index) => [
+          side,
+          new AssetKey("minecraft", `decorated_pot/${textures[index] ?? "decorated_pot_side"}`, "textures", "entity", "assets", ".png", root)
+        ]));
+      }
+    };
+  }
+});
+
 // src/assets/_fonts/Unihex.ts
 var Unihex_exports = {};
 __export(Unihex_exports, {
@@ -17835,7 +17881,7 @@ var AnvilWorldSource = class {
     read.waiters++;
     return new Promise((resolve, reject) => {
       let finished = false;
-      const release2 = () => {
+      const release = () => {
         if (finished) return false;
         finished = true;
         signal?.removeEventListener("abort", abort);
@@ -17843,7 +17889,7 @@ var AnvilWorldSource = class {
         return true;
       };
       const abort = () => {
-        if (!release2()) return;
+        if (!release()) return;
         if (!read.waiters && !read.settled) {
           if (this.pending.get(key) === read) this.pending.delete(key);
           read.controller.abort(signal.reason);
@@ -17853,10 +17899,10 @@ var AnvilWorldSource = class {
       signal?.addEventListener("abort", abort, { once: true });
       read.promise.then(
         (data) => {
-          if (release2()) resolve(data);
+          if (release()) resolve(data);
         },
         (error) => {
-          if (release2()) reject(error);
+          if (release()) reject(error);
         }
       );
       if (signal?.aborted) abort();
@@ -17878,7 +17924,7 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-import { Color as Color13, Vector3 as Vector320 } from "three";
+import { Color as Color13, Vector3 as Vector321 } from "three";
 init_BlockStates();
 init_AssetKey();
 
@@ -19138,7 +19184,7 @@ init_BlockEntities();
 // src/world/SectionMesh.ts
 init_CanvasCompat();
 init_Materials();
-import { BufferGeometry as BufferGeometry9, Color as Color12, DoubleSide as DoubleSide8, Float32BufferAttribute as Float32BufferAttribute10, FrontSide as FrontSide4, Group as Group3, Mesh as Mesh12, Uint32BufferAttribute } from "three";
+import { BufferGeometry as BufferGeometry9, Color as Color12, DoubleSide as DoubleSide8, DynamicDrawUsage, Float32BufferAttribute as Float32BufferAttribute10, FrontSide as FrontSide4, Group as Group3, Matrix4 as Matrix413, Mesh as Mesh12, Uint32BufferAttribute, Vector3 as Vector320 } from "three";
 
 // src/world/SectionGeometry.ts
 init_FluidQuads();
@@ -19465,6 +19511,9 @@ var SectionWorker = class _SectionWorker {
 };
 
 // src/world/SectionMesh.ts
+var BLOCK_SIZE = 16;
+var QUAD_VERTICES = 4;
+var QUAD_INDICES = 6;
 var templateCache = /* @__PURE__ */ new WeakMap();
 var WATER_TINT = new Color12(4159204).toArray();
 function toInput(entries, maxAtlasSize, fluids, lighting) {
@@ -19501,8 +19550,8 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
       if (!data) {
         const indices = template.geometry.getIndex();
         const position = template.geometry.getAttribute("position");
-        const quads = indices.count / 6;
-        if (indices.count % 6 !== 0 || position.count !== quads * 4) {
+        const quads = indices.count / QUAD_INDICES;
+        if (indices.count % QUAD_INDICES !== 0 || position.count !== quads * QUAD_VERTICES) {
           throw new RangeError("Section template geometry must hold four vertices and six indices per quad");
         }
         data = {
@@ -19512,8 +19561,8 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
           uvs: new Float32Array(quads * 8),
           uvBounds: new Float32Array(quads * 16),
           colors: new Float32Array(quads * 12),
-          shade: new Float32Array(quads * 4),
-          indices: new Uint16Array(quads * 6),
+          shade: new Float32Array(quads * QUAD_VERTICES),
+          indices: new Uint16Array(quads * QUAD_INDICES),
           cullFaces: new Uint8Array(template.cullFaces),
           biomeTint: template.biomeTint ? new Uint8Array(template.biomeTint) : void 0,
           atlas: 0,
@@ -19525,7 +19574,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
         const bounds = template.geometry.getAttribute("uvBounds");
         const color2 = template.geometry.getAttribute("color");
         const shade = template.geometry.getAttribute("shade");
-        for (let vertex = 0; vertex < quads * 4; vertex++) {
+        for (let vertex = 0; vertex < quads * QUAD_VERTICES; vertex++) {
           data.positions.set([position.getX(vertex), position.getY(vertex), position.getZ(vertex)], vertex * 3);
           data.normals.set([normal.getX(vertex), normal.getY(vertex), normal.getZ(vertex)], vertex * 3);
           data.uvs.set([uv.getX(vertex), uv.getY(vertex)], vertex * 2);
@@ -19538,7 +19587,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
           data.colors.set([color2?.getX(vertex) ?? 1, color2?.getY(vertex) ?? 1, color2?.getZ(vertex) ?? 1], vertex * 3);
           data.shade[vertex] = shade?.getX(vertex) ?? 1;
         }
-        for (let i2 = 0; i2 < data.indices.length; i2++) data.indices[i2] = indices.getX(i2) - 4 * Math.floor(i2 / 6);
+        for (let i2 = 0; i2 < data.indices.length; i2++) data.indices[i2] = indices.getX(i2) - QUAD_VERTICES * Math.floor(i2 / QUAD_INDICES);
         templateCache.set(template, data);
       }
       id = input.templateData.length;
@@ -19571,6 +19620,54 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
   }
   return { input, atlases: atlases2 };
 }
+function sortTransparentQuads(mesh) {
+  const index = mesh.geometry.getIndex();
+  if (index.count <= QUAD_INDICES) return;
+  index.setUsage(DynamicDrawUsage);
+  const count = index.count / QUAD_INDICES;
+  let source, centers, depths, order;
+  const view = new Matrix413(), localCamera = new Vector320(), key = new Vector320(), previous = new Vector320();
+  let previousOrthographic;
+  mesh.onBeforeRender = (_renderer, _scene, camera) => {
+    localCamera.setFromMatrixPosition(camera.matrixWorld).applyMatrix4(view.copy(mesh.matrixWorld).invert());
+    const orthographic = !!camera.isOrthographicCamera;
+    if (orthographic) {
+      view.multiplyMatrices(camera.matrixWorldInverse, mesh.matrixWorld);
+      key.set(view.elements[2], view.elements[6], view.elements[10]);
+    } else {
+      key.copy(localCamera).divideScalar(BLOCK_SIZE).floor();
+    }
+    if (orthographic === previousOrthographic && key.equals(previous)) return;
+    previous.copy(key);
+    previousOrthographic = orthographic;
+    if (!centers) {
+      source = new Uint32Array(index.array);
+      centers = new Float32Array(count * 3);
+      depths = new Float32Array(count);
+      order = Uint32Array.from({ length: count }, (_, quad) => quad);
+      const positions = mesh.geometry.getAttribute("position");
+      for (let quad = 0; quad < count; quad++) {
+        for (let axis = 0; axis < 3; axis++) {
+          let center = 0;
+          for (let corner = 0; corner < QUAD_VERTICES; corner++) center += positions.getComponent(quad * QUAD_VERTICES + corner, axis);
+          centers[quad * 3 + axis] = center / QUAD_VERTICES;
+        }
+      }
+    }
+    for (let quad = 0; quad < count; quad++) {
+      const x = centers[quad * 3], y = centers[quad * 3 + 1], z = centers[quad * 3 + 2];
+      depths[quad] = orthographic ? key.x * x + key.y * y + key.z * z : -((x - localCamera.x) ** 2 + (y - localCamera.y) ** 2 + (z - localCamera.z) ** 2);
+    }
+    order.sort((a, b) => depths[a] - depths[b] || a - b);
+    if (!order.some((quad, offset) => index.array[offset * QUAD_INDICES] !== source[quad * QUAD_INDICES])) return;
+    for (let offset = 0; offset < count; offset++) {
+      for (let indexOffset = 0; indexOffset < QUAD_INDICES; indexOffset++) {
+        index.array[offset * QUAD_INDICES + indexOffset] = source[order[offset] * QUAD_INDICES + indexOffset];
+      }
+    }
+    index.needsUpdate = true;
+  };
+}
 var SectionMesh = class _SectionMesh extends Group3 {
   constructor() {
     super(...arguments);
@@ -19580,7 +19677,11 @@ var SectionMesh = class _SectionMesh extends Group3 {
   /** Returns the owning section cell for a triangle hit on this mesh's merged geometry. */
   getBlockIndex(hit) {
     if (hit.faceIndex === void 0 || hit.faceIndex === null) return void 0;
-    return this.blockIndices.get(hit.object)?.[Math.floor(hit.faceIndex / 2)];
+    const mesh = hit.object;
+    const owners = this.blockIndices.get(mesh);
+    if (!owners) return void 0;
+    const vertex = mesh.geometry.getIndex().getX(hit.faceIndex * 3);
+    return owners[Math.floor(vertex / QUAD_VERTICES)];
   }
   /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
   static build(entries, maxAtlasSize = 2048, fluids, lighting) {
@@ -19616,13 +19717,14 @@ var SectionMesh = class _SectionMesh extends Group3 {
       const material = Materials.createShadedCanvasMaterial(canvas, transparent, false, true);
       material.side = FrontSide4;
       if (page.layer === 2) {
+        material.depthWrite = !material.transparent;
         material.side = DoubleSide8;
         material.forceSinglePass = true;
-        material.depthWrite = !material.transparent;
       }
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
       const mesh = new Mesh12(geometry, material);
+      if (transparent) sortTransparentQuads(mesh);
       section.add(mesh);
       section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
@@ -19681,7 +19783,7 @@ var Chunk = class _Chunk {
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
     this.fluidCells = new Uint8Array(4096);
-    this.blockPosition = new Vector320();
+    this.blockPosition = new Vector321();
     this.meshDirty = false;
     this.meshGeneration = 0;
     this.blockChanges = /* @__PURE__ */ new Set();
@@ -19741,7 +19843,7 @@ var Chunk = class _Chunk {
       const info = owner.chunk.renderedBlocks.get(owner.index);
       if (!info) continue;
       return {
-        position: new Vector320(
+        position: new Vector321(
           owner.chunk.x * 16 + owner.index % 16,
           owner.chunk.y * 16 + Math.floor(owner.index / 256),
           owner.chunk.z * 16 + Math.floor(owner.index / 16) % 16
@@ -19756,18 +19858,18 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector320(posOrX, y, z));
+      return this.getBlockAt(new Vector321(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector320(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector321(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.blockPosition.set(posOrX.x - this.x * 16, posOrX.y - this.y * 16, posOrX.z - this.z * 16);
     const index = _Chunk.chunkPosToBlockIndex(pos);
     return this.renderedBlocks.get(index);
   }
   getBiomeAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getBiomeAt(new Vector320(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector320(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new Vector321(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector321(...posOrX));
     const pos = this.worldPosToChunkPos(posOrX);
     _Chunk.chunkPosToBlockIndex(pos);
     return this.biomeAt ? this.biomeAt(posOrX.x, posOrX.y, posOrX.z) : this.biomes?.[Math.floor(pos.x / 4) + Math.floor(pos.z / 4) * 4 + Math.floor(pos.y / 4) * 16];
@@ -19845,17 +19947,17 @@ var Chunk = class _Chunk {
         this.hiddenBlocks.add(index);
         this.renderedBlocks.get(index)?.object?.setVisible(false);
       }
-      const positions = blocks.map(({ index }) => new Vector320(...this.positionAt(index)));
+      const positions = blocks.map(({ index }) => new Vector321(...this.positionAt(index)));
       if (this.onBlocksChanged) await this.onBlocksChanged(positions, deferCulling);
       else await this.rebuildSectionMesh();
     }
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector320(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector321(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector320(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector321(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -19928,7 +20030,7 @@ var Chunk = class _Chunk {
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
       this.objectBlocks.delete(index);
-      const worldPos = new Vector320(
+      const worldPos = new Vector321(
         this.x * 16 + index % 16,
         this.y * 16 + Math.floor(index / 256),
         this.z * 16 + Math.floor(index / 16) % 16
@@ -20066,7 +20168,7 @@ var Chunk = class _Chunk {
           biome,
           biomePosition: this.biomePosition(index, blockState3, this.data.stateAt(this.data.idAt(index)))
         });
-        object4.setPosition(new Vector320(
+        object4.setPosition(new Vector321(
           this.x * 256 + index % 16 * 16,
           this.y * 256 + Math.floor(index / 256) * 16,
           this.z * 256 + Math.floor(index / 16) % 16 * 16
@@ -20373,7 +20475,7 @@ var Chunk = class _Chunk {
   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)
+      new Vector321(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     )) : [];
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -20409,14 +20511,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector320(
+    return new Vector321(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector320(
+    return new Vector321(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z