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

package/dist/node/index.js

@@ -310,6 +310,9 @@ var init_Caching = __esm({
       static {
         this.blockEntityIndexCache = _Caching.createAssetCache();
       }
+      static {
+        this.unihexCache = _Caching.createAssetCache();
+      }
       static {
         this.fontCache = _Caching.createAssetCache();
       }
@@ -352,6 +355,7 @@ var init_Caching = __esm({
           this.entityAnimationCache,
           this.blockEntityIndexCache,
           this.fontCache,
+          this.unihexCache,
           this.bannerPatternCache,
           this.mineRenderDataCache,
           this.usernameUuidCache,
@@ -1409,6 +1413,7 @@ var init_AssetParsers = __esm({
       AssetParser2["IMAGE"] = "image";
       AssetParser2["LIST"] = "list";
       AssetParser2["JSON"] = "json";
+      AssetParser2["BINARY"] = "binary";
       return AssetParser2;
     })(AssetParser || {});
   }
@@ -2881,7 +2886,7 @@ var init_parser = __esm({
 });
 
 // src/assets/source/HostedAssetSource.ts
-var p3, DEFAULT_OPTIONS, HostedAssetSource;
+var BINARY_TIMEOUT, p3, DEFAULT_OPTIONS, HostedAssetSource;
 var init_HostedAssetSource = __esm({
   "src/assets/source/HostedAssetSource.ts"() {
     init_AssetSource();
@@ -2894,6 +2899,7 @@ var init_HostedAssetSource = __esm({
     init_AssetLoader();
     init_parser();
     init_merge();
+    BINARY_TIMEOUT = 6e4;
     p3 = prefix("HostedAssetSource");
     DEFAULT_OPTIONS = {
       retryDefaults: true
@@ -2964,6 +2970,17 @@ var init_HostedAssetSource = __esm({
           }
         };
       }
+      static {
+        this.BINARY = {
+          config(request) {
+            request.timeout = BINARY_TIMEOUT;
+            request.responseType = "arraybuffer";
+          },
+          parse(response) {
+            return { data: new Uint8Array(response.data) };
+          }
+        };
+      }
       static {
         this.PARSER_MAP = /* @__PURE__ */ new Map([
           ["model" /* MODEL */, _HostedAssetSource.MODEL],
@@ -2972,7 +2989,8 @@ var init_HostedAssetSource = __esm({
           ["nbt" /* NBT */, _HostedAssetSource.NBT],
           ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
           ["list" /* LIST */, _HostedAssetSource.LIST],
-          ["json" /* JSON */, _HostedAssetSource.JSON]
+          ["json" /* JSON */, _HostedAssetSource.JSON],
+          ["binary" /* BINARY */, _HostedAssetSource.BINARY]
         ]);
       }
       /** Retries missing assets with the `minecraft` namespace and default root. Other failures reject. */
@@ -4858,6 +4876,178 @@ var init_Entities = __esm({
   }
 });
 
+// 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 y = 0; y < GLYPH_HEIGHT; y++) {
+      rows[y] = parseInt(match[2].slice(y * rowLength, (y + 1) * rowLength), 16);
+      mask |= rows[y];
+    }
+    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 import_zip2.ZipReader(new import_zip2.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 import_zip2.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 (error) {
+    console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error);
+    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 (error) {
+    console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error);
+    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 ??= 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 import_zip2, ATLAS_SIZE, GLYPH_HEIGHT, UnihexAtlas, atlases;
+var init_Unihex = __esm({
+  "src/assets/_fonts/Unihex.ts"() {
+    import_zip2 = require("@zip.js/zip.js");
+    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 = createCanvas2(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 y = 0; y < GLYPH_HEIGHT; y++) {
+          for (let x = 0; x < width; x++) {
+            const column = glyph.left + x;
+            if (column < 0 || column >= glyph.bitWidth || !(glyph.rows[y] >>> glyph.bitWidth - column - 1 & 1)) continue;
+            pixels.data.fill(255, (y * width + x) * 4, (y * width + x + 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({
@@ -4868,7 +5058,7 @@ var init_Fonts = __esm({
     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, []));
@@ -4884,6 +5074,7 @@ var init_Fonts = __esm({
         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;
@@ -4902,17 +5093,43 @@ var init_Fonts = __esm({
                 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, 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);
+              }
+            }
           }
-        }
-        return { glyphs };
+        } };
       }
       static async bitmap(provider, fontKey) {
         const rows = provider.chars.map((row) => [...row]);
@@ -5005,6 +5222,13 @@ var init_EntityAnimation = __esm({
 });
 
 // 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 import_three11, ZERO, EntityAnimationPlayer;
 var init_EntityAnimationPlayer = __esm({
   "src/entity/scene/EntityAnimationPlayer.ts"() {
@@ -5014,12 +5238,20 @@ var init_EntityAnimationPlayer = __esm({
     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;
@@ -5029,10 +5261,20 @@ var init_EntityAnimationPlayer = __esm({
        * 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 = [];
@@ -5041,7 +5283,8 @@ var init_EntityAnimationPlayer = __esm({
               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);
             }
@@ -5065,7 +5308,7 @@ var init_EntityAnimationPlayer = __esm({
       }
       /** 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);
@@ -5077,12 +5320,14 @@ var init_EntityAnimationPlayer = __esm({
       /** 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;
@@ -5091,8 +5336,30 @@ var init_EntityAnimationPlayer = __esm({
       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 i = 0; i < this._animations.length; i++) {
+          const weight = this._weights[i];
+          if (weight === 0) continue;
+          const sampled = sampleEntityAnimation(this._animations[i], this._time, this.loops[i]);
+          for (const [bone, channels] of Object.entries(sampled)) {
+            const blended = pose[bone] ??= {};
+            for (const channel of ENTITY_ANIMATION_CHANNELS) {
+              const value = channels[channel];
+              if (!value) continue;
+              const target = 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]);
@@ -5716,7 +5983,7 @@ var init_EntityObject = __esm({
         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();
       }
@@ -5751,15 +6018,31 @@ var init_EntityObject = __esm({
       //<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, i) => {
+            animations[indices[i]] = 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, i) => {
+            weights[indices[i]] = 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.
@@ -5770,42 +6053,59 @@ var init_EntityObject = __esm({
       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((name) => name.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((name) => !targets.has(name.split("#")[0])));
+        const main = selections.get("main");
+        if (main) main.names.push(...Object.keys(this.entityLayers).filter((name) => !selections.has(name.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((name) => this.getLayerGroup(name)), animation, options, this.partPoses);
-          this.animationPlayers.push(player);
+          player.playAnimations(
+            names.map((name) => this.getLayerGroup(name)),
+            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>
@@ -8038,6 +8338,7 @@ async function layoutGuiText(text2, options = {}) {
   }
   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;
@@ -8064,7 +8365,7 @@ async function layoutGuiText(text2, options = {}) {
         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) {
@@ -8092,7 +8393,7 @@ function createGuiTextGeometry(layout, shadow = true) {
         batches.push(batch);
       }
       const color2 = new import_three20.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;
@@ -8122,7 +8423,7 @@ function createGuiTextGeometry(layout, shadow = true) {
         for (let i = 0; i < 4; i++) batch.colors.push(color2.r, color2.g, color2.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);
@@ -11399,6 +11700,7 @@ __export(index_node_exports, {
   toRadians: () => toRadians,
   toTrianglesDrawMode: () => toTrianglesDrawMode,
   trimCanvas: () => trimCanvas,
+  validateAnimationWeights: () => validateAnimationWeights,
   yieldToEventLoop: () => yieldToEventLoop
 });
 module.exports = __toCommonJS(index_node_exports);
@@ -18937,7 +19239,7 @@ 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, 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");
@@ -18972,8 +19274,8 @@ function buildSectionGeometry(input) {
   const locations = /* @__PURE__ */ new Map();
   for (const [layer, layerAtlases] of [...visibleAtlases].sort(([a], [b]) => a - b)) {
     const firstPage = pages.length;
-    for (const atlas of [...layerAtlases].sort((a, b) => Number(atlases[a].animated) - Number(atlases[b].animated) || (atlases[a].animated ? a - b : atlases[b].height - atlases[a].height))) {
-      const { width, height, animated } = atlases[atlas];
+    for (const atlas of [...layerAtlases].sort((a, b) => Number(atlases2[a].animated) - Number(atlases2[b].animated) || (atlases2[a].animated ? a - b : atlases2[b].height - atlases2[a].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 i = firstPage; !animated && i < pages.length; i++) {
@@ -19016,7 +19318,7 @@ function buildSectionGeometry(input) {
       });
       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,
@@ -19034,7 +19336,7 @@ function buildSectionGeometry(input) {
       const tint = fluid === "water" && fluids.waterTints ? fluids.waterTints.subarray(tintIndex, tintIndex + 3) : data.tint;
       fluidPages.get(fluid).fluids.push({ quads, x, y, z, data, tint });
     }
-    pages.push(...[...fluidPages.values()].sort((a, b) => Number(atlases[a.placements[0].atlas].animated) - Number(atlases[b.placements[0].atlas].animated) || a.placements[0].atlas - b.placements[0].atlas));
+    pages.push(...[...fluidPages.values()].sort((a, b) => Number(atlases2[a.placements[0].atlas].animated) - Number(atlases2[b.placements[0].atlas].animated) || a.placements[0].atlas - b.placements[0].atlas));
   }
   return pages.map((page) => {
     let faces = page.fluids.reduce((sum, fluid) => sum + fluid.quads.sprites.length, 0);
@@ -19051,7 +19353,7 @@ function buildSectionGeometry(input) {
     let vertex = 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 = (u) => (placement.x + u * atlas.width) / page.width;
       const mapV = (v) => 1 - (placement.y + (1 - v) * atlas.height) / page.height;
@@ -19090,7 +19392,7 @@ function buildSectionGeometry(input) {
       }
     }
     for (const { quads, x, y, z, data, tint } of page.fluids) {
-      const atlas = atlases[data.atlas];
+      const atlas = atlases2[data.atlas];
       const placement = page.placements[0];
       const mapU = (u) => (placement.x + u * atlas.width) / page.width;
       const mapV = (v) => 1 - (placement.y + (1 - v) * atlas.height) / page.height;
@@ -19192,7 +19494,7 @@ var templateCache = /* @__PURE__ */ new WeakMap();
 var WATER_TINT = new import_three46.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 = {
@@ -19215,9 +19517,9 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
     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);
@@ -19276,9 +19578,9 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
       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] = {
@@ -19289,7 +19591,7 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
       };
     }
   }
-  return { input, atlases };
+  return { input, atlases: atlases2 };
 }
 var SectionMesh = class _SectionMesh extends import_three46.Group {
   constructor() {
@@ -19304,23 +19606,23 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
   }
   /** 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 = createCanvas2(page.width, page.height);
       const context = canvas.getContext("2d");
       for (const { atlas, x, y } of page.placements) {
-        context.drawImage(atlases[atlas].image.canvas, x, y);
+        context.drawImage(atlases2[atlas].image.canvas, x, y);
       }
       const geometry = new import_three46.BufferGeometry();
       geometry.setAttribute("position", new import_three46.Float32BufferAttribute(page.positions.buffer, 3));
@@ -19331,7 +19633,7 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
       geometry.setIndex(new import_three46.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 = import_three46.FrontSide;
       if (page.layer === 2) {
@@ -19346,7 +19648,7 @@ var SectionMesh = class _SectionMesh extends import_three46.Group {
       section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
       for (const { atlas: id, x, y } of page.placements) {
-        const atlas = atlases[id];
+        const atlas = atlases2[id];
         if (!atlas.hasAnimation) continue;
         unsubscribe.push(atlas.subscribe(() => {
           context.clearRect(x, y, atlas.image.width, atlas.image.height);
@@ -20690,6 +20992,7 @@ var NodeRenderer = class _NodeRenderer extends Renderer {
   toRadians,
   toTrianglesDrawMode,
   trimCanvas,
+  validateAnimationWeights,
   yieldToEventLoop
 });
 //# sourceMappingURL=index.js.map