minerender 2.1.0-alpha.131 → 2.1.0-alpha.133

package/dist/bundle.js

@@ -35632,6 +35632,7 @@ void main() {
             this.entityAnimationCache,
             this.blockEntityIndexCache,
             this.fontCache,
+            this.unihexCache,
             this.bannerPatternCache,
             this.mineRenderDataCache,
             this.usernameUuidCache,
@@ -35685,6 +35686,7 @@ void main() {
       _Caching.entityTextureCache = _Caching.createAssetCache();
       _Caching.entityAnimationCache = _Caching.createAssetCache();
       _Caching.blockEntityIndexCache = _Caching.createAssetCache();
+      _Caching.unihexCache = _Caching.createAssetCache();
       _Caching.fontCache = _Caching.createAssetCache();
       _Caching.bannerPatternCache = _Caching.createAssetCache();
       _Caching.mineRenderDataCache = _Caching.createAssetCache();
@@ -37098,6 +37100,7 @@ void main() {
         AssetParser2["IMAGE"] = "image";
         AssetParser2["LIST"] = "list";
         AssetParser2["JSON"] = "json";
+        AssetParser2["BINARY"] = "binary";
         return AssetParser2;
       })(AssetParser || {});
     }
@@ -73063,7 +73066,7 @@ return ${compiler2.callType("value", tagType)}
   });
 
   // src/assets/source/HostedAssetSource.ts
-  var p7, DEFAULT_OPTIONS2, _HostedAssetSource, HostedAssetSource;
+  var BINARY_TIMEOUT, p7, DEFAULT_OPTIONS2, _HostedAssetSource, HostedAssetSource;
   var init_HostedAssetSource = __esm({
     "src/assets/source/HostedAssetSource.ts"() {
       init_dirname();
@@ -73079,6 +73082,7 @@ return ${compiler2.callType("value", tagType)}
       init_AssetLoader();
       init_parser();
       init_merge();
+      BINARY_TIMEOUT = 6e4;
       p7 = prefix("HostedAssetSource");
       DEFAULT_OPTIONS2 = {
         retryDefaults: true
@@ -73219,6 +73223,15 @@ return ${compiler2.callType("value", tagType)}
           return response.data;
         }
       };
+      _HostedAssetSource.BINARY = {
+        config(request) {
+          request.timeout = BINARY_TIMEOUT;
+          request.responseType = "arraybuffer";
+        },
+        parse(response) {
+          return { data: new Uint8Array(response.data) };
+        }
+      };
       _HostedAssetSource.PARSER_MAP = /* @__PURE__ */ new Map([
         ["model" /* MODEL */, _HostedAssetSource.MODEL],
         ["blockstate" /* BLOCKSTATE */, _HostedAssetSource.BLOCKSTATE],
@@ -73226,7 +73239,8 @@ return ${compiler2.callType("value", tagType)}
         ["nbt" /* NBT */, _HostedAssetSource.NBT],
         ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
         ["list" /* LIST */, _HostedAssetSource.LIST],
-        ["json" /* JSON */, _HostedAssetSource.JSON]
+        ["json" /* JSON */, _HostedAssetSource.JSON],
+        ["binary" /* BINARY */, _HostedAssetSource.BINARY]
       ]);
       HostedAssetSource = _HostedAssetSource;
     }
@@ -81841,7 +81855,7 @@ return ${compiler2.callType("value", tagType)}
   function readUint8Array(reader, offset, size, diskNumber) {
     return reader.readUint8Array(offset, size, diskNumber);
   }
-  var ERR_ITERATOR_COMPLETED_TOO_SOON, HTTP_HEADER_CONTENT_TYPE, DEFAULT_CHUNK_SIZE, PROPERTY_NAME_WRITABLE, Stream, Reader, BlobReader, BlobWriter, SplitDataReader, SplitDataWriter;
+  var ERR_ITERATOR_COMPLETED_TOO_SOON, HTTP_HEADER_CONTENT_TYPE, DEFAULT_CHUNK_SIZE, PROPERTY_NAME_WRITABLE, Stream, Reader, BlobReader, BlobWriter, TextWriter, Uint8ArrayReader, SplitDataReader, SplitDataWriter;
   var init_io = __esm({
     "../../node_modules/@zip.js/zip.js/lib/core/io.js"() {
       init_dirname();
@@ -81924,6 +81938,46 @@ return ${compiler2.callType("value", tagType)}
           return this.blob;
         }
       };
+      TextWriter = class extends BlobWriter {
+        constructor(encoding) {
+          super(encoding);
+          Object.assign(this, {
+            encoding,
+            utf8: !encoding || encoding.toLowerCase() == "utf-8"
+          });
+        }
+        async getData() {
+          const {
+            encoding,
+            utf8
+          } = this;
+          const blob = await super.getData();
+          if (blob.text && utf8) {
+            return blob.text();
+          } else {
+            const reader = new FileReader();
+            return new Promise((resolve, reject) => {
+              Object.assign(reader, {
+                onload: ({ target }) => resolve(target.result),
+                onerror: () => reject(reader.error)
+              });
+              reader.readAsText(blob, encoding);
+            });
+          }
+        }
+      };
+      Uint8ArrayReader = class extends Reader {
+        constructor(array) {
+          super();
+          Object.assign(this, {
+            array,
+            size: array.length
+          });
+        }
+        readUint8Array(index, length) {
+          return this.array.slice(index, index + length);
+        }
+      };
       SplitDataReader = class extends Reader {
         constructor(readers) {
           super();
@@ -84682,6 +84736,181 @@ ${key}` : key;
     }
   });
 
+  // src/assets/_fonts/Unihex.ts
+  var Unihex_exports = {};
+  __export(Unihex_exports, {
+    loadUnihex: () => loadUnihex
+  });
+  function readHex(text2, filename, glyphs) {
+    const lines = text2.split("\n");
+    if (lines[lines.length - 1] === "") lines.pop();
+    lines.forEach((line, index) => {
+      const match = /^([0-9A-F]{4,6}):([0-9A-F]+)$/.exec(line);
+      if (!match || ![32, 64, 96, 128].includes(match[2].length)) {
+        throw new Error(`Invalid Unihex record in ${filename} at line ${index + 1}`);
+      }
+      const codepoint = parseInt(match[1], 16);
+      if (codepoint > 1114111) throw new Error(`Invalid Unihex codepoint in ${filename} at line ${index + 1}`);
+      const bitWidth = match[2].length / 4;
+      const rowLength = bitWidth / 4;
+      const rows = new Uint32Array(GLYPH_HEIGHT);
+      let mask = 0;
+      for (let y5 = 0; y5 < GLYPH_HEIGHT; y5++) {
+        rows[y5] = parseInt(match[2].slice(y5 * rowLength, (y5 + 1) * rowLength), 16);
+        mask |= rows[y5];
+      }
+      let left = 0, right = bitWidth;
+      if (mask) {
+        while (!(mask >>> bitWidth - left - 1 & 1)) left++;
+        right = bitWidth - 1;
+        while (!(mask >>> bitWidth - right - 1 & 1)) right--;
+      }
+      glyphs.set(codepoint, { rows, bitWidth, left, right });
+    });
+  }
+  async function parseUnihex(key) {
+    try {
+      const asset2 = await AssetLoader.get(key, "binary" /* BINARY */);
+      if (!asset2) throw new Error(`Could not load Unihex archive ${key.toNamespacedString()}`);
+      const records = /* @__PURE__ */ new Map();
+      const reader = new ZipReader(new Uint8ArrayReader(asset2.data), { useWebWorkers: false, useCompressionStream: false });
+      try {
+        for (const entry of await reader.getEntries()) {
+          if (!entry.directory && entry.filename.endsWith(".hex")) {
+            readHex(await entry.getData(new TextWriter(), { checkSignature: true }), entry.filename, records);
+          }
+        }
+      } finally {
+        await reader.close();
+      }
+      const indices = new Int32Array(1114112).fill(-1);
+      const rows = new Uint32Array(records.size * GLYPH_HEIGHT), metrics = new Uint8Array(records.size * 3);
+      let index = 0;
+      for (const [codepoint, record] of records) {
+        indices[codepoint] = index;
+        rows.set(record.rows, index * GLYPH_HEIGHT);
+        metrics.set([record.bitWidth, record.left, record.right], index * 3);
+        index++;
+      }
+      return { indices, rows, metrics };
+    } catch (error2) {
+      console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
+      return void 0;
+    }
+  }
+  async function loadUnihex(provider, fontKey, characters) {
+    const origin = new AssetKey(DEFAULT_NAMESPACE, "", void 0, void 0, "assets", "", fontKey.root);
+    const key = AssetKey.parse("font", provider.hex_file, origin);
+    key.assetType = void 0;
+    const glyphs = /* @__PURE__ */ new Map();
+    let overrides;
+    try {
+      overrides = (provider.size_overrides ?? []).map((override) => {
+        const from = override.from.codePointAt(0), to = override.to.codePointAt(0);
+        if ([...override.from].length !== 1 || [...override.to].length !== 1 || from >= to || !Number.isInteger(override.left) || !Number.isInteger(override.right) || override.right < override.left) {
+          throw new Error(`Invalid Unihex size override in font ${fontKey.toNamespacedString()}`);
+        }
+        return { ...override, from, to };
+      });
+    } catch (error2) {
+      console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
+      return glyphs;
+    }
+    const file = await Caching.unihexCache.get(key.serialize(), () => parseUnihex(key));
+    if (!file) return glyphs;
+    let atlas = atlases.get(provider);
+    if (!atlas) {
+      atlas = new UnihexAtlas();
+      atlases.set(provider, atlas);
+    }
+    for (const character of characters) {
+      const codepoint = character.codePointAt(0), index = file.indices[codepoint];
+      if (index < 0) continue;
+      const record = {
+        rows: file.rows.subarray(index * GLYPH_HEIGHT, (index + 1) * GLYPH_HEIGHT),
+        bitWidth: file.metrics[index * 3],
+        left: file.metrics[index * 3 + 1],
+        right: file.metrics[index * 3 + 2]
+      };
+      const override = overrides.find((range) => codepoint >= range.from && codepoint <= range.to);
+      if (override) {
+        record.left = override.left;
+        record.right = override.right;
+      }
+      const width = record.right - record.left + 1;
+      let rendered;
+      const render = () => rendered ?? (rendered = atlas.draw(record));
+      glyphs.set(character, {
+        get image() {
+          return render().image;
+        },
+        get x() {
+          return render().x;
+        },
+        get y() {
+          return render().y;
+        },
+        width,
+        height: GLYPH_HEIGHT,
+        scale: 0.5,
+        ascent: 7,
+        advance: Math.floor(width / 2) + 1,
+        boldOffset: 0.5,
+        shadowOffset: 0.5
+      });
+    }
+    return glyphs;
+  }
+  var ATLAS_SIZE, GLYPH_HEIGHT, UnihexAtlas, atlases;
+  var init_Unihex = __esm({
+    "src/assets/_fonts/Unihex.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_zip();
+      init_AssetKey();
+      init_AssetLoader();
+      init_Assets();
+      init_Caching();
+      init_AssetParsers();
+      init_CanvasCompat();
+      ATLAS_SIZE = 512;
+      GLYPH_HEIGHT = 16;
+      UnihexAtlas = class {
+        constructor() {
+          this.x = 0;
+          this.y = 0;
+        }
+        draw(glyph) {
+          const width = glyph.right - glyph.left + 1;
+          if (this.image && this.x + width > this.image.width) {
+            this.x = 0;
+            this.y += GLYPH_HEIGHT;
+          }
+          if (!this.image || this.y + GLYPH_HEIGHT > this.image.height || width > this.image.width) {
+            this.image = createCanvas(Math.max(ATLAS_SIZE, width), ATLAS_SIZE);
+            this.x = 0;
+            this.y = 0;
+          }
+          const context = this.image.getContext("2d");
+          const pixels = context.createImageData(width, GLYPH_HEIGHT);
+          for (let y5 = 0; y5 < GLYPH_HEIGHT; y5++) {
+            for (let x4 = 0; x4 < width; x4++) {
+              const column = glyph.left + x4;
+              if (column < 0 || column >= glyph.bitWidth || !(glyph.rows[y5] >>> glyph.bitWidth - column - 1 & 1)) continue;
+              pixels.data.fill(255, (y5 * width + x4) * 4, (y5 * width + x4 + 1) * 4);
+            }
+          }
+          const result = { image: this.image, x: this.x, y: this.y };
+          context.putImageData(pixels, this.x, this.y);
+          this.x += width;
+          return result;
+        }
+      };
+      atlases = /* @__PURE__ */ new WeakMap();
+    }
+  });
+
   // src/assets/Fonts.ts
   var Fonts;
   var init_Fonts = __esm({
@@ -84695,7 +84924,7 @@ ${key}` : key;
       init_ModelTextures();
       init_Caching();
       Fonts = class {
-        /** Combines font definitions in source-priority order. Unsupported Unihex and TrueType providers are skipped. */
+        /** Combines font definitions in source-priority order. TrueType providers are skipped. */
         static async get(key = "minecraft:default") {
           const fontKey = typeof key === "string" ? AssetKey.parse("font", key) : key;
           return await Caching.fontCache.get(fontKey.serialize(), () => this.load(fontKey, []));
@@ -84711,6 +84940,7 @@ ${key}` : key;
           const stack = await AssetLoader.getAll(key, "json" /* JSON */);
           if (stack.length === 0) throw new Error(`Could not load font ${key.toNamespacedString()}`);
           const glyphs = /* @__PURE__ */ new Map();
+          const providers = [];
           for (const asset2 of stack) {
             for (const provider of asset2.providers) {
               if (provider.filter?.uniform || provider.filter?.jp) continue;
@@ -84729,17 +84959,43 @@ ${key}` : key;
                   break;
                 case "reference":
                 case "minecraft:reference":
-                  provided = (await this.load(this.relatedKey("font", provider.id, key), [...parents, serialized])).glyphs;
+                  const reference = await this.load(this.relatedKey("font", provider.id, key), [...parents, serialized]);
+                  if (reference.resolve) {
+                    providers.push(async (characters) => {
+                      await reference.resolve(characters);
+                      return reference.glyphs;
+                    });
+                    continue;
+                  }
+                  provided = reference.glyphs;
                   break;
+                case "unihex":
+                case "minecraft:unihex":
+                  providers.push(async (characters) => (await Promise.resolve().then(() => (init_Unihex(), Unihex_exports))).loadUnihex(provider, key, characters));
+                  continue;
                 default:
                   continue;
               }
-              for (const [character, glyph] of provided) {
+              if (providers.every((provider2) => provider2 instanceof Map)) for (const [character, glyph] of provided) {
                 if (character !== "\0" && !glyphs.has(character)) glyphs.set(character, glyph);
               }
+              providers.push(provided);
             }
           }
-          return { glyphs };
+          return { glyphs, resolve: providers.every((provider) => provider instanceof Map) ? void 0 : async (characters) => {
+            const remaining = new Set([...characters].filter((character) => character !== "\0" && character !== "\n" && character !== "\r" && !glyphs.has(character)));
+            for (const provider of providers) {
+              if (!remaining.size) break;
+              const provided = provider instanceof Map ? provider : await provider([...remaining].join(""));
+              for (const character of remaining) {
+                const glyph = provided.get(character);
+                if (glyph) {
+                  glyphs.set(character, glyph);
+                  remaining.delete(character);
+                }
+              }
+            }
+          } };
         }
         static async bitmap(provider, fontKey) {
           const rows = provider.chars.map((row) => [...row]);
@@ -84835,6 +85091,13 @@ ${key}` : key;
   });
 
   // src/entity/scene/EntityAnimationPlayer.ts
+  function validateAnimationWeights(weights, count) {
+    const values = Array.from(weights);
+    if (values.length !== count || values.some((weight) => !Number.isFinite(weight) || weight < 0)) {
+      throw new Error("Animation weights must match the clip count and contain only finite nonnegative numbers");
+    }
+    return values;
+  }
   var ZERO, EntityAnimationPlayer;
   var init_EntityAnimationPlayer = __esm({
     "src/entity/scene/EntityAnimationPlayer.ts"() {
@@ -84847,12 +85110,20 @@ ${key}` : key;
       EntityAnimationPlayer = class {
         constructor() {
           this.parts = [];
+          this._animations = [];
+          this._weights = [];
+          this.loops = [];
           this._time = 0;
-          this.loop = false;
           this.speed = 1;
         }
         get animation() {
-          return this._animation;
+          return this._animations[0];
+        }
+        get animations() {
+          return this._animations.slice();
+        }
+        get weights() {
+          return this._weights.slice();
         }
         get time() {
           return this._time;
@@ -84862,10 +85133,20 @@ ${key}` : key;
          * without them, the current pose is used. Stopping restores the pose from before playback.
          */
         play(layers, animation, options = {}, poses) {
+          this.playAnimations(layers, [animation], options, poses);
+        }
+        /**
+         * Starts clips on matching parts with a shared clock. Weighted offsets add to the supplied baked poses
+         * or, without poses, to each animated part's pose when playback starts.
+         */
+        playAnimations(layers, animations, options = {}, poses) {
+          const weights = validateAnimationWeights(options.weights ?? animations.map(() => 1), animations.length);
           this.stop();
-          this._animation = animation;
+          this._animations = animations.slice();
+          this._weights = weights;
+          if (!animations.length) return;
           this._time = options.time ?? 0;
-          this.loop = options.loop ?? animation.loop;
+          this.loops = animations.map((animation) => options.loop ?? animation.loop);
           this.speed = options.speed ?? 1;
           for (const layer of layers) {
             const objects = [];
@@ -84874,7 +85155,8 @@ ${key}` : key;
                 if (poses.has(object4)) objects.push(object4);
               });
             } else {
-              for (const bone of Object.keys(animation.bones)) {
+              const bones = new Set(animations.flatMap((animation) => Object.keys(animation.bones)));
+              for (const bone of bones) {
                 const object4 = layer.getObjectByName(`group:${bone}`);
                 if (object4) objects.push(object4);
               }
@@ -84898,7 +85180,7 @@ ${key}` : key;
         }
         /** Restores the poses from before playback. Returns whether an animation was active. */
         stop() {
-          if (!this._animation) return false;
+          if (!this._animations.length) return false;
           for (const part of this.parts) {
             part.object.position.copy(part.position);
             part.object.rotation.copy(part.rotation);
@@ -84910,12 +85192,14 @@ ${key}` : key;
         /** Forgets the animation without touching the parts, for parts that no longer exist. */
         clear() {
           this.parts = [];
-          this._animation = void 0;
+          this._animations = [];
+          this._weights = [];
+          this.loops = [];
           this._time = 0;
         }
         /** Applies the pose at an absolute playback time. Returns `false` when no clip is active. */
         setTime(seconds) {
-          if (!this._animation) return false;
+          if (!this._animations.length) return false;
           this._time = seconds;
           this.apply();
           return true;
@@ -84924,8 +85208,30 @@ ${key}` : key;
         advance(deltaSeconds) {
           return this.setTime(this._time + deltaSeconds * this.speed);
         }
+        /** Changes weights in clip order and reapplies the current time without restarting playback. */
+        setWeights(weights) {
+          if (!this._animations.length) return false;
+          const validated = validateAnimationWeights(weights, this._animations.length);
+          this._weights = validated;
+          this.apply();
+          return true;
+        }
         apply() {
-          const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
+          const pose = /* @__PURE__ */ Object.create(null);
+          for (let i4 = 0; i4 < this._animations.length; i4++) {
+            const weight = this._weights[i4];
+            if (weight === 0) continue;
+            const sampled = sampleEntityAnimation(this._animations[i4], this._time, this.loops[i4]);
+            for (const [bone, channels] of Object.entries(sampled)) {
+              const blended = pose[bone] ?? (pose[bone] = {});
+              for (const channel of ENTITY_ANIMATION_CHANNELS) {
+                const value = channels[channel];
+                if (!value) continue;
+                const target = blended[channel] ?? (blended[channel] = [0, 0, 0]);
+                for (let axis = 0; axis < 3; axis++) target[axis] += value[axis] * weight;
+              }
+            }
+          }
           for (const part of this.parts) {
             const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone] ?? {};
             part.object.position.set(part.basePosition.x + position[0], part.basePosition.y + position[1], part.basePosition.z + position[2]);
@@ -85554,7 +85860,7 @@ ${key}` : key;
           for (const geometry of this.geometries) geometry.dispose();
           this.geometries.clear();
           for (const dispose of this.disposeWireframes.splice(0)) dispose();
-          for (const player of this.animationPlayers.splice(0)) player.clear();
+          for (const { player } of this.animationPlayers.splice(0)) player.clear();
           this.partPoses.clear();
           super.disposeAndRemoveAllChildren();
         }
@@ -85589,15 +85895,31 @@ ${key}` : key;
         //<editor-fold desc="ANIMATION">
         /** The first active clip, until playback is stopped or the object is disposed. */
         get animation() {
-          return this.animationPlayers[0]?.animation;
+          return this.animationPlayers[0]?.player.animation;
         }
-        /** Clips playing together, each targeting a separate geometry layer. */
+        /** Clips playing together, in the order passed to {@link playAnimations}. */
         get activeAnimations() {
-          return this.animationPlayers.map((player) => player.animation);
+          const animations = [];
+          for (const { player, indices } of this.animationPlayers) {
+            player.animations.forEach((animation, i4) => {
+              animations[indices[i4]] = animation;
+            });
+          }
+          return animations;
+        }
+        /** Weights of the active clips, in the same order as {@link activeAnimations}. */
+        get animationWeights() {
+          const weights = [];
+          for (const { player, indices } of this.animationPlayers) {
+            player.weights.forEach((weight, i4) => {
+              weights[indices[i4]] = weight;
+            });
+          }
+          return weights;
         }
         /** Seconds since the animation started, before looping. */
         get animationTime() {
-          return this.animationPlayers[0]?.time ?? 0;
+          return this.animationPlayers[0]?.player.time ?? 0;
         }
         /**
          * Plays a clip from {@link Entities.getAnimations}, replacing all active clips.
@@ -85608,42 +85930,59 @@ ${key}` : key;
         playAnimation(animation, options) {
           this.playAnimations([animation], options);
         }
-        /** Plays clips with a shared clock and no blending. Selected layers without their own clip follow `main`. */
+        /**
+         * Plays clips with a shared clock, adding their weighted offsets within each geometry layer.
+         * Weights default to 1 and are not normalized. Selected layers without their own clip follow `main`.
+         */
         playAnimations(animations, options) {
-          const targets = /* @__PURE__ */ new Set();
-          const selections = animations.map((animation) => {
+          const weights = validateAnimationWeights(options?.weights ?? animations.map(() => 1), animations.length);
+          const selections = /* @__PURE__ */ new Map();
+          animations.forEach((animation, index) => {
             const layer = animation.layer ?? "main";
-            if (targets.has(layer)) throw new Error(`Multiple animations target layer "${layer}"`);
-            targets.add(layer);
             const names = Object.keys(this.entityLayers).filter((name2) => name2.split("#")[0] === layer);
             if (!names.length) throw new Error(`Entity ${this.entity.id} has no selected animation layer "${layer}"`);
-            return { animation, names };
+            let selection = selections.get(layer);
+            if (!selection) selections.set(layer, selection = { animations: [], names, indices: [] });
+            selection.animations.push(animation);
+            selection.indices.push(index);
           });
-          const main = selections.find(({ animation }) => (animation.layer ?? "main") === "main");
-          if (main) main.names.push(...Object.keys(this.entityLayers).filter((name2) => !targets.has(name2.split("#")[0])));
+          const main = selections.get("main");
+          if (main) main.names.push(...Object.keys(this.entityLayers).filter((name2) => !selections.has(name2.split("#")[0])));
           this.createMeshes();
           this.stopAnimation();
-          for (const { animation, names } of selections) {
+          for (const { animations: clips, names, indices } of selections.values()) {
             const player = new EntityAnimationPlayer();
-            player.play(names.map((name2) => this.getLayerGroup(name2)), animation, options, this.partPoses);
-            this.animationPlayers.push(player);
+            player.playAnimations(
+              names.map((name2) => this.getLayerGroup(name2)),
+              clips,
+              { ...options, weights: indices.map((index) => weights[index]) },
+              this.partPoses
+            );
+            this.animationPlayers.push({ player, indices });
           }
           this.notifyDirty();
         }
+        /** Changes weights in active clip order, notifying the scene without restarting the shared clock. Has no effect without an animation. */
+        setAnimationWeights(weights) {
+          if (!this.animationPlayers.length) return;
+          const values = validateAnimationWeights(weights, this.activeAnimations.length);
+          for (const { player, indices } of this.animationPlayers) player.setWeights(indices.map((index) => values[index]));
+          this.notifyDirty();
+        }
         /** Stops all clips and restores the poses from before playback. */
         stopAnimation() {
           const players = this.animationPlayers.splice(0);
-          for (const player of players) player.stop();
+          for (const { player } of players) player.stop();
           if (players.length) this.notifyDirty();
         }
         /** Poses the object at an explicit time in seconds. Has no effect without an animation. */
         setAnimationTime(seconds) {
-          for (const player of this.animationPlayers) player.setTime(seconds);
+          for (const { player } of this.animationPlayers) player.setTime(seconds);
           if (this.animationPlayers.length) this.notifyDirty();
         }
         /** Advances the animation by a frame delta in seconds, scaled by its speed. Has no effect without an animation. */
         advanceAnimation(deltaSeconds) {
-          for (const player of this.animationPlayers) player.advance(deltaSeconds);
+          for (const { player } of this.animationPlayers) player.advance(deltaSeconds);
           if (this.animationPlayers.length) this.notifyDirty();
         }
         //</editor-fold>
@@ -87881,6 +88220,7 @@ ${key}` : key;
     }
     const font = await Fonts.get(options.font);
     const runs = typeof text2 === "string" ? [{ text: text2 }] : text2;
+    await font.resolve?.(runs.map((run) => run.text).join(""));
     const glyphs = [], lineWidths = [];
     let line = [], width = 0;
     let trailingNewline = false;
@@ -87907,7 +88247,7 @@ ${key}` : key;
           continue;
         }
         const glyph = font.glyphs.get(character);
-        const advance = (glyph?.advance ?? 6) + (style.bold ? 1 : 0);
+        const advance = (glyph?.advance ?? 6) + (style.bold ? glyph?.boldOffset ?? 1 : 0);
         line.push({ character, glyph, advance, style, x: 0, y: 0 });
         width += advance;
         while (width > maxWidth && line.length > 1) {
@@ -87935,7 +88275,7 @@ ${key}` : key;
           batches.push(batch);
         }
         const color3 = new Color(isShadow ? (style.color & 16579836) >> 2 : style.color);
-        const offset = isShadow ? 1 : 0;
+        const offset = isShadow ? glyph?.shadowOffset ?? 1 : 0;
         const top = glyph ? 7 - glyph.ascent : 0;
         const height = glyph ? glyph.height * glyph.scale : 8;
         const width = glyph ? glyph.width * glyph.scale : 5;
@@ -87965,7 +88305,7 @@ ${key}` : key;
           for (let i4 = 0; i4 < 4; i4++) batch.colors.push(color3.r, color3.g, color3.b);
           batch.indices.push(base, base + 2, base + 1, base + 2, base + 3, base + 1);
         };
-        for (const boldOffset of style.bold ? [0, 1] : [0]) {
+        for (const boldOffset of style.bold ? [0, glyph?.boldOffset ?? 1] : [0]) {
           if (glyph) quad(0, top, width, top + height, boldOffset);
           else {
             quad(0, 0, 5, 1, boldOffset);
@@ -94105,6 +94445,7 @@ ${shader.fragmentShader}`.replace(
     toRadians: () => toRadians,
     toTrianglesDrawMode: () => toTrianglesDrawMode,
     trimCanvas: () => trimCanvas,
+    validateAnimationWeights: () => validateAnimationWeights,
     yieldToEventLoop: () => yieldToEventLoop
   });
   init_dirname();
@@ -104074,7 +104415,7 @@ gl_FragDepth=readDepth(vUv);
 
   // src/world/SectionGeometry.ts
   function buildSectionGeometry(input) {
-    const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion, biomeTints } = input;
+    const { count, indices, templates, cullMasks, templateData, atlases: atlases2, 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");
@@ -104109,8 +104450,8 @@ gl_FragDepth=readDepth(vUv);
     const locations = /* @__PURE__ */ new Map();
     for (const [layer, layerAtlases] of [...visibleAtlases].sort(([a4], [b4]) => a4 - b4)) {
       const firstPage = pages.length;
-      for (const atlas of [...layerAtlases].sort((a4, b4) => Number(atlases[a4].animated) - Number(atlases[b4].animated) || (atlases[a4].animated ? a4 - b4 : atlases[b4].height - atlases[a4].height))) {
-        const { width, height, animated } = atlases[atlas];
+      for (const atlas of [...layerAtlases].sort((a4, b4) => Number(atlases2[a4].animated) - Number(atlases2[b4].animated) || (atlases2[a4].animated ? a4 - b4 : atlases2[b4].height - atlases2[a4].height))) {
+        const { width, height, animated } = atlases2[atlas];
         if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
         let selected = -1;
         for (let i4 = firstPage; !animated && i4 < pages.length; i4++) {
@@ -104153,7 +104494,7 @@ gl_FragDepth=readDepth(vUv);
         });
         if (!quads.sprites.length) continue;
         if (!fluidPages.has(fluid)) {
-          const { width, height } = atlases[data.atlas];
+          const { width, height } = atlases2[data.atlas];
           if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
           fluidPages.set(fluid, {
             layer: 2,
@@ -104171,7 +104512,7 @@ gl_FragDepth=readDepth(vUv);
         const tint = fluid === "water" && fluids.waterTints ? fluids.waterTints.subarray(tintIndex, tintIndex + 3) : data.tint;
         fluidPages.get(fluid).fluids.push({ quads, x: x4, y: y5, z: z4, data, tint });
       }
-      pages.push(...[...fluidPages.values()].sort((a4, b4) => Number(atlases[a4.placements[0].atlas].animated) - Number(atlases[b4.placements[0].atlas].animated) || a4.placements[0].atlas - b4.placements[0].atlas));
+      pages.push(...[...fluidPages.values()].sort((a4, b4) => Number(atlases2[a4.placements[0].atlas].animated) - Number(atlases2[b4.placements[0].atlas].animated) || a4.placements[0].atlas - b4.placements[0].atlas));
     }
     return pages.map((page) => {
       let faces = page.fluids.reduce((sum, fluid) => sum + fluid.quads.sprites.length, 0);
@@ -104188,7 +104529,7 @@ gl_FragDepth=readDepth(vUv);
       let vertex2 = 0, indexOffset = 0;
       for (const entry of page.entries) {
         const template = templateData[templates[entry]];
-        const atlas = atlases[template.atlas];
+        const atlas = atlases2[template.atlas];
         const placement = locations.get(template.atlas);
         const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
         const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
@@ -104227,7 +104568,7 @@ gl_FragDepth=readDepth(vUv);
         }
       }
       for (const { quads, x: x4, y: y5, z: z4, data, tint } of page.fluids) {
-        const atlas = atlases[data.atlas];
+        const atlas = atlases2[data.atlas];
         const placement = page.placements[0];
         const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
         const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
@@ -104331,7 +104672,7 @@ gl_FragDepth=readDepth(vUv);
   var WATER_TINT = new Color(4159204).toArray();
   function toInput(entries, maxAtlasSize, fluids, lighting) {
     if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
-    const atlases = [];
+    const atlases2 = [];
     const atlasIds = /* @__PURE__ */ new Map();
     const templateIds = /* @__PURE__ */ new Map();
     const input = {
@@ -104354,9 +104695,9 @@ gl_FragDepth=readDepth(vUv);
       if (id === void 0) {
         let atlas = atlasIds.get(template.atlas);
         if (atlas === void 0) {
-          atlas = atlases.length;
+          atlas = atlases2.length;
           atlasIds.set(template.atlas, atlas);
-          atlases.push(template.atlas);
+          atlases2.push(template.atlas);
           input.atlases.push({ width: template.atlas.image.width, height: template.atlas.image.height, animated: template.atlas.hasAnimation });
         }
         let data = templateCache.get(template);
@@ -104415,9 +104756,9 @@ gl_FragDepth=readDepth(vUv);
         if (!atlas) continue;
         let id = atlasIds.get(atlas);
         if (id === void 0) {
-          id = atlases.length;
+          id = atlases2.length;
           atlasIds.set(atlas, id);
-          atlases.push(atlas);
+          atlases2.push(atlas);
           input.atlases.push({ width: atlas.image.width, height: atlas.image.height, animated: atlas.hasAnimation });
         }
         input.fluids[kind] = {
@@ -104428,7 +104769,7 @@ gl_FragDepth=readDepth(vUv);
         };
       }
     }
-    return { input, atlases };
+    return { input, atlases: atlases2 };
   }
   var SectionMesh = class _SectionMesh extends Group {
     constructor() {
@@ -104443,23 +104784,23 @@ gl_FragDepth=readDepth(vUv);
     }
     /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
     static build(entries, maxAtlasSize = 2048, fluids, lighting) {
-      const { input, atlases } = toInput(entries, maxAtlasSize, fluids, lighting);
-      return this.fromPages(buildSectionGeometry(input), atlases);
+      const { input, atlases: atlases2 } = toInput(entries, maxAtlasSize, fluids, lighting);
+      return this.fromPages(buildSectionGeometry(input), atlases2);
     }
     /** Builds section-local meshes in a browser worker when available, with synchronous fallback. */
     static async buildAsync(entries, maxAtlasSize = 2048, fluids, lighting) {
-      const { input, atlases } = toInput(entries, maxAtlasSize, fluids, lighting);
+      const { input, atlases: atlases2 } = toInput(entries, maxAtlasSize, fluids, lighting);
       const worker = SectionWorker.shared();
       const pages = worker ? await worker.build(input).catch(() => buildSectionGeometry(input)) : buildSectionGeometry(input);
-      return this.fromPages(pages, atlases);
+      return this.fromPages(pages, atlases2);
     }
-    static fromPages(pages, atlases) {
+    static fromPages(pages, atlases2) {
       const section = new _SectionMesh();
       for (const page of pages) {
         const canvas = createCanvas(page.width, page.height);
         const context = canvas.getContext("2d");
         for (const { atlas, x: x4, y: y5 } of page.placements) {
-          context.drawImage(atlases[atlas].image.canvas, x4, y5);
+          context.drawImage(atlases2[atlas].image.canvas, x4, y5);
         }
         const geometry = new BufferGeometry();
         geometry.setAttribute("position", new Float32BufferAttribute(page.positions.buffer, 3));
@@ -104470,7 +104811,7 @@ gl_FragDepth=readDepth(vUv);
         geometry.setIndex(new Uint32BufferAttribute(page.indices.buffer, 1));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
-        const transparent = page.layer === 2 ? atlases[page.placements[0].atlas].hasTranslucency : page.layer === 1;
+        const transparent = page.layer === 2 ? atlases2[page.placements[0].atlas].hasTranslucency : page.layer === 1;
         const material = Materials.createShadedCanvasMaterial(canvas, transparent, false, true);
         material.side = FrontSide;
         if (page.layer === 2) {
@@ -104485,7 +104826,7 @@ gl_FragDepth=readDepth(vUv);
         section.blockIndices.set(mesh, page.blockIndices);
         const unsubscribe = [];
         for (const { atlas: id, x: x4, y: y5 } of page.placements) {
-          const atlas = atlases[id];
+          const atlas = atlases2[id];
           if (!atlas.hasAnimation) continue;
           unsubscribe.push(atlas.subscribe(() => {
             context.clearRect(x4, y5, atlas.image.width, atlas.image.height);