@nodecraft/rendermite 1.2.1 → 1.3.1

package/README.md

@@ -91,6 +91,14 @@ Everything the CLI does is exported, from the high-level `run()` and `exportBloc
 import { run, exportBlockPack, prepareModResources, builtinPackPath } from '@nodecraft/rendermite';
 ```
 
+Reading a published block pack needs none of that toolchain, so it has its own entry — no `sharp`,
+no `node:` builtin, 13 KB bundled:
+
+```ts
+import { evaluateBlockState } from '@nodecraft/rendermite/pack';
+import type { BlockPackModel } from '@nodecraft/rendermite/pack';
+```
+
 ## Performance
 
 Benchmarked against PHP renderchest v5.1.0 on the same machine, rendering the same extracted 1.21.8 assets at 64px (PNG + WebP):

package/dist/blocks/blockstate-eval.d.ts

@@ -1,2 +1,2 @@
-import { a as BlockStateMultipartCase, c as ParseBlockStateOptions, d as matchesCondition, f as parseBlockState, i as BlockStateError, l as collectModels, n as BlockProperties, o as BlockStateVariantCase, p as weightedVariantIndex, r as BlockStateDefinition, s as MultipartCondition, t as BlockModelVariant, u as evaluateBlockState } from "../blockstate-eval-CObtPWzJ.js";
+import { a as BlockStateMultipartCase, c as ParseBlockStateOptions, d as matchesCondition, f as parseBlockState, i as BlockStateError, l as collectModels, n as BlockProperties, o as BlockStateVariantCase, p as weightedVariantIndex, r as BlockStateDefinition, s as MultipartCondition, t as BlockModelVariant, u as evaluateBlockState } from "../blockstate-eval-BzznRcVY.js";
 export { BlockModelVariant, BlockProperties, BlockStateDefinition, BlockStateError, BlockStateMultipartCase, BlockStateVariantCase, MultipartCondition, ParseBlockStateOptions, collectModels, evaluateBlockState, matchesCondition, parseBlockState, weightedVariantIndex };

package/dist/blocks/cli.js

@@ -1,2 +1,2 @@
-import { t as runBlocksCli } from "../cli-CWUKXFbx.js";
+import { t as runBlocksCli } from "../cli-BaoVzDGo.js";
 export { runBlocksCli };

package/dist/blocks/export.js

@@ -1,2 +1,2 @@
-import { t as exportBlockPack } from "../export-DY5sGwt0.js";
+import { t as exportBlockPack } from "../export-BNvYiw6i.js";
 export { exportBlockPack };

package/dist/blocks/pack-format.d.ts

@@ -0,0 +1,2 @@
+import { a as BlockPackElement, c as BlockPackModel, d as BlockPackSprite, f as BlockPackSpriteFrame, i as BlockPackBlockStatesFile, l as BlockPackModelsFile, m as BlockPackVariant, n as BlockPackAtlasPage, o as BlockPackFace, p as BlockPackTintsFile, r as BlockPackBlockState, s as BlockPackMetaFile, t as BlockPackAtlasFile, u as BlockPackRenderLayer } from "../pack-format-CfCP4kzy.js";
+export { BlockPackAtlasFile, BlockPackAtlasPage, BlockPackBlockState, BlockPackBlockStatesFile, BlockPackElement, BlockPackFace, BlockPackMetaFile, BlockPackModel, BlockPackModelsFile, BlockPackRenderLayer, BlockPackSprite, BlockPackSpriteFrame, BlockPackTintsFile, BlockPackVariant };

package/dist/blocks/pack-format.js

@@ -0,0 +1 @@
+export {};

package/dist/{blockstate-eval-CObtPWzJ.d.ts → blockstate-eval-BzznRcVY.d.ts}

@@ -32,11 +32,19 @@ interface BlockModelVariant {
   /** Relative weight within its list; the game picks one per block position. */
   weight: number;
 }
-/** One entry of a `variants` map, with its `a=b,c=d` key already parsed. */
-interface BlockStateVariantCase {
+/**
+ * One entry of a `variants` map, with its `a=b,c=d` key already parsed.
+ *
+ * Generic over the variant because the evaluation reads only `model`: a pack
+ * consumer holds variants whose rotations are optional (the emit omits them at
+ * their defaults) and can evaluate those directly, getting its own shape back.
+ */
+interface BlockStateVariantCase<Variant extends {
+  model: string;
+} = BlockModelVariant> {
   /** Properties this case constrains; unstated ones are wildcards. */
   when: Record<string, string>;
-  apply: BlockModelVariant[];
+  apply: Variant[];
 }
 /**
  * A `multipart` predicate. `match` holds one or more accepted values per
@@ -52,17 +60,21 @@ type MultipartCondition = {
   op: 'or';
   terms: MultipartCondition[];
 };
-interface BlockStateMultipartCase {
+interface BlockStateMultipartCase<Variant extends {
+  model: string;
+} = BlockModelVariant> {
   /** null for an unconditional part, which always applies. */
   when: MultipartCondition | null;
-  apply: BlockModelVariant[];
+  apply: Variant[];
 }
-type BlockStateDefinition = {
+type BlockStateDefinition<Variant extends {
+  model: string;
+} = BlockModelVariant> = {
   kind: 'variants';
-  cases: BlockStateVariantCase[];
+  cases: Array<BlockStateVariantCase<Variant>>;
 } | {
   kind: 'multipart';
-  cases: BlockStateMultipartCase[];
+  cases: Array<BlockStateMultipartCase<Variant>>;
 };
 declare class BlockStateError extends Error {}
 interface ParseBlockStateOptions {
@@ -104,7 +116,9 @@ declare function matchesCondition(condition: MultipartCondition, properties: Blo
  * Still empty when even that finds nothing, which is a real answer: a blockstate
  * that covers only some of a block's states draws nothing for the rest.
  */
-declare function evaluateBlockState(definition: BlockStateDefinition, properties: BlockProperties): BlockModelVariant[][];
+declare function evaluateBlockState<Variant extends {
+  model: string;
+}>(definition: BlockStateDefinition<Variant>, properties: BlockProperties): Variant[][];
 /** Every model a blockstate can name, for deciding what to export. */
 declare function collectModels(definition: BlockStateDefinition): string[];
 /**

package/dist/{cli-CWUKXFbx.js → cli-BaoVzDGo.js}

@@ -1,6 +1,6 @@
 import { n as builtinPackPath } from "./builtin-WkWjATeh.js";
 import { n as LayeredResourceManager, t as FolderResourceManager } from "./manager-CYbAkWuT.js";
-import { t as exportBlockPack } from "./export-DY5sGwt0.js";
+import { t as exportBlockPack } from "./export-BNvYiw6i.js";
 import { n as prepareModResources } from "./prepare-B8oPdGYz.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";
 import { a as prepareVersionResources, r as compareVersions } from "./prepare-C95vjt_o.js";

package/dist/cli.js

@@ -6,7 +6,7 @@ import { n as harvestTintOverrides, t as curatedTintOverrides } from "./tints-nx
 import { t as JarResourceManager } from "./jar-5aLDI0nT.js";
 import { t as downloadClientJar } from "./download-1wAfrGKx.js";
 import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS } from "./prepare-C95vjt_o.js";
-import { t as runBlocksCli } from "./cli-CWUKXFbx.js";
+import { t as runBlocksCli } from "./cli-BaoVzDGo.js";
 import { t as run } from "./run-Diql5y56.js";
 import path from "node:path";
 import os from "node:os";

package/dist/{export-DY5sGwt0.js → export-BNvYiw6i.js}

@@ -191,26 +191,35 @@ function translateElements(elements, offset) {
 	});
 }
 function serializeBlockState(definition, exported) {
-	const cases = [];
-	for (const entry of definition.cases) {
-		const apply = entry.apply.filter((variant) => exported(variant.model));
-		if (apply.length === 0) continue;
-		cases.push({
-			when: entry.when,
-			apply: apply.map((variant) => {
-				return {
-					model: variant.model,
-					...variant.x !== 0 && { x: variant.x },
-					...variant.y !== 0 && { y: variant.y },
-					...variant.z !== 0 && { z: variant.z },
-					...variant.uvlock && { uvlock: true },
-					...variant.weight !== 1 && { weight: variant.weight }
-				};
-			})
+	/** Every default dropped, since most variants state none of these. */
+	const serializeApply = (apply) => apply.filter((variant) => exported(variant.model)).map((variant) => {
+		return {
+			model: variant.model,
+			...variant.x !== 0 && { x: variant.x },
+			...variant.y !== 0 && { y: variant.y },
+			...variant.z !== 0 && { z: variant.z },
+			...variant.uvlock && { uvlock: true },
+			...variant.weight !== 1 && { weight: variant.weight }
+		};
+	});
+	if (definition.kind === "variants") {
+		const cases = definition.cases.flatMap((entry) => {
+			const apply = serializeApply(entry.apply);
+			return apply.length === 0 ? [] : [{
+				when: entry.when,
+				apply
+			}];
 		});
+		return cases.length === 0 ? null : { variants: cases };
 	}
-	if (cases.length === 0) return null;
-	return definition.kind === "variants" ? { variants: cases } : { multipart: cases };
+	const cases = definition.cases.flatMap((entry) => {
+		const apply = serializeApply(entry.apply);
+		return apply.length === 0 ? [] : [{
+			when: entry.when,
+			apply
+		}];
+	});
+	return cases.length === 0 ? null : { multipart: cases };
 }
 /**
 * Any texture the model binds, for a model that declares no `particle`. Ordered

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { a as TextureMeta, i as TextureLoader, o as TextureResolutionError, r as
 import { d as parseAtlasSources, n as AtlasSource, r as AtlasSourceError, s as ResolvedSprite, t as AtlasResolver, u as createAtlasResolver } from "./sources-B9X9w3qP.js";
 import { a as PackedRect, i as PackedPage, n as PackOptions, o as packAtlas, r as PackedAtlas, t as PackEntry } from "./atlas-pack-DRTrWcSU.js";
 import { a as resolveTexture, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "./loader-C_1_amsq.js";
-import { a as BlockStateMultipartCase, d as matchesCondition, f as parseBlockState, i as BlockStateError, l as collectModels, n as BlockProperties, o as BlockStateVariantCase, p as weightedVariantIndex, r as BlockStateDefinition, s as MultipartCondition, t as BlockModelVariant, u as evaluateBlockState } from "./blockstate-eval-CObtPWzJ.js";
+import { a as BlockStateMultipartCase, d as matchesCondition, f as parseBlockState, i as BlockStateError, l as collectModels, n as BlockProperties, o as BlockStateVariantCase, p as weightedVariantIndex, r as BlockStateDefinition, s as MultipartCondition, t as BlockModelVariant, u as evaluateBlockState } from "./blockstate-eval-BzznRcVY.js";
 import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-BIpqNU3H.js";
 import { i as buildObjMesh, n as ObjMesh, r as ObjMeshError, t as MeshGroup } from "./obj-mesh-C6Sp4Ysc.js";
 import { i as buildBlockTints, n as BlockTintPack, t as BlockTint } from "./tints-2k3ZhkY3.js";

package/dist/index.js

@@ -10,7 +10,7 @@ import { t as buildBlockTints } from "./tints-a9FWZLma.js";
 import { o as createAtlasResolver, s as parseAtlasSources, t as AtlasSourceError } from "./sources-BlUriDCs.js";
 import { n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "./manager-CYbAkWuT.js";
 import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "./loader-C18GpurU.js";
-import { t as exportBlockPack } from "./export-DY5sGwt0.js";
+import { t as exportBlockPack } from "./export-BNvYiw6i.js";
 import { a as defaultProperties, i as UNKNOWN_MODEL, n as InvalidItemDefinitionError, o as evaluateItemModel } from "./definition-ColsvWrH.js";
 import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "./jar-5aLDI0nT.js";
 import { n as prepareModResources } from "./prepare-B8oPdGYz.js";

package/dist/pack-format-CfCP4kzy.d.ts

@@ -0,0 +1,131 @@
+import { a as FaceDirectionName, l as Vec3, o as ModelElementJson, u as Vec4 } from "./types-qlp3I8_-.js";
+import { a as BlockStateMultipartCase, o as BlockStateVariantCase } from "./blockstate-eval-BzznRcVY.js";
+import { t as MeshGroup } from "./obj-mesh-C6Sp4Ysc.js";
+import { n as BlockTintPack } from "./tints-2k3ZhkY3.js";
+//#region src/blocks/pack-format.d.ts
+/** How a sprite's alpha classifies it, inferred because assets rarely say. */
+type BlockPackRenderLayer = 'solid' | 'cutout' | 'translucent';
+interface BlockPackFace {
+  sprite: string;
+  /** [u1, v1, u2, v2] in 0–16 sprite space, derived when the model omits it. */
+  uv: Vec4;
+  rotation?: number;
+  tintindex?: number;
+  cullface?: FaceDirectionName;
+}
+interface BlockPackElement {
+  from: Vec3;
+  to: Vec3;
+  rotation?: ModelElementJson['rotation'];
+  shade?: false;
+  faces: Partial<Record<FaceDirectionName, BlockPackFace>>;
+}
+interface BlockPackModel {
+  ao: boolean;
+  elements: BlockPackElement[];
+  /**
+   * The model's `particle` texture. What the game throws when the block breaks
+   * or is walked on, and the only colour a consumer has to work with for a
+   * block that draws nothing — a placeholder cube for a chest comes out oak
+   * rather than magenta.
+   */
+  particle?: string;
+  /** Triangle geometry from an OBJ loader, when the model uses one. */
+  mesh?: MeshGroup[];
+  /**
+   * The layer the model states it draws on. Authoritative where present, and
+   * it beats the per-sprite alpha inference — the same sprite can be solid in
+   * one model and translucent in another.
+   */
+  renderType?: BlockPackRenderLayer;
+  /** Block offsets a split-multiblock mesh spans. */
+  multiblock?: Array<[number, number, number]>;
+  /**
+   * Present when the block is a fluid, whose real surface height and flow
+   * direction come from its neighbours and so cannot be baked. The cube here is
+   * a stand-in; these are the sheets to mesh the real thing with.
+   */
+  fluid?: {
+    still: string;
+    flow: string;
+    overlay?: string;
+  };
+}
+interface BlockPackSpriteFrame {
+  page: number;
+  x: number;
+  y: number;
+  /** Duration in game ticks. */
+  time: number;
+}
+interface BlockPackSprite {
+  page: number;
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  layer: BlockPackRenderLayer;
+  /** The displayed sequence, which can revisit a frame; absent when static. */
+  frames?: BlockPackSpriteFrame[];
+  interpolate?: true;
+}
+interface BlockPackAtlasPage {
+  file: string;
+  width: number;
+  height: number;
+}
+/** `atlas.json`. */
+interface BlockPackAtlasFile {
+  /** Edge-extended border per sprite, in pixels. */
+  padding: number;
+  pages: BlockPackAtlasPage[];
+  sprites: Record<string, BlockPackSprite>;
+}
+/** `models.json`, by fully-qualified model id. */
+type BlockPackModelsFile = Record<string, BlockPackModel>;
+/** `blockstates.json`, by block id, with keys and predicates already parsed. */
+type BlockPackBlockStatesFile = Record<string, BlockPackBlockState>;
+/**
+ * A variant as the pack writes it. Every rotation is optional because the emit
+ * drops each one at its default, which is most of them.
+ */
+interface BlockPackVariant {
+  model: string;
+  x?: number;
+  y?: number;
+  z?: number;
+  uvlock?: true;
+  weight?: number;
+}
+/**
+ * One block's cases as the pack writes them: what `evaluateBlockState` takes,
+ * flattened to the key the file uses. Pass it as
+ * `{ kind: 'variants', cases: state.variants }` and the models come back as
+ * `BlockPackVariant`, no cast in either direction.
+ */
+type BlockPackBlockState = {
+  variants: Array<BlockStateVariantCase<BlockPackVariant>>;
+  multipart?: undefined;
+} | {
+  multipart: Array<BlockStateMultipartCase<BlockPackVariant>>;
+  variants?: undefined;
+};
+/** `tints.json`. */
+type BlockPackTintsFile = BlockTintPack;
+/** `meta.json`, written last because it hashes every other file. */
+interface BlockPackMetaFile {
+  generator: string;
+  version: string;
+  namespaces: string[];
+  counts: {
+    blocks: number;
+    models: number;
+    sprites: number;
+    pages: number;
+    failures: number;
+  };
+  /** sha256 per file, enough to verify a cached copy without refetching it. */
+  hashes: Record<string, string>;
+}
+//#endregion
+export { BlockPackElement as a, BlockPackModel as c, BlockPackSprite as d, BlockPackSpriteFrame as f, BlockPackBlockStatesFile as i, BlockPackModelsFile as l, BlockPackVariant as m, BlockPackAtlasPage as n, BlockPackFace as o, BlockPackTintsFile as p, BlockPackBlockState as r, BlockPackMetaFile as s, BlockPackAtlasFile as t, BlockPackRenderLayer as u };

package/dist/pack.d.ts

@@ -0,0 +1,5 @@
+import { a as BlockStateMultipartCase, d as matchesCondition, n as BlockProperties, o as BlockStateVariantCase, p as weightedVariantIndex, r as BlockStateDefinition, s as MultipartCondition, t as BlockModelVariant, u as evaluateBlockState } from "./blockstate-eval-BzznRcVY.js";
+import { n as ObjMesh, t as MeshGroup } from "./obj-mesh-C6Sp4Ysc.js";
+import { n as BlockTintPack, t as BlockTint } from "./tints-2k3ZhkY3.js";
+import { a as BlockPackElement, c as BlockPackModel, d as BlockPackSprite, f as BlockPackSpriteFrame, i as BlockPackBlockStatesFile, l as BlockPackModelsFile, m as BlockPackVariant, n as BlockPackAtlasPage, o as BlockPackFace, p as BlockPackTintsFile, r as BlockPackBlockState, s as BlockPackMetaFile, t as BlockPackAtlasFile, u as BlockPackRenderLayer } from "./pack-format-CfCP4kzy.js";
+export { type BlockModelVariant, type BlockPackAtlasFile, type BlockPackAtlasPage, type BlockPackBlockState, type BlockPackBlockStatesFile, type BlockPackElement, type BlockPackFace, type BlockPackMetaFile, type BlockPackModel, type BlockPackModelsFile, type BlockPackRenderLayer, type BlockPackSprite, type BlockPackSpriteFrame, type BlockPackTintsFile, type BlockPackVariant, type BlockProperties, type BlockStateDefinition, type BlockStateMultipartCase, type BlockStateVariantCase, type BlockTint, type BlockTintPack, type MeshGroup, type MultipartCondition, type ObjMesh, evaluateBlockState, matchesCondition, weightedVariantIndex };

package/dist/pack.js

@@ -0,0 +1,2 @@
+import { i as matchesCondition, o as weightedVariantIndex, r as evaluateBlockState } from "./blockstate-eval-BRQ3NWY2.js";
+export { evaluateBlockState, matchesCondition, weightedVariantIndex };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nodecraft/rendermite",
-	"version": "1.2.1",
+	"version": "1.3.1",
 	"description": "Minecraft item icon renderer: renders inventory-identical item icons from vanilla and modded assets across game versions, outputting optimized PNG/WebP/AVIF plus CSS and a JSON item library.",
 	"type": "module",
 	"license": "MIT",
@@ -28,6 +28,10 @@
 		".": {
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
+		},
+		"./pack": {
+			"types": "./dist/pack.d.ts",
+			"import": "./dist/pack.js"
 		}
 	},
 	"files": [
@@ -65,6 +69,7 @@
 		"@types/yazl": "3.3.1",
 		"eslint": "10.8.0",
 		"rimraf": "6.1.3",
+		"rolldown": "1.2.3",
 		"semantic-release": "25.0.9",
 		"tsdown": "0.22.14",
 		"typescript": "6.0.3",