minerender 2.1.0-alpha.77 → 2.1.0-alpha.79

package/dist/bundle.js

@@ -43053,6 +43053,8 @@ void main() {
       ModelMerger = class {
         /** Loads the parent chain and returns a merged model without modifying the supplied definition. */
         static async mergeWithParents(model) {
+          const parts = model.parts;
+          if (parts) return { ...model, parts: await Promise.all(parts.map((part) => this.mergeWithParents(part))) };
           const models = await this.collectAllParents(model);
           let merged = {};
           for (const source of [...models, model]) {
@@ -43119,6 +43121,7 @@ void main() {
       init_PersistentCache();
       init_AssetKey();
       init_AssetParsers();
+      init_DisplayPosition();
       Models = class _Models {
         // opened lazily: touching the store at import time would hit IndexedDB/disk just for loading
         // the library, and would require an EnvProvider before any entry has had a chance to register
@@ -43133,34 +43136,174 @@ void main() {
             return (await AssetLoader.getFirst([key, legacyKey], "list" /* LIST */))?.asset;
           }).then((r5) => r5?.files ?? []);
         }
-        static async loadAndMerge(key) {
-          const model = key.type === "item" ? await this.getItemModel(key) : await this.getRaw(key);
+        static async loadAndMerge(key, context = {}) {
+          const model = key.type === "item" ? await this.getItemModel(key, context) : await this.getRaw(key);
           if (!model) {
             return void 0;
           }
           return ModelMerger.mergeWithParents(model);
         }
-        static async getItemModel(key) {
+        static async getItemModel(key, context = {}) {
+          const preview = this.snapshotContext(key, context);
           const itemKey = new AssetKey(key.namespace, key.path, "items", void 0, key.rootType, ".json", key.root);
-          const model = await this.PERSISTENT_CACHE.getOrLoad(`item-v2:${AssetLoader.persistentKey(itemKey.serialize())}`, async () => {
+          const cacheKey = itemKey.serialize() + this.contextKey(preview);
+          const model = await this.PERSISTENT_CACHE.getOrLoad(`item-v3:${AssetLoader.persistentKey(cacheKey)}`, async () => {
             const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
             if (!result) return void 0;
             if (result.key.assetType !== "items") return { ...result.asset, key };
-            const selected = this.defaultItemModel(result.asset.model, key);
-            const modelKey = AssetKey.parse("models", selected.model);
-            modelKey.root = key.root;
-            const model2 = await this.getRaw(modelKey);
-            if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${selected.model}`);
-            return { ...model2, ...selected.special && { special: selected.special }, ...selected.tints && { tints: selected.tints } };
+            const load = async (selected) => {
+              if ("parts" in selected) {
+                return { key, parts: await Promise.all(selected.parts.map(load)) };
+              }
+              if ("item" in selected) {
+                const model3 = await this.getItemModel(selected.item, { displayContext: preview.displayContext });
+                if (!model3) throw new Error(`Item ${key.toNamespacedString()} references missing item ${selected.item.toNamespacedString()}`);
+                return model3;
+              }
+              const modelKey = AssetKey.parse("models", selected.model);
+              modelKey.root = key.root;
+              const model2 = await this.getRaw(modelKey);
+              if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${selected.model}`);
+              return { ...model2, ...selected.special && { special: selected.special }, ...selected.tints && { tints: selected.tints } };
+            };
+            return load(this.selectItemModel(result.asset.model, key, preview));
+          });
+          const restore = (model2) => ({
+            ...model2,
+            key: Object.assign(new AssetKey("", ""), model2.key),
+            ...model2.parts && { parts: model2.parts.map(restore) }
           });
-          return model ? { ...model, key: Object.assign(new AssetKey("", ""), model.key) } : void 0;
+          return model ? restore(model) : void 0;
+        }
+        static contextIdentifier(id) {
+          if (typeof id !== "string" || !/^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(id)) {
+            throw new Error(`Invalid item-preview identifier: ${id}`);
+          }
+          return id.includes(":") ? id : `minecraft:${id}`;
+        }
+        static snapshotContext(key, context) {
+          const displayContext = context.displayContext ?? "gui" /* GUI */;
+          if (displayContext !== "none" && !Object.values(DisplayPosition).includes(displayContext)) {
+            throw new Error(`Unsupported item display context: ${displayContext}`);
+          }
+          for (const map of [context.properties, context.components, context.itemReferences]) {
+            if (map !== void 0 && (!map || typeof map !== "object" || Array.isArray(map))) {
+              throw new Error("Item-preview properties, components, and references must be objects keyed by identifier");
+            }
+          }
+          const count = context.count === void 0 ? 1 : context.count;
+          if (!Number.isSafeInteger(count) || count < 0) throw new Error("Item-preview count must be a nonnegative safe integer");
+          const properties = {};
+          for (const [id, value] of Object.entries(context.properties ?? {})) {
+            const property = this.contextIdentifier(id);
+            if (!["boolean", "string", "number"].includes(typeof value) || typeof value === "number" && !Number.isFinite(value)) {
+              throw new Error(`Item-preview property ${property} must be a boolean, string, or finite number`);
+            }
+            if (Object.prototype.hasOwnProperty.call(properties, property)) throw new Error(`Duplicate item-preview property: ${property}`);
+            properties[property] = value;
+          }
+          const components = {};
+          for (const [id, value] of Object.entries(context.components ?? {})) {
+            const component = this.contextIdentifier(id);
+            if (Object.prototype.hasOwnProperty.call(components, component)) throw new Error(`Duplicate item-preview component: ${component}`);
+            components[component] = this.snapshotJson(value);
+          }
+          const itemReferences = {};
+          for (const [id, value] of Object.entries(context.itemReferences ?? {})) {
+            const reference = this.contextIdentifier(id);
+            if (!isAssetKey(value) || value.assetType !== "models" || value.type !== "item") {
+              throw new Error(`Item-preview reference ${reference} must be an item-model AssetKey`);
+            }
+            this.contextIdentifier(`${value.namespace}:${value.path}`);
+            if (Object.prototype.hasOwnProperty.call(itemReferences, reference)) throw new Error(`Duplicate item-preview reference: ${reference}`);
+            itemReferences[reference] = Object.assign(new AssetKey("", ""), value, { root: value.root ?? key.root });
+          }
+          return { displayContext, properties, components, count, itemReferences };
+        }
+        static contextKey(context) {
+          const itemReferences = Object.fromEntries(Object.entries(context.itemReferences).map(([id, key]) => [id, key.serialize()]));
+          return `|item-v3:${JSON.stringify(this.snapshotJson({ ...context, itemReferences }))}`;
+        }
+        static snapshotJson(value, ancestors = /* @__PURE__ */ new Set()) {
+          if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return value;
+          if (typeof value !== "object" || ancestors.has(value) || !Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+            throw new Error("Item-preview components must contain finite JSON values without circular references");
+          }
+          ancestors.add(value);
+          const copy = Array.isArray(value) ? Array.from(value, (entry) => this.snapshotJson(entry, ancestors)) : Object.fromEntries(Object.keys(value).sort().map((key) => [key, this.snapshotJson(value[key], ancestors)]));
+          ancestors.delete(value);
+          return copy;
+        }
+        static propertyValue(node, context) {
+          const kind = node.type.replace(/^minecraft:/, "");
+          const property = node.property ? this.contextIdentifier(node.property) : void 0;
+          if (kind === "select" && property === "minecraft:display_context") return context.displayContext;
+          if (property && Object.prototype.hasOwnProperty.call(context.properties, property)) return context.properties[property];
+          const fallback = kind === "condition" ? false : kind === "range_dispatch" ? 0 : void 0;
+          const component = (id) => context.components[this.contextIdentifier(id)];
+          if (property === "minecraft:custom_model_data") {
+            const index = node.index ?? 0;
+            if (!Number.isSafeInteger(index) || index < 0) throw new Error("Item-model custom_model_data index must be a nonnegative integer");
+            const data = component("custom_model_data");
+            if (data === void 0) return fallback;
+            if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error("Item-preview custom_model_data must be an object");
+            const field = kind === "condition" ? "flags" : kind === "select" ? "strings" : "floats";
+            const values = data[field];
+            if (values === void 0) return fallback;
+            if (!Array.isArray(values)) throw new Error(`Item-preview custom_model_data.${field} must be an array`);
+            return index < values.length ? values[index] : fallback;
+          }
+          if (kind === "condition" && property === "minecraft:has_component") {
+            if (node.ignore_default) throw new Error("Item-preview has_component with ignore_default requires an explicit properties override; item defaults are unavailable");
+            return Object.prototype.hasOwnProperty.call(context.components, this.contextIdentifier(node.component));
+          }
+          if (kind === "select") {
+            switch (property) {
+              case "minecraft:component":
+                return component(node.component);
+              case "minecraft:block_state": {
+                const state = component("block_state");
+                if (state === void 0) return void 0;
+                if (!state || typeof state !== "object" || Array.isArray(state)) throw new Error("Item-preview block_state must be an object");
+                if (typeof node.block_state_property !== "string") throw new Error("Item-model block_state requires block_state_property");
+                return Object.prototype.hasOwnProperty.call(state, node.block_state_property) ? state[node.block_state_property] : void 0;
+              }
+              case "minecraft:charge_type": {
+                const projectiles = component("charged_projectiles");
+                if (projectiles === void 0) return "none";
+                if (!Array.isArray(projectiles)) throw new Error("Item-preview charged_projectiles must be an array of item stacks");
+                const ids = projectiles.map((stack) => {
+                  if (!stack || typeof stack !== "object" || Array.isArray(stack)) throw new Error("Item-preview charged_projectiles must contain item-stack objects");
+                  return this.contextIdentifier(stack.id);
+                });
+                return !ids.length ? "none" : ids.includes("minecraft:firework_rocket") ? "rocket" : "arrow";
+              }
+            }
+          }
+          if (kind === "range_dispatch" && (property === "minecraft:damage" || property === "minecraft:count")) {
+            const damage = property === "minecraft:damage";
+            const maximumComponent = component(damage ? "max_damage" : "max_stack_size");
+            const maximum = maximumComponent === void 0 ? damage ? 0 : 1 : maximumComponent;
+            const damageComponent = component("damage");
+            const value = damage ? damageComponent === void 0 ? 0 : damageComponent : context.count;
+            if (typeof value !== "number" || typeof maximum !== "number" || maximum < 0) throw new Error(`Item-preview ${property} requires numeric components and a nonnegative maximum`);
+            const clamped = Math.max(0, Math.min(maximum, value));
+            return node.normalize === false ? clamped : clamped / maximum;
+          }
+          return fallback;
         }
-        // Item previews use the GUI context, false conditions, and zero numeric properties.
-        static defaultItemModel(node, key) {
+        static selectItemModel(node, key, context) {
           if (!node || typeof node.type !== "string") {
             throw new Error(`Unsupported item model definition for ${key.toNamespacedString()}`);
           }
           switch (node.type.replace(/^minecraft:/, "")) {
+            case "composite":
+              if (Array.isArray(node.models)) return { parts: node.models.map((child) => this.selectItemModel(child, key, context)) };
+              break;
+            case "bundle/selected_item": {
+              const item = context.itemReferences["minecraft:bundle/selected_item"];
+              return item ? { item } : { parts: [] };
+            }
             case "model":
               if (typeof node.model === "string" && node.model) return { model: node.model, tints: node.tints };
               break;
@@ -43181,17 +43324,29 @@ void main() {
               }
               throw new Error(`Unsupported special item renderer ${special.type} for ${key.toNamespacedString()}`);
             }
-            case "condition":
-              return this.defaultItemModel(node.on_false, key);
+            case "condition": {
+              const value = this.propertyValue(node, context);
+              if (typeof value !== "boolean") throw new Error(`Item-preview condition ${node.property} requires a boolean`);
+              return this.selectItemModel(value ? node.on_true : node.on_false, key, context);
+            }
             case "select": {
-              const selected = node.property?.replace(/^minecraft:/, "") === "display_context" ? node.cases?.find((entry) => Array.isArray(entry.when) ? entry.when.includes("gui") : entry.when === "gui")?.model : void 0;
-              return this.defaultItemModel(selected ?? node.fallback, key);
+              const value = this.propertyValue(node, context);
+              const component = node.property && this.contextIdentifier(node.property) === "minecraft:component";
+              if (!component && value !== void 0 && typeof value !== "string") throw new Error(`Item-preview selector ${node.property} requires a string`);
+              const matches = (candidate) => component ? JSON.stringify(this.snapshotJson(candidate)) === JSON.stringify(this.snapshotJson(value)) : candidate === value;
+              const selected = value === void 0 ? void 0 : node.cases?.find((entry) => matches(entry.when) || Array.isArray(entry.when) && entry.when.some(matches))?.model;
+              return this.selectItemModel(selected ?? node.fallback, key, context);
             }
             case "range_dispatch": {
+              const value = this.propertyValue(node, context);
+              if (typeof value !== "number") throw new Error(`Item-preview range ${node.property} requires a number`);
+              if (Number.isNaN(value)) return this.selectItemModel(node.fallback, key, context);
+              const scaled = value * (node.scale ?? 1);
+              if (!Number.isFinite(scaled)) throw new Error(`Item-preview range ${node.property} requires a finite value and scale`);
               const selected = node.entries?.reduce((match, entry) => {
-                return entry.threshold <= 0 && (!match || entry.threshold >= match.threshold) ? entry : match;
+                return entry.threshold <= scaled && (!match || entry.threshold >= match.threshold) ? entry : match;
               }, void 0);
-              return this.defaultItemModel(selected?.model ?? node.fallback, key);
+              return this.selectItemModel(selected?.model ?? node.fallback, key, context);
             }
           }
           throw new Error(`Unsupported item model ${node?.type ?? "definition"} for ${key.toNamespacedString()}`);
@@ -43218,25 +43373,28 @@ void main() {
         }
         /**
          * Loads a model and resolves its parent chain. Returns `undefined` when the model is missing.
-         * Item keys use GUI context, false conditions, and zero numeric properties.
+         * Item keys default to GUI context and a stack count of 1. Unresolved conditions are false and numeric properties are zero.
+         * Pass `context` to supply component values, property overrides, and item references for a preview.
+         * Composite items retain independently merged children in `ItemModel.parts`.
          *
          * @param key - Model key, for example `AssetKey.parse("models", "minecraft:item/diamond_sword")`.
          */
-        static async getMerged(key) {
+        static async getMerged(key, context = {}) {
           if (!key.assetType) {
             key.assetType = "models";
           }
           if (!key.extension) {
             key.extension = ".json";
           }
-          const keyStr = key.serialize();
+          const preview = this.snapshotContext(key, context);
+          const keyStr = key.serialize() + (key.type === "item" ? this.contextKey(preview) : "");
           return Caching.mergedModelCache.get(keyStr, (k4) => {
-            return _Models.loadAndMerge(key);
+            return _Models.loadAndMerge(key, preview);
           });
         }
         /** Alias for {@link getMerged}. */
-        static async get(key) {
-          return this.getMerged(key);
+        static async get(key, context = {}) {
+          return this.getMerged(key, context);
         }
         /** Clears persisted models. Use {@link Caching.clear} to also discard in-memory assets. */
         static async clearCache() {
@@ -90454,22 +90612,45 @@ ${shader.fragmentShader}`.replace(
           this.originalModel = originalModel;
           this.isModelObject = true;
           this.specialMaterials = /* @__PURE__ */ new Map();
+          this.geometries = /* @__PURE__ */ new Set();
           this.meshesCreated = false;
           this.options = (0, import_ts_deepmerge5.default)({}, _ModelObject.DEFAULT_OPTIONS, options ?? {});
-          if (originalModel.special) this.options.instanceMeshes = false;
+          if (originalModel.special || originalModel.parts) this.options.instanceMeshes = false;
           if (this.options.tints) this.options.tints = { ...this.options.tints };
           this.addEventListener("added", () => this.updateAnimationSubscription());
           this.addEventListener("removed", () => this.updateAnimationSubscription());
         }
         async init() {
+          const parts = this.originalModel.parts;
+          if (parts) {
+            try {
+              for (const part of parts) {
+                const object3 = new _ModelObject(part, { ...this.options, instanceMeshes: false });
+                this.add(object3);
+                await object3.init();
+              }
+              let order = 0;
+              this.iterateAllMeshes((mesh) => {
+                mesh.renderOrder = order++;
+                for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) {
+                  material.transparent = true;
+                }
+              });
+            } catch (error2) {
+              this.disposeAndRemoveAllChildren();
+              throw error2;
+            }
+            this.notifyDirty();
+            return;
+          }
           this.options.tints = await ItemTints.get(this.originalModel, this.options.tints);
           const special = this.originalModel.special;
           if (special) {
-            const parts = await SpecialItems.getParts(special, this.originalModel.key?.root);
+            const parts2 = await SpecialItems.getParts(special, this.originalModel.key?.root);
             const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new Matrix4();
             transform.multiply(new Matrix4().makeTranslation(-8, -8, -8));
             try {
-              for (const part of parts) {
+              for (const part of parts2) {
                 const object3 = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
                 object3.matrix.copy(transform).multiply(part.transform);
                 object3.matrixWorldNeedsUpdate = true;
@@ -90520,6 +90701,7 @@ ${shader.fragmentShader}`.replace(
             if (this.atlas.model.elements) {
               this.atlas.model.elements?.forEach((el) => {
                 const elGeo = this._getBoxGeometryFromElement(el).clone();
+                this.geometries.add(elGeo);
                 if (this.options.cullMask) {
                   const indices = Array.from(elGeo.getIndex().array);
                   elGeo.setIndex(indices.filter((_4, index) => {
@@ -90573,10 +90755,14 @@ ${shader.fragmentShader}`.replace(
             let combinedGeo;
             if (allGeos.length > 0) {
               combinedGeo = mergeBufferGeometries(allGeos);
+              for (const geometry of allGeos) {
+                this.geometries.delete(geometry);
+              }
             } else {
               combinedGeo = new BoxGeometry(16, 16, 16);
               if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
             }
+            this.geometries.add(combinedGeo);
             combinedGeo.computeBoundingBox();
             let mesh;
             if (this.options.instanceMeshes) {
@@ -90601,6 +90787,9 @@ ${shader.fragmentShader}`.replace(
             const mat = Materials.createShadedCanvasMaterial(this.atlas.image.canvas, this.atlas.hasTransparency, false, true);
             this.atlasMaterial = mat;
             this.atlasTexture = mat.uniforms?.map?.value ?? mat.map;
+            if (this.options.displayPosition === "gui" /* GUI */ && this.originalModel.gui_light === "front" /* FRONT */ && mat.uniforms?.SHADE) {
+              mat.uniforms.SHADE.value = false;
+            }
             this.iterateAllMeshes((mesh) => {
               if (mesh.geometry.hasAttribute("color")) mat.vertexColors = true;
               mesh.material = mat;
@@ -90609,7 +90798,9 @@ ${shader.fragmentShader}`.replace(
           }
         }
         updateAnimationSubscription() {
-          const active = !!this.parent && (!this.isInstanced || this.instanceCounter > 0);
+          let root = this;
+          while (root.parent && isModelObject(root.parent)) root = root.parent;
+          const active = !!root.parent && (!this.isInstanced || this.instanceCounter > 0);
           if (active && this.atlas?.hasAnimation && this.atlasTexture) {
             if (!this.unsubscribeAtlas) {
               this.atlasTexture.needsUpdate = true;
@@ -90625,6 +90816,9 @@ ${shader.fragmentShader}`.replace(
             this.unsubscribeAtlas?.();
             this.unsubscribeAtlas = void 0;
           }
+          for (const child of this.children) {
+            if (isModelObject(child)) child.updateAnimationSubscription();
+          }
         }
         nextInstance() {
           const reference = super.nextInstance();
@@ -90644,6 +90838,8 @@ ${shader.fragmentShader}`.replace(
           this.atlasMaterial = void 0;
           for (const material of this.specialMaterials.values()) material.dispose();
           this.specialMaterials.clear();
+          for (const geometry of this.geometries) geometry.dispose();
+          this.geometries.clear();
           super.disposeAndRemoveAllChildren();
         }
       };
@@ -93757,6 +93953,7 @@ ${shader.fragmentShader}`.replace(
     Env: () => Env,
     FluidModelObject: () => FluidModelObject,
     Fonts: () => Fonts,
+    GUI_CONTAINER_LAYOUTS: () => GUI_CONTAINER_LAYOUTS,
     Geometries: () => Geometries,
     GuiHelper: () => GuiHelper,
     GuiLight: () => GuiLight,
@@ -97340,6 +97537,7 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
   init_AssetKey();
+  init_ModelTextures();
 
   // src/gui/GuiText.ts
   init_dirname();
@@ -97452,7 +97650,128 @@ property list uchar int vertex_index
   }
 
   // src/gui/GuiHelper.ts
+  var GUI_CONTAINER_LAYOUTS = {
+    generic_54: {
+      texture: "minecraft:gui/container/generic_54",
+      crop: [0, 0, 176, 222],
+      slotOrigin: [8, 18],
+      slotOffset: [18, 18],
+      rowSize: 9,
+      slotCount: 54
+    },
+    crafting_table: {
+      texture: "minecraft:gui/container/crafting_table",
+      crop: [0, 0, 176, 166],
+      slotOrigin: [30, 17],
+      slotOffset: [18, 18],
+      rowSize: 3,
+      slotCount: 9,
+      resultPosition: [124, 35]
+    }
+  };
   var GuiHelper = class {
+    /**
+     * Creates a 182×5 boss bar using the active resource pack. Finite progress is clamped to 0–1.
+     * The fill crops the source image; explicit crops do not apply `.mcmeta` sprite scaling.
+     */
+    static async bossBar(options = {}) {
+      const { color: color3 = "pink", progress = 1, position = [0, 0] } = options;
+      this.validatePosition(position);
+      if (!["pink", "blue", "red", "green", "yellow", "purple", "white"].includes(color3)) {
+        throw new Error(`Unsupported boss bar color: ${color3}`);
+      }
+      if (!Number.isFinite(progress)) throw new Error("Boss bar progress must be finite");
+      const value = Math.max(0, Math.min(1, progress));
+      const width = value > 0 ? Math.floor(value * 181) + 1 : 0;
+      const texture = `minecraft:gui/sprites/boss_bar/${color3}`;
+      const layers = [{
+        name: "boss-bar-background",
+        texture: `${texture}_background`,
+        position: [...position],
+        size: [182, 5]
+      }];
+      if (width > 0) {
+        layers.push({
+          ...await this.cropTexture(`${texture}_progress`, [0, 0, width, 5], [182, 5], position),
+          name: "boss-bar-progress"
+        });
+      }
+      return layers;
+    }
+    /**
+     * Creates a 192×192 book page with optional arrows and supplied text. Buttons are hidden by default.
+     * Callers choose the page content and button states; this helper does not paginate or handle clicks.
+     */
+    static async book(options = {}) {
+      const {
+        position = [0, 0],
+        previous = "hidden",
+        next = "hidden",
+        text: text2,
+        color: color3 = 0,
+        shadow = false,
+        maxWidth = 114,
+        lineHeight = 9,
+        ...style
+      } = options;
+      this.validatePosition(position);
+      for (const state of [previous, next]) {
+        if (!["hidden", "normal", "hover"].includes(state)) throw new Error(`Unsupported book button state: ${state}`);
+      }
+      const layers = [{
+        ...await this.cropTexture("minecraft:gui/book", [0, 0, 192, 192], [256, 256], position),
+        name: "book-background"
+      }];
+      for (const [name2, direction, state, x4] of [
+        ["previous", "backward", previous, 43],
+        ["next", "forward", next, 116]
+      ]) {
+        if (state === "hidden") continue;
+        layers.push({
+          name: `book-${name2}`,
+          texture: `minecraft:gui/sprites/widget/page_${direction}${state === "hover" ? "_highlighted" : ""}`,
+          position: [position[0] + x4, position[1] + 157],
+          size: [23, 13]
+        });
+      }
+      if (text2 !== void 0) {
+        layers.push({
+          name: "book-text",
+          text: text2,
+          position: [position[0] + 36, position[1] + 30],
+          color: color3,
+          shadow,
+          maxWidth,
+          lineHeight,
+          ...style
+        });
+      }
+      return layers;
+    }
+    /** Creates a container background. Use {@link GUI_CONTAINER_LAYOUTS} with {@link inventorySlot} to place its items. */
+    static async container(type, position = [0, 0]) {
+      this.validatePosition(position);
+      if (type !== "generic_54" && type !== "crafting_table") throw new Error(`Unsupported GUI container: ${type}`);
+      const layout = GUI_CONTAINER_LAYOUTS[type];
+      return [{ ...await this.cropTexture(layout.texture, layout.crop, [256, 256], position), name: "background" }];
+    }
+    static validatePosition(position) {
+      if (!Array.isArray(position) || position.length !== 2 || !position.every(Number.isFinite)) {
+        throw new Error("GUI position must contain two finite coordinates");
+      }
+    }
+    static async cropTexture(texture, crop, referenceSize, position) {
+      const image = await ModelTextures.preload(AssetKey.parse("textures", texture));
+      if (!image) throw new Error(`Could not load GUI texture ${texture}`);
+      const [x4, y5, width, height] = crop;
+      const scaleX = image.width / referenceSize[0], scaleY = image.height / referenceSize[1];
+      return {
+        texture,
+        crop: [x4 * scaleX, y5 * scaleY, width * scaleX, height * scaleY],
+        position: [...position],
+        size: [width, height]
+      };
+    }
     /** Sizes a tooltip around supplied text; the first entry is its title. */
     static async tooltip(lines, options = {}) {
       if (!lines.length) return [];
@@ -97487,8 +97806,9 @@ property list uchar int vertex_index
     }
     /** Creates crafting-table layers for ingredients and the result; stack counts are not drawn. */
     static recipe(recipe, options = {}) {
+      const layout = GUI_CONTAINER_LAYOUTS.crafting_table;
       const layers = [
-        { name: "background", texture: "minecraft:gui/container/crafting_table", crop: [0, 0, 176, 166] }
+        { name: "background", texture: layout.texture, crop: [...layout.crop] }
       ];
       const itemKey = (ingredient) => {
         const item = typeof ingredient === "string" && !ingredient.startsWith("#") ? ingredient : typeof ingredient === "object" && "item" in ingredient ? ingredient.item : options.resolveIngredient?.(ingredient);
@@ -97503,7 +97823,7 @@ property list uchar int vertex_index
         layers.push({
           name: `ingredient-${slot}`,
           item: itemKey(ingredient),
-          position: this.inventorySlot(slot, [30, 17], [18, 18], 3)
+          position: this.inventorySlot(slot, layout.slotOrigin, layout.slotOffset, layout.rowSize)
         });
       };
       switch (recipe.type) {
@@ -97538,7 +97858,7 @@ property list uchar int vertex_index
       layers.push({
         name: "result",
         item: itemKey("id" in recipe.result ? recipe.result.id : recipe.result.item),
-        position: [124, 35]
+        position: [...layout.resultPosition]
       });
       return layers;
     }
@@ -97649,7 +97969,6 @@ property list uchar int vertex_index
   init_Materials();
   init_ModelObject();
   init_DisplayPosition();
-  init_GuiLight();
   var GuiObject = class extends SceneObject {
     constructor(textureLayers, options) {
       super({ ...options, instanceMeshes: false, mergeMeshes: false });
@@ -97717,12 +98036,16 @@ property list uchar int vertex_index
               mesh2.geometry.computeBoundingBox();
               bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new Matrix4().multiplyMatrices(inverse, mesh2.matrixWorld)));
             });
-            item.position.z = depth - bounds.min.z;
-            depth += bounds.max.z - bounds.min.z + 0.01;
+            item.position.z = depth;
+            if (!bounds.isEmpty()) {
+              item.position.z -= bounds.min.z;
+              depth += bounds.max.z - bounds.min.z;
+              this.bounds.expandByPoint(new Vector2(bounds.min.x, -bounds.max.y));
+              this.bounds.expandByPoint(new Vector2(bounds.max.x, -bounds.min.y));
+            }
+            depth += 0.01;
             this.bounds.expandByPoint(new Vector2(x4, y5));
             this.bounds.expandByPoint(new Vector2(x4 + width2, y5 + height2));
-            this.bounds.expandByPoint(new Vector2(bounds.min.x, -bounds.max.y));
-            this.bounds.expandByPoint(new Vector2(bounds.max.x, -bounds.min.y));
             continue;
           }
           const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
@@ -97762,15 +98085,13 @@ property list uchar int vertex_index
       item.name = `group:${layer.name ?? index}`;
       this.add(item);
       await item.init();
-      item.iterateAllMeshes((mesh) => {
-        if (!model.special) this.geometries.add(mesh.geometry);
+      const meshes = [];
+      item.iterateAllMeshes((mesh) => meshes.push(mesh));
+      meshes.forEach((mesh, partIndex) => {
         mesh.name = `mesh:${layer.name ?? index}`;
-        mesh.renderOrder = index;
+        mesh.renderOrder = index + partIndex / (meshes.length + 1) * 0.5;
         for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) {
           material.transparent = true;
-          if (model.gui_light === "front" /* FRONT */ && material.uniforms?.SHADE) {
-            material.uniforms.SHADE.value = false;
-          }
         }
       });
       return item;