@nodecraft/rendermite 1.7.4 → 1.9.0

package/dist/light-bytecode-DYxb6pJk.js

@@ -0,0 +1,1799 @@
+import { r as parseDescriptor } from "./model-bytecode-VaLUQfGO.js";
+import { n as statedMapColor } from "./block-behaviour-D-SG2Xfp.js";
+//#region src/blocks/light-bytecode.ts
+/**
+* Block light emission, read out of the code that registers blocks.
+*
+* No jar states how bright a torch is. Emission is a property set in Java — `Properties.lightLevel(state
+* -> 14)` in the registry class since 1.16, `lightValue(14)` before it — so the only automatic source
+* is the bytecode, exactly as for entity geometry (see docs/entity-geometry.md). The interpreter here
+* is its own rather than the geometry one because the questions differ: geometry follows a builder
+* vocabulary and abstracts everything else, where this follows *values* — a string naming a block, a
+* `Properties` object carrying its light, and a lambda from a state to a level — through whatever
+* code carries them, and abstracts the rest.
+*
+* Three ideas do the work:
+*
+* - **Taint.** Every object the interpreter cannot see into remembers the strings that went into it.
+*   `ResourceLocation.withDefaultNamespace("torch")`, a 26.x `BlockItemId.create("torch")` and a mod's
+*   `new ResourceLocation(MODID, "glow")` all become a value that knows it is about `torch` or `glow`.
+* - **Registration by shape.** A call whose arguments carry a name *and* a block or its `Properties`
+*   is a registration, whatever it is called and whichever class it is on. That covers vanilla's
+*   `register(String, Block)`, `register(String, Function, Properties)`, `Registry.register(Registry,
+*   ResourceLocation, T)`, and a mod's `DeferredRegister.register(String, Supplier)`, where the
+*   supplier is run to find the block.
+* - **Concrete evaluation.** A light *function* is run once per combination of the blockstate
+*   properties it reads, with real values, so `lit ? 3 * candles : 0` comes out as the eight cases it
+*   is rather than as a guess.
+*
+* Whatever this cannot follow is recorded, never guessed: a block whose registration was not found, or
+* whose light function reads something the interpreter does not model, is a failure entry, not a
+* dark block.
+*/
+/** Whether a call is to one of the block's light methods. */
+function matchesGetter(getter, name, descriptor) {
+	if (getter.name !== name) return false;
+	if (getter.descriptor !== "") return getter.descriptor === descriptor;
+	const shape = parseDescriptor(descriptor);
+	return shape.args.length === 3 && shape.returns === "I";
+}
+/** The light method a block class declares or inherits, resolved to a real descriptor. */
+function findGetter(source, owner, getter) {
+	if (getter.descriptor === "") {
+		const found = findMethodNamed(source, owner, getter.name, 3, "I");
+		return found ? {
+			classFile: found.classFile,
+			descriptor: found.descriptor
+		} : null;
+	}
+	const found = findMethod(source, owner, getter.name, getter.descriptor);
+	return found ? {
+		classFile: found.classFile,
+		descriptor: getter.descriptor
+	} : null;
+}
+const UNKNOWN = { kind: "unknown" };
+const TO_INT_FUNCTION = "Ljava/util/function/ToIntFunction;";
+/** JDK collections a mod fills with the names it registers, modelled as their elements. */
+const LIST_CLASSES = /^java\/util\/(?:ArrayList|LinkedList|HashSet|LinkedHashSet|TreeSet|ArrayDeque|Vector|Stack)$/;
+/** Instructions one root method may spend, every frame it inlines included. */
+const STEP_BUDGET = 4e6;
+/** Instructions one `<clinit>` may spend. Kept apart so a registry's own initialiser cannot starve the root. */
+const CLINIT_BUDGET = 4e5;
+const CLINIT_FRAMES = 8e3;
+/** Instructions a constructor followed for its `super(...)` may spend. */
+const CTOR_BUDGET = 4e4;
+/** Frames one root may open. `Blocks.<clinit>` inlines a few calls per block, for a thousand blocks. */
+const FRAME_BUDGET = 6e4;
+const MAX_DEPTH = 14;
+const MAX_ARRAY = 4096;
+/** Times round a backward jump before a frame gives up on it. */
+const MAX_ITERATIONS = 512;
+const MAX_METHOD_HOPS = 8;
+const STATIC = 8;
+function isTracked(value) {
+	return [
+		"object",
+		"lambda",
+		"state"
+	].includes(value.kind);
+}
+/** Whether a string could be a registry name: a path, or `namespace:path`. */
+function looksLikeId(text) {
+	return /^[a-z0-9_.\-/]+(?::[a-z0-9_.\-/]+)?$/.test(text) && text.length < 128;
+}
+const LOAD_CONSTANT = /* @__PURE__ */ new Set([
+	18,
+	19,
+	20
+]);
+const RETURNS = /* @__PURE__ */ new Set([
+	172,
+	173,
+	174,
+	175,
+	176,
+	177
+]);
+const ARRAY_LOADS = /* @__PURE__ */ new Set([
+	46,
+	47,
+	48,
+	49,
+	50,
+	51,
+	52,
+	53
+]);
+const ARRAY_STORES = /* @__PURE__ */ new Set([
+	79,
+	80,
+	81,
+	82,
+	83,
+	84,
+	85,
+	86
+]);
+const INVOKES = /* @__PURE__ */ new Set([
+	182,
+	183,
+	184,
+	185
+]);
+/** The wide (long/double) opcodes among the constants, loads and arithmetic, for stack bookkeeping. */
+const WIDE_CONSTANTS = /* @__PURE__ */ new Set([
+	9,
+	10,
+	14,
+	15,
+	20
+]);
+/** Java `int` arithmetic: truncate, then wrap to 32 bits. */
+function toInt(value) {
+	return Number.isFinite(value) ? Number(BigInt.asIntN(32, BigInt(Math.trunc(value)))) : 0;
+}
+function compare(op, difference) {
+	switch (op) {
+		case 153:
+		case 159: return difference === 0;
+		case 154:
+		case 160: return difference !== 0;
+		case 155:
+		case 161: return difference < 0;
+		case 156:
+		case 162: return difference >= 0;
+		case 157:
+		case 163: return difference > 0;
+		default: return difference <= 0;
+	}
+}
+/** The method a call names, where the JVM would look: the owner, then its ancestors. */
+function findMethod(source, owner, name, descriptor) {
+	let at = owner;
+	for (let hops = 0; at && hops < MAX_METHOD_HOPS; hops++) {
+		const classFile = source.resolve(at);
+		if (!classFile) return null;
+		const method = classFile.methods.find((candidate) => candidate.name === name && candidate.descriptor === descriptor && candidate.code);
+		if (method?.code) return {
+			code: method.code,
+			classFile,
+			accessFlags: method.accessFlags
+		};
+		at = classFile.superClass ? source.remapClass(classFile.superClass) : null;
+	}
+	return null;
+}
+/** A method by name alone, for a loader extension a mod overrides; the descriptor is the loader's. */
+function findMethodNamed(source, owner, name, argCount, returns) {
+	let at = owner;
+	for (let hops = 0; at && hops < MAX_METHOD_HOPS; hops++) {
+		const classFile = source.resolve(at);
+		if (!classFile) return null;
+		const method = classFile.methods.find((candidate) => {
+			if (candidate.name !== name || !candidate.code) return false;
+			const shape = parseDescriptor(candidate.descriptor);
+			return shape.args.length === argCount && shape.returns === returns;
+		});
+		if (method?.code) return {
+			code: method.code,
+			classFile,
+			descriptor: method.descriptor
+		};
+		at = classFile.superClass ? source.remapClass(classFile.superClass) : null;
+	}
+	return null;
+}
+var Interpreter = class Interpreter {
+	stack = [];
+	locals = /* @__PURE__ */ new Map();
+	loops = /* @__PURE__ */ new Map();
+	/**
+	* Whether a conditional since the last backward jump could not be decided. A loop whose head this
+	* cannot evaluate — `for (Block block : registry)` over an iterator it never saw — would otherwise
+	* fall through its exit test every time round and spin to the iteration cap, and two of them nested
+	* is the whole step budget.
+	*/
+	undecided = false;
+	returned = null;
+	/** The class whose code this frame runs, for saying who made a registration. */
+	caller = null;
+	shared;
+	depth;
+	constructor(shared, depth = 0) {
+		this.shared = shared;
+		this.depth = depth;
+	}
+	handle(type) {
+		return {
+			id: this.shared.nextHandle++,
+			type,
+			strings: [],
+			numbers: [],
+			classes: [],
+			fields: /* @__PURE__ */ new Map(),
+			isProps: type !== null && this.isPropsType(type),
+			light: null,
+			props: null,
+			ctorArgs: null
+		};
+	}
+	isPropsType(name) {
+		const { propsClasses, remapClass } = this.shared.source;
+		return propsClasses.has(name) || propsClasses.has(remapClass(name));
+	}
+	note(message) {
+		if (!this.shared.notes.includes(message)) this.shared.notes.push(message);
+	}
+	pop() {
+		return this.stack.pop() ?? UNKNOWN;
+	}
+	push(value) {
+		if (value) this.stack.push(value);
+	}
+	number(value) {
+		return value.kind === "number" ? value.value : 0;
+	}
+	isWide(value) {
+		return value.kind === "number" && value.wide === true;
+	}
+	/** Puts receiver and arguments where the callee reads them; longs and doubles take two slots. */
+	seed(receiver, descriptor, args) {
+		let slot = 0;
+		if (receiver) this.locals.set(slot++, receiver);
+		for (const [index, shape] of parseDescriptor(descriptor).args.entries()) {
+			this.locals.set(slot, args[index] ?? UNKNOWN);
+			slot += shape === "J" || shape === "D" ? 2 : 1;
+		}
+	}
+	/** Copies the strings, numbers and classes that flowed through the arguments onto a result. */
+	taint(target, values) {
+		for (const value of values) {
+			if (target.strings.length > 64) break;
+			if (value.kind === "string") target.strings.push(value.value);
+			else if (value.kind === "number") target.numbers.push(value.value);
+			else if (value.kind === "class") target.classes.push(value.name);
+			else if (value.kind === "object" && value.handle !== target) {
+				target.strings.push(...value.handle.strings);
+				target.numbers.push(...value.handle.numbers);
+				target.classes.push(...value.handle.classes);
+				if (value.handle.builder) target.strings.push(value.handle.builder.join(""));
+			}
+		}
+	}
+	/** What an opaque call leaves behind, by its return type: nothing, a number, or a tainted object. */
+	opaqueResult(returns, inputs) {
+		if (returns === "V") return null;
+		if (returns.startsWith("L") || returns.startsWith("[")) {
+			if (returns === "Ljava/lang/String;") {
+				const strings = inputs.flatMap((value) => value.kind === "string" ? [value.value] : value.kind === "object" ? value.handle.strings : []);
+				return strings.length > 0 ? {
+					kind: "string",
+					value: strings.at(-1)
+				} : UNKNOWN;
+			}
+			const created = this.handle(returns.startsWith("L") ? returns.slice(1, -1) : null);
+			created.origin = `opaque ${returns} from ${inputs.map((value) => value.kind).join(",")}`;
+			this.taint(created, inputs);
+			if (/(?:List|Set|Collection|Iterable);$/.test(returns)) {
+				const from = inputs.find((value) => value.kind === "array" || value.kind === "object" && value.handle.items);
+				created.items = from?.kind === "array" ? [...from.items] : from?.kind === "object" ? [...from.handle.items ?? []] : inputs.filter((value) => value.kind !== "unknown");
+			}
+			if (returns.endsWith("Map;")) {
+				const source = inputs.find((value) => value.kind === "object" && value.handle.map);
+				if (source?.kind === "object" && source.handle.map) created.map = [...source.handle.map];
+				else if (inputs.length > 0 && inputs.length % 2 === 0 && inputs.every((value) => value.kind !== "unknown")) {
+					created.map = [];
+					for (let index = 0; index < inputs.length; index += 2) created.map.push({
+						key: inputs[index],
+						value: inputs[index + 1]
+					});
+				}
+			}
+			if (created.isProps) {
+				const sources = inputs.filter((value) => value.kind === "object" && (value.handle.isProps || value.handle.props));
+				if (sources.length > 0) {
+					const from = sources[0].handle;
+					created.light = from.isProps ? from.light : from.props?.light ?? null;
+					created.copyOf = from.isProps ? from : from.props;
+				} else if (inputs.some((value) => value.kind === "unknown" || value.kind === "null")) created.light = {
+					kind: "opaque",
+					reason: "properties copied from a block the interpreter could not identify"
+				};
+			}
+			return {
+				kind: "object",
+				handle: created
+			};
+		}
+		return UNKNOWN;
+	}
+	/**
+	* Runs a class's `<clinit>` once, on its own budget and at its own depth.
+	*
+	* A registry class's initialiser is the point of the whole exercise, and a `getstatic` from it
+	* reaches sound types, map colours and — through `BuiltInRegistries` — the entire registry system.
+	* Each gets its own allowance so a sprawling one cannot spend what the block table needs.
+	*
+	* Its own depth, because an initialiser runs once and its results stand for the rest of the run:
+	* `Direction`'s was first reached fourteen frames down inside a codec builder, its `$values()` could
+	* not be followed from there, and every later read of `Direction.values()` was an opaque object.
+	*/
+	initialise(owner) {
+		if (this.shared.initialised.has(owner)) return;
+		this.shared.initialised.add(owner);
+		const target = findMethod(this.shared.source, owner, "<clinit>", "()V");
+		if (!target) return;
+		const saved = {
+			steps: this.shared.steps,
+			frames: this.shared.frames,
+			probe: this.shared.probe
+		};
+		this.shared.steps = CLINIT_BUDGET;
+		this.shared.frames = CLINIT_FRAMES;
+		this.shared.probe = null;
+		try {
+			new Interpreter(this.shared, 0).run(target.code, target.classFile);
+		} finally {
+			if (this.depth === 0) {
+				const key = `${owner}.<clinit>`;
+				this.shared.frameCounts.set(key, (this.shared.frameCounts.get(key) ?? 0) + (CLINIT_BUDGET - this.shared.steps));
+			}
+			this.shared.steps = saved.steps;
+			this.shared.frames = saved.frames;
+			this.shared.probe = saved.probe;
+		}
+	}
+	inline(owner, name, descriptor, receiver, args) {
+		if (this.depth >= MAX_DEPTH || this.shared.frames <= 0) return { ok: false };
+		const target = findMethod(this.shared.source, owner, name, descriptor);
+		if (!target) return { ok: false };
+		this.shared.frames--;
+		const frame = new Interpreter(this.shared, this.depth + 1);
+		frame.seed((target.accessFlags & STATIC) === 0 ? receiver : null, descriptor, args);
+		const before = this.shared.steps;
+		frame.run(target.code, target.classFile);
+		if (this.depth === 0) {
+			const key = `${owner}.${name}${descriptor}`;
+			this.shared.frameCounts.set(key, (this.shared.frameCounts.get(key) ?? 0) + (before - this.shared.steps));
+		}
+		return {
+			ok: true,
+			value: frame.returned
+		};
+	}
+	/** Applies a constructor to a fresh object: records what went in, and follows it for `super(...)`. */
+	construct(created, reference, args) {
+		created.ctorArgs = args;
+		this.taint(created, args);
+		for (const arg of args) if (arg.kind === "object" && arg.handle.isProps) created.props = arg.handle;
+		if (created.type === "java/lang/StringBuilder") {
+			created.builder = args.flatMap((arg) => arg.kind === "string" || arg.kind === "number" ? [arg.value] : []);
+			return;
+		}
+		if (created.type !== null && LIST_CLASSES.test(created.type)) {
+			const from = args.find((arg) => arg.kind === "array" || arg.kind === "object" && arg.handle.items);
+			created.items = from?.kind === "array" ? [...from.items] : from?.kind === "object" ? [...from.handle.items ?? []] : [];
+			return;
+		}
+		if (created.props) return;
+		const saved = this.shared.steps;
+		this.shared.steps = Math.min(saved, CTOR_BUDGET);
+		try {
+			this.inline(reference.owner, reference.name, reference.descriptor, {
+				kind: "object",
+				handle: created
+			}, args);
+		} finally {
+			this.shared.steps = saved - Math.max(0, Math.min(saved, CTOR_BUDGET) - this.shared.steps);
+		}
+	}
+	/**
+	* Runs a lambda with the values it captured followed by the arguments it is called with.
+	*
+	* A method reference to a constructor — `TorchBlock::new` — is a lambda too, and calling it
+	* constructs: which is how a 1.21.2+ factory hands the interpreter the block class.
+	*/
+	invokeLambda(lambda, args) {
+		const reference = this.shared.source.remap({
+			owner: lambda.owner,
+			name: lambda.name,
+			descriptor: lambda.descriptor
+		}, false);
+		const all = [...lambda.captured, ...args];
+		if (reference.name === "<init>") {
+			const created = this.handle(reference.owner);
+			this.construct(created, reference, all);
+			return {
+				kind: "object",
+				handle: created
+			};
+		}
+		const target = findMethod(this.shared.source, reference.owner, reference.name, reference.descriptor);
+		if (!target) return null;
+		const [receiver, ...rest] = all;
+		const result = (target.accessFlags & STATIC) === 0 ? this.inline(reference.owner, reference.name, reference.descriptor, receiver ?? UNKNOWN, rest) : this.inline(reference.owner, reference.name, reference.descriptor, null, all);
+		return result.ok ? result.value : null;
+	}
+	/**
+	* A call whose arguments carry a name and a block (or its properties) is a registration, whatever
+	* it is called. Recorded first-come: a helper that registers on the caller's behalf fires first,
+	* from inside, and the outer call then agrees with it.
+	*/
+	/** Whether a handle is an enum constant, whose name-like strings (`"white"`) name nothing registered. */
+	isEnumConstant(handle) {
+		if (!handle.type || !handle.ctorArgs) return false;
+		const parent = this.shared.source.resolve(handle.type)?.superClass ?? null;
+		return parent === "java/lang/Enum" || parent !== null && this.shared.source.resolve(parent)?.superClass === "java/lang/Enum";
+	}
+	detectRegistration(args, site) {
+		const names = [];
+		for (const arg of args) if (arg.kind === "string") names.push(arg.value);
+		else if (arg.kind === "object" && !arg.handle.props && !arg.handle.isProps && !this.isEnumConstant(arg.handle)) {
+			names.push(...arg.handle.strings);
+			if (arg.handle.builder) names.push(arg.handle.builder.join(""));
+		}
+		const ids = names.filter((name) => looksLikeId(name));
+		if (ids.length === 0) return null;
+		const known = ids.map((name) => this.shared.registrations.get(name)).find((entry) => entry !== void 0);
+		if (known && ids.every((name) => this.shared.registrations.has(name))) return known.block ?? this.blockFor(known);
+		let props = null;
+		let block = null;
+		let blockType = null;
+		for (const arg of args) if (arg.kind === "object" && arg.handle.isProps) props ??= arg.handle;
+		else if (arg.kind === "object" && arg.handle.props) block ??= arg.handle;
+		else if (arg.kind === "lambda" && arg.name === "<init>") blockType ??= this.shared.source.remapClass(arg.owner);
+		if (!props && !block) for (const arg of args) {
+			if (arg.kind !== "lambda") continue;
+			const made = this.invokeLambda(arg, []);
+			if (made?.kind === "object" && made.handle.props) {
+				block = made.handle;
+				break;
+			}
+		}
+		if (!props && !block) return null;
+		const registration = {
+			props: props ?? block?.props ?? null,
+			block,
+			blockType: blockType ?? block?.type ?? null,
+			site,
+			vanilla: this.caller !== null && this.shared.source.isVanillaClass(this.caller)
+		};
+		for (const name of ids) if (!this.shared.registrations.has(name)) this.shared.registrations.set(name, registration);
+		return block ?? this.blockFor(registration);
+	}
+	/**
+	* The block a registration stands for, when the call was handed properties and a factory rather than
+	* a built block. What `Blocks.TORCH` then holds has to carry the properties, or a later
+	* `ofFullCopy(TORCH)` copies nothing.
+	*/
+	blockFor(registration) {
+		if (registration.block) return registration.block;
+		const created = this.handle(registration.blockType);
+		created.props = registration.props;
+		created.ctorArgs = [];
+		registration.block = created;
+		return created;
+	}
+	/** The property a `getValue` names, and the values it can take, from what flowed into its handle. */
+	domainOf(property) {
+		const name = property.strings.find((text) => /^[a-z][a-z0-9_]*$/.test(text));
+		if (!name) {
+			this.note(`property ${property.type ?? "?"} carries no name: strings ${JSON.stringify(property.strings)} origin ${property.origin ?? (property.ctorArgs ? `new with ${property.ctorArgs.map((arg) => arg.kind).join(",")}` : "new, never constructed")} id ${property.id}`);
+			return null;
+		}
+		const probe = this.shared.probe;
+		const known = probe.domains.get(name);
+		if (known) return known;
+		const valueClass = property.classes.find((name) => name !== "java/lang/Boolean" && name !== "java/lang/Integer");
+		let domain;
+		if (valueClass) {
+			const constants = this.enumConstants(this.shared.source.remapClass(valueClass));
+			if (constants.size === 0) {
+				this.note(`enum ${valueClass} for property ${name} yielded no constants`);
+				return null;
+			}
+			domain = {
+				name,
+				values: constants.keys().toArray(),
+				constants
+			};
+		} else if (property.numbers.length >= 2 && !property.classes.includes("java/lang/Boolean")) {
+			const [min, max] = property.numbers;
+			if (max - min > 64) return null;
+			const values = [];
+			for (let value = min; value <= max; value++) values.push(String(value));
+			domain = {
+				name,
+				values
+			};
+		} else domain = {
+			name,
+			values: ["false", "true"]
+		};
+		probe.domains.set(name, domain);
+		return domain;
+	}
+	/**
+	* An enum's constants by serialized name, in ordinal order.
+	*
+	* Each is an object its `<clinit>` constructed with `(name, ordinal, ...)`, and the name a blockstate
+	* writes is a lower-case constructor argument after those — or the constant's own name lowered where
+	* there is none.
+	*/
+	enumConstants(owner) {
+		this.initialise(owner);
+		const constants = [];
+		for (const [key, value] of this.shared.statics) {
+			if (!key.startsWith(`${owner}.`) || value.kind !== "object" || !value.handle.ctorArgs) continue;
+			const type = value.handle.type;
+			if (type === owner || type !== null && this.shared.source.resolve(type)?.superClass === owner) constants.push(value.handle);
+		}
+		constants.sort((left, right) => this.number(left.ctorArgs?.[1] ?? UNKNOWN) - this.number(right.ctorArgs?.[1] ?? UNKNOWN));
+		const byName = /* @__PURE__ */ new Map();
+		for (const constant of constants) {
+			const args = constant.ctorArgs ?? [];
+			const serialized = args.slice(2).find((arg) => arg.kind === "string" && /^[a-z][a-z0-9_]*$/.test(arg.value));
+			const name = serialized?.kind === "string" ? serialized.value : args[0]?.kind === "string" ? args[0].value.toLowerCase() : `#${byName.size}`;
+			byName.set(name, constant);
+		}
+		return byName;
+	}
+	/** `state.getValue(PROPERTY)` against the probe: the assigned value, or the first if none yet. */
+	readProperty(probe, property) {
+		const domain = this.domainOf(property);
+		if (!domain) {
+			probe.failure = `reads a property the interpreter cannot resolve (${property.type ?? "unknown class"})`;
+			return UNKNOWN;
+		}
+		probe.reads.add(domain.name);
+		const value = probe.values.get(domain.name) ?? domain.values[0];
+		if (domain.constants) {
+			const constant = domain.constants.get(value);
+			return constant ? {
+				kind: "object",
+				handle: constant
+			} : UNKNOWN;
+		}
+		if (value === "true" || value === "false") return {
+			kind: "number",
+			value: value === "true" ? 1 : 0
+		};
+		return {
+			kind: "number",
+			value: Number(value)
+		};
+	}
+	/** The handful of JDK calls a light function or a registry can lean on. */
+	jdkCall(reference, receiver, args) {
+		const { owner, name } = reference;
+		const numbers = args.map((arg) => this.number(arg));
+		if (owner === "java/lang/Math") switch (name) {
+			case "max": return {
+				kind: "number",
+				value: Math.max(...numbers)
+			};
+			case "min": return {
+				kind: "number",
+				value: Math.min(...numbers)
+			};
+			case "abs": return {
+				kind: "number",
+				value: Math.abs(numbers[0])
+			};
+			case "floor": return {
+				kind: "number",
+				value: Math.floor(numbers[0]),
+				wide: true
+			};
+			case "ceil": return {
+				kind: "number",
+				value: Math.ceil(numbers[0]),
+				wide: true
+			};
+			case "round": return {
+				kind: "number",
+				value: Math.round(numbers[0])
+			};
+			default: return;
+		}
+		if (/^java\/lang\/(?:Integer|Boolean|Float|Double|Long|Short|Byte|Character)$/.test(owner)) {
+			if (name === "valueOf" && args.length === 1) return args[0];
+			if (receiver && name.endsWith("Value")) return receiver;
+		}
+		if (receiver?.kind === "object" && receiver.handle.builder) {
+			if (name === "append") {
+				const arg = args[0];
+				if (arg?.kind === "string" || arg?.kind === "number") receiver.handle.builder.push(arg.value);
+				else if (arg?.kind === "object") receiver.handle.builder.push(...arg.handle.strings.slice(-1));
+				return receiver;
+			}
+			if (name === "toString") return {
+				kind: "string",
+				value: receiver.handle.builder.join("")
+			};
+		}
+		if (receiver?.kind === "string" && reference.descriptor.endsWith("Ljava/lang/String;")) {
+			if ((name === "replace" || name === "replaceAll") && args.length === 2 && args[0].kind === "string" && args[1].kind === "string") {
+				const replacement = args[1].value;
+				return {
+					kind: "string",
+					value: receiver.value.replaceAll(args[0].value, () => replacement)
+				};
+			}
+			if (name === "concat" && args[0]?.kind === "string") return {
+				kind: "string",
+				value: receiver.value + args[0].value
+			};
+			return receiver;
+		}
+		if (owner === "java/lang/String" && name === "format" && args[0]?.kind === "string") {
+			const operands = args[1]?.kind === "array" ? args[1].items : args.slice(1);
+			let index = 0;
+			let known = true;
+			const text = args[0].value.replaceAll(/%[sd]/g, () => {
+				const value = operands[index++];
+				if (value?.kind === "string" || value?.kind === "number") return String(value.value);
+				known = false;
+				return "";
+			});
+			return known ? {
+				kind: "string",
+				value: text
+			} : UNKNOWN;
+		}
+		if (receiver?.kind === "array" && name === "clone") return {
+			kind: "array",
+			items: [...receiver.items]
+		};
+		if (owner === "java/util/Arrays" && (name === "stream" || name === "asList") || (owner === "java/util/List" || owner === "java/util/Set") && name === "of") return args.length === 1 && args[0].kind === "array" ? args[0] : {
+			kind: "array",
+			items: args
+		};
+		if (receiver?.kind === "object" && receiver.handle.iterator) {
+			const cursor = receiver.handle.iterator;
+			if (name === "hasNext") return {
+				kind: "number",
+				value: cursor.at < cursor.items.length ? 1 : 0
+			};
+			if (name === "next") return cursor.items[cursor.at++] ?? UNKNOWN;
+		}
+		if (receiver?.kind === "object" && receiver.handle.items && !receiver.handle.isProps) {
+			const items = receiver.handle.items;
+			if (name === "add" && args.length === 1) {
+				items.push(args[0]);
+				return {
+					kind: "number",
+					value: 1
+				};
+			}
+			if (name === "addAll" && args.length === 1) {
+				const more = args[0].kind === "array" ? args[0].items : args[0].kind === "object" ? args[0].handle.items ?? [] : [];
+				items.push(...more);
+				return {
+					kind: "number",
+					value: 1
+				};
+			}
+			if (name === "get" && args.length === 1 && args[0].kind === "number") return items[args[0].value] ?? UNKNOWN;
+			if (name === "size" || name === "isEmpty") return {
+				kind: "number",
+				value: name === "size" ? items.length : items.length === 0 ? 1 : 0
+			};
+			if (name === "iterator") {
+				const created = this.handle("java/util/Iterator");
+				created.iterator = {
+					items,
+					at: 0
+				};
+				return {
+					kind: "object",
+					handle: created
+				};
+			}
+			if ([
+				"stream",
+				"toArray",
+				"toList",
+				"values",
+				"keySet"
+			].includes(name)) return {
+				kind: "array",
+				items: [...items]
+			};
+			if (name === "forEach" && args[0]?.kind === "lambda") {
+				for (const item of items) this.invokeLambda(args[0], [item]);
+				return null;
+			}
+		}
+		if (receiver?.kind === "array") {
+			if ([
+				"stream",
+				"toList",
+				"collect",
+				"sorted",
+				"distinct"
+			].includes(name)) return receiver;
+			if (name === "iterator") {
+				const created = this.handle("java/util/Iterator");
+				created.iterator = {
+					items: receiver.items,
+					at: 0
+				};
+				return {
+					kind: "object",
+					handle: created
+				};
+			}
+			if (name === "forEach" && args[0]?.kind === "lambda") {
+				for (const item of receiver.items) this.invokeLambda(args[0], [item]);
+				return null;
+			}
+			if (name === "map" && args[0]?.kind === "lambda") return {
+				kind: "array",
+				items: receiver.items.map((item) => this.invokeLambda(args[0], [item]) ?? UNKNOWN)
+			};
+			if (name === "filter" && args[0]?.kind === "lambda") return {
+				kind: "array",
+				items: receiver.items.filter((item) => {
+					const verdict = this.invokeLambda(args[0], [item]);
+					return verdict?.kind === "number" ? verdict.value !== 0 : true;
+				})
+			};
+			if ([
+				"anyMatch",
+				"allMatch",
+				"noneMatch"
+			].includes(name) && args[0]?.kind === "lambda") {
+				const predicate = args[0];
+				const results = receiver.items.map((item) => this.invokeLambda(predicate, [item]));
+				if (results.some((result) => result?.kind !== "number")) return UNKNOWN;
+				const hits = results.filter((result) => result?.kind === "number" && result.value !== 0).length;
+				let value = hits === 0;
+				if (name === "anyMatch") value = hits > 0;
+				else if (name === "allMatch") value = hits === receiver.items.length;
+				return {
+					kind: "number",
+					value: value ? 1 : 0
+				};
+			}
+			if (name === "count" || name === "size") return {
+				kind: "number",
+				value: receiver.items.length,
+				wide: name === "count"
+			};
+		}
+	}
+	/**
+	* A map the code fills and reads back, kept as its entries.
+	*
+	* `MultifaceBlock` decides whether glow lichen has any face through `PROPERTY_BY_DIRECTION.get(d)`,
+	* a map its initialiser filled from `Direction` to property. Keys compare as the JVM would: an enum
+	* constant is the same object, a string or number the same value.
+	*/
+	mapCall(target, name, args) {
+		const same = (left, right) => left.kind === "object" && right.kind === "object" ? left.handle === right.handle : (left.kind === "string" || left.kind === "number") && left.kind === right.kind && left.value === right.value;
+		target.map ??= [];
+		if (name === "put" && args.length === 2) {
+			const existing = target.map.find((entry) => same(entry.key, args[0]));
+			if (existing) existing.value = args[1];
+			else target.map.push({
+				key: args[0],
+				value: args[1]
+			});
+			return UNKNOWN;
+		}
+		if ((name === "get" || name === "getOrDefault") && args.length > 0) return target.map.find((entry) => same(entry.key, args[0]))?.value ?? args[1] ?? UNKNOWN;
+		if (name === "containsKey" && args.length === 1) return {
+			kind: "number",
+			value: target.map.some((entry) => same(entry.key, args[0])) ? 1 : 0
+		};
+	}
+	call(reference, hasReceiver, special = false) {
+		const remapped = this.shared.source.remap(reference, false);
+		const { args: shapes, returns } = parseDescriptor(remapped.descriptor);
+		const args = [];
+		for (let index = 0; index < shapes.length; index++) args.unshift(this.pop());
+		const receiver = hasReceiver ? this.pop() : null;
+		const { source } = this.shared;
+		if (receiver?.kind === "lambda") {
+			const result = this.invokeLambda(receiver, args);
+			this.push(returns === "V" ? null : result ?? UNKNOWN);
+			return;
+		}
+		if (receiver?.kind === "state") {
+			const probe = receiver.probe;
+			if ((args.length === 1 || args.length === 2) && args[0].kind === "object" && !args[0].handle.isProps) {
+				if (returns === "Z") {
+					this.push({
+						kind: "number",
+						value: 1
+					});
+					return;
+				}
+				this.push(this.readProperty(probe, args[0].handle));
+				return;
+			}
+			probe.failure ??= `calls ${remapped.owner}.${remapped.name}${remapped.descriptor} on the state with (${args.map((arg) => arg.kind === "object" ? `object ${arg.handle.type ?? "?"}` : arg.kind).join(", ")}), which the interpreter does not model`;
+			this.push(this.opaqueResult(returns, args));
+			return;
+		}
+		if (receiver?.kind === "object" && remapped.owner.endsWith("Map") && !receiver.handle.isProps) {
+			const handled = this.mapCall(receiver.handle, remapped.name, args);
+			if (handled !== void 0) {
+				this.push(returns === "V" ? null : handled);
+				return;
+			}
+		}
+		if (remapped.owner.startsWith("java/") || receiver?.kind === "string" || receiver?.kind === "number" || receiver?.kind === "array" || receiver?.kind === "object" && (receiver.handle.builder || receiver.handle.items || receiver.handle.iterator)) {
+			const handled = this.jdkCall(remapped, receiver, args);
+			if (handled !== void 0) {
+				this.push(returns === "V" ? null : handled);
+				return;
+			}
+			if (receiver?.kind === "number" && args.length === 0) {
+				this.push(returns === "V" ? null : receiver);
+				return;
+			}
+			if (remapped.owner.startsWith("java/")) {
+				this.push(this.opaqueResult(returns, receiver ? [receiver, ...args] : args));
+				return;
+			}
+		}
+		const registered = this.detectRegistration(args, `${remapped.owner}.${remapped.name}${remapped.descriptor}`);
+		if (registered) {
+			this.push(returns === "V" ? null : returns.startsWith("L") ? {
+				kind: "object",
+				handle: registered
+			} : UNKNOWN);
+			return;
+		}
+		if (receiver?.kind === "object") {
+			const target = receiver.handle;
+			const named = source.nameOf?.(reference, false) ?? remapped.name;
+			if (target.props && args.length === 0 && (named === "defaultMapColor" || named === "defaultMaterialColor")) {
+				const colour = statedMapColor(target.props);
+				if (colour && colour.kind !== "lambda") {
+					this.push(colour);
+					return;
+				}
+			}
+			const getter = source.lightGetters.find((candidate) => matchesGetter(candidate, remapped.name, remapped.descriptor));
+			if (getter && target.props && args[0]?.kind === "state") {
+				const found = findGetter(source, target.type ?? remapped.owner, getter);
+				if (!(found !== null && found.classFile.thisClass !== getter.root && !special)) {
+					const light = target.props.light;
+					let answer = UNKNOWN;
+					if (light === null) answer = {
+						kind: "number",
+						value: 0
+					};
+					else if (light.kind === "constant") answer = {
+						kind: "number",
+						value: light.level
+					};
+					else if (light.kind === "function") answer = this.invokeLambda(light.fn, [args[0]]) ?? UNKNOWN;
+					this.push(answer);
+					return;
+				}
+			}
+			if (target.isProps) {
+				if (shapes.length === 1 && shapes[0] === TO_INT_FUNCTION) {
+					const fn = args[0];
+					target.light = fn.kind === "lambda" ? {
+						kind: "function",
+						fn
+					} : {
+						kind: "opaque",
+						reason: "light function is a value the interpreter did not build"
+					};
+					this.push(returns === "V" ? null : receiver);
+					return;
+				}
+				if (shapes.length === 1 && shapes[0] === "I" && this.isPropsType(returns.slice(1, -1))) {
+					target.light = args[0].kind === "number" ? {
+						kind: "constant",
+						level: args[0].value
+					} : {
+						kind: "opaque",
+						reason: "light level is a value the interpreter did not compute"
+					};
+					this.push(receiver);
+					return;
+				}
+				if (returns.startsWith("L") && this.isPropsType(returns.slice(1, -1))) {
+					const name = source.nameOf?.(reference, false) ?? remapped.name;
+					(target.calls ??= []).push({
+						name: name === reference.name ? remapped.name : name,
+						descriptor: remapped.descriptor,
+						args
+					});
+					this.push(receiver);
+					return;
+				}
+			}
+			if (target.ctorArgs && args.length === 0 && (remapped.name === "ordinal" || remapped.name === "name")) {
+				this.push(target.ctorArgs[remapped.name === "ordinal" ? 1 : 0] ?? UNKNOWN);
+				return;
+			}
+		}
+		const returnsProps = returns.startsWith("L") && this.isPropsType(returns.slice(1, -1));
+		if (returnsProps && !hasReceiver && args.some((arg) => arg.kind === "object" && (arg.handle.isProps || arg.handle.props))) {
+			this.push(this.opaqueResult(returns, args));
+			return;
+		}
+		const helper = !hasReceiver && !args.some((arg) => arg.kind === "unknown") && (returns.startsWith("L") && !returns.startsWith("Ljava/") && source.resolve(returns.slice(1, -1)) !== null || returns.startsWith("[L") && source.resolve(remapped.owner) !== null || args.length > 0 && args.every((arg) => arg.kind === "number") && !returns.startsWith("L") && !returns.startsWith("["));
+		if (receiver?.kind === "object" || args.some((arg) => isTracked(arg)) || returnsProps || returns === TO_INT_FUNCTION || helper) {
+			const inlined = this.inline(remapped.owner, remapped.name, remapped.descriptor, receiver, args);
+			if (inlined.ok) {
+				this.push(returns === "V" ? null : inlined.value ?? this.opaqueResult(returns, receiver ? [receiver, ...args] : args));
+				return;
+			}
+		}
+		this.push(this.opaqueResult(returns, receiver ? [receiver, ...args] : args));
+	}
+	/** Runs one method's code. Returns false when it stopped early. */
+	run(code, constants) {
+		this.caller = constants.thisClass;
+		let at = 0;
+		let wide = false;
+		while (at < code.length) {
+			if (this.shared.steps-- <= 0) return false;
+			const op = code[at++];
+			switch (true) {
+				case op === 0: break;
+				case op === 1:
+					this.push({ kind: "null" });
+					break;
+				case op >= 2 && op <= 8:
+					this.push({
+						kind: "number",
+						value: op - 3
+					});
+					break;
+				case WIDE_CONSTANTS.has(op) && op !== 20:
+					this.push({
+						kind: "number",
+						value: op === 10 || op === 15 ? 1 : 0,
+						wide: true
+					});
+					break;
+				case op >= 11 && op <= 13:
+					this.push({
+						kind: "number",
+						value: op - 11
+					});
+					break;
+				case op === 16:
+					this.push({
+						kind: "number",
+						value: code[at++] << 24 >> 24
+					});
+					break;
+				case op === 17:
+					this.push({
+						kind: "number",
+						value: (code[at] << 8 | code[at + 1]) << 16 >> 16
+					});
+					at += 2;
+					break;
+				case LOAD_CONSTANT.has(op): {
+					let index;
+					if (op === 18) index = code[at++];
+					else {
+						index = code[at] << 8 | code[at + 1];
+						at += 2;
+					}
+					if (constants.constants[index]?.tag === "class") {
+						this.push({
+							kind: "class",
+							name: constants.utf8(index)
+						});
+						break;
+					}
+					const value = constants.literal(index);
+					if (typeof value === "string") this.push({
+						kind: "string",
+						value
+					});
+					else if (typeof value === "number") this.push({
+						kind: "number",
+						value,
+						wide: op === 20
+					});
+					else if (typeof value === "bigint") this.push({
+						kind: "number",
+						value: Number(value),
+						wide: true
+					});
+					else this.push(UNKNOWN);
+					break;
+				}
+				case op >= 21 && op <= 25: {
+					const index = wide ? code[at] << 8 | code[at + 1] : code[at];
+					at += wide ? 2 : 1;
+					wide = false;
+					this.push(this.locals.get(index) ?? UNKNOWN);
+					break;
+				}
+				case op >= 26 && op <= 45:
+					this.push(this.locals.get((op - 26) % 4) ?? UNKNOWN);
+					break;
+				case op >= 54 && op <= 58: {
+					const index = wide ? code[at] << 8 | code[at + 1] : code[at];
+					at += wide ? 2 : 1;
+					wide = false;
+					this.locals.set(index, this.pop());
+					break;
+				}
+				case op >= 59 && op <= 78:
+					this.locals.set((op - 59) % 4, this.pop());
+					break;
+				case ARRAY_LOADS.has(op): {
+					const index = this.pop();
+					const array = this.pop();
+					const position = index.kind === "number" ? index.value : -1;
+					this.push(array.kind === "array" ? array.items[position] ?? UNKNOWN : UNKNOWN);
+					break;
+				}
+				case ARRAY_STORES.has(op): {
+					const value = this.pop();
+					const index = this.pop();
+					const array = this.pop();
+					if (array.kind === "array" && index.kind === "number" && index.value >= 0 && index.value < MAX_ARRAY) array.items[index.value] = value;
+					break;
+				}
+				case op === 87:
+					this.pop();
+					break;
+				case op === 88:
+					if (!this.isWide(this.pop())) this.pop();
+					break;
+				case op === 89: {
+					const top = this.pop();
+					this.push(top);
+					this.push(top);
+					break;
+				}
+				case op === 90: {
+					const top = this.pop();
+					const under = this.pop();
+					this.push(top);
+					this.push(under);
+					this.push(top);
+					break;
+				}
+				case op === 91: {
+					const top = this.pop();
+					const second = this.pop();
+					if (this.isWide(second)) this.push(top);
+					else {
+						const third = this.pop();
+						this.push(top);
+						this.push(third);
+					}
+					this.push(second);
+					this.push(top);
+					break;
+				}
+				case op === 92: {
+					const top = this.pop();
+					if (this.isWide(top)) this.push(top);
+					else {
+						const second = this.pop();
+						this.push(second);
+						this.push(top);
+						this.push(second);
+					}
+					this.push(top);
+					break;
+				}
+				case op === 93: {
+					const top = this.pop();
+					const second = this.pop();
+					if (this.isWide(top)) this.push(top);
+					else {
+						const third = this.pop();
+						this.push(second);
+						this.push(top);
+						this.push(third);
+					}
+					this.push(second);
+					this.push(top);
+					break;
+				}
+				case op === 94: {
+					const top = this.pop();
+					const second = this.pop();
+					if (this.isWide(top)) {
+						if (this.isWide(second)) this.push(top);
+						else {
+							const third = this.pop();
+							this.push(top);
+							this.push(third);
+						}
+					} else {
+						const third = this.pop();
+						if (this.isWide(third)) {
+							this.push(second);
+							this.push(top);
+						} else {
+							const fourth = this.pop();
+							this.push(second);
+							this.push(top);
+							this.push(fourth);
+						}
+						this.push(third);
+					}
+					this.push(second);
+					this.push(top);
+					break;
+				}
+				case op === 95: {
+					const top = this.pop();
+					const under = this.pop();
+					this.push(top);
+					this.push(under);
+					break;
+				}
+				case op >= 96 && op <= 111: {
+					const right = this.number(this.pop());
+					const left = this.number(this.pop());
+					const which = Math.floor((op - 96) / 4);
+					const type = (op - 96) % 4;
+					const integral = type <= 1;
+					let value;
+					switch (which) {
+						case 0:
+							value = left + right;
+							break;
+						case 1:
+							value = left - right;
+							break;
+						case 2:
+							value = left * right;
+							break;
+						default: value = integral ? right === 0 ? 0 : Math.trunc(left / right) : left / right;
+					}
+					if (type === 0) value = toInt(value);
+					this.push({
+						kind: "number",
+						value,
+						wide: type === 1 || type === 3
+					});
+					break;
+				}
+				case op >= 112 && op <= 115: {
+					const right = this.number(this.pop());
+					const left = this.number(this.pop());
+					const type = op - 112;
+					this.push({
+						kind: "number",
+						value: right === 0 ? 0 : left % right,
+						wide: type === 1 || type === 3
+					});
+					break;
+				}
+				case op >= 116 && op <= 119: {
+					const type = op - 116;
+					this.push({
+						kind: "number",
+						value: -this.number(this.pop()),
+						wide: type === 1 || type === 3
+					});
+					break;
+				}
+				case op >= 120 && op <= 131: {
+					const right = this.number(this.pop());
+					const left = this.number(this.pop());
+					const isLong = (op - 120) % 2 === 1;
+					let value;
+					switch (op) {
+						case 120:
+						case 121:
+							value = isLong ? left * 2 ** (right & 63) : left << (right & 31);
+							break;
+						case 122:
+						case 123:
+							value = isLong ? Math.floor(left / 2 ** (right & 63)) : left >> (right & 31);
+							break;
+						case 124:
+						case 125:
+							value = isLong ? Math.floor(left / 2 ** (right & 63)) : left >>> (right & 31);
+							break;
+						case 126:
+						case 127:
+							value = Number(BigInt(toInt(left)) & BigInt(toInt(right)));
+							break;
+						case 128:
+						case 129:
+							value = Number(BigInt(toInt(left)) | BigInt(toInt(right)));
+							break;
+						default: value = Number(BigInt(toInt(left)) ^ BigInt(toInt(right)));
+					}
+					this.push({
+						kind: "number",
+						value,
+						wide: isLong
+					});
+					break;
+				}
+				case op === 132: {
+					const slot = wide ? code[at] << 8 | code[at + 1] : code[at];
+					const step = wide ? (code[at + 2] << 8 | code[at + 3]) << 16 >> 16 : code[at + 1] << 24 >> 24;
+					at += wide ? 4 : 2;
+					wide = false;
+					this.locals.set(slot, {
+						kind: "number",
+						value: this.number(this.locals.get(slot) ?? UNKNOWN) + step
+					});
+					break;
+				}
+				case op >= 133 && op <= 147: {
+					const value = this.pop();
+					if (value.kind !== "number") {
+						this.push(UNKNOWN);
+						break;
+					}
+					let result = value.value;
+					let isWide = false;
+					switch (op) {
+						case 133:
+						case 143:
+							isWide = true;
+							break;
+						case 135:
+						case 138:
+						case 141:
+							isWide = true;
+							break;
+						case 136:
+						case 139:
+						case 142:
+							result = toInt(result);
+							break;
+						case 145:
+							result = toInt(result) << 24 >> 24;
+							break;
+						case 146:
+							result = toInt(result) & 65535;
+							break;
+						case 147: result = toInt(result) << 16 >> 16;
+					}
+					this.push({
+						kind: "number",
+						value: result,
+						wide: isWide
+					});
+					break;
+				}
+				case op >= 148 && op <= 152: {
+					const right = this.pop();
+					const left = this.pop();
+					if (left.kind !== "number" || right.kind !== "number") {
+						this.push(UNKNOWN);
+						break;
+					}
+					this.push({
+						kind: "number",
+						value: Math.sign(left.value - right.value)
+					});
+					break;
+				}
+				case op >= 153 && op <= 166: {
+					const twoOperands = op >= 159;
+					const right = this.pop();
+					const left = twoOperands ? this.pop() : {
+						kind: "number",
+						value: 0
+					};
+					const offset = (code[at] << 8 | code[at + 1]) << 16 >> 16;
+					at += 2;
+					let decided = null;
+					if (op >= 165) {
+						let same = false;
+						if (left.kind === "object" && right.kind === "object") same = left.handle === right.handle;
+						else if (left.kind === "null" && right.kind === "null") same = true;
+						else if (left.kind === "unknown" || right.kind === "unknown") same = null;
+						if (same !== null) decided = op === 165 ? same : !same;
+					} else if (left.kind === "number" && right.kind === "number") decided = compare(op, twoOperands ? left.value - right.value : right.value);
+					if (decided === null) {
+						this.undecided = true;
+						if (this.shared.probe) this.shared.probe.failure ??= "branches on a value the interpreter could not compute";
+						break;
+					}
+					if (decided) at += offset - 3;
+					break;
+				}
+				case op === 198 || op === 199: {
+					const value = this.pop();
+					const offset = (code[at] << 8 | code[at + 1]) << 16 >> 16;
+					at += 2;
+					if (value.kind === "unknown") {
+						this.undecided = true;
+						break;
+					}
+					const isNull = value.kind === "null";
+					if (op === 198 ? isNull : !isNull) at += offset - 3;
+					break;
+				}
+				case op === 167 || op === 200: {
+					const offset = op === 167 ? (code[at] << 8 | code[at + 1]) << 16 >> 16 : code[at] << 24 | code[at + 1] << 16 | code[at + 2] << 8 | code[at + 3];
+					const size = op === 167 ? 3 : 5;
+					at += size - 1;
+					if (offset > 0) {
+						at += offset - size;
+						break;
+					}
+					const site = at - size;
+					const round = (this.loops.get(site) ?? 0) + 1;
+					this.loops.set(site, round);
+					if (this.undecided) {
+						this.undecided = false;
+						break;
+					}
+					if (round > MAX_ITERATIONS) {
+						this.note(`a loop at ${site} went round more than ${MAX_ITERATIONS} times`);
+						break;
+					}
+					at += offset - size;
+					break;
+				}
+				case op === 170 || op === 171: {
+					const start = at - 1;
+					let cursor = at;
+					while ((cursor & 3) !== 0) cursor++;
+					const int32 = (position) => code[position] << 24 | code[position + 1] << 16 | code[position + 2] << 8 | code[position + 3];
+					const fallback = int32(cursor);
+					cursor += 4;
+					const key = this.pop();
+					let target = fallback;
+					if (op === 170) {
+						const low = int32(cursor);
+						const high = int32(cursor + 4);
+						cursor += 8;
+						if (key.kind === "number" && key.value >= low && key.value <= high) target = int32(cursor + (key.value - low) * 4);
+						cursor += (high - low + 1) * 4;
+					} else {
+						const pairs = int32(cursor);
+						cursor += 4;
+						for (let pair = 0; pair < pairs; pair++) {
+							const match = int32(cursor);
+							if (key.kind === "number" && key.value === match) target = int32(cursor + 4);
+							cursor += 8;
+						}
+					}
+					if (key.kind !== "number") {
+						this.undecided = true;
+						if (this.shared.probe) this.shared.probe.failure ??= "switches on a value the interpreter could not compute";
+						at = cursor;
+						break;
+					}
+					at = start + target;
+					break;
+				}
+				case RETURNS.has(op):
+					if (op !== 177) this.returned = this.pop();
+					return true;
+				case op === 178: {
+					const index = code[at] << 8 | code[at + 1];
+					at += 2;
+					const raw = constants.reference(index);
+					if (!raw) {
+						this.push(UNKNOWN);
+						break;
+					}
+					const reference = this.shared.source.remap(raw, true);
+					if (reference.owner === "java/lang/Boolean" && (reference.name === "TRUE" || reference.name === "FALSE")) {
+						this.push({
+							kind: "number",
+							value: reference.name === "TRUE" ? 1 : 0
+						});
+						break;
+					}
+					const key = `${reference.owner}.${reference.name}`;
+					if (!this.shared.statics.has(key)) this.initialise(reference.owner);
+					this.push(this.shared.statics.get(key) ?? UNKNOWN);
+					break;
+				}
+				case op === 179: {
+					const index = code[at] << 8 | code[at + 1];
+					at += 2;
+					const value = this.pop();
+					const raw = constants.reference(index);
+					if (raw) {
+						const reference = this.shared.source.remap(raw, true);
+						this.shared.statics.set(`${reference.owner}.${reference.name}`, value);
+					}
+					break;
+				}
+				case op === 180: {
+					const index = code[at] << 8 | code[at + 1];
+					at += 2;
+					const target = this.pop();
+					const reference = constants.reference(index);
+					this.push(target.kind === "object" && reference ? target.handle.fields.get(reference.name) ?? UNKNOWN : UNKNOWN);
+					break;
+				}
+				case op === 181: {
+					const index = code[at] << 8 | code[at + 1];
+					at += 2;
+					const value = this.pop();
+					const target = this.pop();
+					const reference = constants.reference(index);
+					if (target.kind === "object" && reference) {
+						target.handle.fields.set(reference.name, value);
+						const mapped = this.shared.source.nameOf?.(reference, true) ?? reference.name;
+						if (mapped !== reference.name) target.handle.fields.set(`mapped:${mapped}`, value);
+						if (value.kind === "object" && value.handle.isProps) target.handle.props = value.handle;
+					}
+					break;
+				}
+				case INVOKES.has(op): {
+					const index = code[at] << 8 | code[at + 1];
+					at += op === 185 ? 4 : 2;
+					const reference = constants.reference(index);
+					if (!reference) break;
+					if (op === 183 && reference.name === "<init>") {
+						const remapped = this.shared.source.remap(reference, false);
+						const { args: shapes } = parseDescriptor(remapped.descriptor);
+						const args = [];
+						for (let count = 0; count < shapes.length; count++) args.unshift(this.pop());
+						const objectRef = this.pop();
+						if (objectRef.kind === "object") {
+							if (objectRef.handle.ctorArgs === null) this.construct(objectRef.handle, remapped, args);
+							else {
+								this.taint(objectRef.handle, args);
+								for (const arg of args) if (arg.kind === "object" && arg.handle.isProps) objectRef.handle.props = arg.handle;
+								this.inline(remapped.owner, remapped.name, remapped.descriptor, objectRef, args);
+							}
+						}
+						break;
+					}
+					this.call(reference, op !== 184, op === 183);
+					break;
+				}
+				case op === 187: {
+					const index = code[at] << 8 | code[at + 1];
+					at += 2;
+					const type = this.shared.source.remapClass(constants.utf8(index));
+					this.push({
+						kind: "object",
+						handle: this.handle(type)
+					});
+					break;
+				}
+				case op === 188 || op === 189: {
+					at += op === 188 ? 1 : 2;
+					const length = this.pop();
+					const size = length.kind === "number" ? Math.min(Math.max(length.value, 0), MAX_ARRAY) : 0;
+					this.push({
+						kind: "array",
+						items: Array.from({ length: size }, () => UNKNOWN)
+					});
+					break;
+				}
+				case op === 197: {
+					at += 2;
+					const dimensions = code[at++];
+					for (let count = 0; count < dimensions; count++) this.pop();
+					this.push({
+						kind: "array",
+						items: []
+					});
+					break;
+				}
+				case op === 190: {
+					const array = this.pop();
+					this.push(array.kind === "array" ? {
+						kind: "number",
+						value: array.items.length
+					} : UNKNOWN);
+					break;
+				}
+				case op === 191: return true;
+				case op === 192:
+					at += 2;
+					break;
+				case op === 193:
+					at += 2;
+					this.pop();
+					this.push(UNKNOWN);
+					break;
+				case op === 194 || op === 195:
+					this.pop();
+					break;
+				case op === 196:
+					wide = true;
+					break;
+				case op === 186: {
+					const index = code[at] << 8 | code[at + 1];
+					at += 4;
+					const site = constants.invokeDynamic(index);
+					const { args: shapes, returns } = site ? parseDescriptor(site.descriptor) : {
+						args: [],
+						returns: "V"
+					};
+					const captured = [];
+					for (let count = 0; count < shapes.length; count++) captured.unshift(this.pop());
+					const row = constants.bootstrap(index);
+					if (row?.factory?.name === "makeConcatWithConstants") {
+						const recipe = row.args.find((argument) => typeof argument === "string") ?? "";
+						let operand = 0;
+						let known = true;
+						const text = recipe.replaceAll("
", () => {
+							const value = captured[operand++];
+							if (value?.kind === "string" || value?.kind === "number") return String(value.value);
+							if (value?.kind === "object" && value.handle.strings.length > 0) return value.handle.strings.at(-1);
+							known = false;
+							return "";
+						});
+						this.push(known ? {
+							kind: "string",
+							value: text
+						} : UNKNOWN);
+						break;
+					}
+					const target = constants.lambdaTarget(index);
+					this.push(returns === "V" ? null : target ? {
+						kind: "lambda",
+						...target,
+						captured
+					} : UNKNOWN);
+					break;
+				}
+				default:
+					this.note(`unsupported opcode 0x${op.toString(16)} at ${at - 1}`);
+					return false;
+			}
+		}
+		return true;
+	}
+	/** Runs a method as a root: unknown arguments, a fresh receiver for an instance method. */
+	runRoot(method, classFile) {
+		const receiver = (method.accessFlags & STATIC) === 0 ? {
+			kind: "object",
+			handle: this.handle(classFile.thisClass)
+		} : null;
+		this.seed(receiver, method.descriptor, []);
+		try {
+			if (!this.run(method.code, classFile) && (this.shared.steps <= 0 || this.shared.frames <= 0)) {
+				const busiest = this.shared.frameCounts.entries().toArray().toSorted((left, right) => right[1] - left[1]).slice(0, 6).map(([key, count]) => `${key} ${count} steps`).join(", ");
+				this.note(`${classFile.thisClass}.${method.name} ran past the ${this.shared.steps <= 0 ? "step" : "frame"} budget; busiest: ${busiest}`);
+			}
+		} catch (err) {
+			this.note(`${classFile.thisClass}: ${err.message}`);
+		}
+	}
+	/** Runs a function of a block state against one state; null where the interpreter lost the value. */
+	evaluateLambda(fn, probe) {
+		this.shared.probe = probe;
+		this.shared.steps = STEP_BUDGET;
+		this.shared.frames = FRAME_BUDGET;
+		try {
+			const result = this.invokeLambda(fn, [{
+				kind: "state",
+				probe
+			}]);
+			return probe.failure ? null : result;
+		} finally {
+			this.shared.probe = null;
+		}
+	}
+	/** Evaluates a light spec against one state; null where the interpreter lost the value. */
+	evaluate(spec, probe) {
+		this.shared.probe = probe;
+		this.shared.steps = STEP_BUDGET;
+		this.shared.frames = FRAME_BUDGET;
+		try {
+			const state = {
+				kind: "state",
+				probe
+			};
+			let result;
+			if (spec.kind === "function") result = this.invokeLambda(spec.fn, [state]);
+			else if (spec.kind === "method") {
+				const method = findMethod(this.shared.source, spec.owner, spec.getter.name, spec.getter.descriptor);
+				if (!method) return null;
+				const receiver = spec.receiver ? {
+					kind: "object",
+					handle: spec.receiver
+				} : {
+					kind: "object",
+					handle: this.handle(spec.owner)
+				};
+				const extra = parseDescriptor(spec.getter.descriptor).args.length - 1;
+				const inlined = this.inline(method.classFile.thisClass, spec.getter.name, spec.getter.descriptor, receiver, [state, ...Array.from({ length: extra }, () => UNKNOWN)]);
+				result = inlined.ok ? inlined.value : null;
+			} else return spec.kind === "constant" ? spec.level : null;
+			if (probe.failure || result?.kind !== "number" || !Number.isFinite(result.value)) return null;
+			return Math.max(0, Math.min(15, Math.round(result.value)));
+		} finally {
+			this.shared.probe = null;
+		}
+	}
+};
+/** All combinations of the given properties' values, as assignments. */
+function combinations(domains) {
+	let out = [/* @__PURE__ */ new Map()];
+	for (const domain of domains) {
+		const next = [];
+		for (const partial of out) for (const value of domain.values) next.push(new Map([...partial, [domain.name, value]]));
+		out = next;
+	}
+	return out;
+}
+/** The largest state table a light function may need; anything bigger is not a real block. */
+const MAX_STATES = 4096;
+/**
+* Folds a table of (assignment → level) into the pack's shape: a number when every state agrees,
+* otherwise the commonest level as the default and the rest as cases, each stripped of the properties
+* that do not change its answer.
+*/
+function foldCases(table, properties) {
+	if (new Set(table.map((row) => row.level)).size === 1) return table[0].level;
+	const counts = /* @__PURE__ */ new Map();
+	for (const row of table) counts.set(row.level, (counts.get(row.level) ?? 0) + 1);
+	const fallback = [...counts].toSorted((left, right) => right[1] - left[1] || left[0] - right[0])[0][0];
+	const key = (values, keep) => keep.map((name) => `${name}=${values.get(name)}`).join(",");
+	const cases = /* @__PURE__ */ new Map();
+	for (const row of table) {
+		if (row.level === fallback) continue;
+		let keep = [...properties];
+		for (const name of properties) {
+			const without = keep.filter((other) => other !== name);
+			if (table.filter((other) => key(other.values, without) === key(row.values, without)).every((other) => other.level === row.level)) keep = without;
+		}
+		const when = {};
+		const kept = properties.filter((name) => keep.includes(name)).toSorted((left, right) => left.localeCompare(right));
+		for (const name of kept) when[name] = row.values.get(name);
+		cases.set(key(row.values, keep), {
+			when,
+			level: row.level
+		});
+	}
+	const order = (left, right) => {
+		for (const name of properties) {
+			const [leftValue, rightValue] = [left[name] ?? "", right[name] ?? ""];
+			const difference = leftValue !== "" && rightValue !== "" && !Number.isNaN(Number(leftValue)) && !Number.isNaN(Number(rightValue)) ? Number(leftValue) - Number(rightValue) : leftValue.localeCompare(rightValue);
+			if (difference !== 0) return difference;
+		}
+		return 0;
+	};
+	return {
+		default: fallback,
+		cases: cases.values().toArray().toSorted((left, right) => order(left.when, right.when))
+	};
+}
+/**
+* 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.
+*/
+function extractBlockLight(roots, source) {
+	const shared = {
+		source,
+		statics: /* @__PURE__ */ new Map(),
+		initialised: /* @__PURE__ */ new Set(),
+		registrations: /* @__PURE__ */ new Map(),
+		steps: STEP_BUDGET,
+		frames: FRAME_BUDGET,
+		notes: [],
+		nextHandle: 1,
+		probe: null,
+		frameCounts: /* @__PURE__ */ new Map()
+	};
+	for (const classFile of roots) {
+		shared.initialised.add(classFile.thisClass);
+		const methods = classFile.methods.filter((method) => method.code).toSorted((left, right) => Number(right.name === "<clinit>") - Number(left.name === "<clinit>"));
+		for (const method of methods) {
+			shared.steps = STEP_BUDGET;
+			shared.frames = FRAME_BUDGET;
+			shared.frameCounts.clear();
+			new Interpreter(shared).runRoot(method, classFile);
+		}
+	}
+	/**
+	* The registration for a block: under its full id, or its bare path when the code that made it is the
+	* block's own side — the game's for `minecraft:`, a mod's for anything else.
+	*/
+	const registrationOf = (blockId) => {
+		const colon = blockId.indexOf(":");
+		const namespace = colon === -1 ? "minecraft" : blockId.slice(0, colon);
+		const path = colon === -1 ? blockId : blockId.slice(colon + 1);
+		const byPath = shared.registrations.get(path);
+		const wantVanilla = namespace === "minecraft";
+		return shared.registrations.get(blockId) ?? (byPath && byPath.vanilla === wantVanilla ? byPath : null);
+	};
+	const lightOf = (blockId) => {
+		const registration = registrationOf(blockId);
+		if (!registration) return { failure: "no registration found in the code; light unknown" };
+		let spec = registration.props?.light ?? null;
+		if (registration.blockType) for (const getter of source.lightGetters) {
+			const found = findGetter(source, registration.blockType, getter);
+			if (found && found.classFile.thisClass !== getter.root) {
+				spec = {
+					kind: "method",
+					owner: registration.blockType,
+					getter: {
+						...getter,
+						descriptor: found.descriptor
+					},
+					receiver: registration.block
+				};
+				break;
+			}
+		}
+		if (spec === null) {
+			if (registration.props === null) return { failure: `registered without a recognisable properties builder (at ${registration.site}); light unknown` };
+			return { light: 0 };
+		}
+		if (spec.kind === "constant") return { light: Math.max(0, Math.min(15, Math.round(spec.level))) };
+		if (spec.kind === "opaque") return { failure: `light could not be read: ${spec.reason}` };
+		const evaluator = new Interpreter(shared);
+		const folded = tabulateStates(shared, (probe) => evaluator.evaluate(spec, probe), "light function");
+		return "failure" in folded ? folded : { light: folded.value };
+	};
+	const tabulate = (fn, read) => {
+		const evaluator = new Interpreter(shared);
+		return tabulateStates(shared, (probe) => {
+			const value = evaluator.evaluateLambda(fn, probe);
+			return value === null ? null : read(value);
+		}, "state function");
+	};
+	const describe = (blockId) => {
+		const registration = registrationOf(blockId);
+		if (!registration) return `${blockId}: not registered`;
+		const light = registration.props?.light;
+		return `${blockId}: registered at ${registration.site}; class ${registration.blockType ?? "?"}, properties ${registration.props ? `#${registration.props.id}` : "none"}, light ${light ? light.kind === "function" ? `function ${light.fn.owner}.${light.fn.name}${light.fn.descriptor}` : JSON.stringify(light) : "unset"}`;
+	};
+	return {
+		registrations: shared.registrations,
+		notes: shared.notes,
+		lightOf,
+		registrationOf,
+		tabulate,
+		describe
+	};
+}
+/**
+* Runs `evaluate` over every combination of the properties it turns out to read, discovering them as
+* it goes: the first round runs with none, and each round adds whatever the last one read.
+*/
+function tabulateStates(shared, evaluate, what) {
+	const domains = /* @__PURE__ */ new Map();
+	let properties = [];
+	for (let rounds = 0; rounds < 8; rounds++) {
+		const table = [];
+		const discovered = /* @__PURE__ */ new Set();
+		const assignments = combinations(properties.map((name) => domains.get(name)));
+		if (assignments.length > MAX_STATES) return { failure: `${what} depends on ${assignments.length} states; too many to be a real block` };
+		for (const values of assignments) {
+			const probe = {
+				values,
+				domains,
+				reads: /* @__PURE__ */ new Set(),
+				failure: null
+			};
+			const before = shared.notes.length;
+			const level = evaluate(probe);
+			if (level === null) {
+				const detail = shared.notes.slice(before).join("; ");
+				return { failure: `${what} ${probe.failure ?? "did not return a number"}${detail ? ` (${detail})` : ""}` };
+			}
+			table.push({
+				values,
+				level
+			});
+			for (const read of probe.reads) if (!properties.includes(read)) discovered.add(read);
+		}
+		if (discovered.size === 0) return { value: foldCases(table, properties) };
+		properties = [...properties, ...discovered];
+	}
+	return { failure: `${what} reads more properties than a blockstate can have` };
+}
+//#endregion
+export { extractBlockLight as t };