@moku-labs/game 0.6.0 → 0.7.1

package/dist/project.mjs

@@ -3,1022 +3,1299 @@ import { readFile, readdir, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { watch } from "node:fs";
-/** The definers whose calls make keys. */
-const DEFINERS = [
-	"defineFlow",
-	"defineFeature",
-	"defineScene",
-	"projection",
-	"defineEmitter",
-	"defineTextStyles",
-	"defineStyle"
-];
+//#region src/project/extract/scope.ts
 /**
-* Whether a name is a definer whose calls make keys.
+* Unwraps the expressions that change no value: parentheses, `as`, `satisfies`, `!` and `<T>`.
 *
-* @param name - A name.
-* @returns True for the definers of `DEFINERS`.
-* @example
-* ```ts
-* isDefiner("defineScene"); // true
-* ```
+* @param typescript - The TypeScript module.
+* @param node - An expression.
+* @returns The expression inside.
 */
-function isDefiner(name) {
-	return DEFINERS.includes(name);
+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;
 }
 /**
-* Whether a statement carries a modifier.
+* The text of a property name written literally: an identifier, a string or a number.
 *
 * @param typescript - The TypeScript module.
-* @param node - The statement.
-* @param kind - `ExportKeyword` or `DefaultKeyword`.
-* @returns True when the modifier is there.
+* @param name - A property name.
+* @returns The text, or `undefined` for a computed or a private name.
 */
-function hasModifier(typescript, node, kind) {
-	if (!typescript.canHaveModifiers(node)) return false;
-	return typescript.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false;
+function literalNameOf(typescript, name) {
+	return typescript.isIdentifier(name) || typescript.isStringLiteral(name) || typescript.isNumericLiteral(name) ? name.text : void 0;
 }
 /**
-* The names a binding declares: the identifier, or every name of a destructure.
+* 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 name - The binding name.
-* @returns The declared names.
+* @param node - Any node.
+* @returns The name, or `undefined` for a spread, a computed name or a node without a name.
 */
-function namesOf(typescript, name) {
-	if (typescript.isIdentifier(name)) return [name.text];
-	return name.elements.flatMap((element) => typescript.isBindingElement(element) ? namesOf(typescript, element.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;
 }
 /**
-* Records the value imports of one import statement.
+* Whether a node holds statements: a block, a source file, a module block or a case clause.
 *
-* @param typescript - The TypeScript module.
-* @param statement - The import statement.
-* @param draft - The facts so far.
+* @param node - A node.
+* @returns True when it has a `statements` list.
 */
-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
-		});
-	}
+function holdsStatements(node) {
+	return "statements" in node && Array.isArray(node.statements);
 }
 /**
-* Records one export statement: a re-export from another module, a star, or a list of local
-* bindings.
+* Whether a node is a function whose parameters a name can be.
 *
 * @param typescript - The TypeScript module.
-* @param statement - The export statement.
-* @param draft - The facts so far.
+* @param node - A node.
+* @returns True for function declarations, expressions, arrows and methods.
 */
-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);
-	}
+function isFunctionScope(typescript, node) {
+	return typescript.isFunctionDeclaration(node) || typescript.isFunctionExpression(node) || typescript.isArrowFunction(node) || typescript.isMethodDeclaration(node);
 }
 /**
-* Whether an import brings a name of the engine package.
+* The meaning of a `const` declarator: a function when its initializer is one.
 *
-* @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
-* ```
+* @param typescript - The TypeScript module.
+* @param initializer - The initializer of the const.
+* @returns The meaning.
 */
-function isGameImport(ref, name) {
-	return ref?.specifier === "@moku-labs/game" && ref.imported === name;
+function constMeaning(typescript, initializer) {
+	const inner = unwrap(typescript, initializer);
+	return typescript.isArrowFunction(inner) || typescript.isFunctionExpression(inner) ? {
+		kind: "function",
+		node: inner
+	} : {
+		kind: "const",
+		initializer
+	};
 }
 /**
-* Whether an expression calls `defineGame` of the engine: by a named import, renamed or not, or
-* through a namespace import of the package.
+* Looks for a name among the statements of one block.
 *
 * @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.
+* @param holder - The block.
+* @param name - The name.
+* @returns What the name means there, or `undefined`.
 */
-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), "*");
+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);
+	}
 }
 /**
-* Records the definers a `defineGame` destructure hands out, under their local names.
+* Looks for a name among the names of a destructured parameter (`({ id }) => …`).
 *
 * @param typescript - The TypeScript module.
 * @param pattern - The destructure.
-* @param draft - The facts so far.
+* @param name - The name.
+* @returns The parameter meaning with the property it takes, or `undefined`.
 */
-function readKit(typescript, pattern, draft) {
+function destructuredIn(typescript, pattern, name) {
 	for (const element of pattern.elements) {
-		if (!typescript.isIdentifier(element.name)) continue;
+		if (!(typescript.isBindingElement(element) && typescript.isIdentifier(element.name) && element.name.text === 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);
+		return {
+			kind: "param",
+			property: property !== void 0 && typescript.isIdentifier(property) ? property.text : name
+		};
 	}
 }
 /**
-* Records one top-level variable statement: its names, its exports and a kit destructure.
+* 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 statement - The statement.
-* @param draft - The facts so far.
+* @param scope - The function.
+* @param name - The name.
+* @returns The parameter meaning, or `undefined`.
 */
-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);
+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;
 	}
 }
 /**
-* Records a top-level function or class: its name, and its export.
+* Says what a name means at the place it is used, walking up from there.
 *
 * @param typescript - The TypeScript module.
-* @param statement - The declaration.
-* @param draft - The facts so far.
+* @param identifier - The name where it is used.
+* @returns What it means, or `undefined` when the file does not declare it.
 */
-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 });
+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;
+	}
 }
 /**
-* 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.
+* The statement directly under the file that a node sits in.
 *
 * @param typescript - The TypeScript module.
-* @param source - The parsed file.
-* @returns The facts.
+* @param node - Any node.
+* @returns The statement, or the file itself for the file.
 */
-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;
+function topStatementOf(typescript, node) {
+	let statement = node;
+	while (statement.parent !== void 0 && !typescript.isSourceFile(statement.parent)) statement = statement.parent;
+	return statement;
 }
-//#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.
+* 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.
 */
-/** 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)$/;
+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;
+}
 /**
-* Whether a module specifier is relative to the importing file.
+* The function a const declarator holds, through parentheses, `as` and `satisfies`.
 *
-* @param specifier - The module specifier.
-* @returns True for `./…` and `../…`.
-* @example
-* ```ts
-* isRelative("../kit"); // true
-* ```
+* @param typescript - The TypeScript module.
+* @param declaration - The declarator.
+* @returns The arrow or function expression, or `undefined` for any other value.
 */
-function isRelative(specifier) {
-	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+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;
 }
 /**
-* 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`.
+* 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 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.
+* @param typescript - The TypeScript module.
+* @param statement - A statement directly under the file.
+* @returns The functions, in source order.
 */
-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));
+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
+		}];
+	});
 }
 /**
-* Follows an imported name into the module that the specifier names.
+* 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 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.
+* @param typescript - The TypeScript module.
+* @param node - Any node.
+* @returns The name of the function, or `undefined`.
 */
-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);
+function enclosingFunction(typescript, node) {
+	return declaredFunctions(typescript, topStatementOf(typescript, node)).find((item) => item.node.pos <= node.pos && node.end <= item.node.end)?.name;
 }
 /**
-* Follows an exported name of a module: a local binding, a re-export, or a star export.
+* The name of the object property whose value an expression is: `disc` for the call in
+* `{ disc: defineStyle(…) }`, through parentheses, `as` and `satisfies`.
 *
-* @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.
+* @param typescript - The TypeScript module.
+* @param node - An expression.
+* @returns The property name when it is written literally; `undefined` for anything else.
 */
-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;
-	}
+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);
 }
 /**
-* 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.
+* 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`.
 */
-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);
-}
+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 definer a target is, if any: one the kit hands out, or one imported from the engine.
+* The hole a prop of a component leaves in a key.
 *
-* @param target - Where a name ends up.
-* @returns The definer, or `undefined`.
+* @param property - The name of the prop.
+* @returns The hole: `{amountKey}` for `amountKey`.
 * @example
 * ```ts
-* definerOf({ kind: "package", specifier: "@moku-labs/game", imported: "defineStyle" }); // "defineStyle"
+* holeOf("amountKey"); // "{amountKey}"
 * ```
 */
-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;
+function holeOf(property) {
+	return `{${property}}`;
 }
-//#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.
+* Whether a pattern holds a hole a prop fills.
 *
-* @param bytes - The file bytes, or a text.
-* @returns The hex digest.
+* @param pattern - A pattern or a key.
+* @returns True when it holds `{id}`, `{amountKey}` or another prop hole.
 * @example
 * ```ts
-* sha1(""); // "da39a3ee5e6b4b0d3255bfef95601890afd80709"
+* hasHole("{id}Close"); // true
 * ```
 */
-function sha1(bytes) {
-	return createHash("sha1").update(bytes).digest("hex");
+function hasHole(pattern) {
+	return pattern.search(HOLE) !== -1;
 }
 /**
-* The revision of an index: the sha1 of the lines `${path}\0${hash}\n`, sorted by path.
+* The hole a prop of a parameter object leaves: its own hole for a key-carrying prop, `*` else.
 *
-* @param files - Every indexed file with its hash.
-* @returns The hex digest.
+* @param property - The name of the prop, when the parameter is read through one.
+* @returns The hole.
 * @example
 * ```ts
-* revisionOf({}); // "da39a3ee5e6b4b0d3255bfef95601890afd80709"
+* propertyHole("tab"); // "*"
 * ```
 */
-function revisionOf(files) {
-	return sha1(Object.entries(files).map(([file, entry]) => `${file}\0${entry.hash}\n`).toSorted().join(""));
+function propertyHole(property) {
+	return property !== void 0 && KEY_PROP.test(property) ? holeOf(property) : "*";
 }
-//#endregion
-//#region src/project/assemble.ts
 /**
-* The entry of a key, made on first use.
+* The one expression a function returns, when it has exactly one.
 *
-* @param symbols - The keys so far.
-* @param key - The key.
-* @returns Its entry.
+* @param typescript - The TypeScript module.
+* @param node - The function.
+* @returns The returned expression, or `undefined`.
 */
-function entryOf(symbols, key) {
-	const existing = symbols.get(key);
-	if (existing !== void 0) return existing;
-	const entry = {
-		def: [],
-		uses: []
+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);
 	};
-	symbols.set(key, entry);
-	return entry;
+	typescript.forEachChild(body, collect);
+	return returns.length === 1 ? returns[0]?.expression : void 0;
 }
 /**
-* 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.
+* Reads a name: a bound parameter, a const, or a destructured key-carrying prop.
 *
-* @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.
+* @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 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
-			});
-		}
-	}
+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 "*";
 }
 /**
-* Adds, to every style key, the files that import its binding by name.
+* Reads `props.id` or `props.amountKey`: a key-carrying prop of a parameter object becomes its
+* hole, any other prop `*`.
 *
-* @param assembly - The records and module facts.
-* @param symbols - The keys so far.
+* @param typescript - The TypeScript module.
+* @param access - The property access.
+* @param bindings - The parameters bound by the call being read.
+* @returns The pattern.
 */
-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
-		});
-	}
+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) : "*";
 }
 /**
-* 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.
+* Reads a call of a same-file function: its one returned expression, with each parameter bound
+* to the pattern of its argument.
 *
-* @param symbols - The keys as collected.
-* @returns The symbols of the index.
+* @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 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 } : {}
-		};
+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 finished;
+	return read(typescript, returned, inner, depth + 1);
 }
 /**
-* Freezes a value and everything it holds.
+* Reads a template: its literal parts stay, each span is read into a pattern.
 *
-* @param value - A plain value.
-* @returns The same value, frozen.
+* @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 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;
+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("");
 }
 /**
-* Assembles the index of a catalog.
+* Reads one expression into a pattern.
 *
-* @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.
+* @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 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);
-	return deepFreeze({
-		schemaVersion: 1,
-		revision: revisionOf(files),
-		...manifest === void 0 ? {} : { manifest },
-		symbols: finishSymbols(symbols),
-		files,
-		unresolved
-	});
+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 "*";
 }
-//#endregion
-//#region src/project/extract/scope.ts
 /**
-* Unwraps the expressions that change no value: parentheses, `as`, `satisfies`, `!` and `<T>`.
+* Reduces a key expression to its pattern, with neighbouring `*` holes merged into one.
 *
 * @param typescript - The TypeScript module.
-* @param node - An expression.
-* @returns The expression inside.
+* @param expression - The expression of a JSX `key` attribute.
+* @returns The pattern: `card*Picture`, `{id}Close`, `{amountKey}`, `hudRow`, or `*` when nothing
+* is literal.
 */
-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;
+function patternOf(typescript, expression) {
+	return read(typescript, expression, /* @__PURE__ */ new Map(), 0).replaceAll(/\*+/g, "*");
 }
 /**
-* Whether a node holds statements: a block, a source file, a module block or a case clause.
+* The literal head of a pattern: the text before its first hole.
 *
-* @param node - A node.
-* @returns True when it has a `statements` list.
+* @param pattern - A pattern.
+* @returns The head, empty when the pattern starts with a hole.
+* @example
+* ```ts
+* stemOf("card*Picture"); // "card"
+* ```
 */
-function holdsStatements(node) {
-	return "statements" in node && Array.isArray(node.statements);
+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]/;
 /**
-* Whether a node is a function whose parameters a name can be.
+* The expression a JSX attribute holds: the string of `key="x"` or the code of `key={x}`.
 *
 * @param typescript - The TypeScript module.
-* @param node - A node.
-* @returns True for function declarations, expressions, arrows and methods.
+* @param attribute - The attribute.
+* @returns The expression, or `undefined` for `<a key />` and `key={}`.
 */
-function isFunctionScope(typescript, node) {
-	return typescript.isFunctionDeclaration(node) || typescript.isFunctionExpression(node) || typescript.isArrowFunction(node) || typescript.isMethodDeclaration(node);
+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;
 }
 /**
-* The meaning of a `const` declarator: a function when its initializer is one.
+* How a key expression is written.
 *
 * @param typescript - The TypeScript module.
-* @param initializer - The initializer of the const.
-* @returns The meaning.
+* @param expression - The key expression.
+* @returns `literal` for a string, `template` for a template with holes, `ident` for the rest.
 */
-function constMeaning(typescript, initializer) {
-	const inner = unwrap(typescript, initializer);
-	return typescript.isArrowFunction(inner) || typescript.isFunctionExpression(inner) ? {
-		kind: "function",
-		node: inner
-	} : {
-		kind: "const",
-		initializer
-	};
+function kindOf$1(typescript, expression) {
+	const inner = unwrap(typescript, expression);
+	if (typescript.isStringLiteralLike(inner)) return "literal";
+	return typescript.isTemplateExpression(inner) ? "template" : "ident";
 }
 /**
-* Looks for a name among the statements of one block.
+* The upper-case top-level declaration a node sits in: the component a `{prop}` pattern belongs to.
 *
 * @param typescript - The TypeScript module.
-* @param holder - The block.
-* @param name - The name.
-* @returns What the name means there, or `undefined`.
+* @param node - The attribute.
+* @returns The component name, or `undefined` inside a lower-case helper.
 */
-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);
-	}
+function componentAround(typescript, node) {
+	const name = enclosingName(typescript, node);
+	return name !== void 0 && COMPONENT_TAG.test(name) ? name : void 0;
 }
 /**
-* Looks for a name among the names of a destructured parameter (`({ id }) => …`).
+* Quotes a key expression for an unresolved reason: one line, cut to a readable length.
 *
-* @param typescript - The TypeScript module.
-* @param pattern - The destructure.
-* @param name - The name.
-* @returns The parameter meaning with the property it takes, or `undefined`.
+* @param text - The expression as written.
+* @returns The quote.
+* @example
+* ```ts
+* quoteOf("card.key"); // "card.key"
+* ```
 */
-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
-		};
-	}
+function quoteOf(text) {
+	const line = text.replaceAll(/\s+/g, " ");
+	return line.length > QUOTE_LENGTH ? `${line.slice(0, QUOTE_LENGTH)}…` : line;
 }
 /**
-* Looks for a name among the parameters of one function: a plain parameter, or a property of a
-* destructured one.
+* The hit of a `key` attribute.
 *
 * @param typescript - The TypeScript module.
-* @param scope - The function.
-* @param name - The name.
-* @returns The parameter meaning, or `undefined`.
+* @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 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;
-	}
+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 }
+	};
 }
 /**
-* Says what a name means at the place it is used, walking up from there.
+* The hit of a literal key-carrying prop on a component: `id="settingsBoard"`,
+* `amountKey="giftReward"`.
 *
 * @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.
+* @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 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;
-	}
+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 name of the top-level declaration a node sits in: the function, class or first const of
-* the statement directly under the file.
+* The hits of the attributes of one opening or self-closing element.
 *
 * @param typescript - The TypeScript module.
-* @param node - Any node.
-* @returns The declared name, or `undefined` for a statement that declares none.
+* @param opening - The opening or self-closing element.
+* @returns Its hits.
 */
-function enclosingName(typescript, node) {
-	let statement = node;
-	while (statement.parent !== void 0 && !typescript.isSourceFile(statement.parent)) statement = statement.parent;
-	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;
+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;
 }
-/** A hole filled by the `id` prop of the component, at run time. */
-const ID = "{id}";
-/** How deep names and calls are followed before a hole is given up on. */
-const MAX_DEPTH = 8;
 /**
-* The one expression a function returns, when it has exactly one.
+* Collects every JSX key of a file, in source order.
 *
 * @param typescript - The TypeScript module.
-* @param node - The function.
-* @returns The returned expression, or `undefined`.
+* @param source - The parsed file.
+* @returns The hits; a key that reads `*` is among them.
 */
-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);
+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);
 	};
-	typescript.forEachChild(body, collect);
-	return returns.length === 1 ? returns[0]?.expression : void 0;
+	if (source.languageVariant === typescript.LanguageVariant.JSX) visit(source);
+	return hits;
 }
 /**
-* Reads a name: a bound parameter, a const, or a destructured `id` prop.
+* Whether a hit holds nothing literal: its key reads `*` alone.
 *
-* @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.
+* @param hit - A hit.
+* @returns True for a key nothing in the file can read.
 */
-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" && meaning.property === "id") return ID;
-	return "*";
+function isOpaque(hit) {
+	return hit.key === "*";
 }
 /**
-* Reads `props.id`: the `id` of a parameter object becomes `{id}`.
+* The anchor of a hit.
 *
-* @param typescript - The TypeScript module.
-* @param access - The property access.
-* @param bindings - The parameters bound by the call being read.
-* @returns The pattern.
+* @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 readAccess(typescript, access, bindings) {
-	const owner = access.expression;
-	return access.name.text === "id" && typescript.isIdentifier(owner) && !bindings.has(owner.text) && meaningOf(typescript, owner)?.kind === "param" ? ID : "*";
+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 }
+	};
 }
 /**
-* Reads a call of a same-file function: its one returned expression, with each parameter bound
-* to the pattern of its argument.
+* The unresolved reason of a key that reads `*`.
 *
-* @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.
+* @param hit - The hit.
+* @returns The reason: `JSX key "card.key" on <row> resolves to "*"`.
 */
-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);
+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 a template: its literal parts stay, each span is read into a pattern.
+* Reads the plain components of a file: the module-level upper-case functions of a `.tsx` file.
 *
 * @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("");
+* @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
+		}
+	}));
 }
 /**
-* Reads one expression into a pattern.
+* 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 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.
+* @param tag - The tag name of an element.
+* @returns The name, or `undefined` for an element of the engine and for `this`.
 */
-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 "*";
+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;
 }
 /**
-* Reduces a key expression to its pattern, with neighbouring `*` holes merged into one.
+* The component names a file renders, each once.
 *
 * @param typescript - The TypeScript module.
-* @param expression - The expression of a JSX `key` attribute.
-* @returns The pattern: `card*Picture`, `{id}Close`, `hudRow`, or `*` when nothing is literal.
+* @param source - The parsed file.
+* @returns The names, sorted; none for a file without JSX.
 */
-function patternOf(typescript, expression) {
-	return read(typescript, expression, /* @__PURE__ */ new Map(), 0).replaceAll(/\*+/g, "*");
+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"
+];
 /**
-* The literal head of a pattern: the text before its first hole.
+* Whether a name is a definer whose calls make keys.
 *
-* @param pattern - A pattern.
-* @returns The head, empty when the pattern starts with a hole.
+* @param name - A name.
+* @returns True for the definers of `DEFINERS`.
 * @example
 * ```ts
-* stemOf("card*Picture"); // "card"
+* isDefiner("defineScene"); // true
 * ```
 */
-function stemOf(pattern) {
-	const holes = [pattern.indexOf("*"), pattern.indexOf(ID)].filter((at) => at >= 0);
-	return pattern.slice(0, holes.length === 0 ? void 0 : Math.min(...holes));
+function isDefiner(name) {
+	return DEFINERS.includes(name);
 }
-//#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}`.
+* Whether a statement carries a modifier.
 *
 * @param typescript - The TypeScript module.
-* @param attribute - The attribute.
-* @returns The expression, or `undefined` for `<a key />` and `key={}`.
+* @param node - The statement.
+* @param kind - `ExportKeyword` or `DefaultKeyword`.
+* @returns True when the modifier is there.
 */
-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;
+function hasModifier(typescript, node, kind) {
+	if (!typescript.canHaveModifiers(node)) return false;
+	return typescript.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false;
 }
 /**
-* How a key expression is written.
+* The names a binding declares: the identifier, or every name of a destructure.
 *
 * @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.
+* @param name - The binding name.
+* @returns The declared names.
 */
-function kindOf(typescript, expression) {
-	const inner = unwrap(typescript, expression);
-	if (typescript.isStringLiteralLike(inner)) return "literal";
-	return typescript.isTemplateExpression(inner) ? "template" : "ident";
+function namesOf(typescript, name) {
+	if (typescript.isIdentifier(name)) return [name.text];
+	return name.elements.flatMap((element) => typescript.isBindingElement(element) ? namesOf(typescript, element.name) : []);
 }
 /**
-* The upper-case top-level declaration a node sits in: the component an `{id}` pattern belongs to.
+* Records the value imports of one import statement.
 *
 * @param typescript - The TypeScript module.
-* @param node - The attribute.
-* @returns The component name, or `undefined` inside a lower-case helper.
+* @param statement - The import statement.
+* @param draft - The facts so far.
 */
-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 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 quoteOf(text) {
-	const line = text.replaceAll(/\s+/g, " ");
-	return line.length > QUOTE_LENGTH ? `${line.slice(0, QUOTE_LENGTH)}…` : line;
+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 hit of a `key` attribute.
+* 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 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(typescript, expression);
-	const key = patternOf(typescript, expression);
-	const stem = kind === "literal" ? "" : stemOf(key);
-	const component = key.includes("{id}") ? componentAround(typescript, attribute) : void 0;
-	const written = quoteOf(expression.getText());
-	return {
-		key,
-		kind,
-		attribute,
-		...place,
-		written,
-		...stem === "" ? {} : { stem },
-		...component === void 0 ? {} : { component }
-	};
+* @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 hit of a literal `id` prop on a component.
+* The component names one file renders.
 *
-* @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` when the value is not a string literal.
+* @param record - The record of the file.
+* @returns The names; none for a broken file.
 */
-function idHit(typescript, attribute, 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,
-		attribute,
-		...place,
-		written: value.text
-	};
+function renderedBy(record) {
+	return record.good === void 0 ? [] : record.extracted?.result.rendered ?? [];
 }
 /**
-* The hits of the attributes of one opening or self-closing element.
+* Adds one use of a rendered binding to every component entry bound to it.
 *
-* @param typescript - The TypeScript module.
-* @param opening - The opening or self-closing element.
-* @returns Its hits.
+* @param byBinding - Binding to the component entries bound to it.
+* @param file - The file that renders the binding.
+* @param binding - The rendered name.
 */
-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 = name === "id" && isComponent ? idHit(typescript, attribute, place) : void 0;
-		if (keyEntry !== void 0) hits.push(keyEntry);
-		if (idEntry !== void 0) hits.push(idEntry);
-	}
-	return hits;
+function useComponent(byBinding, file, binding) {
+	for (const entry of byBinding.get(binding) ?? []) entry.uses.push({
+		path: file,
+		binding
+	});
 }
 /**
-* Collects every JSX key of a file, in source order.
+* 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 typescript - The TypeScript module.
-* @param source - The parsed file.
-* @returns The hits; a key that reads `*` is among them.
+* @param assembly - The records and module facts.
+* @param symbols - The keys so far.
 */
-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;
+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);
 }
 /**
-* Whether a hit holds nothing literal: its key reads `*` alone.
+* 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 hit - A hit.
-* @returns True for a key nothing in the file can read.
+* @param symbols - The keys as collected.
+* @returns The symbols of the index.
 */
-function isOpaque(hit) {
-	return hit.key === "*";
+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;
 }
 /**
-* The anchor of a hit.
+* Freezes a value and everything it holds.
 *
-* @param file - The root-relative path of the file.
-* @param hit - The hit.
-* @returns The anchor: path, key, kind, and the stem and component when there are.
+* @param value - A plain value.
+* @returns The same value, frozen.
 */
-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 }
-	};
+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;
 }
 /**
-* The unresolved reason of a key that reads `*`.
+* Assembles the index of a catalog.
 *
-* @param hit - The hit.
-* @returns The reason: `JSX key "card.key" on <row> resolves to "*"`.
+* @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 opaqueReason(hit) {
-	return `JSX key "${hit.written}" on <${hit.tag}> resolves to "*"`;
+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
@@ -1027,7 +1304,8 @@ const ID_PREFIXES = {
 	defineFlow: "flow",
 	defineFeature: "feature",
 	defineScene: "scene",
-	defineEmitter: "emitter"
+	defineEmitter: "emitter",
+	defineComponent: "component"
 };
 /**
 * The text of a string literal or a template without holes.
@@ -1041,18 +1319,6 @@ function literalOf(typescript, node) {
 	return inner !== void 0 && typescript.isStringLiteralLike(inner) ? inner.text : void 0;
 }
 /**
-* The name of an object property when it is written literally.
-*
-* @param typescript - The TypeScript module.
-* @param property - The property.
-* @returns The name, or `undefined` for a spread or a computed name.
-*/
-function propertyName(typescript, property) {
-	const name = property.name;
-	if (name === void 0) return void 0;
-	return typescript.isIdentifier(name) || typescript.isStringLiteral(name) || typescript.isNumericLiteral(name) ? name.text : void 0;
-}
-/**
 * The value of a named property of an object literal; for a shorthand, the name itself.
 *
 * @param typescript - The TypeScript module.
@@ -1062,7 +1328,7 @@ function propertyName(typescript, property) {
 */
 function propertyValue(typescript, object, name) {
 	for (const property of object.properties) {
-		if (propertyName(typescript, property) !== name) continue;
+		if (propertyNameOf(typescript, property) !== name) continue;
 		if (typescript.isPropertyAssignment(property)) return property.initializer;
 		if (typescript.isShorthandPropertyAssignment(property)) return property.name;
 	}
@@ -1182,7 +1448,7 @@ function readTable(reading, call, flow) {
 			unresolve(reading, `defineFlow "${flow}" nodes has a spread`);
 			continue;
 		}
-		const name = propertyName(typescript, property);
+		const name = propertyNameOf(typescript, property);
 		if (name === void 0) {
 			unresolve(reading, `defineFlow "${flow}" node name is not a literal`);
 			continue;
@@ -1204,7 +1470,8 @@ function readTable(reading, call, flow) {
 	});
 }
 /**
-* Reads a definer that takes its id as the first argument; a flow also brings its table.
+* 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.
@@ -1251,7 +1518,7 @@ function readTextStyles(reading, call) {
 	}
 	const binding = bindingOf(typescript, call);
 	for (const property of table.properties) {
-		const key = propertyName(typescript, property);
+		const key = propertyNameOf(typescript, property);
 		if (key === void 0) {
 			unresolve(reading, "defineTextStyles key is not a literal");
 			continue;
@@ -1271,24 +1538,79 @@ function readTextStyles(reading, call) {
 	}
 }
 /**
-* Reads a style: only one bound to a module const has a key, `style:<path>#<binding>`.
+* 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 binding = bindingOf(reading.typescript, call);
+	const { typescript, path } = reading;
+	const binding = bindingOf(typescript, call);
 	if (binding !== void 0) {
-		reading.definitions.push({
-			key: `style:${reading.path}#${binding}`,
-			anchor: {
-				path: reading.path,
-				binding
-			}
+		addStyle(reading, `style:${path}#${binding}`, {
+			path,
+			binding
 		});
 		return;
 	}
-	const around = enclosingName(reading.typescript, call);
+	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`);
 }
 /**
@@ -1336,7 +1658,8 @@ function readJsx(reading, source) {
 * @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.
+* @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 = {
@@ -1345,7 +1668,8 @@ function extractFile(typescript, source, path, definers) {
 		definers,
 		definitions: [],
 		tables: [],
-		unresolved: []
+		unresolved: [],
+		styles: /* @__PURE__ */ new Set()
 	};
 	const visit = (node) => {
 		const definer = typescript.isCallExpression(node) ? definerOfCall(typescript, node, definers) : void 0;
@@ -1353,11 +1677,13 @@ function extractFile(typescript, source, path, definers) {
 		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
+		unresolved: reading.unresolved,
+		rendered: renderedOf(typescript, source)
 	};
 }
 //#endregion
@@ -1541,6 +1867,8 @@ function buildIndex(catalog, 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.
 *
@@ -1581,18 +1909,6 @@ function declares(typescript, statement, binding) {
 	});
 }
 /**
-* The name of a property-like node, when it is written literally.
-*
-* @param typescript - The TypeScript module.
-* @param node - Any node.
-* @returns The name of a property, a shorthand or a method; `undefined` for anything else.
-*/
-function propertyNameOf(typescript, node) {
-	if (!(typescript.isPropertyAssignment(node) || typescript.isShorthandPropertyAssignment(node) || typescript.isMethodDeclaration(node))) return void 0;
-	const name = node.name;
-	return typescript.isIdentifier(name) || typescript.isStringLiteral(name) || typescript.isNumericLiteral(name) ? name.text : void 0;
-}
-/**
 * The shallowest property of a key inside a declaration, the first one at that depth.
 *
 * @param typescript - The TypeScript module.
@@ -1628,20 +1944,61 @@ function writtenAt(typescript, source, key) {
 	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 jsxHits - The JSX hits of the parse; collected on this call by default.
+* @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, jsxHits = () => collectJsx(typescript, source)) {
-	if (anchor.kind !== void 0) return jsxHits().filter((hit) => hit.key === anchor.key && hit.kind === anchor.kind && hit.component === anchor.component).map((hit) => placeOf(source, hit.attribute, hit.element));
+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 [];
@@ -1798,35 +2155,12 @@ async function readInside(root, file) {
 		if (real !== void 0) return await readFile(real);
 	} catch {}
 }
-/**
-* The anchors of the JSX patterns and of the literal `id=` props of an index.
-*
-* @param index - The index.
-* @returns The `{id}` patterns, the `*` patterns and the `id=` props.
-*/
-function jsxShapes(index) {
-	const shapes = {
-		idPatterns: [],
-		wildPatterns: [],
-		idAttributes: []
-	};
-	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.idAttributes.push(anchor);
-			else if (pattern.includes("{id}")) shapes.idPatterns.push(anchor);
-			else if (pattern.includes("*")) shapes.wildPatterns.push(anchor);
-		}
-	}
-	return shapes;
-}
 //#endregion
 //#region src/project/find.ts
 /**
 * Whether a key matches a pattern whose `*` holes stand for any text.
 *
-* @param pattern - A pattern, `{id}` already filled.
+* @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
@@ -1854,18 +2188,21 @@ function shapesOf(session) {
 	return shapes;
 }
 /**
-* Whether an `id=` prop fills an `{id}` pattern into the wanted key. A pattern written in a
-* component takes only the props of that component; one written in a helper takes any.
+* 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 `{id}` pattern.
-* @param idAttribute - The anchor of the `id=` prop.
+* @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, idAttribute, wanted) {
-	const isSameComponent = pattern.component === void 0 || pattern.component === idAttribute.component;
-	const filled = (pattern.key ?? "").replaceAll(ID, idAttribute.key ?? "");
-	return isSameComponent && matchesPattern(filled, wanted);
+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.
@@ -1878,7 +2215,7 @@ function fills(pattern, idAttribute, wanted) {
 * ```
 */
 function specificityOf(anchor) {
-	return (anchor.key ?? "").replaceAll(ID, "").replaceAll("*", "").length;
+	return (anchor.key ?? "").replaceAll(HOLE, "").replaceAll("*", "").length;
 }
 /**
 * Orders patterns from the most specific to the least, keeping their order otherwise.
@@ -1891,25 +2228,25 @@ function bySpecificity(first, second) {
 	return specificityOf(second) - specificityOf(first);
 }
 /**
-* The anchors a runtime JSX key reaches through patterns: each `{id}` pattern filled with an `id=`
-* prop (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*`.
+* 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 { idPatterns, wildPatterns, idAttributes } = shapes;
+	const { holePatterns, wildPatterns, idProps } = shapes;
 	const reached = [];
-	for (const pattern of idPatterns.toSorted(bySpecificity)) for (const idAttribute of idAttributes.filter((item) => fills(pattern, item, wanted))) reached.push(pattern, idAttribute);
+	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 `{id}`), the patterns that read as it.
+* the game reports it (no `*`, no prop hole), the patterns that read as it.
 *
 * @param session - The open project.
 * @param key - The key.
@@ -1917,7 +2254,7 @@ function patternAnchors(shapes, wanted) {
 */
 function anchorsOf(session, key) {
 	const exact = session.index.symbols[key]?.def ?? [];
-	const reached = key.startsWith("jsx:") && !key.includes("*") && !key.includes("{id}") ? patternAnchors(shapesOf(session), key.slice(4)) : [];
+	const reached = key.startsWith("jsx:") && !key.includes("*") && !hasHole(key) ? patternAnchors(shapesOf(session), key.slice(4)) : [];
 	return [.../* @__PURE__ */ new Set([...exact, ...reached])];
 }
 /**
@@ -1965,6 +2302,33 @@ async function viewOf(session, file) {
 	};
 }
 /**
+* 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.
 *
@@ -1989,11 +2353,16 @@ 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, view.jsx).map((place) => ({
+		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,