@moku-labs/game 0.5.0 → 0.7.0

package/dist/project.mjs

@@ -0,0 +1,3113 @@
+import { createBrandConsole } from "@moku-labs/common/cli";
+import { readFile, readdir, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { watch } from "node:fs";
+//#region src/project/extract/scope.ts
+/**
+* Unwraps the expressions that change no value: parentheses, `as`, `satisfies`, `!` and `<T>`.
+*
+* @param typescript - The TypeScript module.
+* @param node - An expression.
+* @returns The expression inside.
+*/
+function unwrap(typescript, node) {
+	let inner = node;
+	while (typescript.isParenthesizedExpression(inner) || typescript.isAsExpression(inner) || typescript.isSatisfiesExpression(inner) || typescript.isNonNullExpression(inner) || typescript.isTypeAssertionExpression(inner)) inner = inner.expression;
+	return inner;
+}
+/**
+* The text of a property name written literally: an identifier, a string or a number.
+*
+* @param typescript - The TypeScript module.
+* @param name - A property name.
+* @returns The text, or `undefined` for a computed or a private name.
+*/
+function literalNameOf(typescript, name) {
+	return typescript.isIdentifier(name) || typescript.isStringLiteral(name) || typescript.isNumericLiteral(name) ? name.text : void 0;
+}
+/**
+* The name of a property-like node, when it is written literally: a property, a shorthand, a
+* method or an accessor.
+*
+* @param typescript - The TypeScript module.
+* @param node - Any node.
+* @returns The name, or `undefined` for a spread, a computed name or a node without a name.
+*/
+function propertyNameOf(typescript, node) {
+	return typescript.isPropertyAssignment(node) || typescript.isShorthandPropertyAssignment(node) || typescript.isMethodDeclaration(node) || typescript.isGetAccessorDeclaration(node) || typescript.isSetAccessorDeclaration(node) ? literalNameOf(typescript, node.name) : void 0;
+}
+/**
+* Whether a node holds statements: a block, a source file, a module block or a case clause.
+*
+* @param node - A node.
+* @returns True when it has a `statements` list.
+*/
+function holdsStatements(node) {
+	return "statements" in node && Array.isArray(node.statements);
+}
+/**
+* Whether a node is a function whose parameters a name can be.
+*
+* @param typescript - The TypeScript module.
+* @param node - A node.
+* @returns True for function declarations, expressions, arrows and methods.
+*/
+function isFunctionScope(typescript, node) {
+	return typescript.isFunctionDeclaration(node) || typescript.isFunctionExpression(node) || typescript.isArrowFunction(node) || typescript.isMethodDeclaration(node);
+}
+/**
+* The meaning of a `const` declarator: a function when its initializer is one.
+*
+* @param typescript - The TypeScript module.
+* @param initializer - The initializer of the const.
+* @returns The meaning.
+*/
+function constMeaning(typescript, initializer) {
+	const inner = unwrap(typescript, initializer);
+	return typescript.isArrowFunction(inner) || typescript.isFunctionExpression(inner) ? {
+		kind: "function",
+		node: inner
+	} : {
+		kind: "const",
+		initializer
+	};
+}
+/**
+* Looks for a name among the statements of one block.
+*
+* @param typescript - The TypeScript module.
+* @param holder - The block.
+* @param name - The name.
+* @returns What the name means there, or `undefined`.
+*/
+function declaredIn(typescript, holder, name) {
+	for (const statement of holder.statements) {
+		if (typescript.isFunctionDeclaration(statement) && statement.name?.text === name) return {
+			kind: "function",
+			node: statement
+		};
+		if (!typescript.isVariableStatement(statement)) continue;
+		const isConst = (statement.declarationList.flags & typescript.NodeFlags.Const) !== 0;
+		const declaration = statement.declarationList.declarations.find((item) => typescript.isIdentifier(item.name) && item.name.text === name);
+		if (isConst && declaration?.initializer !== void 0) return constMeaning(typescript, declaration.initializer);
+	}
+}
+/**
+* Looks for a name among the names of a destructured parameter (`({ id }) => …`).
+*
+* @param typescript - The TypeScript module.
+* @param pattern - The destructure.
+* @param name - The name.
+* @returns The parameter meaning with the property it takes, or `undefined`.
+*/
+function destructuredIn(typescript, pattern, name) {
+	for (const element of pattern.elements) {
+		if (!(typescript.isBindingElement(element) && typescript.isIdentifier(element.name) && element.name.text === name)) continue;
+		const property = element.propertyName;
+		return {
+			kind: "param",
+			property: property !== void 0 && typescript.isIdentifier(property) ? property.text : name
+		};
+	}
+}
+/**
+* Looks for a name among the parameters of one function: a plain parameter, or a property of a
+* destructured one.
+*
+* @param typescript - The TypeScript module.
+* @param scope - The function.
+* @param name - The name.
+* @returns The parameter meaning, or `undefined`.
+*/
+function parameterIn(typescript, scope, name) {
+	for (const parameter of scope.parameters) {
+		const binding = parameter.name;
+		if (typescript.isIdentifier(binding) && binding.text === name) return { kind: "param" };
+		if (typescript.isIdentifier(binding)) continue;
+		const meaning = destructuredIn(typescript, binding, name);
+		if (meaning !== void 0) return meaning;
+	}
+}
+/**
+* Says what a name means at the place it is used, walking up from there.
+*
+* @param typescript - The TypeScript module.
+* @param identifier - The name where it is used.
+* @returns What it means, or `undefined` when the file does not declare it.
+*/
+function meaningOf(typescript, identifier) {
+	const name = identifier.text;
+	for (let node = identifier.parent; node !== void 0; node = node.parent) {
+		const parameter = isFunctionScope(typescript, node) ? parameterIn(typescript, node, name) : void 0;
+		if (parameter !== void 0) return parameter;
+		const declared = holdsStatements(node) ? declaredIn(typescript, node, name) : void 0;
+		if (declared !== void 0) return declared;
+	}
+}
+/**
+* The statement directly under the file that a node sits in.
+*
+* @param typescript - The TypeScript module.
+* @param node - Any node.
+* @returns The statement, or the file itself for the file.
+*/
+function topStatementOf(typescript, node) {
+	let statement = node;
+	while (statement.parent !== void 0 && !typescript.isSourceFile(statement.parent)) statement = statement.parent;
+	return statement;
+}
+/**
+* The name of the top-level declaration a node sits in: the function, class or first const of
+* the statement directly under the file.
+*
+* @param typescript - The TypeScript module.
+* @param node - Any node.
+* @returns The declared name, or `undefined` for a statement that declares none.
+*/
+function enclosingName(typescript, node) {
+	const statement = topStatementOf(typescript, node);
+	if (typescript.isFunctionDeclaration(statement) || typescript.isClassDeclaration(statement)) return statement.name?.text;
+	if (!typescript.isVariableStatement(statement)) return void 0;
+	const [first] = statement.declarationList.declarations;
+	return first !== void 0 && typescript.isIdentifier(first.name) ? first.name.text : void 0;
+}
+/**
+* The function a const declarator holds, through parentheses, `as` and `satisfies`.
+*
+* @param typescript - The TypeScript module.
+* @param declaration - The declarator.
+* @returns The arrow or function expression, or `undefined` for any other value.
+*/
+function functionValueOf(typescript, declaration) {
+	const value = declaration.initializer === void 0 ? void 0 : unwrap(typescript, declaration.initializer);
+	return value !== void 0 && (typescript.isArrowFunction(value) || typescript.isFunctionExpression(value)) ? value : void 0;
+}
+/**
+* The functions one module-level statement declares: a named function with a body, or the
+* consts whose value is an arrow or a function expression. An overload signature, a `let`, a
+* `var` and a const of any other value declare none.
+*
+* @param typescript - The TypeScript module.
+* @param statement - A statement directly under the file.
+* @returns The functions, in source order.
+*/
+function declaredFunctions(typescript, statement) {
+	if (typescript.isFunctionDeclaration(statement)) {
+		const name = statement.name?.text;
+		return name !== void 0 && statement.body !== void 0 ? [{
+			name,
+			node: statement
+		}] : [];
+	}
+	if (!typescript.isVariableStatement(statement)) return [];
+	if ((statement.declarationList.flags & typescript.NodeFlags.Const) === 0) return [];
+	return statement.declarationList.declarations.flatMap((declaration) => {
+		const node = functionValueOf(typescript, declaration);
+		if (node === void 0 || !typescript.isIdentifier(declaration.name)) return [];
+		return [{
+			name: declaration.name.text,
+			node
+		}];
+	});
+}
+/**
+* The module-level function a node sits in, at any depth: a named function declaration, or a
+* const whose value is a function. A node in a class, an object const or a statement that
+* declares no function has none.
+*
+* @param typescript - The TypeScript module.
+* @param node - Any node.
+* @returns The name of the function, or `undefined`.
+*/
+function enclosingFunction(typescript, node) {
+	return declaredFunctions(typescript, topStatementOf(typescript, node)).find((item) => item.node.pos <= node.pos && node.end <= item.node.end)?.name;
+}
+/**
+* The name of the object property whose value an expression is: `disc` for the call in
+* `{ disc: defineStyle(…) }`, through parentheses, `as` and `satisfies`.
+*
+* @param typescript - The TypeScript module.
+* @param node - An expression.
+* @returns The property name when it is written literally; `undefined` for anything else.
+*/
+function propertyOfValue(typescript, node) {
+	let outer = node;
+	while (typescript.isExpression(outer.parent) && unwrap(typescript, outer.parent) === node) outer = outer.parent;
+	const holder = outer.parent;
+	if (!typescript.isPropertyAssignment(holder) || holder.initializer !== outer) return void 0;
+	return literalNameOf(typescript, holder.name);
+}
+/**
+* A hole filled at run time by a key-carrying prop of the component: `{id}`, `{amountKey}`. The
+* regex is global, so `.test` keeps `lastIndex` between calls: test a pattern with `hasHole`, never
+* `HOLE.test`.
+*/
+const HOLE = /\{\w+\}/g;
+/** A key-carrying prop: `id`, or a name that ends in `Key`. */
+const KEY_PROP = /^(?:id|\w+Key)$/;
+/** How deep names and calls are followed before a hole is given up on. */
+const MAX_DEPTH = 8;
+/**
+* The hole a prop of a component leaves in a key.
+*
+* @param property - The name of the prop.
+* @returns The hole: `{amountKey}` for `amountKey`.
+* @example
+* ```ts
+* holeOf("amountKey"); // "{amountKey}"
+* ```
+*/
+function holeOf(property) {
+	return `{${property}}`;
+}
+/**
+* Whether a pattern holds a hole a prop fills.
+*
+* @param pattern - A pattern or a key.
+* @returns True when it holds `{id}`, `{amountKey}` or another prop hole.
+* @example
+* ```ts
+* hasHole("{id}Close"); // true
+* ```
+*/
+function hasHole(pattern) {
+	return pattern.search(HOLE) !== -1;
+}
+/**
+* The hole a prop of a parameter object leaves: its own hole for a key-carrying prop, `*` else.
+*
+* @param property - The name of the prop, when the parameter is read through one.
+* @returns The hole.
+* @example
+* ```ts
+* propertyHole("tab"); // "*"
+* ```
+*/
+function propertyHole(property) {
+	return property !== void 0 && KEY_PROP.test(property) ? holeOf(property) : "*";
+}
+/**
+* The one expression a function returns, when it has exactly one.
+*
+* @param typescript - The TypeScript module.
+* @param node - The function.
+* @returns The returned expression, or `undefined`.
+*/
+function returnedBy(typescript, node) {
+	const body = node.body;
+	if (body === void 0) return void 0;
+	if (!typescript.isBlock(body)) return body;
+	const returns = [];
+	const collect = (child) => {
+		if (typescript.isReturnStatement(child)) returns.push(child);
+		if (!typescript.isFunctionLike(child)) typescript.forEachChild(child, collect);
+	};
+	typescript.forEachChild(body, collect);
+	return returns.length === 1 ? returns[0]?.expression : void 0;
+}
+/**
+* Reads a name: a bound parameter, a const, or a destructured key-carrying prop.
+*
+* @param typescript - The TypeScript module.
+* @param identifier - The name.
+* @param bindings - The parameters bound by the call being read.
+* @param depth - How deep the reading is.
+* @returns The pattern.
+*/
+function readName(typescript, identifier, bindings, depth) {
+	const bound = bindings.get(identifier.text);
+	if (bound !== void 0) return bound;
+	const meaning = meaningOf(typescript, identifier);
+	if (meaning?.kind === "const") return read(typescript, meaning.initializer, bindings, depth + 1);
+	if (meaning?.kind === "param") return propertyHole(meaning.property);
+	return "*";
+}
+/**
+* Reads `props.id` or `props.amountKey`: a key-carrying prop of a parameter object becomes its
+* hole, any other prop `*`.
+*
+* @param typescript - The TypeScript module.
+* @param access - The property access.
+* @param bindings - The parameters bound by the call being read.
+* @returns The pattern.
+*/
+function readAccess(typescript, access, bindings) {
+	const owner = access.expression;
+	return typescript.isIdentifier(owner) && !bindings.has(owner.text) && meaningOf(typescript, owner)?.kind === "param" ? propertyHole(access.name.text) : "*";
+}
+/**
+* Reads a call of a same-file function: its one returned expression, with each parameter bound
+* to the pattern of its argument.
+*
+* @param typescript - The TypeScript module.
+* @param call - The call.
+* @param bindings - The parameters bound by the call being read.
+* @param depth - How deep the reading is.
+* @returns The pattern.
+*/
+function readCall$1(typescript, call, bindings, depth) {
+	const callee = call.expression;
+	const meaning = typescript.isIdentifier(callee) ? meaningOf(typescript, callee) : void 0;
+	if (meaning?.kind !== "function") return "*";
+	const returned = returnedBy(typescript, meaning.node);
+	if (returned === void 0) return "*";
+	const inner = /* @__PURE__ */ new Map();
+	for (const [index, parameter] of meaning.node.parameters.entries()) {
+		const argument = call.arguments[index];
+		if (!typescript.isIdentifier(parameter.name)) continue;
+		inner.set(parameter.name.text, argument === void 0 ? "*" : read(typescript, argument, bindings, depth + 1));
+	}
+	return read(typescript, returned, inner, depth + 1);
+}
+/**
+* Reads a template: its literal parts stay, each span is read into a pattern.
+*
+* @param typescript - The TypeScript module.
+* @param template - The template expression.
+* @param bindings - The parameters bound by the call being read.
+* @param depth - How deep the reading is.
+* @returns The pattern.
+*/
+function readTemplate(typescript, template, bindings, depth) {
+	const spans = template.templateSpans.map((span) => read(typescript, span.expression, bindings, depth + 1) + span.literal.text);
+	return template.head.text + spans.join("");
+}
+/**
+* Reads one expression into a pattern.
+*
+* @param typescript - The TypeScript module.
+* @param node - The expression.
+* @param bindings - The parameters bound by the call being read.
+* @param depth - How deep the reading is.
+* @returns The pattern, holes not yet merged.
+*/
+function read(typescript, node, bindings, depth) {
+	const expression = unwrap(typescript, node);
+	if (depth > MAX_DEPTH) return "*";
+	if (typescript.isStringLiteralLike(expression) || typescript.isNumericLiteral(expression)) return expression.text;
+	if (typescript.isTemplateExpression(expression)) return readTemplate(typescript, expression, bindings, depth);
+	if (typescript.isBinaryExpression(expression) && expression.operatorToken.kind === typescript.SyntaxKind.PlusToken) return read(typescript, expression.left, bindings, depth + 1) + read(typescript, expression.right, bindings, depth + 1);
+	if (typescript.isIdentifier(expression)) return readName(typescript, expression, bindings, depth);
+	if (typescript.isPropertyAccessExpression(expression)) return readAccess(typescript, expression, bindings);
+	if (typescript.isCallExpression(expression)) return readCall$1(typescript, expression, bindings, depth);
+	return "*";
+}
+/**
+* Reduces a key expression to its pattern, with neighbouring `*` holes merged into one.
+*
+* @param typescript - The TypeScript module.
+* @param expression - The expression of a JSX `key` attribute.
+* @returns The pattern: `card*Picture`, `{id}Close`, `{amountKey}`, `hudRow`, or `*` when nothing
+* is literal.
+*/
+function patternOf(typescript, expression) {
+	return read(typescript, expression, /* @__PURE__ */ new Map(), 0).replaceAll(/\*+/g, "*");
+}
+/**
+* The literal head of a pattern: the text before its first hole.
+*
+* @param pattern - A pattern.
+* @returns The head, empty when the pattern starts with a hole.
+* @example
+* ```ts
+* stemOf("card*Picture"); // "card"
+* ```
+*/
+function stemOf(pattern) {
+	const holes = [pattern.indexOf("*"), pattern.search(HOLE)].filter((at) => at >= 0);
+	return pattern.slice(0, holes.length === 0 ? void 0 : Math.min(...holes));
+}
+//#endregion
+//#region src/project/extract/jsx.ts
+/** The longest key expression an unresolved reason quotes. */
+const QUOTE_LENGTH = 60;
+/** A component tag: its name starts upper-case. */
+const COMPONENT_TAG = /^[A-Z]/;
+/**
+* The expression a JSX attribute holds: the string of `key="x"` or the code of `key={x}`.
+*
+* @param typescript - The TypeScript module.
+* @param attribute - The attribute.
+* @returns The expression, or `undefined` for `<a key />` and `key={}`.
+*/
+function attributeValue(typescript, attribute) {
+	const initializer = attribute.initializer;
+	if (initializer === void 0) return void 0;
+	if (typescript.isStringLiteral(initializer)) return initializer;
+	if (typescript.isJsxExpression(initializer)) return initializer.expression;
+}
+/**
+* How a key expression is written.
+*
+* @param typescript - The TypeScript module.
+* @param expression - The key expression.
+* @returns `literal` for a string, `template` for a template with holes, `ident` for the rest.
+*/
+function kindOf$1(typescript, expression) {
+	const inner = unwrap(typescript, expression);
+	if (typescript.isStringLiteralLike(inner)) return "literal";
+	return typescript.isTemplateExpression(inner) ? "template" : "ident";
+}
+/**
+* The upper-case top-level declaration a node sits in: the component a `{prop}` pattern belongs to.
+*
+* @param typescript - The TypeScript module.
+* @param node - The attribute.
+* @returns The component name, or `undefined` inside a lower-case helper.
+*/
+function componentAround(typescript, node) {
+	const name = enclosingName(typescript, node);
+	return name !== void 0 && COMPONENT_TAG.test(name) ? name : void 0;
+}
+/**
+* Quotes a key expression for an unresolved reason: one line, cut to a readable length.
+*
+* @param text - The expression as written.
+* @returns The quote.
+* @example
+* ```ts
+* quoteOf("card.key"); // "card.key"
+* ```
+*/
+function quoteOf(text) {
+	const line = text.replaceAll(/\s+/g, " ");
+	return line.length > QUOTE_LENGTH ? `${line.slice(0, QUOTE_LENGTH)}…` : line;
+}
+/**
+* The hit of a `key` attribute.
+*
+* @param typescript - The TypeScript module.
+* @param attribute - The attribute.
+* @param place - The element and its tag.
+* @param place.element - The whole element.
+* @param place.tag - The tag as written.
+* @returns The hit, or `undefined` for a key without a value.
+*/
+function keyHit(typescript, attribute, place) {
+	const expression = attributeValue(typescript, attribute);
+	if (expression === void 0) return void 0;
+	const kind = kindOf$1(typescript, expression);
+	const key = patternOf(typescript, expression);
+	const stem = kind === "literal" ? "" : stemOf(key);
+	const component = hasHole(key) ? componentAround(typescript, attribute) : void 0;
+	const written = quoteOf(expression.getText());
+	return {
+		key,
+		kind,
+		attribute,
+		...place,
+		written,
+		...stem === "" ? {} : { stem },
+		...component === void 0 ? {} : { component }
+	};
+}
+/**
+* The hit of a literal key-carrying prop on a component: `id="settingsBoard"`,
+* `amountKey="giftReward"`.
+*
+* @param typescript - The TypeScript module.
+* @param attribute - The attribute.
+* @param property - The name of the attribute.
+* @param place - The element and its tag.
+* @param place.element - The whole element.
+* @param place.tag - The tag as written.
+* @returns The hit, or `undefined` when the value is not a string literal.
+*/
+function idHit(typescript, attribute, property, place) {
+	const expression = attributeValue(typescript, attribute);
+	const value = expression === void 0 ? void 0 : unwrap(typescript, expression);
+	if (value === void 0 || !typescript.isStringLiteralLike(value)) return void 0;
+	return {
+		key: value.text,
+		kind: "idProp",
+		component: place.tag,
+		prop: property,
+		attribute,
+		...place,
+		written: value.text
+	};
+}
+/**
+* The hits of the attributes of one opening or self-closing element.
+*
+* @param typescript - The TypeScript module.
+* @param opening - The opening or self-closing element.
+* @returns Its hits.
+*/
+function hitsOf(typescript, opening) {
+	const place = {
+		element: typescript.isJsxOpeningElement(opening) ? opening.parent : opening,
+		tag: opening.tagName.getText()
+	};
+	const isComponent = COMPONENT_TAG.test(place.tag);
+	const hits = [];
+	for (const attribute of opening.attributes.properties) {
+		if (!typescript.isJsxAttribute(attribute) || !typescript.isIdentifier(attribute.name)) continue;
+		const name = attribute.name.text;
+		const keyEntry = name === "key" ? keyHit(typescript, attribute, place) : void 0;
+		const idEntry = isComponent && KEY_PROP.test(name) ? idHit(typescript, attribute, name, place) : void 0;
+		if (keyEntry !== void 0) hits.push(keyEntry);
+		if (idEntry !== void 0) hits.push(idEntry);
+	}
+	return hits;
+}
+/**
+* Collects every JSX key of a file, in source order.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parsed file.
+* @returns The hits; a key that reads `*` is among them.
+*/
+function collectJsx(typescript, source) {
+	const hits = [];
+	const visit = (node) => {
+		if (typescript.isJsxOpeningElement(node) || typescript.isJsxSelfClosingElement(node)) hits.push(...hitsOf(typescript, node));
+		typescript.forEachChild(node, visit);
+	};
+	if (source.languageVariant === typescript.LanguageVariant.JSX) visit(source);
+	return hits;
+}
+/**
+* Whether a hit holds nothing literal: its key reads `*` alone.
+*
+* @param hit - A hit.
+* @returns True for a key nothing in the file can read.
+*/
+function isOpaque(hit) {
+	return hit.key === "*";
+}
+/**
+* The anchor of a hit.
+*
+* @param file - The root-relative path of the file.
+* @param hit - The hit.
+* @returns The anchor: path, key, kind, and the stem, component and prop when there are.
+*/
+function anchorOfHit(file, hit) {
+	return {
+		path: file,
+		key: hit.key,
+		kind: hit.kind,
+		...hit.stem === void 0 ? {} : { stem: hit.stem },
+		...hit.component === void 0 ? {} : { component: hit.component },
+		...hit.prop === void 0 ? {} : { prop: hit.prop }
+	};
+}
+/**
+* The unresolved reason of a key that reads `*`.
+*
+* @param hit - The hit.
+* @returns The reason: `JSX key "card.key" on <row> resolves to "*"`.
+*/
+function opaqueReason(hit) {
+	return `JSX key "${hit.written}" on <${hit.tag}> resolves to "*"`;
+}
+//#endregion
+//#region src/project/extract/components.ts
+/** The prefix of a component key. */
+const COMPONENT = "component:";
+/** The extension of the files whose plain functions can be components. */
+const JSX_FILE = ".tsx";
+/**
+* Reads the plain components of a file: the module-level upper-case functions of a `.tsx` file.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parsed file.
+* @param path - The root-relative path of the file.
+* @returns One `component:<Name>` definition per component, bound to its name, in source order.
+*/
+function readComponents(typescript, source, path) {
+	if (!path.endsWith(JSX_FILE)) return [];
+	return source.statements.flatMap((statement) => declaredFunctions(typescript, statement).map((item) => item.name)).filter((name) => COMPONENT_TAG.test(name)).map((binding) => ({
+		key: `${COMPONENT}${binding}`,
+		anchor: {
+			path,
+			binding
+		}
+	}));
+}
+/**
+* The component name a tag renders: an upper-case identifier, or the last segment of a member
+* or namespaced tag. A lower-case identifier is an element of the engine, not a component.
+*
+* @param typescript - The TypeScript module.
+* @param tag - The tag name of an element.
+* @returns The name, or `undefined` for an element of the engine and for `this`.
+*/
+function renderedName(typescript, tag) {
+	if (typescript.isIdentifier(tag)) return COMPONENT_TAG.test(tag.text) ? tag.text : void 0;
+	if (typescript.isPropertyAccessExpression(tag) || typescript.isJsxNamespacedName(tag)) return tag.name.text;
+}
+/**
+* The component names a file renders, each once.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parsed file.
+* @returns The names, sorted; none for a file without JSX.
+*/
+function renderedOf(typescript, source) {
+	const names = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		const name = typescript.isJsxOpeningElement(node) || typescript.isJsxSelfClosingElement(node) ? renderedName(typescript, node.tagName) : void 0;
+		if (name !== void 0) names.add(name);
+		typescript.forEachChild(node, visit);
+	};
+	if (source.languageVariant === typescript.LanguageVariant.JSX) visit(source);
+	return [...names].toSorted();
+}
+/** The definers whose calls make keys. */
+const DEFINERS = [
+	"defineFlow",
+	"defineFeature",
+	"defineScene",
+	"projection",
+	"defineEmitter",
+	"defineTextStyles",
+	"defineStyle",
+	"defineComponent"
+];
+/**
+* Whether a name is a definer whose calls make keys.
+*
+* @param name - A name.
+* @returns True for the definers of `DEFINERS`.
+* @example
+* ```ts
+* isDefiner("defineScene"); // true
+* ```
+*/
+function isDefiner(name) {
+	return DEFINERS.includes(name);
+}
+/**
+* Whether a statement carries a modifier.
+*
+* @param typescript - The TypeScript module.
+* @param node - The statement.
+* @param kind - `ExportKeyword` or `DefaultKeyword`.
+* @returns True when the modifier is there.
+*/
+function hasModifier(typescript, node, kind) {
+	if (!typescript.canHaveModifiers(node)) return false;
+	return typescript.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false;
+}
+/**
+* The names a binding declares: the identifier, or every name of a destructure.
+*
+* @param typescript - The TypeScript module.
+* @param name - The binding name.
+* @returns The declared names.
+*/
+function namesOf(typescript, name) {
+	if (typescript.isIdentifier(name)) return [name.text];
+	return name.elements.flatMap((element) => typescript.isBindingElement(element) ? namesOf(typescript, element.name) : []);
+}
+/**
+* Records the value imports of one import statement.
+*
+* @param typescript - The TypeScript module.
+* @param statement - The import statement.
+* @param draft - The facts so far.
+*/
+function readImport(typescript, statement, draft) {
+	const clause = statement.importClause;
+	if (clause === void 0 || clause.isTypeOnly) return;
+	if (!typescript.isStringLiteral(statement.moduleSpecifier)) return;
+	const specifier = statement.moduleSpecifier.text;
+	const bindings = clause.namedBindings;
+	if (clause.name !== void 0) draft.imports.set(clause.name.text, {
+		specifier,
+		imported: "default"
+	});
+	if (bindings === void 0) return;
+	if (typescript.isNamespaceImport(bindings)) {
+		draft.imports.set(bindings.name.text, {
+			specifier,
+			imported: "*"
+		});
+		return;
+	}
+	for (const element of bindings.elements) {
+		if (element.isTypeOnly) continue;
+		const imported = element.propertyName?.text ?? element.name.text;
+		draft.imports.set(element.name.text, {
+			specifier,
+			imported
+		});
+	}
+}
+/**
+* Records one export statement: a re-export from another module, a star, or a list of local
+* bindings.
+*
+* @param typescript - The TypeScript module.
+* @param statement - The export statement.
+* @param draft - The facts so far.
+*/
+function readExport(typescript, statement, draft) {
+	const source = statement.moduleSpecifier;
+	const specifier = source !== void 0 && typescript.isStringLiteral(source) ? source.text : "";
+	const clause = statement.exportClause;
+	if (statement.isTypeOnly) return;
+	if (clause === void 0) {
+		if (specifier !== "") draft.stars.push(specifier);
+		return;
+	}
+	if (typescript.isNamespaceExport(clause)) {
+		draft.exports.set(clause.name.text, {
+			specifier,
+			imported: "*"
+		});
+		return;
+	}
+	for (const element of clause.elements) {
+		if (element.isTypeOnly) continue;
+		const inner = element.propertyName?.text ?? element.name.text;
+		const target = specifier === "" ? { local: inner } : {
+			specifier,
+			imported: inner
+		};
+		draft.exports.set(element.name.text, target);
+	}
+}
+/**
+* Whether an import brings a name of the engine package.
+*
+* @param ref - The import, if any.
+* @param name - The name taken from the package, `*` for a namespace.
+* @returns True for that import of `@moku-labs/game`.
+* @example
+* ```ts
+* isGameImport({ specifier: "@moku-labs/game", imported: "defineGame" }, "defineGame"); // true
+* ```
+*/
+function isGameImport(ref, name) {
+	return ref?.specifier === "@moku-labs/game" && ref.imported === name;
+}
+/**
+* Whether an expression calls `defineGame` of the engine: by a named import, renamed or not, or
+* through a namespace import of the package.
+*
+* @param typescript - The TypeScript module.
+* @param expression - The initializer of a destructure.
+* @param imports - The value imports of the file.
+* @returns True for the kit call.
+*/
+function callsDefineGame(typescript, expression, imports) {
+	if (expression === void 0 || !typescript.isCallExpression(expression)) return false;
+	const callee = expression.expression;
+	if (typescript.isIdentifier(callee)) return isGameImport(imports.get(callee.text), "defineGame");
+	return typescript.isPropertyAccessExpression(callee) && typescript.isIdentifier(callee.expression) && callee.name.text === "defineGame" && isGameImport(imports.get(callee.expression.text), "*");
+}
+/**
+* Records the definers a `defineGame` destructure hands out, under their local names.
+*
+* @param typescript - The TypeScript module.
+* @param pattern - The destructure.
+* @param draft - The facts so far.
+*/
+function readKit(typescript, pattern, draft) {
+	for (const element of pattern.elements) {
+		if (!typescript.isIdentifier(element.name)) continue;
+		const property = element.propertyName;
+		const handed = property !== void 0 && typescript.isIdentifier(property) ? property.text : element.name.text;
+		if (isDefiner(handed)) draft.kit.set(element.name.text, handed);
+	}
+}
+/**
+* Records one top-level variable statement: its names, its exports and a kit destructure.
+*
+* @param typescript - The TypeScript module.
+* @param statement - The statement.
+* @param draft - The facts so far.
+*/
+function readVariables(typescript, statement, draft) {
+	const exported = hasModifier(typescript, statement, typescript.SyntaxKind.ExportKeyword);
+	for (const declaration of statement.declarationList.declarations) {
+		for (const name of namesOf(typescript, declaration.name)) {
+			draft.declared.add(name);
+			if (exported) draft.exports.set(name, { local: name });
+		}
+		const pattern = declaration.name;
+		if (typescript.isObjectBindingPattern(pattern) && callsDefineGame(typescript, declaration.initializer, draft.imports)) readKit(typescript, pattern, draft);
+	}
+}
+/**
+* Records a top-level function or class: its name, and its export.
+*
+* @param typescript - The TypeScript module.
+* @param statement - The declaration.
+* @param draft - The facts so far.
+*/
+function readNamed(typescript, statement, draft) {
+	const name = statement.name?.text;
+	if (name === void 0) return;
+	draft.declared.add(name);
+	if (!hasModifier(typescript, statement, typescript.SyntaxKind.ExportKeyword)) return;
+	const isDefault = hasModifier(typescript, statement, typescript.SyntaxKind.DefaultKeyword);
+	draft.exports.set(isDefault ? "default" : name, { local: name });
+}
+/**
+* Reads the module facts of one parsed file. Imports come first, so a kit destructure anywhere
+* in the file knows where its `defineGame` comes from.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parsed file.
+* @returns The facts.
+*/
+function readModule(typescript, source) {
+	const draft = {
+		imports: /* @__PURE__ */ new Map(),
+		exports: /* @__PURE__ */ new Map(),
+		stars: [],
+		declared: /* @__PURE__ */ new Set(),
+		kit: /* @__PURE__ */ new Map()
+	};
+	for (const statement of source.statements) if (typescript.isImportDeclaration(statement)) readImport(typescript, statement, draft);
+	for (const statement of source.statements) {
+		if (typescript.isVariableStatement(statement)) readVariables(typescript, statement, draft);
+		if (typescript.isFunctionDeclaration(statement) || typescript.isClassDeclaration(statement)) readNamed(typescript, statement, draft);
+		if (typescript.isExportDeclaration(statement)) readExport(typescript, statement, draft);
+		if (typescript.isExportAssignment(statement) && typescript.isIdentifier(statement.expression)) draft.exports.set("default", { local: statement.expression.text });
+	}
+	return draft;
+}
+//#endregion
+//#region src/project/extract/resolve.ts
+/**
+* @file project, extract — following a name across files with the module facts only: an import
+* to the module it names, a re-export to the module behind it, a star export to the first module
+* that has the name, until the name is declared, handed out by the kit, or comes from a package.
+* This is how a definer is recognised by binding (a renamed import still is the definer) and how
+* a node of a flow table reaches the file that declares it.
+*/
+/** How many imports and re-exports a name is followed through before giving up. */
+const MAX_HOPS = 12;
+/** The extensions a TypeScript import may name instead of the source file. */
+const SCRIPT_EXTENSION = /\.(?:[cm]?js|jsx)$/;
+/**
+* Whether a module specifier is relative to the importing file.
+*
+* @param specifier - The module specifier.
+* @returns True for `./…` and `../…`.
+* @example
+* ```ts
+* isRelative("../kit"); // true
+* ```
+*/
+function isRelative(specifier) {
+	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+}
+/**
+* Resolves a relative module specifier to an indexed file, the way a bundler does: the path as
+* written, then with `.ts`, `.tsx`, `/index.ts` and `/index.tsx`.
+*
+* @param modules - The module facts by path.
+* @param from - The importing file.
+* @param specifier - The module specifier.
+* @returns The root-relative path, or `undefined` for a package or a file the index does not hold.
+*/
+function resolveModulePath(modules, from, specifier) {
+	if (!isRelative(specifier)) return void 0;
+	const base = path.posix.normalize(path.posix.join(path.posix.dirname(from), specifier));
+	const stem = base.replace(SCRIPT_EXTENSION, "");
+	return [
+		base,
+		`${stem}.ts`,
+		`${stem}.tsx`,
+		`${stem}/index.ts`,
+		`${stem}/index.tsx`
+	].find((candidate) => modules.has(candidate));
+}
+/**
+* Follows an imported name into the module that the specifier names.
+*
+* @param modules - The module facts by path.
+* @param from - The importing file.
+* @param ref - The specifier and the name.
+* @param hops - How many hops were taken so far.
+* @returns Where the name ends up.
+*/
+function followImport(modules, from, ref, hops) {
+	if (!isRelative(ref.specifier)) return {
+		kind: "package",
+		...ref
+	};
+	if (ref.imported === "*") return void 0;
+	const target = resolveModulePath(modules, from, ref.specifier);
+	return target === void 0 ? void 0 : resolveExport(modules, target, ref.imported, hops + 1);
+}
+/**
+* Follows an exported name of a module: a local binding, a re-export, or a star export.
+*
+* @param modules - The module facts by path.
+* @param file - The module.
+* @param name - The exported name.
+* @param hops - How many hops were taken so far.
+* @returns Where the name ends up.
+*/
+function resolveExport(modules, file, name, hops = 0) {
+	const facts = modules.get(file);
+	if (facts === void 0 || hops > MAX_HOPS) return void 0;
+	const ref = facts.exports.get(name);
+	if (ref !== void 0 && "local" in ref) return resolveBinding(modules, file, ref.local, hops + 1);
+	if (ref !== void 0) return followImport(modules, file, ref, hops);
+	for (const specifier of facts.stars) {
+		const found = followImport(modules, file, {
+			specifier,
+			imported: name
+		}, hops);
+		if (found !== void 0) return found;
+	}
+}
+/**
+* Follows a name used in a file to where it ends up: the kit hands it out, the file declares it,
+* or an import brings it.
+*
+* @param modules - The module facts by path.
+* @param file - The file that uses the name.
+* @param local - The name as the file writes it.
+* @param hops - How many hops were taken so far.
+* @returns Where the name ends up, or `undefined` when it cannot be followed.
+*/
+function resolveBinding(modules, file, local, hops = 0) {
+	const facts = modules.get(file);
+	if (facts === void 0 || hops > MAX_HOPS) return void 0;
+	const definer = facts.kit.get(local);
+	if (definer !== void 0) return {
+		kind: "definer",
+		definer
+	};
+	if (facts.declared.has(local)) return {
+		kind: "declared",
+		path: file,
+		binding: local
+	};
+	const ref = facts.imports.get(local);
+	return ref === void 0 ? void 0 : followImport(modules, file, ref, hops);
+}
+/**
+* The definer a target is, if any: one the kit hands out, or one imported from the engine.
+*
+* @param target - Where a name ends up.
+* @returns The definer, or `undefined`.
+* @example
+* ```ts
+* definerOf({ kind: "package", specifier: "@moku-labs/game", imported: "defineStyle" }); // "defineStyle"
+* ```
+*/
+function definerOf(target) {
+	if (target?.kind === "definer") return target.definer;
+	if (target?.kind !== "package" || target.specifier !== "@moku-labs/game") return void 0;
+	return isDefiner(target.imported) ? target.imported : void 0;
+}
+/**
+* Adds the definers a namespace import reaches as `ns.name`.
+*
+* @param modules - The module facts by path.
+* @param file - The importing file.
+* @param namespace - The local name of the namespace.
+* @param specifier - The module it imports.
+* @param definers - The map to add to.
+*/
+function addNamespace(modules, file, namespace, specifier, definers) {
+	if (specifier === "@moku-labs/game") {
+		for (const definer of DEFINERS) definers.set(`${namespace}.${definer}`, definer);
+		return;
+	}
+	const target = resolveModulePath(modules, file, specifier);
+	const names = target === void 0 ? [] : [...modules.get(target)?.exports.keys() ?? []];
+	for (const name of names) {
+		const definer = definerOf(resolveExport(modules, target ?? "", name));
+		if (definer !== void 0) definers.set(`${namespace}.${name}`, definer);
+	}
+}
+/**
+* The definers a file can call, by the callee as the file writes it: `defineFlow`, a renamed
+* `scene`, or `kit.defineScene` through a namespace.
+*
+* @param modules - The module facts by path.
+* @param file - The file.
+* @returns The callee text to the definer.
+*/
+function definersOf(modules, file) {
+	const facts = modules.get(file);
+	const definers = new Map(facts?.kit);
+	for (const [local, ref] of facts?.imports ?? []) {
+		if (ref.imported === "*") {
+			addNamespace(modules, file, local, ref.specifier, definers);
+			continue;
+		}
+		const definer = definerOf(resolveBinding(modules, file, local));
+		if (definer !== void 0) definers.set(local, definer);
+	}
+	return definers;
+}
+//#endregion
+//#region src/project/hash.ts
+/**
+* @file project — the two hashes of the index: the sha1 of a file's bytes, the same value the
+* editor uses as a file version, and the revision over every file of the index.
+*/
+/**
+* Hashes bytes or text with sha1.
+*
+* @param bytes - The file bytes, or a text.
+* @returns The hex digest.
+* @example
+* ```ts
+* sha1(""); // "da39a3ee5e6b4b0d3255bfef95601890afd80709"
+* ```
+*/
+function sha1(bytes) {
+	return createHash("sha1").update(bytes).digest("hex");
+}
+/**
+* The revision of an index: the sha1 of the lines `${path}\0${hash}\n`, sorted by path.
+*
+* @param files - Every indexed file with its hash.
+* @returns The hex digest.
+* @example
+* ```ts
+* revisionOf({}); // "da39a3ee5e6b4b0d3255bfef95601890afd80709"
+* ```
+*/
+function revisionOf(files) {
+	return sha1(Object.entries(files).map(([file, entry]) => `${file}\0${entry.hash}\n`).toSorted().join(""));
+}
+/**
+* The anchors of the JSX patterns and of the literal key-carrying props of an index.
+*
+* @param index - The index.
+* @returns The prop-hole patterns, the `*` patterns and the `idProp` anchors.
+*/
+function jsxShapes(index) {
+	const shapes = {
+		holePatterns: [],
+		wildPatterns: [],
+		idProps: []
+	};
+	for (const [key, entry] of Object.entries(index.symbols)) {
+		if (!key.startsWith("jsx:")) continue;
+		for (const anchor of entry.def) {
+			const pattern = anchor.key ?? "";
+			if (anchor.kind === "idProp") shapes.idProps.push(anchor);
+			else if (hasHole(pattern)) shapes.holePatterns.push(anchor);
+			else if (pattern.includes("*")) shapes.wildPatterns.push(anchor);
+		}
+	}
+	return shapes;
+}
+//#endregion
+//#region src/project/assemble.ts
+/** The prefix of a node key. */
+const NODE = "node:";
+/**
+* The entry of a key, made on first use.
+*
+* @param symbols - The keys so far.
+* @param key - The key.
+* @returns Its entry.
+*/
+function entryOf(symbols, key) {
+	const existing = symbols.get(key);
+	if (existing !== void 0) return existing;
+	const entry = {
+		def: [],
+		uses: []
+	};
+	symbols.set(key, entry);
+	return entry;
+}
+/**
+* Adds the `node:` keys of one flow table. A plain name is followed to the file that declares
+* it, and the table is its use; a slot or an inline node is anchored at the table. A name that
+* cannot be followed is anchored at the table and listed as unresolved.
+*
+* @param assembly - The records and module facts.
+* @param symbols - The keys so far.
+* @param unresolved - The unresolved list so far.
+* @param file - The flow file.
+* @param table - The table.
+*/
+function addTable(assembly, symbols, unresolved, file, table) {
+	const use = table.binding === void 0 ? { path: file } : {
+		path: file,
+		binding: table.binding
+	};
+	for (const { name, ref } of table.entries) {
+		const entry = entryOf(symbols, `${NODE}${table.flow}/${name}`);
+		const atTable = {
+			...use,
+			key: name
+		};
+		const target = ref === void 0 ? void 0 : resolveBinding(assembly.modules, file, ref);
+		if (target?.kind === "declared") {
+			entry.def.push({
+				path: target.path,
+				binding: target.binding
+			});
+			entry.uses.push(atTable);
+			continue;
+		}
+		entry.def.push(atTable);
+		if (ref !== void 0) {
+			const reason = `node "${table.flow}/${name}": "${ref}" is not declared in a file of the root`;
+			unresolved.push({
+				path: file,
+				reason
+			});
+		}
+	}
+}
+/**
+* Adds, to every style key, the files that import its binding by name.
+*
+* @param assembly - The records and module facts.
+* @param symbols - The keys so far.
+*/
+function addStyleUses(assembly, symbols) {
+	for (const [file, record] of assembly.files) for (const [local, ref] of record.good?.module.imports ?? []) {
+		const target = ref.imported === "*" ? void 0 : resolveBinding(assembly.modules, file, local);
+		(target?.kind === "declared" ? symbols.get(`style:${target.path}#${target.binding}`) : void 0)?.uses.push({
+			path: file,
+			binding: local
+		});
+	}
+}
+/**
+* The component entries by the binding they are rendered as. Two anchors of one name in a
+* conflict share one binding, so a file that renders it is one use.
+*
+* @param symbols - The keys so far.
+* @returns Binding to the component entries bound to it.
+*/
+function componentsByBinding(symbols) {
+	const byBinding = /* @__PURE__ */ new Map();
+	for (const [key, entry] of symbols) {
+		if (!key.startsWith("component:")) continue;
+		const bindings = new Set(entry.def.flatMap((anchor) => anchor.binding ?? []));
+		for (const binding of bindings) byBinding.set(binding, [...byBinding.get(binding) ?? [], entry]);
+	}
+	return byBinding;
+}
+/**
+* The component names one file renders.
+*
+* @param record - The record of the file.
+* @returns The names; none for a broken file.
+*/
+function renderedBy(record) {
+	return record.good === void 0 ? [] : record.extracted?.result.rendered ?? [];
+}
+/**
+* Adds one use of a rendered binding to every component entry bound to it.
+*
+* @param byBinding - Binding to the component entries bound to it.
+* @param file - The file that renders the binding.
+* @param binding - The rendered name.
+*/
+function useComponent(byBinding, file, binding) {
+	for (const entry of byBinding.get(binding) ?? []) entry.uses.push({
+		path: file,
+		binding
+	});
+}
+/**
+* Adds, to every component key, the files that render its binding: one use per file and binding,
+* in path order. A member tag `<ui.RoundButton>` renders `RoundButton`.
+*
+* @param assembly - The records and module facts.
+* @param symbols - The keys so far.
+*/
+function addComponentUses(assembly, symbols) {
+	const byBinding = componentsByBinding(symbols);
+	for (const [file, record] of assembly.files) for (const binding of renderedBy(record)) useComponent(byBinding, file, binding);
+}
+/**
+* The symbols as the index holds them: sorted by key, `uses` only when there are some, and
+* `conflict` on a key other than `jsx:` defined twice.
+*
+* @param symbols - The keys as collected.
+* @returns The symbols of the index.
+*/
+function finishSymbols(symbols) {
+	const finished = {};
+	const sorted = [...symbols].toSorted(([first], [second]) => first < second ? -1 : 1);
+	for (const [key, { def, uses }] of sorted) {
+		const isConflict = !key.startsWith("jsx:") && def.length > 1;
+		finished[key] = {
+			def,
+			...uses.length === 0 ? {} : { uses },
+			...isConflict ? { conflict: true } : {}
+		};
+	}
+	return finished;
+}
+/**
+* Freezes a value and everything it holds.
+*
+* @param value - A plain value.
+* @returns The same value, frozen.
+*/
+function deepFreeze(value) {
+	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+	Object.freeze(value);
+	for (const child of Object.values(value)) deepFreeze(child);
+	return value;
+}
+/**
+* Assembles the index of a catalog.
+*
+* @param assembly - The records sorted by path, and the module facts of the good files.
+* @param manifest - The root-relative manifest path when the file exists.
+* @returns The index, frozen.
+*/
+function assembleIndex(assembly, manifest) {
+	const symbols = /* @__PURE__ */ new Map();
+	const files = {};
+	const unresolved = [];
+	for (const [file, record] of assembly.files) {
+		files[file] = {
+			hash: record.hash,
+			state: record.state,
+			...record.error === void 0 ? {} : { error: record.error }
+		};
+		const extracted = record.extracted?.result;
+		if (record.good === void 0 || extracted === void 0) {
+			unresolved.push({
+				path: file,
+				reason: record.error ?? "the file never parsed"
+			});
+			continue;
+		}
+		for (const { key, anchor } of extracted.definitions) entryOf(symbols, key).def.push(anchor);
+		unresolved.push(...extracted.unresolved);
+		for (const table of extracted.tables) addTable(assembly, symbols, unresolved, file, table);
+	}
+	addStyleUses(assembly, symbols);
+	addComponentUses(assembly, symbols);
+	return deepFreeze({
+		schemaVersion: 1,
+		revision: revisionOf(files),
+		...manifest === void 0 ? {} : { manifest },
+		symbols: finishSymbols(symbols),
+		files,
+		unresolved
+	});
+}
+//#endregion
+//#region src/project/extract/definitions.ts
+/** The key prefix of each definer that takes its id as the first argument. */
+const ID_PREFIXES = {
+	defineFlow: "flow",
+	defineFeature: "feature",
+	defineScene: "scene",
+	defineEmitter: "emitter",
+	defineComponent: "component"
+};
+/**
+* The text of a string literal or a template without holes.
+*
+* @param typescript - The TypeScript module.
+* @param node - An expression, if any.
+* @returns The text, or `undefined` for anything else.
+*/
+function literalOf(typescript, node) {
+	const inner = node === void 0 ? void 0 : unwrap(typescript, node);
+	return inner !== void 0 && typescript.isStringLiteralLike(inner) ? inner.text : void 0;
+}
+/**
+* The value of a named property of an object literal; for a shorthand, the name itself.
+*
+* @param typescript - The TypeScript module.
+* @param object - The object literal.
+* @param name - The property name.
+* @returns The value, or `undefined` when the object has no such property.
+*/
+function propertyValue(typescript, object, name) {
+	for (const property of object.properties) {
+		if (propertyNameOf(typescript, property) !== name) continue;
+		if (typescript.isPropertyAssignment(property)) return property.initializer;
+		if (typescript.isShorthandPropertyAssignment(property)) return property.name;
+	}
+}
+/**
+* The object literal an expression is, directly or through a same-file const.
+*
+* @param typescript - The TypeScript module.
+* @param node - An expression, if any.
+* @returns The object literal, or `undefined`.
+*/
+function objectOf(typescript, node) {
+	const inner = node === void 0 ? void 0 : unwrap(typescript, node);
+	if (inner === void 0) return void 0;
+	if (typescript.isObjectLiteralExpression(inner)) return inner;
+	if (!typescript.isIdentifier(inner)) return void 0;
+	const meaning = meaningOf(typescript, inner);
+	const value = meaning?.kind === "const" ? unwrap(typescript, meaning.initializer) : void 0;
+	return value !== void 0 && typescript.isObjectLiteralExpression(value) ? value : void 0;
+}
+/**
+* The const a call is bound to: `export const boardFlow = defineFlow(…)` at the top of the file.
+*
+* @param typescript - The TypeScript module.
+* @param call - The definer call.
+* @returns The binding, or `undefined` when the call is not the initializer of a module const.
+*/
+function bindingOf(typescript, call) {
+	let node = call.parent;
+	while (typescript.isExpression(node)) node = node.parent;
+	if (!typescript.isVariableDeclaration(node) || !typescript.isIdentifier(node.name)) return void 0;
+	if (node.initializer === void 0 || unwrap(typescript, node.initializer) !== call) return void 0;
+	const list = node.parent;
+	return (list.flags & typescript.NodeFlags.Const) !== 0 && typescript.isVariableStatement(list.parent) && typescript.isSourceFile(list.parent.parent) ? node.name.text : void 0;
+}
+/**
+* The definer a call calls, by its callee as written: `defineFlow(…)` or `kit.defineFlow(…)`.
+*
+* @param typescript - The TypeScript module.
+* @param call - The call.
+* @param definers - The definers of the file.
+* @returns The definer, or `undefined` for any other call.
+*/
+function definerOfCall(typescript, call, definers) {
+	const callee = call.expression;
+	if (typescript.isIdentifier(callee)) return definers.get(callee.text);
+	if (!typescript.isPropertyAccessExpression(callee) || !typescript.isIdentifier(callee.expression)) return;
+	return definers.get(`${callee.expression.text}.${callee.name.text}`);
+}
+/**
+* Adds a key bound to the const of a call, or anchored by its id when the call has no const.
+*
+* @param reading - The file being read.
+* @param call - The definer call.
+* @param key - The key.
+* @param id - The literal id, the anchor key when there is no binding.
+* @param bound - What the anchor adds to the binding: the `name` key of a projection.
+*/
+function define(reading, call, key, id, bound = {}) {
+	const binding = bindingOf(reading.typescript, call);
+	const anchor = binding === void 0 ? {
+		path: reading.path,
+		key: id
+	} : {
+		path: reading.path,
+		binding,
+		...bound
+	};
+	reading.definitions.push({
+		key,
+		anchor
+	});
+}
+/**
+* Notes something the file holds that cannot be read.
+*
+* @param reading - The file being read.
+* @param reason - What and why.
+*/
+function unresolve(reading, reason) {
+	reading.unresolved.push({
+		path: reading.path,
+		reason
+	});
+}
+/**
+* The plain name a table entry's value is: `merge` for `{ merge }` and for `{ merge: merge }`.
+*
+* @param typescript - The TypeScript module.
+* @param property - The table entry.
+* @returns The name, or `undefined` for a slot, an inline node or anything else.
+*/
+function refOf(typescript, property) {
+	if (typescript.isShorthandPropertyAssignment(property)) return property.name.text;
+	if (!typescript.isPropertyAssignment(property)) return void 0;
+	const value = unwrap(typescript, property.initializer);
+	return typescript.isIdentifier(value) ? value.text : void 0;
+}
+/**
+* Reads the `nodes` table of a flow into its entries.
+*
+* @param reading - The file being read.
+* @param call - The `defineFlow` call.
+* @param flow - The flow id.
+*/
+function readTable(reading, call, flow) {
+	const { typescript } = reading;
+	const spec = objectOf(typescript, call.arguments[1]);
+	const nodes = spec === void 0 ? void 0 : objectOf(typescript, propertyValue(typescript, spec, "nodes"));
+	if (nodes === void 0) {
+		unresolve(reading, `defineFlow "${flow}" nodes is not an object literal`);
+		return;
+	}
+	const entries = [];
+	for (const property of nodes.properties) {
+		if (typescript.isSpreadAssignment(property)) {
+			unresolve(reading, `defineFlow "${flow}" nodes has a spread`);
+			continue;
+		}
+		const name = propertyNameOf(typescript, property);
+		if (name === void 0) {
+			unresolve(reading, `defineFlow "${flow}" node name is not a literal`);
+			continue;
+		}
+		const ref = refOf(typescript, property);
+		entries.push(ref === void 0 ? { name } : {
+			name,
+			ref
+		});
+	}
+	const binding = bindingOf(typescript, call);
+	reading.tables.push(binding === void 0 ? {
+		flow,
+		entries
+	} : {
+		flow,
+		binding,
+		entries
+	});
+}
+/**
+* Reads a definer that takes its id as the first argument; a flow also brings its table. A
+* component is bound to its const, and the key takes the literal id.
+*
+* @param reading - The file being read.
+* @param call - The call.
+* @param definer - The definer.
+* @param prefix - The key prefix.
+*/
+function readIdCall(reading, call, definer, prefix) {
+	const id = literalOf(reading.typescript, call.arguments[0]);
+	if (id === void 0) {
+		unresolve(reading, `${definer} id is not a string literal`);
+		return;
+	}
+	define(reading, call, `${prefix}:${id}`, id);
+	if (definer === "defineFlow") readTable(reading, call, id);
+}
+/**
+* Reads a projection: its key is its `name`, its line the `name` property.
+*
+* @param reading - The file being read.
+* @param call - The call.
+*/
+function readProjection(reading, call) {
+	const { typescript } = reading;
+	const spec = objectOf(typescript, call.arguments[0]);
+	const name = spec === void 0 ? void 0 : literalOf(typescript, propertyValue(typescript, spec, "name"));
+	if (name === void 0) {
+		unresolve(reading, "projection name is not a string literal");
+		return;
+	}
+	define(reading, call, `projection:${name}`, name, { key: "name" });
+}
+/**
+* Reads a text style table: every literal key is a key.
+*
+* @param reading - The file being read.
+* @param call - The call.
+*/
+function readTextStyles(reading, call) {
+	const { typescript } = reading;
+	const table = call.arguments[0] === void 0 ? void 0 : unwrap(typescript, call.arguments[0]);
+	if (table === void 0 || !typescript.isObjectLiteralExpression(table)) {
+		unresolve(reading, "defineTextStyles argument is not an object literal");
+		return;
+	}
+	const binding = bindingOf(typescript, call);
+	for (const property of table.properties) {
+		const key = propertyNameOf(typescript, property);
+		if (key === void 0) {
+			unresolve(reading, "defineTextStyles key is not a literal");
+			continue;
+		}
+		const anchor = binding === void 0 ? {
+			path: reading.path,
+			key
+		} : {
+			path: reading.path,
+			binding,
+			key
+		};
+		reading.definitions.push({
+			key: `textStyle:${key}`,
+			anchor
+		});
+	}
+}
+/**
+* Adds a style key; the same key and anchor twice in one file is one anchor, since `find`
+* answers every style call of a factory.
+*
+* @param reading - The file being read.
+* @param key - The key.
+* @param anchor - The anchor.
+*/
+function addStyle(reading, key, anchor) {
+	const identity = JSON.stringify({
+		key,
+		anchor
+	});
+	if (reading.styles.has(identity)) return;
+	reading.styles.add(identity);
+	reading.definitions.push({
+		key,
+		anchor
+	});
+}
+/**
+* The key and anchor of a style built in a module-level function: `style:<path>#<function>`, or
+* `style:<path>#<function>.<property>` when the call is the value of an object property there.
+*
+* @param reading - The file being read.
+* @param call - The `defineStyle` call.
+* @param factory - The name of the function the call sits in.
+* @returns The key and its anchor.
+*/
+function styleKeyIn(reading, call, factory) {
+	const { typescript, path } = reading;
+	const property = propertyOfValue(typescript, call);
+	if (property === void 0) return {
+		key: `style:${path}#${factory}`,
+		anchor: {
+			path,
+			binding: factory
+		}
+	};
+	return {
+		key: `style:${path}#${factory}.${property}`,
+		anchor: {
+			path,
+			binding: factory,
+			key: property
+		}
+	};
+}
+/**
+* Reads a style. One bound to a module const is `style:<path>#<binding>`. One built in a
+* module-level function, at any depth, is `style:<path>#<function>`, or
+* `style:<path>#<function>.<property>` when it is the value of an object property there. Any
+* other style is unresolved.
+*
+* @param reading - The file being read.
+* @param call - The call.
+*/
+function readStyle(reading, call) {
+	const { typescript, path } = reading;
+	const binding = bindingOf(typescript, call);
+	if (binding !== void 0) {
+		addStyle(reading, `style:${path}#${binding}`, {
+			path,
+			binding
+		});
+		return;
+	}
+	const factory = enclosingFunction(typescript, call);
+	if (factory !== void 0) {
+		const style = styleKeyIn(reading, call, factory);
+		addStyle(reading, style.key, style.anchor);
+		return;
+	}
+	const around = enclosingName(typescript, call);
+	unresolve(reading, `defineStyle${around === void 0 ? "" : ` in "${around}"`} is not bound to a module-level const`);
+}
+/**
+* Reads one definer call.
+*
+* @param reading - The file being read.
+* @param call - The call.
+* @param definer - The definer it calls.
+*/
+function readCall(reading, call, definer) {
+	const prefix = ID_PREFIXES[definer];
+	if (prefix !== void 0) readIdCall(reading, call, definer, prefix);
+	if (definer === "projection") readProjection(reading, call);
+	if (definer === "defineTextStyles") readTextStyles(reading, call);
+	if (definer === "defineStyle") readStyle(reading, call);
+}
+/**
+* Adds the JSX keys of the file; the same key twice in one file is one anchor, since `find`
+* answers every place of an anchor in its file.
+*
+* @param reading - The file being read.
+* @param source - The parsed file.
+*/
+function readJsx(reading, source) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const hit of collectJsx(reading.typescript, source)) {
+		if (isOpaque(hit)) {
+			unresolve(reading, opaqueReason(hit));
+			continue;
+		}
+		const anchor = anchorOfHit(reading.path, hit);
+		const identity = JSON.stringify(anchor);
+		if (seen.has(identity)) continue;
+		seen.add(identity);
+		reading.definitions.push({
+			key: `jsx:${hit.key}`,
+			anchor
+		});
+	}
+}
+/**
+* Reads the keys one file defines.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parsed file.
+* @param path - The root-relative path of the file.
+* @param definers - The definers the file can call, from `definersOf`.
+* @returns The definitions, the node tables and the unresolved items in source order, and the
+*   component names the file renders.
+*/
+function extractFile(typescript, source, path, definers) {
+	const reading = {
+		typescript,
+		path,
+		definers,
+		definitions: [],
+		tables: [],
+		unresolved: [],
+		styles: /* @__PURE__ */ new Set()
+	};
+	const visit = (node) => {
+		const definer = typescript.isCallExpression(node) ? definerOfCall(typescript, node, definers) : void 0;
+		if (definer !== void 0 && typescript.isCallExpression(node)) readCall(reading, node, definer);
+		typescript.forEachChild(node, visit);
+	};
+	if (definers.size > 0) visit(source);
+	reading.definitions.push(...readComponents(typescript, source, path));
+	readJsx(reading, source);
+	return {
+		definitions: reading.definitions,
+		tables: reading.tables,
+		unresolved: reading.unresolved,
+		rendered: renderedOf(typescript, source)
+	};
+}
+//#endregion
+//#region src/project/typescript.ts
+/**
+* Loads the optional peer `typescript`.
+*
+* @param load - The import; the real dynamic import by default.
+* @returns The TypeScript module.
+* @throws {Error} When the package is not installed.
+*/
+async function loadTypeScript(load = () => import("typescript")) {
+	try {
+		const loaded = await load();
+		return loaded.default ?? loaded;
+	} catch {
+		throw new Error("[game] The project index needs the \"typescript\" package.\n  Install it as a dev dependency of the game.");
+	}
+}
+/**
+* Formats the first parse error of a file as `path:line:col message`, 1-based.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parsed file.
+* @param diagnostic - The parse error.
+* @returns The message.
+*/
+function describeError(typescript, source, diagnostic) {
+	const { line, character } = source.getLineAndCharacterOfPosition(diagnostic.start);
+	const message = typescript.flattenDiagnosticMessageText(diagnostic.messageText, " ");
+	return `${source.fileName}:${line + 1}:${character + 1} ${message}`;
+}
+/**
+* Parses one file with parent links, as TSX for a `.tsx` path and as TS otherwise.
+*
+* @param typescript - The TypeScript module.
+* @param path - The root-relative path; it names the file in the error.
+* @param text - The source text.
+* @returns The tree and the first parse error.
+*/
+function parseFile(typescript, path, text) {
+	const kind = path.endsWith(".tsx") ? typescript.ScriptKind.TSX : typescript.ScriptKind.TS;
+	const source = typescript.createSourceFile(path, text, typescript.ScriptTarget.Latest, true, kind);
+	const [first] = source.parseDiagnostics ?? [];
+	if (first === void 0) return { source };
+	return {
+		source,
+		error: describeError(typescript, source, first)
+	};
+}
+//#endregion
+//#region src/project/catalog.ts
+/**
+* @file project — the catalog: one record per indexed file and a cache of parses. A file is
+* parsed once per version of its bytes; a file that stops parsing keeps its last good parse, so
+* its keys stay in the index while it is broken. Building the index reads the module facts of
+* every good file, re-extracts only the files whose bytes or reachable definers changed, and
+* assembles the result.
+*/
+/** How many parses the cache keeps; the oldest goes first. */
+const PARSE_CACHE_SIZE = 512;
+/**
+* Creates an empty catalog.
+*
+* @param typescript - The TypeScript module.
+* @returns The catalog.
+*/
+function createCatalog(typescript) {
+	return {
+		typescript,
+		records: /* @__PURE__ */ new Map(),
+		parses: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* Parses one version of a file, or takes it from the cache.
+*
+* @param catalog - The catalog.
+* @param path - The root-relative path.
+* @param hash - The sha1 of the bytes.
+* @param text - The text of the bytes.
+* @returns The parse.
+*/
+function parseCached(catalog, path, hash, text) {
+	const id = `${path}\0${hash}`;
+	const cached = catalog.parses.get(id);
+	catalog.parses.delete(id);
+	const parsed = cached ?? parseFile(catalog.typescript, path, text);
+	catalog.parses.set(id, parsed);
+	for (const old of catalog.parses.keys()) {
+		if (catalog.parses.size <= PARSE_CACHE_SIZE) break;
+		catalog.parses.delete(old);
+	}
+	return parsed;
+}
+/**
+* Takes in the bytes of a file. Unchanged bytes change nothing; bytes that parse replace the
+* good version; bytes that do not parse mark the file broken and keep the good version.
+*
+* @param catalog - The catalog.
+* @param path - The root-relative path.
+* @param bytes - The bytes on disk.
+* @returns True when the bytes differ from the ones last read.
+*/
+function putFile(catalog, path, bytes) {
+	const hash = sha1(bytes);
+	const record = catalog.records.get(path);
+	if (record?.hash === hash) return false;
+	const text = new TextDecoder().decode(bytes);
+	const parsed = parseCached(catalog, path, hash, text);
+	if (parsed.error === void 0) {
+		const good = {
+			hash,
+			text,
+			module: readModule(catalog.typescript, parsed.source)
+		};
+		catalog.records.set(path, {
+			hash,
+			state: "ok",
+			good
+		});
+		return true;
+	}
+	catalog.records.set(path, {
+		hash,
+		state: "broken",
+		error: parsed.error,
+		...record?.good === void 0 ? {} : { good: record.good },
+		...record?.extracted === void 0 ? {} : { extracted: record.extracted }
+	});
+	return true;
+}
+/**
+* Drops a file that is gone.
+*
+* @param catalog - The catalog.
+* @param path - The root-relative path.
+* @returns True when the catalog held the file.
+*/
+function dropFile(catalog, path) {
+	return catalog.records.delete(path);
+}
+/**
+* Brings the keys of every good file up to date: a file is read again when its good version or
+* the definers it reaches changed since it was last read.
+*
+* @param catalog - The catalog.
+* @param modules - The module facts of every good file.
+*/
+function refreshExtractions(catalog, modules) {
+	for (const [path, record] of catalog.records) {
+		const good = record.good;
+		if (good === void 0) continue;
+		const definers = definersOf(modules, path);
+		const signature = [...definers].map(([callee, definer]) => `${callee}=${definer}`).join(";");
+		const stamp = `${good.hash}|${signature}`;
+		if (record.extracted?.definers === stamp) continue;
+		const { source } = parseCached(catalog, path, good.hash, good.text);
+		record.extracted = {
+			definers: stamp,
+			result: extractFile(catalog.typescript, source, path, definers)
+		};
+	}
+}
+/**
+* Builds the index of everything the catalog holds.
+*
+* @param catalog - The catalog.
+* @param manifest - The root-relative manifest path when the file exists.
+* @returns The index, frozen.
+*/
+function buildIndex(catalog, manifest) {
+	const files = [...catalog.records].toSorted(([first], [second]) => first < second ? -1 : 1);
+	const modules = /* @__PURE__ */ new Map();
+	for (const [path, record] of files) if (record.good !== void 0) modules.set(path, record.good.module);
+	refreshExtractions(catalog, modules);
+	return assembleIndex({
+		files,
+		modules
+	}, manifest);
+}
+//#endregion
+//#region src/project/locate.ts
+/** The kind of a style key. */
+const STYLE_KIND = "style";
+/**
+* The place of a node: the line of one node and the range of another.
+*
+* @param source - The parsed file.
+* @param lineNode - The node whose start line is the line.
+* @param rangeNode - The node whose span is the range.
+* @returns The place.
+*/
+function placeOf(source, lineNode, rangeNode) {
+	const line = source.getLineAndCharacterOfPosition(lineNode.getStart(source)).line + 1;
+	const start = source.getLineAndCharacterOfPosition(rangeNode.getStart(source));
+	const end = source.getLineAndCharacterOfPosition(rangeNode.getEnd());
+	return {
+		line,
+		range: [
+			start.line + 1,
+			start.character + 1,
+			end.line + 1,
+			end.character + 1
+		]
+	};
+}
+/**
+* Whether a top-level statement declares a name.
+*
+* @param typescript - The TypeScript module.
+* @param statement - The statement.
+* @param binding - The name.
+* @returns True for a const, a destructured const, a function or a class of that name.
+*/
+function declares(typescript, statement, binding) {
+	if (typescript.isFunctionDeclaration(statement) || typescript.isClassDeclaration(statement)) return statement.name?.text === binding;
+	if (!typescript.isVariableStatement(statement)) return false;
+	return statement.declarationList.declarations.some((declaration) => {
+		const name = declaration.name;
+		if (typescript.isIdentifier(name)) return name.text === binding;
+		return name.elements.some((element) => typescript.isBindingElement(element) && element.name.getText() === binding);
+	});
+}
+/**
+* The shallowest property of a key inside a declaration, the first one at that depth.
+*
+* @param typescript - The TypeScript module.
+* @param root - The declaration statement.
+* @param key - The property name.
+* @returns The property, or `undefined`.
+*/
+function propertyIn(typescript, root, key) {
+	const queue = [root];
+	for (let next = queue.shift(); next !== void 0; next = queue.shift()) {
+		if (propertyNameOf(typescript, next) === key) return next;
+		typescript.forEachChild(next, (child) => {
+			queue.push(child);
+		});
+	}
+}
+/**
+* The first place a key is written: a string literal of that text, or a property of that name.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parsed file.
+* @param key - The key.
+* @returns The place, or `undefined`.
+*/
+function writtenAt(typescript, source, key) {
+	const visit = (node) => {
+		if (typescript.isStringLiteralLike(node) && node.text === key || propertyNameOf(typescript, node) === key) return node;
+		return typescript.forEachChild(node, visit);
+	};
+	const found = visit(source);
+	if (found === void 0) return void 0;
+	const parent = found.parent;
+	return placeOf(source, found, typescript.isPropertyAssignment(parent) || typescript.isCallExpression(parent) ? parent : found);
+}
+/**
+* The style calls a function makes, at any depth, in source order. A call that is the value of a
+* property is left out: it has a key of its own.
+*
+* @param typescript - The TypeScript module.
+* @param factory - The function.
+* @param definers - The definers of the file.
+* @returns The calls.
+*/
+function styleCallsIn(typescript, factory, definers) {
+	const calls = [];
+	const visit = (node) => {
+		if (typescript.isCallExpression(node) && definerOfCall(typescript, node, definers) === "defineStyle" && propertyOfValue(typescript, node) === void 0) calls.push(node);
+		typescript.forEachChild(node, visit);
+	};
+	visit(factory);
+	return calls;
+}
+/**
+* Reads a style built in a module-level function: every style call of the function, or, with a
+* key, the property of that key with the call as the range.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parsed file.
+* @param anchor - The anchor, bound to the function.
+* @param context - What the caller knows: the definers of the file.
+* @returns The places; none when the binding is not a function or holds no such call.
+*/
+function locateFactory(typescript, source, anchor, context) {
+	const factory = source.statements.flatMap((statement) => declaredFunctions(typescript, statement)).find((item) => item.name === anchor.binding);
+	if (factory === void 0) return [];
+	if (anchor.key !== void 0) {
+		const property = propertyIn(typescript, factory.node, anchor.key);
+		if (property === void 0 || !typescript.isPropertyAssignment(property)) return [];
+		return [placeOf(source, property, unwrap(typescript, property.initializer))];
+	}
+	const definers = context.definers?.() ?? /* @__PURE__ */ new Map();
+	return styleCallsIn(typescript, factory.node, definers).map((call) => placeOf(source, call, call));
+}
+/**
+* Reads an anchor on one parse of its file.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parsed file.
+* @param anchor - The anchor.
+* @param context - The kind of its key, the JSX hits of the parse and the definers of the file.
+* @returns Every place of the anchor in the file; none when the file no longer holds it.
+*/
+function locate(typescript, source, anchor, context = {}) {
+	if (anchor.kind !== void 0) return (context.jsxHits?.() ?? collectJsx(typescript, source)).filter((hit) => hit.key === anchor.key && hit.kind === anchor.kind && hit.component === anchor.component && hit.prop === anchor.prop).map((hit) => placeOf(source, hit.attribute, hit.element));
+	if (anchor.binding === void 0) {
+		const place = anchor.key === void 0 ? void 0 : writtenAt(typescript, source, anchor.key);
+		return place === void 0 ? [] : [place];
+	}
+	const built = context.keyKind === STYLE_KIND ? locateFactory(typescript, source, anchor, context) : [];
+	if (built.length > 0) return built;
+	const binding = anchor.binding;
+	const statement = source.statements.find((item) => declares(typescript, item, binding));
+	if (statement === void 0) return [];
+	const node = (anchor.key === void 0 ? void 0 : propertyIn(typescript, statement, anchor.key)) ?? statement;
+	return [placeOf(source, node, node)];
+}
+//#endregion
+//#region src/project/paths.ts
+/**
+* @file project — which files the index reads, and the guard on every path it reads. Paths in and
+* out are root-relative POSIX. A read resolves the path against the real root with `realpath`, so
+* a `..` or a symlink that leaves the root is refused by name instead of read.
+*/
+/** The folders a game never edits by hand: dependencies, builds, generated code and tests. */
+const SKIPPED_FOLDER = /^(?:node_modules|dist|generated|\.moku|\.git|__tests__|tests)$/;
+/** The source files the index reads. */
+const SOURCE_FILE = /\.tsx?$/;
+/** Test files, skipped wherever they sit. */
+const TEST_FILE = /\.(?:test|spec)\.tsx?$/;
+/** The hint under every root error. */
+const ROOT_HINT = "Pass the folder of the game as root.";
+/**
+* Whether a folder name is one the index never walks into.
+*
+* @param name - One folder name.
+* @returns True for `node_modules`, `dist`, `generated`, `.moku`, `.git`, `__tests__` and `tests`.
+* @example
+* ```ts
+* isSkippedFolder("generated"); // true
+* ```
+*/
+function isSkippedFolder(name) {
+	return SKIPPED_FOLDER.test(name);
+}
+/**
+* Whether a root-relative path sits under a skipped folder.
+*
+* @param file - A path with `/` or `\` separators.
+* @returns True when one of its folders is skipped.
+* @example
+* ```ts
+* isSkippedPath("node_modules/pixi.js/index.ts"); // true
+* ```
+*/
+function isSkippedPath(file) {
+	return file.split(/[/\\]/).slice(0, -1).some((folder) => isSkippedFolder(folder));
+}
+/**
+* Whether the index reads a root-relative path: a `.ts` or `.tsx` file outside the skipped
+* folders that is not a test.
+*
+* @param file - A root-relative POSIX path.
+* @returns True for a source file of the index.
+* @example
+* ```ts
+* isIndexedFile("features/ui/kit.tsx"); // true
+* ```
+*/
+function isIndexedFile(file) {
+	return SOURCE_FILE.test(file) && !TEST_FILE.test(file) && !isSkippedPath(file);
+}
+/**
+* Turns a path into its root-relative POSIX form.
+*
+* @param file - A path with any separators.
+* @returns The path with `/` separators, `.` segments resolved.
+* @example
+* ```ts
+* toPosix("./features\\ui\\kit.tsx"); // "features/ui/kit.tsx"
+* ```
+*/
+function toPosix(file) {
+	return path.posix.normalize(file.replaceAll("\\", "/"));
+}
+/**
+* Whether a file system error says nothing is at the path.
+*
+* @param error - What was thrown.
+* @returns True for `ENOENT` and `ENOTDIR`.
+*/
+function isMissing(error) {
+	const code = error instanceof Error && "code" in error ? error.code : void 0;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+/**
+* Whether an absolute path lies inside a folder.
+*
+* @param folder - The absolute folder.
+* @param file - The absolute path.
+* @returns True for the folder itself and anything below it.
+*/
+function isInside(folder, file) {
+	const relative = path.relative(folder, file);
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+/**
+* The error of a path that leaves the root.
+*
+* @param file - The path as it was given.
+* @param root - The real root.
+* @returns The error to throw.
+*/
+function leavesRoot(file, root) {
+	return /* @__PURE__ */ new Error(`[game] The path "${file}" leaves the project root.\n  Pass a path inside "${root}", relative to it.`);
+}
+/**
+* Checks the root of a project and resolves it: it exists, it is a directory, and its real path
+* is the one every read is held to.
+*
+* @param root - The root as given, absolute or relative to the working directory.
+* @returns The real absolute path of the root.
+* @throws {Error} When the root does not exist or is not a directory.
+*/
+async function openRoot(root) {
+	const absolute = path.resolve(root);
+	if (!(await stat(absolute).catch((error) => {
+		if (!isMissing(error)) throw error;
+		throw new Error(`[game] The project root "${absolute}" does not exist.\n  ${ROOT_HINT}`);
+	})).isDirectory()) throw new Error(`[game] The project root "${absolute}" is not a directory.\n  ${ROOT_HINT}`);
+	return realpath(absolute);
+}
+/**
+* Resolves a root-relative path to the real file, refusing any path that leaves the root.
+*
+* @param root - The real root.
+* @param file - The root-relative path.
+* @returns The real absolute path, or `undefined` when nothing is there.
+* @throws {Error} When the path leaves the root, by `..`, as an absolute path or by a symlink.
+*/
+async function resolveInside(root, file) {
+	const absolute = path.resolve(root, file);
+	if (!isInside(root, absolute)) throw leavesRoot(file, root);
+	let real;
+	try {
+		real = await realpath(absolute);
+	} catch (error) {
+		if (isMissing(error)) return;
+		throw error;
+	}
+	if (!isInside(root, real)) throw leavesRoot(file, root);
+	return real;
+}
+/**
+* Reads the bytes of a root-relative file through the guard. A path that leaves the root reads as
+* nothing here; `changed` refuses it by name with `resolveInside` first.
+*
+* @param root - The real root.
+* @param file - The root-relative path.
+* @returns The bytes, or `undefined` when the file is gone or lies outside the root.
+*/
+async function readInside(root, file) {
+	try {
+		const real = await resolveInside(root, file);
+		if (real !== void 0) return await readFile(real);
+	} catch {}
+}
+//#endregion
+//#region src/project/find.ts
+/**
+* Whether a key matches a pattern whose `*` holes stand for any text.
+*
+* @param pattern - A pattern, its prop holes already filled.
+* @param key - The key without its prefix.
+* @returns True when the key reads as the pattern.
+* @example
+* ```ts
+* matchesPattern("card*Picture", "card2Picture"); // true
+* ```
+*/
+function matchesPattern(pattern, key) {
+	if (!pattern.includes("*")) return pattern === key;
+	const parts = pattern.split("*").map((part) => part.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`));
+	return new RegExp(`^${parts.join(".*")}$`).test(key);
+}
+/**
+* The JSX shapes of the current index, read once per index: an index is frozen, and an update
+* replaces it with a new object.
+*
+* @param session - The open project.
+* @returns The shapes of `session.index`.
+*/
+function shapesOf(session) {
+	const cached = session.shapes.get(session.index);
+	if (cached !== void 0) return cached;
+	const shapes = jsxShapes(session.index);
+	session.shapes.set(session.index, shapes);
+	return shapes;
+}
+/**
+* Whether a literal prop fills the holes of its name in a pattern into the wanted key: `id=` fills
+* `{id}`, `amountKey=` fills `{amountKey}`. A pattern written in a component takes only the props
+* of that component; one written in a helper takes any.
+*
+* @param pattern - The anchor of the pattern.
+* @param filler - The anchor of the prop: an `idProp` anchor.
+* @param wanted - The runtime key, without its prefix.
+* @returns True when the filled pattern reads as the key.
+*/
+function fills(pattern, filler, wanted) {
+	if (pattern.component !== void 0 && pattern.component !== filler.component) return false;
+	const key = pattern.key ?? "";
+	const hole = holeOf(filler.prop ?? "id");
+	if (!key.includes(hole)) return false;
+	return matchesPattern(key.replaceAll(hole, filler.key ?? ""), wanted);
+}
+/**
+* How much literal text a pattern holds: a pattern with more of it says more about a key.
+*
+* @param anchor - The anchor of a pattern.
+* @returns The length of the pattern without its holes.
+* @example
+* ```ts
+* specificityOf({ path: "strip.tsx", key: "card*Picture" }); // 11
+* ```
+*/
+function specificityOf(anchor) {
+	return (anchor.key ?? "").replaceAll(HOLE, "").replaceAll("*", "").length;
+}
+/**
+* Orders patterns from the most specific to the least, keeping their order otherwise.
+*
+* @param first - One pattern anchor.
+* @param second - The other.
+* @returns A negative number when the first holds more literal text.
+*/
+function bySpecificity(first, second) {
+	return specificityOf(second) - specificityOf(first);
+}
+/**
+* The anchors a runtime JSX key reaches through patterns: each prop-hole pattern filled with a
+* literal prop of its name (the pattern, then the prop), then each `*` pattern as a wildcard.
+* Within each tier the pattern with more literal text comes first: `card*Picture` before `card*`.
+*
+* @param shapes - The JSX shapes of the index.
+* @param wanted - The runtime key, without its prefix.
+* @returns The anchors, in that order.
+*/
+function patternAnchors(shapes, wanted) {
+	const { holePatterns, wildPatterns, idProps } = shapes;
+	const reached = [];
+	for (const pattern of holePatterns.toSorted(bySpecificity)) for (const filler of idProps.filter((item) => fills(pattern, item, wanted))) reached.push(pattern, filler);
+	const wild = wildPatterns.filter((pattern) => matchesPattern(pattern.key ?? "", wanted));
+	reached.push(...wild.toSorted(bySpecificity));
+	return reached;
+}
+/**
+* The anchors of a key, in the order `find` answers them: the exact key, then, for a JSX key as
+* the game reports it (no `*`, no prop hole), the patterns that read as it.
+*
+* @param session - The open project.
+* @param key - The key.
+* @returns The anchors, each once.
+*/
+function anchorsOf(session, key) {
+	const exact = session.index.symbols[key]?.def ?? [];
+	const reached = key.startsWith("jsx:") && !key.includes("*") && !hasHole(key) ? patternAnchors(shapesOf(session), key.slice(4)) : [];
+	return [.../* @__PURE__ */ new Set([...exact, ...reached])];
+}
+/**
+* The JSX hits of one parse, collected on the first call and kept for the next ones.
+*
+* @param typescript - The TypeScript module.
+* @param source - The parse.
+* @returns A function that answers the hits.
+*/
+function jsxHitsOnce(typescript, source) {
+	let hits;
+	return () => {
+		hits ??= collectJsx(typescript, source);
+		return hits;
+	};
+}
+/**
+* The parse a file answers from now: the bytes on disk when they parse, else the last good parse
+* of the file, marked broken.
+*
+* @param session - The open project.
+* @param file - The root-relative path.
+* @returns The view, or `undefined` when the file is gone or never parsed.
+*/
+async function viewOf(session, file) {
+	const { catalog } = session;
+	const good = catalog.records.get(file)?.good;
+	const bytes = await readInside(session.root, file);
+	if (bytes === void 0) return void 0;
+	const hash = sha1(bytes);
+	const fresh = parseCached(catalog, file, hash, hash === good?.hash ? good.text : new TextDecoder().decode(bytes));
+	if (fresh.error === void 0) return {
+		source: fresh.source,
+		hash,
+		broken: false,
+		jsx: jsxHitsOnce(catalog.typescript, fresh.source)
+	};
+	if (good === void 0) return void 0;
+	const { source } = parseCached(catalog, file, good.hash, good.text);
+	return {
+		source,
+		hash: good.hash,
+		broken: true,
+		jsx: jsxHitsOnce(catalog.typescript, source)
+	};
+}
+/**
+* The definers a file can call, recognised by binding on the module facts of the catalog, as
+* extraction does.
+*
+* @param catalog - The catalog of the project.
+* @param file - The root-relative path.
+* @returns The callee text to the definer.
+*/
+function definersAt(catalog, file) {
+	const modules = /* @__PURE__ */ new Map();
+	for (const [path, record] of catalog.records) if (record.good !== void 0) modules.set(path, record.good.module);
+	return definersOf(modules, file);
+}
+/**
+* The kind of a key: the text before its first colon.
+*
+* @param key - A key.
+* @returns The kind, or the whole key when it has no colon.
+* @example
+* ```ts
+* kindOf("style:features/ui/kit.tsx#boardStyle"); // "style"
+* ```
+*/
+function kindOf(key) {
+	const colon = key.indexOf(":");
+	return colon === -1 ? key : key.slice(0, colon);
+}
+/**
+* The identity of an answer: two anchors that land on the same element with the same key answer
+* once.
+*
+* @param answer - One answer of `find`.
+* @returns The path, the range, the kind and the key, joined.
+* @example
+* ```ts
+* identityOf({ path: "a.tsx", key: "row", kind: "literal", line: 3, range: [3, 1, 3, 9], hash: "h" }); // "a.tsx|3,1,3,9|literal|row"
+* ```
+*/
+function identityOf(answer) {
+	return `${answer.path}|${answer.range.join(",")}|${answer.kind ?? ""}|${answer.key ?? ""}`;
+}
+/**
+* Answers where a key is defined, with lines read from the files on disk now.
+*
+* @param session - The open project.
+* @param key - The key.
+* @returns One entry per place; `[]` for an unknown key.
+*/
+async function findKey(session, key) {
+	const views = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const found = [];
+	const keyKind = kindOf(key);
+	for (const anchor of anchorsOf(session, key)) {
+		if (!views.has(anchor.path)) views.set(anchor.path, await viewOf(session, anchor.path));
+		const view = views.get(anchor.path);
+		if (view === void 0) continue;
+		const answers = locate(session.catalog.typescript, view.source, anchor, {
+			keyKind,
+			jsxHits: view.jsx,
+			definers: () => definersAt(session.catalog, anchor.path)
+		}).map((place) => ({
+			...anchor,
+			...place,
+			hash: view.hash,
+			...view.broken ? { broken: true } : {}
+		}));
+		for (const answer of answers) {
+			const identity = identityOf(answer);
+			if (seen.has(identity)) continue;
+			seen.add(identity);
+			found.push(answer);
+		}
+	}
+	return found;
+}
+//#endregion
+//#region src/project/change.ts
+/**
+* The files that define a key, each once, in the order of its anchors.
+*
+* @param entry - The symbol entry.
+* @param entry.def - Its definitions.
+* @returns The paths.
+*/
+function pathsOf(entry) {
+	return [...new Set(entry.def.map((anchor) => anchor.path))];
+}
+/**
+* Compares the index before a batch with the index after it.
+*
+* @param before - The index before the batch.
+* @param after - The index after the batch.
+* @param files - The paths whose bytes changed, appeared or vanished.
+* @returns The change: the new revision, the files sorted, the moves and the removed keys.
+*/
+function diffIndexes(before, after, files) {
+	const moved = [];
+	const removed = [];
+	for (const [key, entry] of Object.entries(before.symbols)) {
+		const now = after.symbols[key];
+		if (now === void 0) {
+			removed.push(key);
+			continue;
+		}
+		const was = pathsOf(entry);
+		const is = pathsOf(now);
+		const left = was.filter((file) => !is.includes(file));
+		const arrived = is.filter((file) => !was.includes(file));
+		for (const [index, from] of left.entries()) {
+			const to = arrived[index];
+			if (to !== void 0) moved.push({
+				key,
+				from,
+				to
+			});
+		}
+	}
+	return {
+		revision: after.revision,
+		files: files.toSorted(),
+		moved,
+		removed
+	};
+}
+//#endregion
+//#region src/project/walk.ts
+/**
+* Reads the stamp of a file.
+*
+* @param file - The absolute path.
+* @returns The stamp, or `undefined` when the file is gone.
+*/
+async function stampOf(file) {
+	try {
+		const stats = await stat(file, { bigint: true });
+		return {
+			ino: stats.ino,
+			size: stats.size,
+			mtimeNs: stats.mtimeNs,
+			ctimeNs: stats.ctimeNs
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* Whether two stamps describe the same write.
+*
+* @param first - One stamp.
+* @param second - The other.
+* @returns True when inode, size and both time stamps are equal.
+* @example
+* ```ts
+* const stamp = { ino: 1n, size: 10n, mtimeNs: 5n, ctimeNs: 5n };
+* sameStamp(stamp, { ...stamp, size: 11n }); // false
+* ```
+*/
+function sameStamp(first, second) {
+	return first.ino === second.ino && first.size === second.size && first.mtimeNs === second.mtimeNs && first.ctimeNs === second.ctimeNs;
+}
+/**
+* Lists one folder, empty when it vanished during the walk.
+*
+* @param folder - The absolute folder.
+* @returns Its entries.
+*/
+async function entriesOf(folder) {
+	return readdir(folder, { withFileTypes: true }).catch(() => []);
+}
+/**
+* Reads one folder of the walk: its sub-folders join the queue, its source files join the list
+* with their stamps.
+*
+* @param root - The real root.
+* @param folder - The folder, root-relative; `""` is the root.
+* @param walk - The files so far, and the queue of folders still to read.
+* @param walk.files - The files so far.
+* @param walk.pending - The folders still to read.
+*/
+async function readFolder(root, folder, walk) {
+	for (const entry of await entriesOf(path.join(root, folder))) {
+		const relative = folder === "" ? entry.name : `${folder}/${entry.name}`;
+		if (entry.isDirectory() && !isSkippedFolder(entry.name)) walk.pending.push(relative);
+		if (!entry.isFile() || !isIndexedFile(relative)) continue;
+		const stamp = await stampOf(path.join(root, relative));
+		if (stamp !== void 0) walk.files.set(relative, stamp);
+	}
+}
+/**
+* Walks a root: every indexed source file with its stamp and every folder outside the skipped
+* ones. Symlinks are skipped, files and folders alike.
+*
+* @param root - The real root.
+* @returns The files and the folders, root-relative POSIX.
+*/
+async function walkRoot(root) {
+	const files = /* @__PURE__ */ new Map();
+	const folders = [];
+	const pending = [""];
+	for (let folder = pending.pop(); folder !== void 0; folder = pending.pop()) {
+		folders.push(folder);
+		await readFolder(root, folder, {
+			files,
+			pending
+		});
+	}
+	return {
+		files,
+		folders
+	};
+}
+//#endregion
+//#region src/project/session.ts
+/**
+* @file project — an open project: the real root, the catalog of its files, the stamps of the last
+* walk, the current index and a queue that runs one update at a time. `syncWithDisk` is the batch
+* walk of a watch batch: it walks the root, hashes the files whose stamp moved and every new one,
+* drops the vanished ones and rebuilds the index when bytes changed. `reindexPath` reads one path
+* now for `changed`.
+*/
+/** The manifest the asset scanner writes by default. */
+const MANIFEST_FILE = "manifest.json";
+/**
+* The manifest path to report, when the file exists.
+*
+* @param root - The real root.
+* @param manifest - The root-relative manifest path.
+* @returns The path, or `undefined` when nothing is there.
+*/
+async function presentManifest(root, manifest) {
+	try {
+		if (await resolveInside(root, manifest) !== void 0) return manifest;
+	} catch {}
+}
+/**
+* Reads one file into the catalog, or drops it when it is gone or cannot be read.
+*
+* @param session - The project.
+* @param file - The root-relative path.
+* @returns True when the catalog changed.
+*/
+async function readIntoCatalog(session, file) {
+	const bytes = await readInside(session.root, file);
+	if (bytes === void 0) {
+		session.stamps.delete(file);
+		return dropFile(session.catalog, file);
+	}
+	return putFile(session.catalog, file, bytes);
+}
+/**
+* Rebuilds the index after files changed and says what changed.
+*
+* @param session - The project.
+* @param files - The paths whose bytes changed, appeared or vanished.
+* @returns The change.
+*/
+async function rebuild(session, files) {
+	const before = session.index;
+	const manifest = await presentManifest(session.root, session.manifest);
+	session.index = buildIndex(session.catalog, manifest);
+	return diffIndexes(before, session.index, files);
+}
+/**
+* Opens a project: checks the root, loads TypeScript, reads every source file and builds the
+* index.
+*
+* @param options - The root, the manifest and the debounce.
+* @returns The open project.
+* @throws {Error} When the root is missing or not a directory, the manifest path leaves the root,
+*   or TypeScript is not installed.
+*/
+async function openSession(options) {
+	const root = await openRoot(options.root);
+	const typescript = await loadTypeScript();
+	const manifest = toPosix(options.manifest ?? MANIFEST_FILE);
+	await resolveInside(root, manifest);
+	const walk = await walkRoot(root);
+	const catalog = createCatalog(typescript);
+	const session = {
+		root,
+		manifest,
+		catalog,
+		stamps: walk.files,
+		folders: walk.folders,
+		index: buildIndex(catalog),
+		shapes: /* @__PURE__ */ new WeakMap(),
+		queue: Promise.resolve()
+	};
+	for (const file of [...walk.files.keys()].toSorted()) await readIntoCatalog(session, file);
+	session.index = buildIndex(catalog, await presentManifest(root, manifest));
+	return session;
+}
+/**
+* Runs an update after the ones before it, so two never interleave.
+*
+* @param session - The project.
+* @param task - The update.
+* @returns What the update returns.
+*/
+function serialize(session, task) {
+	const result = session.queue.then(task);
+	session.queue = result.catch(() => {});
+	return result;
+}
+/**
+* The batch walk: walks the root, hashes each file whose stamp moved and each new one, drops the
+* vanished ones, and rebuilds the index when bytes changed. A save with the same bytes changes
+* nothing.
+*
+* @param session - The project.
+* @returns The change, or `undefined` when the index stayed the same.
+*/
+async function syncWithDisk(session) {
+	const walk = await walkRoot(session.root);
+	const files = [];
+	for (const file of session.catalog.records.keys()) if (!walk.files.has(file) && dropFile(session.catalog, file)) files.push(file);
+	const previous = session.stamps;
+	session.stamps = walk.files;
+	session.folders = walk.folders;
+	for (const [file, stamp] of walk.files) {
+		const known = previous.get(file);
+		if (!(known !== void 0 && sameStamp(known, stamp)) && await readIntoCatalog(session, file)) files.push(file);
+	}
+	const manifest = await presentManifest(session.root, session.manifest);
+	if (files.length === 0 && manifest === session.index.manifest) return void 0;
+	return rebuild(session, files);
+}
+/**
+* Reads one root-relative path now: a changed or new source file is parsed, a deleted one is
+* dropped, and anything the index does not read changes nothing.
+*
+* @param session - The project.
+* @param file - The root-relative path.
+* @returns The index after the read.
+* @throws {Error} When the path leaves the root.
+*/
+async function reindexPath(session, file) {
+	const relative = toPosix(file);
+	const real = await resolveInside(session.root, relative);
+	const isLinked = real !== void 0 && real !== path.join(session.root, relative);
+	if (path.isAbsolute(relative) || isLinked || !isIndexedFile(relative)) return session.index;
+	const stamp = real === void 0 ? void 0 : await stampOf(real);
+	if (stamp !== void 0) session.stamps.set(relative, stamp);
+	if (!await readIntoCatalog(session, relative)) return session.index;
+	await rebuild(session, [relative]);
+	return session.index;
+}
+//#endregion
+//#region src/project/watch.ts
+/**
+* @file project — the watcher of an open project. A platform event is only a trigger: Bun on macOS
+* reports every edit as `rename`, drops the destination of a move and names the `.tmp` of an
+* atomic save instead of the file. So events only poke a batcher; when the quiet period ends, the
+* batch walks the root (`syncWithDisk`) and finds what really changed. The watcher can also miss a
+* write made as it starts, so the handle walks once when watching starts and then every two
+* seconds as a backstop. The root is watched recursively; where the platform cannot, every folder
+* of the last walk gets its own watcher, re-armed after each walk. Every caller of `watch` shares
+* the one watcher of the handle.
+*/
+/** The longest a burst of events holds a batch back, at the least. */
+const LONGEST_WAIT_MS = 1e3;
+/** The longest wait as a multiple of the quiet period, when that is longer. */
+const LONGEST_WAIT_FACTOR = 10;
+/**
+* How often a watching handle walks the root with no event: the platform watcher can miss a write
+* made as it starts, and drop events under load. A walk that finds the same bytes calls nobody.
+*/
+const BACKSTOP_MS = 2e3;
+/** The error `watch` throws on a closed handle. */
+const CLOSED = "[game] The project is closed.\n  Open it again with openProject().";
+/**
+* Watches every folder of the last walk with its own watcher, for a platform without recursive
+* watching.
+*
+* @param root - The real root.
+* @param listener - Gets every event.
+* @param onError - Called when a folder watcher errors.
+* @param watchFunction - `fs.watch`.
+* @returns The tree watcher.
+*/
+function watchFolders(root, listener, onError, watchFunction) {
+	const watchers = /* @__PURE__ */ new Map();
+	const arm = (folder) => {
+		try {
+			const handle = watchFunction(path.join(root, folder), { recursive: false }, listener);
+			handle.on("error", () => {
+				handle.close();
+				if (watchers.get(folder) === handle) watchers.delete(folder);
+				onError();
+			});
+			watchers.set(folder, handle);
+		} catch {}
+	};
+	return {
+		rearm: (folders) => {
+			for (const [folder, handle] of watchers) {
+				if (folders.includes(folder)) continue;
+				handle.close();
+				watchers.delete(folder);
+			}
+			for (const folder of folders) if (!watchers.has(folder)) arm(folder);
+		},
+		close: () => {
+			for (const handle of watchers.values()) handle.close();
+			watchers.clear();
+		}
+	};
+}
+/**
+* Watches a root: recursively when the platform can, else one watcher per folder. Events under
+* the skipped folders are ignored.
+*
+* @param root - The real root.
+* @param onEvent - Called on every event that may matter.
+* @param watchFunction - `fs.watch` by default.
+* @returns The tree watcher.
+*/
+function watchTree(root, onEvent, watchFunction = watch) {
+	const listener = (_event, file) => {
+		if (file === null || !isSkippedPath(`${file}/`)) onEvent();
+	};
+	try {
+		const handle = watchFunction(root, { recursive: true }, listener);
+		handle.on("error", () => onEvent());
+		return {
+			rearm: () => {},
+			close: () => handle.close()
+		};
+	} catch {
+		return watchFolders(root, listener, onEvent, watchFunction);
+	}
+}
+/**
+* Creates the debounce of a watcher: a batch runs once the events stop for `quietMs`, or after the
+* longest wait during an endless burst. One batch runs at a time; events during a batch queue one
+* more.
+*
+* @param quietMs - The quiet period that closes a batch.
+* @param run - The batch.
+* @returns The batcher.
+*/
+function createBatcher(quietMs, run) {
+	const longestMs = Math.max(LONGEST_WAIT_MS, quietMs * LONGEST_WAIT_FACTOR);
+	let quiet;
+	let longest;
+	let running = false;
+	let pending = false;
+	let cancelled = false;
+	const clear = () => {
+		clearTimeout(quiet);
+		clearTimeout(longest);
+		quiet = void 0;
+		longest = void 0;
+	};
+	const fire = () => {
+		clear();
+		if (running) {
+			pending = true;
+			return;
+		}
+		const settle = () => {
+			running = false;
+			if (pending && !cancelled) poke();
+			pending = false;
+		};
+		running = true;
+		run().then(settle, settle);
+	};
+	const poke = () => {
+		if (cancelled) return;
+		clearTimeout(quiet);
+		quiet = setTimeout(fire, quietMs);
+		longest ??= setTimeout(fire, longestMs);
+	};
+	return {
+		poke,
+		cancel: () => {
+			cancelled = true;
+			clear();
+		}
+	};
+}
+/**
+* Creates the callers' hub of one handle: the watcher starts with the first caller and stops with
+* the last; each batch that changed the index calls every caller once.
+*
+* @param session - The open project.
+* @param debounceMs - The quiet period.
+* @param watchFunction - `fs.watch` by default.
+* @param backstopMs - The period of the walk with no event, two seconds by default.
+* @returns The hub.
+*/
+function createHub(session, debounceMs, watchFunction = watch, backstopMs = BACKSTOP_MS) {
+	const listeners = /* @__PURE__ */ new Set();
+	let tree;
+	let batcher;
+	let backstop;
+	let closed = false;
+	const batch = async () => {
+		const change = await serialize(session, () => syncWithDisk(session));
+		tree?.rearm(session.folders);
+		if (change === void 0 || closed) return;
+		for (const { listener } of [...listeners]) try {
+			listener(session.index, change);
+		} catch {}
+	};
+	const stop = () => {
+		clearInterval(backstop);
+		tree?.close();
+		batcher?.cancel();
+		backstop = void 0;
+		tree = void 0;
+		batcher = void 0;
+	};
+	const start = () => {
+		const started = createBatcher(debounceMs, batch);
+		batcher = started;
+		tree = watchTree(session.root, () => started.poke(), watchFunction);
+		tree.rearm(session.folders);
+		started.poke();
+		backstop = setInterval(() => started.poke(), backstopMs);
+	};
+	return {
+		add: (listener) => {
+			if (closed) throw new Error(CLOSED);
+			const entry = { listener };
+			listeners.add(entry);
+			if (tree === void 0) start();
+			return () => {
+				listeners.delete(entry);
+				if (listeners.size === 0) stop();
+			};
+		},
+		close: () => {
+			closed = true;
+			listeners.clear();
+			stop();
+		}
+	};
+}
+//#endregion
+//#region src/project/open.ts
+/**
+* @file project — `openProject`, the one function of the project index a caller starts from. It
+* opens the root, builds the index and hands back the handle: the current index, `find`, `watch`,
+* `changed` and `close`.
+*/
+/** The quiet period that closes a watch batch, when the options name none. */
+const DEFAULT_DEBOUNCE_MS = 75;
+/**
+* Opens the project index of a game: checks the root (it exists, it is a directory, its real
+* path), loads TypeScript, parses every source file and builds the index. Nothing is written to
+* disk and nothing is inferred from the working directory but the root itself.
+*
+* @param options - The game root, the manifest path and the quiet period of `watch`.
+* @returns The handle; close it when the game closes.
+* @throws {Error} When the root is missing or not a directory, or the `typescript` package is not
+*   installed: `[game] The project index needs the "typescript" package.`
+* @example
+* ```ts
+* // The editor opens the fixture game and answers where a node and a text style live.
+* const project = await openProject({ root: "tests/integration/merge-game" });
+* Object.keys(project.index.files).length; // 111
+* (await project.find("textStyle:ui.title"))[0]?.line; // 39, in "features/ui/styles.ts"
+* project.close();
+* ```
+*/
+async function openProject(options) {
+	const session = await openSession(options);
+	const hub = createHub(session, options.debounceMs ?? DEFAULT_DEBOUNCE_MS);
+	return {
+		/**
+		* The current index of the session; a batch or `changed` replaces it.
+		*
+		* @returns The index.
+		*/
+		get index() {
+			return session.index;
+		},
+		find: (key) => findKey(session, key),
+		watch: (onIndex) => hub.add(onIndex),
+		changed: (file) => serialize(session, () => reindexPath(session, file)),
+		close: () => hub.close()
+	};
+}
+//#endregion
+//#region src/project/cli.ts
+/**
+* @file project — the command line `moku-game-index`. It opens the project of `--root` and runs one
+* command: `--json` prints the index, `where <key>` prints one `path:line` per place, `--check`
+* reports broken files and conflicts (exit 1) and lists the unresolved items as info. Output goes
+* through the branded console of `@moku-labs/common`; `runCli` returns the exit code instead of
+* taking it.
+*/
+/** The usage line under every flag error. */
+const USAGE = "Run: moku-game-index --root <dir> [--manifest <path>] --json | --check | where <key>.";
+/** Pretty JSON indent of `--json`. */
+const JSON_INDENT = 2;
+/**
+* Wraps a command line problem in the message shape of the framework.
+*
+* @param message - One sentence naming the flag.
+* @returns The error to throw.
+*/
+function problem(message) {
+	return /* @__PURE__ */ new Error(`[game] index: ${message}\n  ${USAGE}`);
+}
+/**
+* Reads the message of anything that was thrown.
+*
+* @param failure - What the `catch` caught.
+* @returns The message.
+*/
+function messageOf(failure) {
+	return failure instanceof Error ? failure.message : String(failure);
+}
+/**
+* The value after a flag that takes one.
+*
+* @param argv - The arguments.
+* @param at - The index of the flag.
+* @param what - What the flag needs, for the error.
+* @returns The value.
+* @throws {Error} When the value is missing.
+*/
+function valueAfter(argv, at, what) {
+	const flag = argv[at] ?? "";
+	const value = argv[at + 1];
+	if (value === void 0 || value.startsWith("--")) throw problem(`"${flag}" needs ${what}.`);
+	return value;
+}
+/**
+* Reads one flag or command into the flags.
+*
+* @param argv - The arguments.
+* @param at - The index of the flag.
+* @param flags - The flags so far.
+* @returns How many arguments the flag took.
+* @throws {Error} When the flag is unknown or misses its value.
+*/
+function readFlag(argv, at, flags) {
+	const flag = argv[at];
+	switch (flag) {
+		case "--json":
+			flags.commands.push({ kind: "json" });
+			return 1;
+		case "--check":
+			flags.commands.push({ kind: "check" });
+			return 1;
+		case "where":
+			flags.commands.push({
+				kind: "where",
+				key: valueAfter(argv, at, "a key, such as node:board/merge")
+			});
+			return 2;
+		case "--root":
+			flags.root = valueAfter(argv, at, "a path");
+			return 2;
+		case "--manifest":
+			flags.manifest = valueAfter(argv, at, "a path");
+			return 2;
+		default: throw problem(`unknown option "${String(flag)}".`);
+	}
+}
+/**
+* Reads the arguments.
+*
+* @param argv - The arguments after the script name.
+* @returns The root, the manifest and the one command.
+* @throws {Error} When a flag is unknown, a value is missing, `--root` is missing or the commands
+*   are not exactly one.
+*/
+function parseArgv(argv) {
+	const flags = { commands: [] };
+	for (let at = 0; at < argv.length;) at += readFlag(argv, at, flags);
+	if (flags.root === void 0) throw new Error("[game] index: \"--root\" is required.\n  Name the game folder: moku-game-index --root <dir> where <key>.");
+	const [command] = flags.commands;
+	if (command === void 0 || flags.commands.length > 1) throw problem("name one command: --json, --check or where <key>.");
+	return {
+		root: flags.root,
+		command,
+		...flags.manifest === void 0 ? {} : { manifest: flags.manifest }
+	};
+}
+/**
+* One line of a `where` answer.
+*
+* @param found - One place of the key.
+* @returns `path:line`, with ` (broken)` when the line comes from the last good parse.
+* @example
+* ```ts
+* whereLine({ path: "nodes/merge.ts", line: 17, range: [17, 1, 38, 4], hash: "ab" }); // "nodes/merge.ts:17"
+* ```
+*/
+function whereLine(found) {
+	return `${found.path}:${found.line}${found.broken === true ? " (broken)" : ""}`;
+}
+/**
+* Counts a thing in words, so the summary reads as a sentence.
+*
+* @param count - How many.
+* @param word - The singular.
+* @returns The count and the word.
+* @example
+* ```ts
+* plural(1, "key"); // "1 key"
+* ```
+*/
+function plural(count, word) {
+	return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+/**
+* The `--check` report: a summary, every broken file and conflict as an error, every unresolved
+* item as info.
+*
+* @param index - The index.
+* @param ui - Where the lines go.
+* @returns `1` when a file is broken or a key is in conflict, else `0`.
+*/
+function printCheck(index, ui) {
+	const files = Object.entries(index.files);
+	const symbols = Object.entries(index.symbols);
+	const broken = files.filter(([, file]) => file.state === "broken");
+	const conflicts = symbols.filter(([, symbol]) => symbol.conflict === true);
+	ui.info(`${plural(files.length, "file")}, ${plural(symbols.length, "key")}: ${broken.length} broken, ${conflicts.length} in conflict, ${index.unresolved.length} unresolved.`);
+	for (const [file, entry] of broken) ui.error(`broken ${file}: ${entry.error ?? ""}`);
+	for (const [key, symbol] of conflicts) ui.error(`conflict ${key}: ${symbol.def.map((anchor) => anchor.path).join(", ")}`);
+	for (const item of index.unresolved) ui.info(`unresolved ${item.path}: ${item.reason}`);
+	return broken.length + conflicts.length > 0 ? 1 : 0;
+}
+/**
+* The `where` answer: one line per place of the key.
+*
+* @param project - The open project.
+* @param key - The key.
+* @param root - The root as given, for the message.
+* @param ui - Where the lines go.
+* @returns `1` when the key is unknown, else `0`.
+*/
+async function printWhere(project, key, root, ui) {
+	const found = await project.find(key);
+	if (found.length === 0) {
+		ui.error(`[game] The key "${key}" is not in the index of "${root}".\n  Run "moku-game-index --root ${root} --json" to list the keys.`);
+		return 1;
+	}
+	for (const place of found) ui.line(whereLine(place));
+	return 0;
+}
+/**
+* Runs the one command of the line on an open project.
+*
+* @param project - The open project.
+* @param options - What the flags asked for.
+* @param ui - Where the lines go.
+* @returns The exit code.
+*/
+async function runCommand(project, options, ui) {
+	const { command } = options;
+	if (command.kind === "where") return printWhere(project, command.key, options.root, ui);
+	if (command.kind === "check") return printCheck(project.index, ui);
+	ui.line(JSON.stringify(project.index, void 0, JSON_INDENT));
+	return 0;
+}
+/**
+* Runs `moku-game-index`: opens the project of `--root` and runs one command. Nothing here calls
+* `process.exit`; the caller does.
+*
+* @param argv - The arguments after the script name.
+* @param ui - Where the lines go. The branded console by default.
+* @returns The exit code: `1` for a bad flag, a root that cannot be opened, an unknown key, or a
+*   `--check` that found a broken file or a conflict; else `0`.
+* @example
+* ```ts
+* // An agent asks where a node of the fixture game lives.
+* await runCli(["--root", "tests/integration/merge-game", "where", "node:board/merge"]);
+* // 0, and the console printed "nodes/merge.ts:17"
+* ```
+*/
+async function runCli(argv, ui = createBrandConsole()) {
+	try {
+		const options = parseArgv(argv);
+		const project = await openProject({
+			root: options.root,
+			...options.manifest === void 0 ? {} : { manifest: options.manifest }
+		});
+		try {
+			return await runCommand(project, options, ui);
+		} finally {
+			project.close();
+		}
+	} catch (error) {
+		ui.error(messageOf(error));
+		return 1;
+	}
+}
+//#endregion
+//#region src/project.ts
+/**
+* @file The project door of the engine (subpath `./project`, node and bun only): the static index
+* of a game's sources. `openProject` parses the game with TypeScript (an optional peer, loaded on
+* the first open) and maps every engine id (flows, nodes, features, scenes, projections, emitters,
+* text styles, styles and JSX keys) to anchors; `find` reads the line of a key from the file on
+* disk at the call, `watch` keeps the index fresh while agents edit files. The package bin
+* `moku-game-index` runs `runCli`. Re-exports only: the code lives in `project/`, and this is the
+* one door to it in `src/`.
+*/
+if (import.meta.main) process.exitCode = await runCli(process.argv.slice(2));
+//#endregion
+export { openProject, runCli };