@nodecraft/rendermite 1.8.0 → 1.9.0

package/dist/biomes-CnnhDCnk.d.ts

@@ -0,0 +1,59 @@
+import { a as ResourceManager } from "./manager-Ct0dEOMg.js";
+//#region src/blocks/biomes.d.ts
+/** Where a biome's colours come from. Colours are `#rrggbb`, as everywhere else in the pack. */
+interface BiomeClimate {
+  /**
+   * The numeric id a chunk stores this biome as, before 1.18 replaced ids with names. Absent from a
+   * 1.18+ pack and from a mod's biomes, whose ids were assigned per world.
+   */
+  id?: number;
+  /** As the biome declares it, unclamped: the peaks run to -0.7 and the deserts to 2. */
+  temperature: number;
+  downfall: number;
+  /** `effects.water_color`, when it is not the default. */
+  water?: string;
+  /** `effects.grass_color_modifier`, applied after the colormap lookup. */
+  modifier?: 'dark_forest' | 'swamp';
+  /** `effects.grass_color`, which replaces the colormap lookup outright. */
+  grass?: string;
+  foliage?: string;
+  dryFoliage?: string;
+}
+/** `biomes.json`: biome id → climate. */
+type BiomeClimatePack = Record<string, BiomeClimate>;
+/** `effects.water_color` where a biome does not override it, which is most of them. */
+declare const DEFAULT_WATER_COLOR = "#3f76e4";
+interface LegacyBiome {
+  id: number;
+  name: string;
+  /** The release that added it; absent for the biomes 1.13 already had. */
+  since?: '1.14' | '1.16' | '1.17';
+  climate: Omit<BiomeClimate, 'id'>;
+}
+/** 1.13–1.17, from the 1.17.1 data generator's `reports/biomes`, in id order. */
+declare const LEGACY_BIOMES: readonly LegacyBiome[];
+/** 1.18–1.19.2, from the 1.19.2 data generator's `worldgen/biome` report. Ordered so a regenerated table diffs cleanly. */
+declare const PRE_JAR_BIOMES: BiomeClimatePack;
+/** @deprecated One version's table stood in for all of them; use `vanillaBiomesFor(version)`. */
+declare const VANILLA_BIOME_CLIMATES: BiomeClimatePack;
+/**
+ * Vanilla's biomes as a version without biome data in its jar has them: the version's own set,
+ * under its own names. A version that is not a release number (an `--assets` run) gets the newest.
+ */
+declare function vanillaBiomesFor(version: string): BiomeClimatePack;
+/** One biome definition as a datapack states it, or `null` when it states no climate. */
+declare function parseBiomeClimate(json: unknown): BiomeClimate | null;
+/**
+ * Climates for the namespaces a pack exports: whatever their datapacks declare,
+ * or for `minecraft` in a jar that declares none, the version's table.
+ *
+ * A mod pack carries only its own biomes. The vanilla pack is always fetched
+ * beside it, so repeating vanilla's would be the same bytes in every one of the
+ * hundreds of mod packs published.
+ */
+declare function buildBiomeClimates(resources: ResourceManager, namespaces: readonly string[], version?: string): Promise<{
+  pack: BiomeClimatePack;
+  unreadable: string[];
+}>;
+//#endregion
+export { LegacyBiome as a, buildBiomeClimates as c, LEGACY_BIOMES as i, parseBiomeClimate as l, BiomeClimatePack as n, PRE_JAR_BIOMES as o, DEFAULT_WATER_COLOR as r, VANILLA_BIOME_CLIMATES as s, BiomeClimate as t, vanillaBiomesFor as u };

package/dist/{blend-C5UYzink.d.ts → blend-mJAeQB3C.d.ts}

@@ -1,4 +1,4 @@
-import { r as Texture } from "./loader-59_eMa8e.js";
+import { r as Texture } from "./loader-C4gsX_wO.js";
 //#region src/render/blend.d.ts
 /** RGBA float pixels for render-time work; converted back to 8-bit at encode. */
 interface FloatTexture {

package/dist/{pack-format-BqWf-DNc.d.ts → block-behaviour-9Tj_GIUC.d.ts}

@@ -1,8 +1,12 @@
-import { n as BiomeClimatePack } from "./biomes-CJDJQqJb.js";
-import { a as FaceDirectionName, l as Vec3, o as ModelElementJson, u as Vec4 } from "./types-qlp3I8_-.js";
+import { n as BiomeClimatePack } from "./biomes-CnnhDCnk.js";
 import { a as BlockStateMultipartCase, o as BlockStateVariantCase } from "./blockstate-eval-BzznRcVY.js";
-import { t as MeshGroup } from "./obj-mesh-ydhVfLKs.js";
-import { n as BlockTintPack } from "./tints-CQX8a1F0.js";
+import { r as TagPack, t as AdvancementPack } from "./datapack-CmEg0Vko.js";
+import { n as GameRulePack } from "./game-rules-ThvdDG3B.js";
+import { a as FaceDirectionName, l as Vec3, o as ModelElementJson, u as Vec4 } from "./types-qlp3I8_-.js";
+import { t as MeshGroup } from "./obj-mesh-CzL0lOlJ.js";
+import { n as BlockStatesPack } from "./states-OzneeCTU.js";
+import { n as BlockTintPack } from "./tints-DwFmEkf3.js";
+import { t as ClassFile } from "./classfile-CsLXlh5z.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';
@@ -133,12 +137,36 @@ type BlockPackLight = number | {
  * pack has emitters and the export could read the code for them — an `--assets` run has none.
  */
 type BlockPackLightFile = Record<string, BlockPackLight>;
+/**
+ * `behaviour.json`, by block id: hardness, collision, replaceability, map colour and the rest of what
+ * the block's `Properties` builder chain states. Read from the code, like `light.json`, so absent
+ * from an `--assets` run and from 1.13, whose builder calls have no names without mappings.
+ */
+type BlockPackBehaviourFile = Record<string, BlockBehaviour>;
 /**
  * `biomes.json`, present only when the pack has biomes to describe: vanilla's
  * whole table, or the ones a mod's datapack declares. Absent is not empty — a
  * consumer with no file falls back to tinting at `tints.json`'s flat climate.
  */
 type BlockPackBiomesFile = BiomeClimatePack;
+/**
+ * `tags.json`: registry → tag id → values, exactly as the version's datapack states them. Unexpanded,
+ * so a value starting `#` names another tag in the same registry. Registries are keyed by their 1.21+
+ * singular folder name (`block`, `item`, `entity_type`, `worldgen/biome`) at every version.
+ */
+type BlockPackTagsFile = TagPack;
+/** `advancements.json`: advancement id → its criteria names, recipe unlocks left out. */
+type BlockPackAdvancementsFile = AdvancementPack;
+/**
+ * `states.json`: every block's properties, values in the game's order, and its default state. Present
+ * only when the export was given the version's data generator reports.
+ */
+type BlockPackStatesFile = BlockStatesPack;
+/**
+ * `game-rules.json`: every rule the version registers, by the name `level.dat` stores it under
+ * (camelCase before 26.x, snake_case from it), with its type and default. Vanilla packs only.
+ */
+type BlockPackGameRulesFile = GameRulePack;
 /** One flat sprite of an item's layer stack, in the order the client draws them. */
 interface ItemPackLayer {
   sprite: string;
@@ -203,6 +231,12 @@ interface EntityPackEntry {
   texture?: string;
   /** Key into `entity-models.json`'s `models`, when geometry was recovered for this entity. */
   model?: string;
+  /**
+   * Hitbox in blocks, as `EntityType.Builder.sized` states it: the base size, before a baby or a big
+   * slime scales its own. Absent where no code was read (an `--assets` run, 1.13).
+   */
+  width?: number;
+  height?: number;
 }
 /**
  * `entities.json`, by entity id. The registry read off the lang file, which is the closest thing a jar
@@ -341,10 +375,258 @@ interface BlockPackMetaFile {
     entityModels: number;
     /** Emitting blocks in `light.json`; `0` means the file is absent. */
     light: number;
+    /** Blocks in `behaviour.json`; `0` means the file is absent. */
+    behaviour: number;
+    /** Tags across every registry in `tags.json`; `0` means the file is absent. */
+    tags: number;
+    /** Advancements in `advancements.json`; `0` means the file is absent. */
+    advancements: number;
+    /** Blocks in `states.json`; `0` means the file is absent. */
+    states: number;
+    /** Rules in `game-rules.json`; `0` means the file is absent. */
+    gameRules: number;
     failures: number;
   };
   /** sha256 per file, enough to verify a cached copy without refetching it. */
   hashes: Record<string, string>;
 }
 //#endregion
-export { ItemPackLayer as A, EntityPackCubeFace as C, EquipmentPack as D, EntityPackPart as E, EquipmentSlot as O, EntityPackCube as S, EntityPackModel as T, BlockPackSprite as _, BlockPackBlockStatesFile as a, BlockPackVariant as b, BlockPackEntityModelsFile as c, BlockPackLight as d, BlockPackLightFile as f, BlockPackRenderLayer as g, BlockPackModelsFile as h, BlockPackBlockState as i, ItemPackEntry as k, BlockPackFace as l, BlockPackModel as m, BlockPackAtlasPage as n, BlockPackElement as o, BlockPackMetaFile as p, BlockPackBiomesFile as r, BlockPackEntitiesFile as s, BlockPackAtlasFile as t, BlockPackItemsFile as u, BlockPackSpriteFrame as v, EntityPackEntry as w, EQUIPMENT_SLOTS as x, BlockPackTintsFile as y };
+//#region src/blocks/light-bytecode.d.ts
+/** A member reference as the constant pool spells it. */
+interface MemberReference {
+  owner: string;
+  name: string;
+  descriptor: string;
+}
+/** What the caller supplies: how to find code, and how to rename a reference before looking. */
+interface LightCodeSource {
+  /** The parsed class, or null for anything outside the jars (the JDK, a loader). */
+  resolve: (internalName: string) => ClassFile | null;
+  /**
+   * A reference as the jar spells it. A mod names the game's classes and members by their original
+   * names; against an obfuscated client those have to be renamed before they can be found.
+   */
+  remap: (reference: MemberReference, field: boolean) => MemberReference;
+  remapClass: (internalName: string) => string;
+  /**
+   * A member's original name, for reading the game's own obfuscated calls: `eea$d.a(FF)` is `strength`.
+   * Absent, or answering the name it was given, where the jar already speaks original names.
+   */
+  nameOf?: (reference: MemberReference, field: boolean) => string;
+  /** Classes that are a block `Properties` builder, in every spelling the jars use. */
+  propsClasses: ReadonlySet<string>;
+  /**
+   * Whether a class is the game's rather than a mod's. A mod export runs the game's own `Blocks` too,
+   * for the properties mods copy, and its registrations must not answer for a mod block that happens
+   * to share a name — `immersiveengineering:lantern` is not `minecraft:lantern`.
+   */
+  isVanillaClass: (internalName: string) => boolean;
+  /**
+   * Methods a block class may override to answer its own light: the game's `getLightValue(state)`
+   * before 1.16, when a lit furnace was an override rather than a lambda, and a loader's
+   * `getLightEmission(state, level, pos)`. `root` is the class whose implementation is the plain
+   * property read, so a call resolving there — `super.getLightValue(state)` — is answered from the
+   * block's `Properties`.
+   */
+  lightGetters: ReadonlyArray<LightGetter>;
+}
+interface LightGetter {
+  name: string;
+  /** Empty to match by name alone: a loader method whose parameter types the jar does not spell. */
+  descriptor: string;
+  root: string | null;
+}
+/** How a block's light is stated, before it is evaluated. */
+type LightSpec = {
+  kind: 'constant';
+  level: number;
+} |
+/** A `ToIntFunction<BlockState>`, to be run per state. */
+{
+  kind: 'function';
+  fn: LambdaValue;
+} |
+/** A block class's own light method: a 1.13–1.15 `getLightValue` override, or a loader's `getLightEmission`. */
+{
+  kind: 'method';
+  owner: string;
+  getter: LightGetter;
+  receiver: Handle | null;
+} |
+/** A light function the interpreter could not identify — one built from a value it never saw. */
+{
+  kind: 'opaque';
+  reason: string;
+};
+interface PropsCall {
+  name: string;
+  descriptor: string;
+  args: Value[];
+}
+interface Handle {
+  id: number;
+  /** Internal class name, from `new` or the declared return type of the opaque call that made it. */
+  type: string | null;
+  /** Strings that flowed into this object: the name a registration key or a property was made from. */
+  strings: string[];
+  numbers: number[];
+  /** Class literals that flowed in: the value class of an enum property. */
+  classes: string[];
+  fields: Map<string, Value>;
+  isProps: boolean;
+  light: LightSpec | null;
+  /** For a `Properties`: every builder call made on it, by its mapped name, for `block-behaviour.ts` to read. */
+  calls?: PropsCall[];
+  /** For a `Properties` made by copying a block's: the properties it copied, whose calls come first. */
+  copyOf?: Handle | null;
+  /** For a block: the `Properties` it was constructed with. */
+  props: Handle | null;
+  ctorArgs: Value[] | null;
+  /** `StringBuilder` parts, for the pre-Java 9 way of building a name. */
+  builder?: Array<string | number>;
+  origin?: string;
+  /** Entries of a map the code filled, for a lookup table of properties by direction. */
+  map?: Array<{
+    key: Value;
+    value: Value;
+  }>;
+  /** Elements of a list or set the code filled, for a table of names a mod registers in a loop. */
+  items?: Value[];
+  /** An iterator over a list: what it walks and where it is. */
+  iterator?: {
+    items: Value[];
+    at: number;
+  };
+}
+interface LambdaValue {
+  kind: 'lambda';
+  owner: string;
+  name: string;
+  descriptor: string;
+  captured: Value[];
+}
+/** A `BlockState` during evaluation of a light function: a bag of property values being read. */
+interface StateProbe {
+  values: Map<string, string>;
+  domains: Map<string, PropertyDomain>;
+  reads: Set<string>;
+  failure: string | null;
+}
+interface PropertyDomain {
+  name: string;
+  values: string[];
+  /** The enum constant per serialized value, for a property whose values are an enum. */
+  constants?: Map<string, Handle>;
+}
+type Value = LambdaValue | {
+  kind: 'number';
+  value: number;
+  wide?: boolean;
+} | {
+  kind: 'string';
+  value: string;
+} | {
+  kind: 'object';
+  handle: Handle;
+} | {
+  kind: 'array';
+  items: Value[];
+} | {
+  kind: 'class';
+  name: string;
+} | {
+  kind: 'null';
+} | {
+  kind: 'state';
+  probe: StateProbe;
+} | {
+  kind: 'unknown';
+};
+/** One registration this found: which `Properties` a name was registered with, and the block if seen. */
+interface Registration {
+  props: Handle | null;
+  block: Handle | null;
+  /** The block's class, when a factory method reference named it. */
+  blockType: string | null;
+  /** The call that registered it, for a person chasing a wrong answer. */
+  site: string;
+  /** Made by the game's own code, which a mod's block of the same bare name must not inherit. */
+  vanilla: boolean;
+}
+/** What one run over a set of registry classes found. */
+interface LightExtraction {
+  registrations: Map<string, Registration>;
+  notes: string[];
+  /** The light a block emits, or why it could not be worked out. */
+  lightOf: (blockId: string) => {
+    light: BlockPackLight;
+  } | {
+    failure: string;
+  };
+  /** The registration the code made for a block, under its full id or its own side's bare path. */
+  registrationOf: (blockId: string) => Registration | null;
+  /**
+   * Runs a function of a block state once per combination of the properties it reads, folded like
+   * light: a number when every state agrees, a default and cases otherwise. `read` turns what the
+   * function returned into a number, or null when it is not one this can use.
+   */
+  tabulate: (fn: LambdaValue, read: (value: Value) => number | null) => {
+    value: BlockPackLight;
+  } | {
+    failure: string;
+  };
+  /** What was recorded for a block, for a person chasing a failure. */
+  describe: (blockId: string) => string;
+}
+/**
+ * Runs the registry code of a set of classes and answers, per block, what it emits.
+ *
+ * `roots` are the classes whose methods register blocks; every method of each is run, because where
+ * the registrations sit differs by era and mod — `<clinit>` for a modern registry, a static
+ * `registerBlocks()` in 1.13, an instance `init()` in a mod. The order is `<clinit>` first, since the
+ * others read what it set up.
+ */
+declare function extractBlockLight(roots: readonly ClassFile[], source: LightCodeSource): LightExtraction;
+//#endregion
+//#region src/blocks/block-behaviour.d.ts
+/** How pistons treat a block; absent means `normal`, pushed and pulled like stone. */
+type PushReactionName = 'destroy' | 'block' | 'ignore' | 'push_only';
+interface BlockBehaviour {
+  /** Seconds-ish to mine by hand, as `destroyTime`; `-1` is unbreakable. */
+  hardness: number;
+  /** Explosion resistance. */
+  resistance: number;
+  /**
+   * Map colour id (0–63, 0 draws nothing). A number, or per-state cases in the shape `light.json`
+   * uses: a log is one colour on its end grain and another on its bark.
+   */
+  mapColor?: BlockPackLight;
+  /** Entities walk through it: grass, flowers, torches. */
+  collision?: false;
+  /** It hides nothing behind it: glass, leaves, anything `noOcclusion()`. */
+  occludes?: false;
+  /** A placed block or a growing tree takes its place without breaking it. */
+  replaceable?: true;
+  air?: true;
+  liquid?: true;
+  /** Lava sets it alight (`ignitedByLava`, or a flammable `Material` before 1.20). */
+  flammable?: true;
+  pushReaction?: PushReactionName;
+  /** Drops nothing unless mined with the right tool. */
+  requiresTool?: true;
+  randomTicks?: true;
+  friction?: number;
+  speedFactor?: number;
+  jumpFactor?: number;
+}
+/**
+ * The colour a block's `Properties` state: a `mapColor` call, the colour a pre-1.20 `Properties` was
+ * constructed with, or its `Material`'s, latest first. A constant or a function of state.
+ */
+declare function statedMapColor(props: Handle): Value | undefined;
+declare function blockBehaviour(registration: Registration, extraction: Pick<LightExtraction, 'tabulate'>): {
+  behaviour: BlockBehaviour;
+  failures: string[];
+} | null;
+//#endregion
+export { BlockPackItemsFile as A, BlockPackTagsFile as B, BlockPackBlockState as C, BlockPackEntityModelsFile as D, BlockPackEntitiesFile as E, BlockPackModelsFile as F, EntityPackCubeFace as G, BlockPackVariant as H, BlockPackRenderLayer as I, EntityPackPart as J, EntityPackEntry as K, BlockPackSprite as L, BlockPackLightFile as M, BlockPackMetaFile as N, BlockPackFace as O, BlockPackModel as P, ItemPackLayer as Q, BlockPackSpriteFrame as R, BlockPackBiomesFile as S, BlockPackElement as T, EQUIPMENT_SLOTS as U, BlockPackTintsFile as V, EntityPackCube as W, EquipmentSlot as X, EquipmentPack as Y, ItemPackEntry as Z, extractBlockLight as _, Handle as a, BlockPackAtlasPage as b, LightExtraction as c, MemberReference as d, PropertyDomain as f, Value as g, StateProbe as h, statedMapColor as i, BlockPackLight as j, BlockPackGameRulesFile as k, LightGetter as l, Registration as m, PushReactionName as n, LambdaValue as o, PropsCall as p, EntityPackModel as q, blockBehaviour as r, LightCodeSource as s, BlockBehaviour as t, LightSpec as u, BlockPackAdvancementsFile as v, BlockPackBlockStatesFile as w, BlockPackBehaviourFile as x, BlockPackAtlasFile as y, BlockPackStatesFile as z };

package/dist/block-behaviour-D-SG2Xfp.js

@@ -0,0 +1,155 @@
+//#region src/blocks/block-behaviour.ts
+const PUSH_REACTIONS = /* @__PURE__ */ new Set([
+	"destroy",
+	"block",
+	"ignore",
+	"push_only"
+]);
+function num(value) {
+	return value?.kind === "number" ? value.value : null;
+}
+function field(handle, name) {
+	return handle.fields.get(`mapped:${name}`) ?? handle.fields.get(name);
+}
+/** A `MapColor` (`MaterialColor` before 1.20) is constructed as `(id, rgb)`; its id is the first. */
+function mapColorId(value) {
+	if (value?.kind !== "object") return null;
+	const args = value.handle.ctorArgs ?? [];
+	const id = num(args[0]);
+	if (args.length === 2 && id !== null && num(args[1]) !== null && id >= 0 && id < 64) return id;
+	if (args[0]?.kind !== "string" || args[1]?.kind !== "number") return null;
+	for (const arg of args) {
+		const nested = arg.kind === "object" && arg.handle !== value.handle ? mapColorId(arg) : null;
+		if (nested !== null) return nested;
+	}
+	return null;
+}
+/** An enum constant's serialized name: the lower-cased constant name it was constructed with. */
+function enumName(value) {
+	const name = value?.kind === "object" ? value.handle.ctorArgs?.[0] : void 0;
+	return name?.kind === "string" ? name.value.toLowerCase() : null;
+}
+/** The chain of `Properties` a block's came from, oldest copy first, so later calls win. */
+function lineage(props) {
+	const chain = [];
+	for (let at = props; at && !chain.includes(at); at = at.copyOf) chain.unshift(at);
+	return chain;
+}
+/** The `Material` a pre-1.20 `Properties` was constructed with, when it was. */
+function materialOf(props) {
+	for (const handle of lineage(props)) for (const arg of handle.ctorArgs ?? []) if (arg.kind === "object" && field(arg.handle, "replaceable") !== void 0) return arg.handle;
+	return null;
+}
+/**
+* The colour a block's `Properties` state: a `mapColor` call, the colour a pre-1.20 `Properties` was
+* constructed with, or its `Material`'s, latest first. A constant or a function of state.
+*/
+function statedMapColor(props) {
+	const material = materialOf(props);
+	let colour = material ? field(material, "color") : void 0;
+	for (const handle of lineage(props)) {
+		colour = (handle.ctorArgs ?? []).find((arg) => arg.kind === "lambda" || mapColorId(arg) !== null) ?? colour;
+		for (const call of handle.calls ?? []) if (call.name === "mapColor") colour = call.args[0];
+	}
+	return colour;
+}
+/** A float as Java wrote it: `0.3F` is 0.30000001192092896 as a double, and 0.3 is what the code says. */
+function float32(value) {
+	for (let digits = 1; digits < 10; digits++) {
+		const candidate = Number(value.toPrecision(digits));
+		if (Math.fround(candidate) === Math.fround(value)) return candidate;
+	}
+	return value;
+}
+function blockBehaviour(registration, extraction) {
+	const props = registration.props;
+	if (!props) return null;
+	const failures = [];
+	const behaviour = {
+		hardness: 0,
+		resistance: 0
+	};
+	const mapColor = statedMapColor(props);
+	const material = materialOf(props);
+	if (material) {
+		if (num(field(material, "replaceable")) === 1) behaviour.replaceable = true;
+		if (num(field(material, "liquid")) === 1) behaviour.liquid = true;
+		if (num(field(material, "flammable")) === 1) behaviour.flammable = true;
+		if (num(field(material, "alwaysDestroyable")) === 0) behaviour.requiresTool = true;
+		const reaction = enumName(field(material, "pushReaction"));
+		if (reaction && PUSH_REACTIONS.has(reaction)) behaviour.pushReaction = reaction;
+	}
+	for (const handle of lineage(props)) for (const call of handle.calls ?? []) {
+		const [first, second] = call.args;
+		switch (call.name) {
+			case "strength":
+				behaviour.hardness = float32(num(first) ?? behaviour.hardness);
+				behaviour.resistance = float32(num(second ?? first) ?? behaviour.resistance);
+				break;
+			case "destroyTime":
+				behaviour.hardness = float32(num(first) ?? behaviour.hardness);
+				break;
+			case "explosionResistance":
+				behaviour.resistance = float32(num(first) ?? behaviour.resistance);
+				break;
+			case "instabreak":
+				behaviour.hardness = 0;
+				behaviour.resistance = 0;
+				break;
+			case "noCollission":
+			case "noCollision":
+				behaviour.collision = false;
+				behaviour.occludes = false;
+				break;
+			case "noOcclusion":
+				behaviour.occludes = false;
+				break;
+			case "replaceable":
+				behaviour.replaceable = true;
+				break;
+			case "air":
+				behaviour.air = true;
+				break;
+			case "liquid":
+				behaviour.liquid = true;
+				break;
+			case "ignitedByLava":
+				behaviour.flammable = true;
+				break;
+			case "requiresCorrectToolForDrops":
+				behaviour.requiresTool = true;
+				break;
+			case "randomTicks":
+				behaviour.randomTicks = true;
+				break;
+			case "pushReaction": {
+				const reaction = enumName(first);
+				if (reaction === "normal") delete behaviour.pushReaction;
+				else if (reaction && PUSH_REACTIONS.has(reaction)) behaviour.pushReaction = reaction;
+				break;
+			}
+			case "friction":
+			case "speedFactor":
+			case "jumpFactor": {
+				const value = num(first);
+				if (value !== null) behaviour[call.name] = float32(value);
+				break;
+			}
+		}
+	}
+	if (mapColor?.kind === "lambda") {
+		const folded = extraction.tabulate(mapColor, mapColorId);
+		if ("failure" in folded) failures.push(`map colour: ${folded.failure}`);
+		else behaviour.mapColor = folded.value;
+	} else if (mapColor !== void 0) {
+		const id = mapColorId(mapColor);
+		if (id === null) failures.push("map colour is a value the interpreter could not identify");
+		else behaviour.mapColor = id;
+	}
+	return {
+		behaviour,
+		failures
+	};
+}
+//#endregion
+export { statedMapColor as n, blockBehaviour as t };

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

@@ -1,2 +1,2 @@
-import { a as PackedRect, i as PackedPage, n as PackOptions, o as packAtlas, r as PackedAtlas, t as PackEntry } from "../atlas-pack-C56gzqAg.js";
+import { a as PackedRect, i as PackedPage, n as PackOptions, o as packAtlas, r as PackedAtlas, t as PackEntry } from "../atlas-pack-BUadroKy.js";
 export { PackEntry, PackOptions, PackedAtlas, PackedPage, PackedRect, packAtlas };

package/dist/blocks/biomes.d.ts

@@ -1,2 +1,2 @@
-import { a as buildBiomeClimates, i as VANILLA_BIOME_CLIMATES, n as BiomeClimatePack, o as parseBiomeClimate, r as DEFAULT_WATER_COLOR, t as BiomeClimate } from "../biomes-CJDJQqJb.js";
-export { BiomeClimate, BiomeClimatePack, DEFAULT_WATER_COLOR, VANILLA_BIOME_CLIMATES, buildBiomeClimates, parseBiomeClimate };
+import { a as LegacyBiome, c as buildBiomeClimates, i as LEGACY_BIOMES, l as parseBiomeClimate, n as BiomeClimatePack, o as PRE_JAR_BIOMES, r as DEFAULT_WATER_COLOR, s as VANILLA_BIOME_CLIMATES, t as BiomeClimate, u as vanillaBiomesFor } from "../biomes-CnnhDCnk.js";
+export { BiomeClimate, BiomeClimatePack, DEFAULT_WATER_COLOR, LEGACY_BIOMES, LegacyBiome, PRE_JAR_BIOMES, VANILLA_BIOME_CLIMATES, buildBiomeClimates, parseBiomeClimate, vanillaBiomesFor };

package/dist/blocks/biomes.js

@@ -1,2 +1,2 @@
-import { i as parseBiomeClimate, n as VANILLA_BIOME_CLIMATES, r as buildBiomeClimates, t as DEFAULT_WATER_COLOR } from "../biomes-5ZwYxMYe.js";
-export { DEFAULT_WATER_COLOR, VANILLA_BIOME_CLIMATES, buildBiomeClimates, parseBiomeClimate };
+import { a as buildBiomeClimates, i as VANILLA_BIOME_CLIMATES, n as LEGACY_BIOMES, o as parseBiomeClimate, r as PRE_JAR_BIOMES, s as vanillaBiomesFor, t as DEFAULT_WATER_COLOR } from "../biomes-BGOF6gRM.js";
+export { DEFAULT_WATER_COLOR, LEGACY_BIOMES, PRE_JAR_BIOMES, VANILLA_BIOME_CLIMATES, buildBiomeClimates, parseBiomeClimate, vanillaBiomesFor };

package/dist/blocks/block-behaviour.d.ts

@@ -0,0 +1,2 @@
+import { i as statedMapColor, n as PushReactionName, r as blockBehaviour, t as BlockBehaviour } from "../block-behaviour-9Tj_GIUC.js";
+export { BlockBehaviour, PushReactionName, blockBehaviour, statedMapColor };

package/dist/blocks/block-behaviour.js

@@ -0,0 +1,2 @@
+import { n as statedMapColor, t as blockBehaviour } from "../block-behaviour-D-SG2Xfp.js";
+export { blockBehaviour, statedMapColor };

package/dist/blocks/block-entities.d.ts

@@ -1,6 +1,6 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { i as TextureLoader } from "../loader-59_eMa8e.js";
-import { t as ModelLoader } from "../loader-DSir1-P0.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { i as TextureLoader } from "../loader-C4gsX_wO.js";
+import { t as ModelLoader } from "../loader-BYyPIs9f.js";
 //#region src/blocks/block-entities.d.ts
 /**
  * What the table is allowed to look at. The vanilla families are a lookup, but

package/dist/blocks/cli.js

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

package/dist/blocks/datapack.d.ts

@@ -0,0 +1,2 @@
+import { i as collectDatapack, n as DatapackResult, r as TagPack, t as AdvancementPack } from "../datapack-CmEg0Vko.js";
+export { AdvancementPack, DatapackResult, TagPack, collectDatapack };

package/dist/blocks/datapack.js

@@ -0,0 +1,2 @@
+import { t as collectDatapack } from "../datapack-D6eH46ay.js";
+export { collectDatapack };

package/dist/blocks/ender-storage.d.ts

@@ -1,5 +1,5 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { m as BlockPackModel } from "../pack-format-BqWf-DNc.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { P as BlockPackModel } from "../block-behaviour-9Tj_GIUC.js";
 //#region src/blocks/ender-storage.d.ts
 /**
  * Ender Storage feeds this OBJ through CodeChickenLib's `swapYZ`, translates it almost exactly onto

package/dist/blocks/entities.d.ts

@@ -1,6 +1,6 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { i as TextureLoader } from "../loader-59_eMa8e.js";
-import { w as EntityPackEntry } from "../pack-format-BqWf-DNc.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { i as TextureLoader } from "../loader-C4gsX_wO.js";
+import { K as EntityPackEntry } from "../block-behaviour-9Tj_GIUC.js";
 //#region src/blocks/entities.d.ts
 interface EntityPackResult {
   entities: Record<string, EntityPackEntry>;

package/dist/blocks/entity-geo.d.ts

@@ -1,4 +1,4 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
 //#region src/blocks/entity-geo.d.ts
 interface GeoEntityModel {

package/dist/blocks/entity-models.d.ts

@@ -1,7 +1,7 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { D as EquipmentPack, T as EntityPackModel } from "../pack-format-BqWf-DNc.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
 import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
-import { t as Mappings } from "../mappings-USwcjtcH.js";
+import { Y as EquipmentPack, q as EntityPackModel } from "../block-behaviour-9Tj_GIUC.js";
+import { t as Mappings } from "../mappings-DhOPQTgV.js";
 import { t as ModelCode } from "../model-code-Csc3bs3h.js";
 //#region src/blocks/entity-models.d.ts
 interface EntityGeometryResult {

package/dist/blocks/entity-models.js

@@ -1,2 +1,2 @@
-import { n as collectEntityGeometry, r as collectEquipment, t as collectArmourTrims } from "../entity-models-BGiy3pey.js";
+import { n as collectEntityGeometry, r as collectEquipment, t as collectArmourTrims } from "../entity-models-BYAxrTsk.js";
 export { collectArmourTrims, collectEntityGeometry, collectEquipment };