@nodecraft/rendermite 1.8.0 → 1.10.0

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

@@ -0,0 +1,673 @@
+import { n as BiomeClimatePack } from "./biomes-CnnhDCnk.js";
+import { a as BlockStateMultipartCase, o as BlockStateVariantCase } from "./blockstate-eval-BzznRcVY.js";
+import { r as TagPack, t as AdvancementPack } from "./datapack-CmEg0Vko.js";
+import { n as GameRulePack } from "./game-rules-ThvdDG3B.js";
+import { t as NamePack } from "./names-D1abAVIB.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-Dzn0gW9M.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;
+/**
+ * How much light a block emits, 0–15.
+ *
+ * A number when every state of the block emits the same. Otherwise the commonest level is `default`
+ * and each other level is a case naming only the properties that decide it: a redstone lamp is
+ * `{ default: 0, cases: [{ when: { lit: 'true' }, level: 15 }] }`. The first case whose every
+ * property matches the state applies; `blockLightLevel` in `light-eval.ts` does that lookup.
+ */
+type BlockPackLight = number | {
+  default: number;
+  cases: Array<{
+    when: Record<string, string>;
+    level: number;
+  }>;
+};
+/**
+ * `light.json`, by block id, holding only the blocks that emit: absent means 0. Present only when the
+ * 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;
+/** `names.json`: English display names by id, for blocks and items, from each namespace's `en_us`. */
+type BlockPackNamesFile = NamePack;
+/** One flat sprite of an item's layer stack, in the order the client draws them. */
+interface ItemPackLayer {
+  sprite: string;
+  /**
+   * Present when the item declares a tint at this layer, which is the client's own
+   * rule: `ItemModelGenerator` passes each layer its own index as the tint index.
+   */
+  tintindex?: number;
+  /**
+   * The colour that tint resolves to in an item's default state, `#rrggbb`.
+   *
+   * Absent where it cannot be known from assets — a dyed leather boot or a potion
+   * takes its colour from the stack's components, which no pack can carry. A
+   * consumer drawing an absent tint untinted gets the mod's own artwork, which is
+   * the same thing the icon renderer settles for.
+   */
+  tint?: string;
+}
+/** One flat item: everything there is to say about how the game draws it. */
+interface ItemPackEntry {
+  layers: ItemPackLayer[];
+}
+/**
+ * `items.json`. Self-contained rather than sharing `atlas.json`'s pages, so a
+ * consumer that only draws blocks never fetches the item sheet at all — a world
+ * viewer needs it only once it finds a dropped stack of something that is not a
+ * block.
+ *
+ * Holds *only* items whose model is a flat sprite stack. An item absent from
+ * `items` either draws from `blockstates.json` under the same id, or is in
+ * `failures.json` saying why nothing can draw it.
+ */
+interface BlockPackItemsFile {
+  /** Edge-extended border per sprite, in pixels. */
+  padding: number;
+  pages: BlockPackAtlasPage[];
+  sprites: Record<string, BlockPackSprite>;
+  items: Record<string, ItemPackEntry>;
+}
+/**
+ * One entity type: what to call it, and what colour it is.
+ *
+ * No geometry, because no jar has any — entity models are Java code at every version. What a consumer
+ * can do with this is name the stand-in box it draws and tint it like the animal, which is the
+ * difference between a field of arbitrary colours and a readable one.
+ */
+interface EntityPackEntry {
+  /** English display name, from the jar's own lang file. */
+  name: string;
+  /**
+   * Mean colour of the opaque pixels of the entity's sheet, `#rrggbb`.
+   *
+   * Absent for everything that is not a mob — an item entity, a falling block, a marker, a display,
+   * a thrown projectile — because those draw from an item or a block and have no sheet of their own.
+   * None is invented for them.
+   */
+  color?: string;
+  /**
+   * The sheet the colour came from, and what the model's `uv` values address. A sprite id in
+   * `entity-models.json`'s atlas once that file is present.
+   */
+  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
+ * carries to it. Absent from a pack whose namespaces register no entities.
+ */
+type BlockPackEntitiesFile = Record<string, EntityPackEntry>;
+/** One box of a part, in the model's own space, exactly as the game's own builder stated it. */
+/** The six faces a box can carry its own texture rect on. */
+type EntityPackCubeFace = 'north' | 'south' | 'east' | 'west' | 'up' | 'down';
+interface EntityPackCube {
+  /** Minimum corner. */
+  origin: Vec3;
+  size: Vec3;
+  /** Texture offset in pixels on the entity's own sheet, as `texOffs` set it. */
+  uv: [number, number];
+  /** Grows the box on every side; `CubeDeformation`, or a builder's `delta`. */
+  inflate?: number;
+  mirror?: true;
+  /**
+   * Per-face texture rects, which replace the box unwrap `uv` implies wherever they are present.
+   *
+   * Java has no such thing, since `addBox` always unwraps the same way, but bedrock geometry does and
+   * leans on it: 56% of the cubes across four GeckoLib mods state their faces individually. A consumer
+   * that ignores this draws over half of every such mob from the wrong part of its sheet.
+   */
+  faces?: Partial<Record<EntityPackCubeFace, {
+    uv: [number, number];
+    size: [number, number];
+  }>>;
+}
+/** One bone: where it pivots, what it is made of, and what hangs off it. */
+interface EntityPackPart {
+  name: string;
+  /** Pivot relative to the parent bone. */
+  pivot: Vec3;
+  /** Radians about x, y, z, as `PartPose.offsetAndRotation` states them. */
+  rotation: Vec3;
+  cubes: EntityPackCube[];
+  children: EntityPackPart[];
+}
+/**
+ * One entity model: a bone hierarchy of boxes, recovered from the client's own code.
+ *
+ * `textureSize` is the sheet the `uv` values are in, which is *not* the atlas page — a consumer maps
+ * `uv` through it into the sprite's rect, exactly as it does for a block face.
+ *
+ * **Prefer the sprite's own `w`/`h` where the entity has one**, and keep this as the fallback. One
+ * model can be drawn on two differently sized sheets: from 1.21.4 a boat and a chest boat are both a
+ * `BoatModel`, on a 128x64 and a 128x128 sheet respectively, so no single value here is right for both.
+ */
+interface EntityPackModel {
+  textureSize: [number, number];
+  parts: EntityPackPart[];
+  /** Anything the extraction had to skip or assume, so a consumer can distrust it knowingly. */
+  notes?: string[];
+}
+/**
+ * `entity-models.json`. Self-contained like `items.json`, with its own atlas of entity sheets, so a
+ * consumer that never draws a mob does not fetch any of it.
+ *
+ * `models` is keyed by the class the geometry came from, and `entities.json`'s `model` points at it —
+ * several entities share one model (every zombie is a `HumanoidModel`), and keying by class is what
+ * makes that one entry rather than twenty copies.
+ */
+interface BlockPackEntityModelsFile {
+  padding: number;
+  pages: BlockPackAtlasPage[];
+  sprites: Record<string, BlockPackSprite>;
+  models: Record<string, EntityPackModel>;
+  /** Worn armour, when the version's classes described any. Absent otherwise. */
+  equipment?: EquipmentPack;
+}
+/** The armour slots the game dresses a humanoid in, in the order it layers them. */
+declare const EQUIPMENT_SLOTS: readonly ["feet", "legs", "chest", "head"];
+type EquipmentSlot = typeof EQUIPMENT_SLOTS[number];
+/**
+ * Worn armour: one humanoid-shaped mesh, the two sizes it is drawn at, and a sheet per material.
+ *
+ * Armour is not geometry of its own — it is the wearer's own humanoid shape grown by a fixed amount,
+ * which is why one mesh dresses a player, a zombie and an armour stand alike. The leggings are the
+ * *inner* layer and everything else the *outer*, drawn a little larger so the two never fight.
+ *
+ * Everything a consumer needs to decide what to draw is stated here rather than derived, in keeping
+ * with the rest of the pack: which parts a slot lights up, which sheet a material uses, and which
+ * material an item is made of.
+ */
+interface EquipmentPack {
+  /** Key into `models`, holding the humanoid armour shape. */
+  model: string;
+  /** How much each layer grows the wearer's boxes by, in pixels. */
+  inflate: {
+    inner: number;
+    outer: number;
+  };
+  /** Parts each slot shows. A slot lights up some of the one mesh rather than owning geometry. */
+  slots: Record<EquipmentSlot, string[]>;
+  /** Which layer a slot is drawn on, which decides the sheet as well as the size. */
+  layerOf: Record<EquipmentSlot, 'inner' | 'outer'>;
+  /** Sprite ids per material and layer, into this file's own `sprites`. */
+  materials: Record<string, Partial<Record<'inner' | 'outer', string>>>;
+  /**
+   * The armour items themselves. Keyed by item id because that is what a world writes into an
+   * entity's `equipment` compound, and nothing in the assets maps one to the other.
+   */
+  items: Record<string, {
+    material: string;
+    slot: EquipmentSlot;
+  }>;
+  /** Materials whose sheet is greyscale and takes the item's own dye colour. */
+  dyeable: string[];
+  /** The colour a dyeable material takes when nothing dyed it, read from the game's own constant. */
+  undyed?: Record<string, string>;
+  /** Worn armour-trim sheets generated from the version's armour-trim atlas. */
+  trims: {
+    /** Sprite ids per pattern and material, into this file's own `sprites`. */
+    patterns: Record<string, Record<string, Partial<Record<'inner' | 'outer', string>>>>;
+    /** Material a trim falls back to when it matches the armour it is on. */
+    darker: Record<string, string>;
+  };
+}
+/** `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;
+    /** Biomes in `biomes.json`; `0` means the pack has none and the file is absent. */
+    biomes: number;
+    /** Flat items in `items.json`; `0` means the pack has none and the file is absent. */
+    items: number;
+    /** Entity types in `entities.json`; `0` means the pack has none and the file is absent. */
+    entities: number;
+    /** Distinct entity models in `entity-models.json`; `0` means the file is absent. */
+    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;
+    /** Block and item names in `names.json`; `0` means the file is absent. */
+    names: number;
+    failures: number;
+  };
+  /** sha256 per file, enough to verify a cached copy without refetching it. */
+  hashes: Record<string, string>;
+}
+//#endregion
+//#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;
+  };
+  /** The same, for a method a block's class declares, run on the block its registration made. */
+  tabulateMethod: (registration: Registration, method: MemberReference, 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 block's shape decides how light crosses its faces (`useShapeForLightOcclusion`): stairs,
+   * slabs, snow layers. `true` in every state, or cases of 1 where a state does (a double slab does not).
+   */
+  lightShape?: true | Exclude<BlockPackLight, number>;
+  /**
+   * Light lost passing through the block, where its class answers for itself (`getLightBlock`): 15
+   * for tinted glass, whose faces are see-through. Absent means the game's default rule.
+   */
+  lightBlock?: BlockPackLight;
+  /** The fluid the block holds in every state, as kelp and seagrass are always under water. */
+  fluid?: 'water' | 'lava';
+  /**
+   * The block model renderer draws nothing for it (`RenderShape.INVISIBLE`): a barrier, a light block, a
+   * structure void, and the blocks something else draws, a fluid or an end portal.
+   */
+  invisible?: true;
+  /**
+   * Its class decides whether a face against a neighbour draws (`skipRendering`): glass hides the faces
+   * it shares with glass, although its texture reads as plain cutout.
+   */
+  hidesSharedFaces?: true;
+}
+/**
+ * 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' | 'tabulateMethod'>,
+/** The block's class's overrides, if it can be read: see `block-overrides.ts`. */
+overrides?: {
+  of: (names: readonly string[]) => MemberReference | null;
+  fluid: (method: MemberReference) => 'water' | 'lava' | null;
+  invisible: (method: MemberReference) => boolean;
+} | null): {
+  behaviour: BlockBehaviour;
+  failures: string[];
+} | null;
+//#endregion
+export { ItemPackLayer as $, BlockPackItemsFile as A, BlockPackStatesFile as B, BlockPackBlockState as C, BlockPackEntityModelsFile as D, BlockPackEntitiesFile as E, BlockPackModelsFile as F, EntityPackCube as G, BlockPackTintsFile as H, BlockPackNamesFile as I, EntityPackModel as J, EntityPackCubeFace as K, BlockPackRenderLayer as L, BlockPackLightFile as M, BlockPackMetaFile as N, BlockPackFace as O, BlockPackModel as P, ItemPackEntry as Q, BlockPackSprite as R, BlockPackBiomesFile as S, BlockPackElement as T, BlockPackVariant as U, BlockPackTagsFile as V, EQUIPMENT_SLOTS as W, EquipmentPack as X, EntityPackPart as Y, EquipmentSlot 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, EntityPackEntry 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, BlockPackSpriteFrame as z };