@moku-labs/game 0.13.0 → 0.13.2

package/dist/project.mjs

@@ -1,2383 +1,5 @@
-import { watch } from "node:fs";
-import path from "node:path";
+import { S as readInside, _ as declaredFunctions, a as reindexPath, b as unwrap, c as definerOfCall, d as sha1, f as definersOf, g as holeOf, h as hasHole, i as openSession, l as JSX, m as HOLE, n as createHub, o as serialize, p as collectJsx, s as parseCached, u as jsxShapes, v as propertyNameOf, y as propertyOfValue } from "./watch-CWI_on4T.mjs";
 import { createBrandConsole } from "@moku-labs/common/cli";
-import { createHash } from "node:crypto";
-import { readFile, readdir, realpath, stat } from "node:fs/promises";
-//#region src/project/extract/scope.ts
-/**
-* Unwraps the expressions that change no value: parentheses, `as`, `satisfies`, `!` and `<T>`.
-*
-* @param typescript - The TypeScript module.
-* @param node - An expression.
-* @returns The expression inside.
-*/
-function unwrap(typescript, node) {
-	let inner = node;
-	while (typescript.isParenthesizedExpression(inner) || typescript.isAsExpression(inner) || typescript.isSatisfiesExpression(inner) || typescript.isNonNullExpression(inner) || typescript.isTypeAssertionExpression(inner)) inner = inner.expression;
-	return inner;
-}
-/**
-* The text of a property name written literally: an identifier, a string or a number.
-*
-* @param typescript - The TypeScript module.
-* @param name - A property name.
-* @returns The text, or `undefined` for a computed or a private name.
-*/
-function literalNameOf(typescript, name) {
-	return typescript.isIdentifier(name) || typescript.isStringLiteral(name) || typescript.isNumericLiteral(name) ? name.text : void 0;
-}
-/**
-* The name of a property-like node, when it is written literally: a property, a shorthand, a
-* method or an accessor.
-*
-* @param typescript - The TypeScript module.
-* @param node - Any node.
-* @returns The name, or `undefined` for a spread, a computed name or a node without a name.
-*/
-function propertyNameOf(typescript, node) {
-	return typescript.isPropertyAssignment(node) || typescript.isShorthandPropertyAssignment(node) || typescript.isMethodDeclaration(node) || typescript.isGetAccessorDeclaration(node) || typescript.isSetAccessorDeclaration(node) ? literalNameOf(typescript, node.name) : void 0;
-}
-/**
-* Whether a node holds statements: a block, a source file, a module block or a case clause.
-*
-* @param node - A node.
-* @returns True when it has a `statements` list.
-*/
-function holdsStatements(node) {
-	return "statements" in node && Array.isArray(node.statements);
-}
-/**
-* Whether a node is a function whose parameters a name can be.
-*
-* @param typescript - The TypeScript module.
-* @param node - A node.
-* @returns True for function declarations, expressions, arrows and methods.
-*/
-function isFunctionScope(typescript, node) {
-	return typescript.isFunctionDeclaration(node) || typescript.isFunctionExpression(node) || typescript.isArrowFunction(node) || typescript.isMethodDeclaration(node);
-}
-/**
-* The meaning of a `const` declarator: a function when its initializer is one.
-*
-* @param typescript - The TypeScript module.
-* @param initializer - The initializer of the const.
-* @returns The meaning.
-*/
-function constMeaning(typescript, initializer) {
-	const inner = unwrap(typescript, initializer);
-	return typescript.isArrowFunction(inner) || typescript.isFunctionExpression(inner) ? {
-		kind: "function",
-		node: inner
-	} : {
-		kind: "const",
-		initializer
-	};
-}
-/**
-* Looks for a name among the statements of one block.
-*
-* @param typescript - The TypeScript module.
-* @param holder - The block.
-* @param name - The name.
-* @returns What the name means there, or `undefined`.
-*/
-function declaredIn(typescript, holder, name) {
-	for (const statement of holder.statements) {
-		if (typescript.isFunctionDeclaration(statement) && statement.name?.text === name) return {
-			kind: "function",
-			node: statement
-		};
-		if (!typescript.isVariableStatement(statement)) continue;
-		const isConst = (statement.declarationList.flags & typescript.NodeFlags.Const) !== 0;
-		const declaration = statement.declarationList.declarations.find((item) => typescript.isIdentifier(item.name) && item.name.text === name);
-		if (isConst && declaration?.initializer !== void 0) return constMeaning(typescript, declaration.initializer);
-	}
-}
-/**
-* Looks for a name among the names of a destructured parameter (`({ id }) => …`).
-*
-* @param typescript - The TypeScript module.
-* @param pattern - The destructure.
-* @param name - The name.
-* @returns The parameter meaning with the property it takes, or `undefined`.
-*/
-function destructuredIn(typescript, pattern, name) {
-	for (const element of pattern.elements) {
-		if (!(typescript.isBindingElement(element) && typescript.isIdentifier(element.name) && element.name.text === name)) continue;
-		const property = element.propertyName;
-		return {
-			kind: "param",
-			property: property !== void 0 && typescript.isIdentifier(property) ? property.text : name
-		};
-	}
-}
-/**
-* Looks for a name among the parameters of one function: a plain parameter, or a property of a
-* destructured one.
-*
-* @param typescript - The TypeScript module.
-* @param scope - The function.
-* @param name - The name.
-* @returns The parameter meaning, or `undefined`.
-*/
-function parameterIn(typescript, scope, name) {
-	for (const parameter of scope.parameters) {
-		const binding = parameter.name;
-		if (typescript.isIdentifier(binding) && binding.text === name) return { kind: "param" };
-		if (typescript.isIdentifier(binding)) continue;
-		const meaning = destructuredIn(typescript, binding, name);
-		if (meaning !== void 0) return meaning;
-	}
-}
-/**
-* Says what a name means at the place it is used, walking up from there.
-*
-* @param typescript - The TypeScript module.
-* @param identifier - The name where it is used.
-* @returns What it means, or `undefined` when the file does not declare it.
-*/
-function meaningOf(typescript, identifier) {
-	const name = identifier.text;
-	for (let node = identifier.parent; node !== void 0; node = node.parent) {
-		const parameter = isFunctionScope(typescript, node) ? parameterIn(typescript, node, name) : void 0;
-		if (parameter !== void 0) return parameter;
-		const declared = holdsStatements(node) ? declaredIn(typescript, node, name) : void 0;
-		if (declared !== void 0) return declared;
-	}
-}
-/**
-* The statement directly under the file that a node sits in.
-*
-* @param typescript - The TypeScript module.
-* @param node - Any node.
-* @returns The statement, or the file itself for the file.
-*/
-function topStatementOf(typescript, node) {
-	let statement = node;
-	while (statement.parent !== void 0 && !typescript.isSourceFile(statement.parent)) statement = statement.parent;
-	return statement;
-}
-/**
-* The name of the top-level declaration a node sits in: the function, class or first const of
-* the statement directly under the file.
-*
-* @param typescript - The TypeScript module.
-* @param node - Any node.
-* @returns The declared name, or `undefined` for a statement that declares none.
-*/
-function enclosingName(typescript, node) {
-	const statement = topStatementOf(typescript, node);
-	if (typescript.isFunctionDeclaration(statement) || typescript.isClassDeclaration(statement)) return statement.name?.text;
-	if (!typescript.isVariableStatement(statement)) return void 0;
-	const [first] = statement.declarationList.declarations;
-	return first !== void 0 && typescript.isIdentifier(first.name) ? first.name.text : void 0;
-}
-/**
-* The function a const declarator holds, through parentheses, `as` and `satisfies`.
-*
-* @param typescript - The TypeScript module.
-* @param declaration - The declarator.
-* @returns The arrow or function expression, or `undefined` for any other value.
-*/
-function functionValueOf(typescript, declaration) {
-	const value = declaration.initializer === void 0 ? void 0 : unwrap(typescript, declaration.initializer);
-	return value !== void 0 && (typescript.isArrowFunction(value) || typescript.isFunctionExpression(value)) ? value : void 0;
-}
-/**
-* The functions one module-level statement declares: a named function with a body, or the
-* consts whose value is an arrow or a function expression. An overload signature, a `let`, a
-* `var` and a const of any other value declare none.
-*
-* @param typescript - The TypeScript module.
-* @param statement - A statement directly under the file.
-* @returns The functions, in source order.
-*/
-function declaredFunctions(typescript, statement) {
-	if (typescript.isFunctionDeclaration(statement)) {
-		const name = statement.name?.text;
-		return name !== void 0 && statement.body !== void 0 ? [{
-			name,
-			node: statement
-		}] : [];
-	}
-	if (!typescript.isVariableStatement(statement)) return [];
-	if ((statement.declarationList.flags & typescript.NodeFlags.Const) === 0) return [];
-	return statement.declarationList.declarations.flatMap((declaration) => {
-		const node = functionValueOf(typescript, declaration);
-		if (node === void 0 || !typescript.isIdentifier(declaration.name)) return [];
-		return [{
-			name: declaration.name.text,
-			node
-		}];
-	});
-}
-/**
-* The module-level function a node sits in, at any depth: a named function declaration, or a
-* const whose value is a function. A node in a class, an object const or a statement that
-* declares no function has none.
-*
-* @param typescript - The TypeScript module.
-* @param node - Any node.
-* @returns The name of the function, or `undefined`.
-*/
-function enclosingFunction(typescript, node) {
-	return declaredFunctions(typescript, topStatementOf(typescript, node)).find((item) => item.node.pos <= node.pos && node.end <= item.node.end)?.name;
-}
-/**
-* The name of the object property whose value an expression is: `disc` for the call in
-* `{ disc: defineStyle(…) }`, through parentheses, `as` and `satisfies`.
-*
-* @param typescript - The TypeScript module.
-* @param node - An expression.
-* @returns The property name when it is written literally; `undefined` for anything else.
-*/
-function propertyOfValue(typescript, node) {
-	let outer = node;
-	while (typescript.isExpression(outer.parent) && unwrap(typescript, outer.parent) === node) outer = outer.parent;
-	const holder = outer.parent;
-	if (!typescript.isPropertyAssignment(holder) || holder.initializer !== outer) return void 0;
-	return literalNameOf(typescript, holder.name);
-}
-/**
-* A hole filled at run time by a key-carrying prop of the component: `{id}`, `{amountKey}`. The
-* regex is global, so `.test` keeps `lastIndex` between calls: test a pattern with `hasHole`, never
-* `HOLE.test`.
-*/
-const HOLE = /\{\w+\}/g;
-/** A key-carrying prop: `id`, or a name that ends in `Key`. */
-const KEY_PROP = /^(?:id|\w+Key)$/;
-/** How deep names and calls are followed before a hole is given up on. */
-const MAX_DEPTH = 8;
-/**
-* The hole a prop of a component leaves in a key.
-*
-* @param property - The name of the prop.
-* @returns The hole: `{amountKey}` for `amountKey`.
-* @example
-* ```ts
-* holeOf("amountKey"); // "{amountKey}"
-* ```
-*/
-function holeOf(property) {
-	return `{${property}}`;
-}
-/**
-* Whether a pattern holds a hole a prop fills.
-*
-* @param pattern - A pattern or a key.
-* @returns True when it holds `{id}`, `{amountKey}` or another prop hole.
-* @example
-* ```ts
-* hasHole("{id}Close"); // true
-* ```
-*/
-function hasHole(pattern) {
-	return pattern.search(HOLE) !== -1;
-}
-/**
-* The hole a prop of a parameter object leaves: its own hole for a key-carrying prop, `*` else.
-*
-* @param property - The name of the prop, when the parameter is read through one.
-* @returns The hole.
-* @example
-* ```ts
-* propertyHole("tab"); // "*"
-* ```
-*/
-function propertyHole(property) {
-	return property !== void 0 && KEY_PROP.test(property) ? holeOf(property) : "*";
-}
-/**
-* The one expression a function returns, when it has exactly one.
-*
-* @param typescript - The TypeScript module.
-* @param node - The function.
-* @returns The returned expression, or `undefined`.
-*/
-function returnedBy(typescript, node) {
-	const body = node.body;
-	if (body === void 0) return void 0;
-	if (!typescript.isBlock(body)) return body;
-	const returns = [];
-	const collect = (child) => {
-		if (typescript.isReturnStatement(child)) returns.push(child);
-		if (!typescript.isFunctionLike(child)) typescript.forEachChild(child, collect);
-	};
-	typescript.forEachChild(body, collect);
-	return returns.length === 1 ? returns[0]?.expression : void 0;
-}
-/**
-* Reads a name: a bound parameter, a const, or a destructured key-carrying prop.
-*
-* @param typescript - The TypeScript module.
-* @param identifier - The name.
-* @param bindings - The parameters bound by the call being read.
-* @param depth - How deep the reading is.
-* @returns The pattern.
-*/
-function readName(typescript, identifier, bindings, depth) {
-	const bound = bindings.get(identifier.text);
-	if (bound !== void 0) return bound;
-	const meaning = meaningOf(typescript, identifier);
-	if (meaning?.kind === "const") return read(typescript, meaning.initializer, bindings, depth + 1);
-	if (meaning?.kind === "param") return propertyHole(meaning.property);
-	return "*";
-}
-/**
-* Reads `props.id` or `props.amountKey`: a key-carrying prop of a parameter object becomes its
-* hole, any other prop `*`.
-*
-* @param typescript - The TypeScript module.
-* @param access - The property access.
-* @param bindings - The parameters bound by the call being read.
-* @returns The pattern.
-*/
-function readAccess(typescript, access, bindings) {
-	const owner = access.expression;
-	return typescript.isIdentifier(owner) && !bindings.has(owner.text) && meaningOf(typescript, owner)?.kind === "param" ? propertyHole(access.name.text) : "*";
-}
-/**
-* Reads a call of a same-file function: its one returned expression, with each parameter bound
-* to the pattern of its argument.
-*
-* @param typescript - The TypeScript module.
-* @param call - The call.
-* @param bindings - The parameters bound by the call being read.
-* @param depth - How deep the reading is.
-* @returns The pattern.
-*/
-function readCall$1(typescript, call, bindings, depth) {
-	const callee = call.expression;
-	const meaning = typescript.isIdentifier(callee) ? meaningOf(typescript, callee) : void 0;
-	if (meaning?.kind !== "function") return "*";
-	const returned = returnedBy(typescript, meaning.node);
-	if (returned === void 0) return "*";
-	const inner = /* @__PURE__ */ new Map();
-	for (const [index, parameter] of meaning.node.parameters.entries()) {
-		const argument = call.arguments[index];
-		if (!typescript.isIdentifier(parameter.name)) continue;
-		inner.set(parameter.name.text, argument === void 0 ? "*" : read(typescript, argument, bindings, depth + 1));
-	}
-	return read(typescript, returned, inner, depth + 1);
-}
-/**
-* Reads a template: its literal parts stay, each span is read into a pattern.
-*
-* @param typescript - The TypeScript module.
-* @param template - The template expression.
-* @param bindings - The parameters bound by the call being read.
-* @param depth - How deep the reading is.
-* @returns The pattern.
-*/
-function readTemplate(typescript, template, bindings, depth) {
-	const spans = template.templateSpans.map((span) => read(typescript, span.expression, bindings, depth + 1) + span.literal.text);
-	return template.head.text + spans.join("");
-}
-/**
-* Reads one expression into a pattern.
-*
-* @param typescript - The TypeScript module.
-* @param node - The expression.
-* @param bindings - The parameters bound by the call being read.
-* @param depth - How deep the reading is.
-* @returns The pattern, holes not yet merged.
-*/
-function read(typescript, node, bindings, depth) {
-	const expression = unwrap(typescript, node);
-	if (depth > MAX_DEPTH) return "*";
-	if (typescript.isStringLiteralLike(expression) || typescript.isNumericLiteral(expression)) return expression.text;
-	if (typescript.isTemplateExpression(expression)) return readTemplate(typescript, expression, bindings, depth);
-	if (typescript.isBinaryExpression(expression) && expression.operatorToken.kind === typescript.SyntaxKind.PlusToken) return read(typescript, expression.left, bindings, depth + 1) + read(typescript, expression.right, bindings, depth + 1);
-	if (typescript.isIdentifier(expression)) return readName(typescript, expression, bindings, depth);
-	if (typescript.isPropertyAccessExpression(expression)) return readAccess(typescript, expression, bindings);
-	if (typescript.isCallExpression(expression)) return readCall$1(typescript, expression, bindings, depth);
-	return "*";
-}
-/**
-* Reduces a key expression to its pattern, with neighbouring `*` holes merged into one.
-*
-* @param typescript - The TypeScript module.
-* @param expression - The expression of a JSX `key` attribute.
-* @returns The pattern: `card*Picture`, `{id}Close`, `{amountKey}`, `hudRow`, or `*` when nothing
-* is literal.
-*/
-function patternOf(typescript, expression) {
-	return read(typescript, expression, /* @__PURE__ */ new Map(), 0).replaceAll(/\*+/g, "*");
-}
-/**
-* The literal head of a pattern: the text before its first hole.
-*
-* @param pattern - A pattern.
-* @returns The head, empty when the pattern starts with a hole.
-* @example
-* ```ts
-* stemOf("card*Picture"); // "card"
-* ```
-*/
-function stemOf(pattern) {
-	const holes = [pattern.indexOf("*"), pattern.search(HOLE)].filter((at) => at >= 0);
-	return pattern.slice(0, holes.length === 0 ? void 0 : Math.min(...holes));
-}
-//#endregion
-//#region src/project/extract/jsx.ts
-/** The longest key expression an unresolved reason quotes. */
-const QUOTE_LENGTH = 60;
-/** A component tag: its name starts upper-case. */
-const COMPONENT_TAG = /^[A-Z]/;
-/**
-* The expression a JSX attribute holds: the string of `key="x"` or the code of `key={x}`.
-*
-* @param typescript - The TypeScript module.
-* @param attribute - The attribute.
-* @returns The expression, or `undefined` for `<a key />` and `key={}`.
-*/
-function attributeValue(typescript, attribute) {
-	const initializer = attribute.initializer;
-	if (initializer === void 0) return void 0;
-	if (typescript.isStringLiteral(initializer)) return initializer;
-	if (typescript.isJsxExpression(initializer)) return initializer.expression;
-}
-/**
-* How a key expression is written.
-*
-* @param typescript - The TypeScript module.
-* @param expression - The key expression.
-* @returns `literal` for a string, `template` for a template with holes, `ident` for the rest.
-*/
-function kindOf$1(typescript, expression) {
-	const inner = unwrap(typescript, expression);
-	if (typescript.isStringLiteralLike(inner)) return "literal";
-	return typescript.isTemplateExpression(inner) ? "template" : "ident";
-}
-/**
-* The upper-case top-level declaration a node sits in: the component a `{prop}` pattern belongs to.
-*
-* @param typescript - The TypeScript module.
-* @param node - The attribute.
-* @returns The component name, or `undefined` inside a lower-case helper.
-*/
-function componentAround(typescript, node) {
-	const name = enclosingName(typescript, node);
-	return name !== void 0 && COMPONENT_TAG.test(name) ? name : void 0;
-}
-/**
-* Quotes a key expression for an unresolved reason: one line, cut to a readable length.
-*
-* @param text - The expression as written.
-* @returns The quote.
-* @example
-* ```ts
-* quoteOf("card.key"); // "card.key"
-* ```
-*/
-function quoteOf(text) {
-	const line = text.replaceAll(/\s+/g, " ");
-	return line.length > QUOTE_LENGTH ? `${line.slice(0, QUOTE_LENGTH)}…` : line;
-}
-/**
-* The hit of a `key` attribute.
-*
-* @param typescript - The TypeScript module.
-* @param attribute - The attribute.
-* @param place - The element and its tag.
-* @param place.element - The whole element.
-* @param place.tag - The tag as written.
-* @returns The hit, or `undefined` for a key without a value.
-*/
-function keyHit(typescript, attribute, place) {
-	const expression = attributeValue(typescript, attribute);
-	if (expression === void 0) return void 0;
-	const kind = kindOf$1(typescript, expression);
-	const key = patternOf(typescript, expression);
-	const stem = kind === "literal" ? "" : stemOf(key);
-	const component = hasHole(key) ? componentAround(typescript, attribute) : void 0;
-	const written = quoteOf(expression.getText());
-	return {
-		key,
-		kind,
-		attribute,
-		...place,
-		written,
-		...stem === "" ? {} : { stem },
-		...component === void 0 ? {} : { component }
-	};
-}
-/**
-* The hit of a literal key-carrying prop on a component: `id="settingsBoard"`,
-* `amountKey="giftReward"`.
-*
-* @param typescript - The TypeScript module.
-* @param attribute - The attribute.
-* @param property - The name of the attribute.
-* @param place - The element and its tag.
-* @param place.element - The whole element.
-* @param place.tag - The tag as written.
-* @returns The hit, or `undefined` when the value is not a string literal.
-*/
-function idHit(typescript, attribute, property, place) {
-	const expression = attributeValue(typescript, attribute);
-	const value = expression === void 0 ? void 0 : unwrap(typescript, expression);
-	if (value === void 0 || !typescript.isStringLiteralLike(value)) return void 0;
-	return {
-		key: value.text,
-		kind: "idProp",
-		component: place.tag,
-		prop: property,
-		attribute,
-		...place,
-		written: value.text
-	};
-}
-/**
-* The hits of the attributes of one opening or self-closing element.
-*
-* @param typescript - The TypeScript module.
-* @param opening - The opening or self-closing element.
-* @returns Its hits.
-*/
-function hitsOf(typescript, opening) {
-	const place = {
-		element: typescript.isJsxOpeningElement(opening) ? opening.parent : opening,
-		tag: opening.tagName.getText()
-	};
-	const isComponent = COMPONENT_TAG.test(place.tag);
-	const hits = [];
-	for (const attribute of opening.attributes.properties) {
-		if (!typescript.isJsxAttribute(attribute) || !typescript.isIdentifier(attribute.name)) continue;
-		const name = attribute.name.text;
-		const keyEntry = name === "key" ? keyHit(typescript, attribute, place) : void 0;
-		const idEntry = isComponent && KEY_PROP.test(name) ? idHit(typescript, attribute, name, place) : void 0;
-		if (keyEntry !== void 0) hits.push(keyEntry);
-		if (idEntry !== void 0) hits.push(idEntry);
-	}
-	return hits;
-}
-/**
-* Collects every JSX key of a file, in source order.
-*
-* @param typescript - The TypeScript module.
-* @param source - The parsed file.
-* @returns The hits; a key that reads `*` is among them.
-*/
-function collectJsx(typescript, source) {
-	const hits = [];
-	const visit = (node) => {
-		if (typescript.isJsxOpeningElement(node) || typescript.isJsxSelfClosingElement(node)) hits.push(...hitsOf(typescript, node));
-		typescript.forEachChild(node, visit);
-	};
-	if (source.languageVariant === typescript.LanguageVariant.JSX) visit(source);
-	return hits;
-}
-/**
-* Whether a hit holds nothing literal: its key reads `*` alone.
-*
-* @param hit - A hit.
-* @returns True for a key nothing in the file can read.
-*/
-function isOpaque(hit) {
-	return hit.key === "*";
-}
-/**
-* The anchor of a hit.
-*
-* @param file - The root-relative path of the file.
-* @param hit - The hit.
-* @returns The anchor: path, key, kind, and the stem, component and prop when there are.
-*/
-function anchorOfHit(file, hit) {
-	return {
-		path: file,
-		key: hit.key,
-		kind: hit.kind,
-		...hit.stem === void 0 ? {} : { stem: hit.stem },
-		...hit.component === void 0 ? {} : { component: hit.component },
-		...hit.prop === void 0 ? {} : { prop: hit.prop }
-	};
-}
-/**
-* The unresolved reason of a key that reads `*`.
-*
-* @param hit - The hit.
-* @returns The reason: `JSX key "card.key" on <row> resolves to "*"`.
-*/
-function opaqueReason(hit) {
-	return `JSX key "${hit.written}" on <${hit.tag}> resolves to "*"`;
-}
-//#endregion
-//#region src/project/extract/components.ts
-/** The prefix of a component key. */
-const COMPONENT = "component:";
-/** The extension of the files whose plain functions can be components. */
-const JSX_FILE = ".tsx";
-/**
-* Reads the plain components of a file: the module-level upper-case functions of a `.tsx` file.
-*
-* @param typescript - The TypeScript module.
-* @param source - The parsed file.
-* @param path - The root-relative path of the file.
-* @returns One `component:<Name>` definition per component, bound to its name, in source order.
-*/
-function readComponents(typescript, source, path) {
-	if (!path.endsWith(JSX_FILE)) return [];
-	return source.statements.flatMap((statement) => declaredFunctions(typescript, statement).map((item) => item.name)).filter((name) => COMPONENT_TAG.test(name)).map((binding) => ({
-		key: `${COMPONENT}${binding}`,
-		anchor: {
-			path,
-			binding
-		}
-	}));
-}
-/**
-* The component name a tag renders: an upper-case identifier, or the last segment of a member
-* or namespaced tag. A lower-case identifier is an element of the engine, not a component.
-*
-* @param typescript - The TypeScript module.
-* @param tag - The tag name of an element.
-* @returns The name, or `undefined` for an element of the engine and for `this`.
-*/
-function renderedName(typescript, tag) {
-	if (typescript.isIdentifier(tag)) return COMPONENT_TAG.test(tag.text) ? tag.text : void 0;
-	if (typescript.isPropertyAccessExpression(tag) || typescript.isJsxNamespacedName(tag)) return tag.name.text;
-}
-/**
-* The component names a file renders, each once.
-*
-* @param typescript - The TypeScript module.
-* @param source - The parsed file.
-* @returns The names, sorted; none for a file without JSX.
-*/
-function renderedOf(typescript, source) {
-	const names = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		const name = typescript.isJsxOpeningElement(node) || typescript.isJsxSelfClosingElement(node) ? renderedName(typescript, node.tagName) : void 0;
-		if (name !== void 0) names.add(name);
-		typescript.forEachChild(node, visit);
-	};
-	if (source.languageVariant === typescript.LanguageVariant.JSX) visit(source);
-	return [...names].toSorted();
-}
-/** The definers whose calls make keys. */
-const DEFINERS = [
-	"defineFlow",
-	"defineFeature",
-	"defineScene",
-	"projection",
-	"defineEmitter",
-	"defineTextStyles",
-	"defineStyle",
-	"defineComponent"
-];
-/**
-* Whether a name is a definer whose calls make keys.
-*
-* @param name - A name.
-* @returns True for the definers of `DEFINERS`.
-* @example
-* ```ts
-* isDefiner("defineScene"); // true
-* ```
-*/
-function isDefiner(name) {
-	return DEFINERS.includes(name);
-}
-/**
-* Whether a statement carries a modifier.
-*
-* @param typescript - The TypeScript module.
-* @param node - The statement.
-* @param kind - `ExportKeyword` or `DefaultKeyword`.
-* @returns True when the modifier is there.
-*/
-function hasModifier(typescript, node, kind) {
-	if (!typescript.canHaveModifiers(node)) return false;
-	return typescript.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false;
-}
-/**
-* The names a binding declares: the identifier, or every name of a destructure.
-*
-* @param typescript - The TypeScript module.
-* @param name - The binding name.
-* @returns The declared names.
-*/
-function namesOf(typescript, name) {
-	if (typescript.isIdentifier(name)) return [name.text];
-	return name.elements.flatMap((element) => typescript.isBindingElement(element) ? namesOf(typescript, element.name) : []);
-}
-/**
-* Records the value imports of one import statement.
-*
-* @param typescript - The TypeScript module.
-* @param statement - The import statement.
-* @param draft - The facts so far.
-*/
-function readImport(typescript, statement, draft) {
-	const clause = statement.importClause;
-	if (clause === void 0 || clause.isTypeOnly) return;
-	if (!typescript.isStringLiteral(statement.moduleSpecifier)) return;
-	const specifier = statement.moduleSpecifier.text;
-	const bindings = clause.namedBindings;
-	if (clause.name !== void 0) draft.imports.set(clause.name.text, {
-		specifier,
-		imported: "default"
-	});
-	if (bindings === void 0) return;
-	if (typescript.isNamespaceImport(bindings)) {
-		draft.imports.set(bindings.name.text, {
-			specifier,
-			imported: "*"
-		});
-		return;
-	}
-	for (const element of bindings.elements) {
-		if (element.isTypeOnly) continue;
-		const imported = element.propertyName?.text ?? element.name.text;
-		draft.imports.set(element.name.text, {
-			specifier,
-			imported
-		});
-	}
-}
-/**
-* Records one export statement: a re-export from another module, a star, or a list of local
-* bindings.
-*
-* @param typescript - The TypeScript module.
-* @param statement - The export statement.
-* @param draft - The facts so far.
-*/
-function readExport(typescript, statement, draft) {
-	const source = statement.moduleSpecifier;
-	const specifier = source !== void 0 && typescript.isStringLiteral(source) ? source.text : "";
-	const clause = statement.exportClause;
-	if (statement.isTypeOnly) return;
-	if (clause === void 0) {
-		if (specifier !== "") draft.stars.push(specifier);
-		return;
-	}
-	if (typescript.isNamespaceExport(clause)) {
-		draft.exports.set(clause.name.text, {
-			specifier,
-			imported: "*"
-		});
-		return;
-	}
-	for (const element of clause.elements) {
-		if (element.isTypeOnly) continue;
-		const inner = element.propertyName?.text ?? element.name.text;
-		const target = specifier === "" ? { local: inner } : {
-			specifier,
-			imported: inner
-		};
-		draft.exports.set(element.name.text, target);
-	}
-}
-/**
-* Whether an import brings a name of the engine package.
-*
-* @param ref - The import, if any.
-* @param name - The name taken from the package, `*` for a namespace.
-* @returns True for that import of `@moku-labs/game`.
-* @example
-* ```ts
-* isGameImport({ specifier: "@moku-labs/game", imported: "defineGame" }, "defineGame"); // true
-* ```
-*/
-function isGameImport(ref, name) {
-	return ref?.specifier === "@moku-labs/game" && ref.imported === name;
-}
-/**
-* Whether an expression calls `defineGame` of the engine: by a named import, renamed or not, or
-* through a namespace import of the package.
-*
-* @param typescript - The TypeScript module.
-* @param expression - The initializer of a destructure.
-* @param imports - The value imports of the file.
-* @returns True for the kit call.
-*/
-function callsDefineGame(typescript, expression, imports) {
-	if (expression === void 0 || !typescript.isCallExpression(expression)) return false;
-	const callee = expression.expression;
-	if (typescript.isIdentifier(callee)) return isGameImport(imports.get(callee.text), "defineGame");
-	return typescript.isPropertyAccessExpression(callee) && typescript.isIdentifier(callee.expression) && callee.name.text === "defineGame" && isGameImport(imports.get(callee.expression.text), "*");
-}
-/**
-* Records the definers a `defineGame` destructure hands out, under their local names.
-*
-* @param typescript - The TypeScript module.
-* @param pattern - The destructure.
-* @param draft - The facts so far.
-*/
-function readKit(typescript, pattern, draft) {
-	for (const element of pattern.elements) {
-		if (!typescript.isIdentifier(element.name)) continue;
-		const property = element.propertyName;
-		const handed = property !== void 0 && typescript.isIdentifier(property) ? property.text : element.name.text;
-		if (isDefiner(handed)) draft.kit.set(element.name.text, handed);
-	}
-}
-/**
-* Records one top-level variable statement: its names, its exports and a kit destructure.
-*
-* @param typescript - The TypeScript module.
-* @param statement - The statement.
-* @param draft - The facts so far.
-*/
-function readVariables(typescript, statement, draft) {
-	const exported = hasModifier(typescript, statement, typescript.SyntaxKind.ExportKeyword);
-	for (const declaration of statement.declarationList.declarations) {
-		for (const name of namesOf(typescript, declaration.name)) {
-			draft.declared.add(name);
-			if (exported) draft.exports.set(name, { local: name });
-		}
-		const pattern = declaration.name;
-		if (typescript.isObjectBindingPattern(pattern) && callsDefineGame(typescript, declaration.initializer, draft.imports)) readKit(typescript, pattern, draft);
-	}
-}
-/**
-* Records a top-level function or class: its name, and its export.
-*
-* @param typescript - The TypeScript module.
-* @param statement - The declaration.
-* @param draft - The facts so far.
-*/
-function readNamed(typescript, statement, draft) {
-	const name = statement.name?.text;
-	if (name === void 0) return;
-	draft.declared.add(name);
-	if (!hasModifier(typescript, statement, typescript.SyntaxKind.ExportKeyword)) return;
-	const isDefault = hasModifier(typescript, statement, typescript.SyntaxKind.DefaultKeyword);
-	draft.exports.set(isDefault ? "default" : name, { local: name });
-}
-/**
-* Reads the module facts of one parsed file. Imports come first, so a kit destructure anywhere
-* in the file knows where its `defineGame` comes from.
-*
-* @param typescript - The TypeScript module.
-* @param source - The parsed file.
-* @returns The facts.
-*/
-function readModule(typescript, source) {
-	const draft = {
-		imports: /* @__PURE__ */ new Map(),
-		exports: /* @__PURE__ */ new Map(),
-		stars: [],
-		declared: /* @__PURE__ */ new Set(),
-		kit: /* @__PURE__ */ new Map()
-	};
-	for (const statement of source.statements) if (typescript.isImportDeclaration(statement)) readImport(typescript, statement, draft);
-	for (const statement of source.statements) {
-		if (typescript.isVariableStatement(statement)) readVariables(typescript, statement, draft);
-		if (typescript.isFunctionDeclaration(statement) || typescript.isClassDeclaration(statement)) readNamed(typescript, statement, draft);
-		if (typescript.isExportDeclaration(statement)) readExport(typescript, statement, draft);
-		if (typescript.isExportAssignment(statement) && typescript.isIdentifier(statement.expression)) draft.exports.set("default", { local: statement.expression.text });
-	}
-	return draft;
-}
-//#endregion
-//#region src/project/paths.ts
-/**
-* @file project — which files the index reads, and the guard on every path it reads. Paths in and
-* out are root-relative POSIX. A read resolves the path against the real root with `realpath`, so
-* a `..` or a symlink that leaves the root is refused by name instead of read.
-*/
-/** The folders a game never edits by hand: dependencies, builds, generated code and tests. */
-const SKIPPED_FOLDER = /^(?:node_modules|dist|generated|\.moku|\.git|__tests__|tests)$/;
-/** The source files the index reads. */
-const SOURCE_FILE = /\.tsx?$/;
-/** Test files, skipped wherever they sit. */
-const TEST_FILE = /\.(?:test|spec)\.tsx?$/;
-/** The hint under every root error. */
-const ROOT_HINT = "Pass the folder of the game as root.";
-/**
-* Whether a folder name is one the index never walks into.
-*
-* @param name - One folder name.
-* @returns True for `node_modules`, `dist`, `generated`, `.moku`, `.git`, `__tests__` and `tests`.
-* @example
-* ```ts
-* isSkippedFolder("generated"); // true
-* ```
-*/
-function isSkippedFolder(name) {
-	return SKIPPED_FOLDER.test(name);
-}
-/**
-* Whether a root-relative path sits under a skipped folder.
-*
-* @param file - A path with `/` or `\` separators.
-* @returns True when one of its folders is skipped.
-* @example
-* ```ts
-* isSkippedPath("node_modules/pixi.js/index.ts"); // true
-* ```
-*/
-function isSkippedPath(file) {
-	return file.split(/[/\\]/).slice(0, -1).some((folder) => isSkippedFolder(folder));
-}
-/**
-* Whether the index reads a root-relative path: a `.ts` or `.tsx` file outside the skipped
-* folders that is not a test.
-*
-* @param file - A root-relative POSIX path.
-* @returns True for a source file of the index.
-* @example
-* ```ts
-* isIndexedFile("features/ui/kit.tsx"); // true
-* ```
-*/
-function isIndexedFile(file) {
-	return SOURCE_FILE.test(file) && !TEST_FILE.test(file) && !isSkippedPath(file);
-}
-/**
-* Turns a path into its root-relative POSIX form.
-*
-* @param file - A path with any separators.
-* @returns The path with `/` separators, `.` segments resolved.
-* @example
-* ```ts
-* toPosix("./features\\ui\\kit.tsx"); // "features/ui/kit.tsx"
-* ```
-*/
-function toPosix(file) {
-	return path.posix.normalize(file.replaceAll("\\", "/"));
-}
-/**
-* Whether a file system error says nothing is at the path.
-*
-* @param error - What was thrown.
-* @returns True for `ENOENT` and `ENOTDIR`.
-*/
-function isMissing(error) {
-	const code = error instanceof Error && "code" in error ? error.code : void 0;
-	return code === "ENOENT" || code === "ENOTDIR";
-}
-/**
-* Whether an absolute path lies inside a folder.
-*
-* @param folder - The absolute folder.
-* @param file - The absolute path.
-* @returns True for the folder itself and anything below it.
-*/
-function isInside(folder, file) {
-	const relative = path.relative(folder, file);
-	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
-}
-/**
-* The error of a path that leaves the root.
-*
-* @param file - The path as it was given.
-* @param root - The real root.
-* @returns The error to throw.
-*/
-function leavesRoot(file, root) {
-	return /* @__PURE__ */ new Error(`[game] The path "${file}" leaves the project root.\n  Pass a path inside "${root}", relative to it.`);
-}
-/**
-* Checks the root of a project and resolves it: it exists, it is a directory, and its real path
-* is the one every read is held to.
-*
-* @param root - The root as given, absolute or relative to the working directory.
-* @returns The real absolute path of the root.
-* @throws {Error} When the root does not exist or is not a directory.
-*/
-async function openRoot(root) {
-	const absolute = path.resolve(root);
-	if (!(await stat(absolute).catch((error) => {
-		if (!isMissing(error)) throw error;
-		throw new Error(`[game] The project root "${absolute}" does not exist.\n  ${ROOT_HINT}`);
-	})).isDirectory()) throw new Error(`[game] The project root "${absolute}" is not a directory.\n  ${ROOT_HINT}`);
-	return realpath(absolute);
-}
-/**
-* Resolves a root-relative path to the real file, refusing any path that leaves the root.
-*
-* @param root - The real root.
-* @param file - The root-relative path.
-* @returns The real absolute path, or `undefined` when nothing is there.
-* @throws {Error} When the path leaves the root, by `..`, as an absolute path or by a symlink.
-*/
-async function resolveInside(root, file) {
-	const absolute = path.resolve(root, file);
-	if (!isInside(root, absolute)) throw leavesRoot(file, root);
-	let real;
-	try {
-		real = await realpath(absolute);
-	} catch (error) {
-		if (isMissing(error)) return;
-		throw error;
-	}
-	if (!isInside(root, real)) throw leavesRoot(file, root);
-	return real;
-}
-/**
-* Reads the bytes of a root-relative file through the guard. A path that leaves the root reads as
-* nothing here; `changed` refuses it by name with `resolveInside` first.
-*
-* @param root - The real root.
-* @param file - The root-relative path.
-* @returns The bytes, or `undefined` when the file is gone or lies outside the root.
-*/
-async function readInside(root, file) {
-	try {
-		const real = await resolveInside(root, file);
-		if (real !== void 0) return await readFile(real);
-	} catch {}
-}
-//#endregion
-//#region src/project/aliases.ts
-/**
-* @file project — the tsconfig `paths` of a game, the one alias resolver of the index. A v15 game
-* imports across its layers through aliases (`@core/kit`, `@features/home`, `@shared`). The
-* tsconfig is read with TypeScript, so JSONC and the `extends` chain are TypeScript's own; a
-* specifier is matched the way TypeScript matches it: an exact key first, then the `*` key with
-* the longest prefix. The engine is a package by definition and is never matched. Paths in and
-* out are root-relative POSIX.
-*/
-/** A specifier relative to the importing file, or an absolute path: never an alias. */
-const NOT_BARE = /^(?:\.{1,2}(?:\/|$)|\/)/;
-/** The hint under a tsconfig that does not parse. */
-const PARSE_HINT = "Fix the file, or name another one with the tsconfig option or --tsconfig.";
-/** TypeScript numbers its syntax diagnostics from 1000 to 1999. */
-const SYNTAX_CODES = {
-	from: 1e3,
-	below: 2e3
-};
-/**
-* Whether a specifier names the engine, which is a package even when the paths map it.
-*
-* @param specifier - A module specifier.
-* @returns True for `@moku-labs/game` and its subpaths.
-* @example
-* ```ts
-* isEngine("@moku-labs/game/testing"); // true
-* ```
-*/
-function isEngine(specifier) {
-	return specifier === "@moku-labs/game" || specifier.startsWith(`@moku-labs/game/`);
-}
-/**
-* How many `*` a key or a target holds.
-*
-* @param text - A key or a target of `paths`.
-* @returns The count.
-* @example
-* ```ts
-* starsOf("@features/*"); // 1
-* ```
-*/
-function starsOf(text) {
-	return text.split("*").length - 1;
-}
-/**
-* Whether a diagnostic of a tsconfig says a file does not parse: a syntax error in the tsconfig
-* or in a file it extends. TypeScript also reports an unknown option, a missing `extends` and
-* the empty file list of a read that lists no files; none of them hides the `paths`.
-*
-* @param diagnostic - A diagnostic of the read.
-* @returns True for a syntax error of a file.
-*/
-function isSyntaxError(diagnostic) {
-	return diagnostic.file !== void 0 && diagnostic.code >= SYNTAX_CODES.from && diagnostic.code < SYNTAX_CODES.below;
-}
-/**
-* The error of a tsconfig that does not parse, naming the file and the place as
-* `path:line:col message`.
-*
-* @param typescript - The TypeScript module.
-* @param root - The real root.
-* @param file - The tsconfig, root-relative.
-* @param diagnostic - The syntax error.
-* @returns The error to throw.
-*/
-function doesNotParse(typescript, root, file, diagnostic) {
-	const text = typescript.flattenDiagnosticMessageText(diagnostic.messageText, " ");
-	const message = text.endsWith(".") ? text : `${text}.`;
-	const source = diagnostic.file;
-	let place = "";
-	if (source !== void 0) {
-		const { line, character } = source.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
-		place = `${toPosix(path.relative(root, source.fileName))}:${line + 1}:${character + 1} `;
-	}
-	return /* @__PURE__ */ new Error(`[game] The tsconfig "${file}" does not parse: ${place}${message}\n  ${PARSE_HINT}`);
-}
-/**
-* The targets of one key of `paths`, root-relative: each string target with one `*` at most,
-* resolved against the base folder. TypeScript does not check the shape of `paths`, so the value
-* is read as the JSON it is.
-*
-* @param root - The real root.
-* @param base - The absolute folder the targets are relative to.
-* @param value - The value of the key.
-* @returns The targets, `*` kept.
-*/
-function targetsOf(root, base, value) {
-	if (!Array.isArray(value)) return [];
-	return value.filter((target) => typeof target === "string" && starsOf(target) <= 1).map((target) => toPosix(path.relative(root, path.resolve(base, target))));
-}
-/**
-* The patterns of a `paths` block: one per key with one `*` at most and a target. A key or a
-* target with two `*` never matches in TypeScript, so it is dropped here.
-*
-* @param root - The real root.
-* @param base - The absolute folder the targets are relative to.
-* @param paths - The `paths` of the merged options.
-* @returns The patterns, in the order of the keys.
-*/
-function patternsOf(root, base, paths) {
-	const patterns = [];
-	for (const [key, value] of Object.entries(paths)) {
-		const targets = targetsOf(root, base, value);
-		const star = key.indexOf("*");
-		if (targets.length === 0 || starsOf(key) > 1) continue;
-		patterns.push(star === -1 ? {
-			prefix: key,
-			targets
-		} : {
-			prefix: key.slice(0, star),
-			suffix: key.slice(star + 1),
-			targets
-		});
-	}
-	return patterns;
-}
-/**
-* The files TypeScript read for a tsconfig that lie inside the root, outside `node_modules`,
-* root-relative and each once. A file it tried and did not find is kept: its arrival changes the
-* aliases.
-*
-* @param root - The real root.
-* @param read - The absolute paths TypeScript asked for, in order.
-* @returns The root-relative paths.
-*/
-function sourcesInside(root, read) {
-	const inside = read.map((file) => toPosix(path.relative(root, file))).filter((file) => !file.startsWith("../") && !path.isAbsolute(file)).filter((file) => !file.split("/").includes("node_modules"));
-	return [...new Set(inside)];
-}
-/**
-* Parses a tsconfig with TypeScript: comments and trailing commas included, its `extends` chain
-* merged, and every file TypeScript reads for that chain noted. No file is listed, so the parse
-* stays cheap.
-*
-* @param typescript - The TypeScript module.
-* @param root - The real root.
-* @param file - The tsconfig, root-relative POSIX.
-* @param text - The text of the tsconfig.
-* @returns The merged options and the files TypeScript read.
-* @throws {Error} When the tsconfig or a file it extends does not parse.
-*/
-function parseTsconfigOptions(typescript, root, file, text) {
-	const absolute = path.join(root, file);
-	const parsed = typescript.parseConfigFileTextToJson(absolute, text);
-	if (parsed.error !== void 0) throw doesNotParse(typescript, root, file, parsed.error);
-	const read = [];
-	const host = {
-		...typescript.sys,
-		readDirectory: () => [],
-		readFile: (name) => {
-			read.push(name);
-			return typescript.sys.readFile(name);
-		}
-	};
-	const { options, errors } = typescript.parseJsonConfigFileContent(parsed.config, host, path.dirname(absolute), void 0, absolute);
-	const syntax = errors.find((diagnostic) => isSyntaxError(diagnostic));
-	if (syntax !== void 0) throw doesNotParse(typescript, root, file, syntax);
-	return {
-		options,
-		read
-	};
-}
-/**
-* The folder TypeScript resolves `paths` against when no `baseUrl` is set: the folder of the
-* config that declares them, which may be a file the tsconfig extends. TypeScript keeps it on the
-* merged options as `pathsBasePath`, outside its published types.
-*
-* @param options - The merged options.
-* @returns The absolute folder, or `undefined` when no config declares `paths`.
-*/
-function pathsBaseOf(options) {
-	const base = options.pathsBasePath;
-	return typeof base === "string" ? base : void 0;
-}
-/**
-* Reads the tsconfig `paths` of a game. TypeScript parses the file and merges its `extends`
-* chain. The targets resolve against `baseUrl` when one is set, else against the folder of the
-* config that declares `paths`, as TypeScript resolves them: the folder of the tsconfig, or of the
-* file it extends that holds the block.
-*
-* @param typescript - The TypeScript module.
-* @param root - The real root.
-* @param file - The tsconfig, root-relative POSIX.
-* @returns The aliases, or `undefined` when the file is missing. A tsconfig without `paths` has
-*   no patterns and still lists its sources, so a `paths` block added to a file it extends is seen.
-* @throws {Error} When the tsconfig or a file it extends does not parse.
-*/
-async function readAliases(typescript, root, file) {
-	const bytes = await readInside(root, file);
-	if (bytes === void 0) return void 0;
-	const { options, read } = parseTsconfigOptions(typescript, root, file, new TextDecoder().decode(bytes));
-	const patterns = patternsOf(root, options.baseUrl ?? pathsBaseOf(options) ?? path.dirname(path.join(root, file)), options.paths ?? {});
-	return {
-		file,
-		sources: [.../* @__PURE__ */ new Set([file, ...sourcesInside(root, read)])],
-		patterns
-	};
-}
-/**
-* Whether a `*` key matches a specifier.
-*
-* @param pattern - A key with `*`.
-* @param suffix - Its suffix.
-* @param specifier - The module specifier.
-* @returns True when the specifier starts with the prefix and ends with the suffix.
-* @example
-* ```ts
-* matchesStar({ prefix: "@core/", suffix: "", targets: ["core/*"] }, "", "@core/kit"); // true
-* ```
-*/
-function matchesStar(pattern, suffix, specifier) {
-	return specifier.length >= pattern.prefix.length + suffix.length && specifier.startsWith(pattern.prefix) && specifier.endsWith(suffix);
-}
-/**
-* Whether a specifier is never an alias: a path relative to the importing file, an absolute path,
-* or the engine.
-*
-* @param specifier - The module specifier as written.
-* @returns True when no key of `paths` may match it.
-* @example
-* ```ts
-* isNeverAlias("@moku-labs/game/testing"); // true
-* ```
-*/
-function isNeverAlias(specifier) {
-	return NOT_BARE.test(specifier) || isEngine(specifier);
-}
-/**
-* Whether a key of `paths` is a `*` key that matches a specifier with a longer prefix than the
-* best match so far.
-*
-* @param pattern - A key of `paths`.
-* @param best - The best `*` match so far, if any.
-* @param specifier - The module specifier.
-* @returns True when the key is the better match.
-* @example
-* ```ts
-* isBetterMatch({ prefix: "@core/", suffix: "", targets: ["core/*"] }, undefined, "@core/kit"); // true
-* ```
-*/
-function isBetterMatch(pattern, best, specifier) {
-	const isLonger = best === void 0 || pattern.prefix.length > best.prefix.length;
-	return pattern.suffix !== void 0 && isLonger && matchesStar(pattern, pattern.suffix, specifier);
-}
-/**
-* The targets a specifier maps to, the way TypeScript maps it: a key without `*` equal to the
-* specifier wins; else the `*` key with the longest prefix, its `*` filled into every target. A
-* relative or absolute specifier, the engine (`@moku-labs/game` and its subpaths) and a specifier
-* no key matches map to nothing.
-*
-* @param aliases - The aliases of the game, if it declares some.
-* @param specifier - The module specifier as written.
-* @returns The root-relative targets in the order of the tsconfig; `[]` for no match.
-* @example
-* ```ts
-* // map: the aliases of tests/fixtures/layout-game/tsconfig.json
-* aliasTargets(map, "@features/orders"); // ["features/orders/index.ts"]
-* aliasTargets(map, "@moku-labs/game/testing"); // []
-* ```
-*/
-function aliasTargets(aliases, specifier) {
-	if (aliases === void 0 || isNeverAlias(specifier)) return [];
-	const exact = aliases.patterns.find((pattern) => pattern.suffix === void 0 && pattern.prefix === specifier);
-	if (exact !== void 0) return [...exact.targets];
-	let best;
-	for (const pattern of aliases.patterns) if (isBetterMatch(pattern, best, specifier)) best = pattern;
-	if (best === void 0) return [];
-	const hole = specifier.slice(best.prefix.length, specifier.length - best.suffix.length);
-	return best.targets.map((target) => target.replace("*", () => hole));
-}
-/**
-* Whether two keys of `paths` are the same key with the same targets.
-*
-* @param first - One pattern.
-* @param second - The other, if any.
-* @returns True when prefix, suffix and targets are equal.
-* @example
-* ```ts
-* samePattern({ prefix: "@kit", targets: ["kit.ts"] }, { prefix: "@kit", targets: ["kit.ts"] }); // true
-* ```
-*/
-function samePattern(first, second) {
-	return second !== void 0 && first.prefix === second.prefix && first.suffix === second.suffix && first.targets.length === second.targets.length && first.targets.every((target, at) => target === second.targets[at]);
-}
-/**
-* Whether two reads of the aliases resolve alike: the same tsconfig and the same patterns in the
-* same order. The sources are left out: they feed the stamps, not the resolution.
-*
-* @param first - The aliases before, or `undefined` for none.
-* @param second - The aliases after, or `undefined` for none.
-* @returns True when the index built with either is the same.
-* @example
-* ```ts
-* sameAliases(undefined, undefined); // true
-* ```
-*/
-function sameAliases(first, second) {
-	if (first === void 0 || second === void 0) return first === second;
-	return first.file === second.file && first.patterns.length === second.patterns.length && first.patterns.every((pattern, at) => samePattern(pattern, second.patterns[at]));
-}
-//#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, through a tsconfig alias when the game declares one, 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("../");
-}
-/**
-* The indexed file a root-relative path names, the way a bundler finds it: the path as written,
-* then with `.ts`, `.tsx`, `/index.ts` and `/index.tsx`.
-*
-* @param modules - The module facts by path.
-* @param base - A root-relative path.
-* @returns The path the index holds, or `undefined`.
-*/
-function indexedFile(modules, base) {
-	const normal = path.posix.normalize(base);
-	const stem = normal.replace(SCRIPT_EXTENSION, "");
-	return [
-		normal,
-		`${stem}.ts`,
-		`${stem}.tsx`,
-		`${stem}/index.ts`,
-		`${stem}/index.tsx`
-	].find((candidate) => modules.has(candidate));
-}
-/**
-* Resolves a module specifier to an indexed file: a relative one against the importing file, any
-* other through the targets of the tsconfig alias it matches, the first target the index holds
-* winning. Each candidate is tried as written, then with `.ts`, `.tsx`, `/index.ts` and
-* `/index.tsx`.
-*
-* @param resolution - The module facts and the aliases.
-* @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(resolution, from, specifier) {
-	const { modules } = resolution;
-	if (isRelative(specifier)) return indexedFile(modules, path.posix.join(path.posix.dirname(from), specifier));
-	for (const target of aliasTargets(resolution.aliases, specifier)) {
-		const found = indexedFile(modules, target);
-		if (found !== void 0) return found;
-	}
-}
-/**
-* Whether a specifier names a package: it is not relative and no tsconfig alias matches it.
-*
-* @param resolution - The module facts and the aliases.
-* @param specifier - The module specifier.
-* @returns True for a package.
-*/
-function isPackage(resolution, specifier) {
-	return !isRelative(specifier) && aliasTargets(resolution.aliases, specifier).length === 0;
-}
-/**
-* Follows an imported name into the module that the specifier names.
-*
-* @param resolution - The module facts and the aliases.
-* @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(resolution, from, ref, hops) {
-	if (isPackage(resolution, ref.specifier)) return {
-		kind: "package",
-		...ref
-	};
-	if (ref.imported === "*") return void 0;
-	const target = resolveModulePath(resolution, from, ref.specifier);
-	return target === void 0 ? void 0 : resolveExport(resolution, target, ref.imported, hops + 1);
-}
-/**
-* Follows an exported name of a module: a local binding, a re-export, or a star export.
-*
-* @param resolution - The module facts and the aliases.
-* @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(resolution, file, name, hops = 0) {
-	const facts = resolution.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(resolution, file, ref.local, hops + 1);
-	if (ref !== void 0) return followImport(resolution, file, ref, hops);
-	for (const specifier of facts.stars) {
-		const found = followImport(resolution, 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 resolution - The module facts and the aliases.
-* @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(resolution, file, local, hops = 0) {
-	const facts = resolution.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(resolution, file, ref, hops);
-}
-/**
-* The alias a name of a file is imported through when that alias reaches no indexed file: a
-* tsconfig key matched the specifier, and none of its targets is a file of the root.
-*
-* @param resolution - The module facts and the aliases.
-* @param file - The file that imports the name.
-* @param local - The name as the file writes it.
-* @returns The specifier as written, or `undefined` when the import is not such an alias.
-*/
-function missedAlias(resolution, file, local) {
-	const ref = resolution.modules.get(file)?.imports.get(local);
-	if (!(ref !== void 0 && !isRelative(ref.specifier) && !isPackage(resolution, ref.specifier))) return void 0;
-	return resolveModulePath(resolution, file, ref.specifier) === void 0 ? ref.specifier : void 0;
-}
-/**
-* 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 resolution - The module facts and the aliases.
-* @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(resolution, file, namespace, specifier, definers) {
-	if (specifier === "@moku-labs/game") {
-		for (const definer of DEFINERS) definers.set(`${namespace}.${definer}`, definer);
-		return;
-	}
-	const target = resolveModulePath(resolution, file, specifier);
-	const names = target === void 0 ? [] : [...resolution.modules.get(target)?.exports.keys() ?? []];
-	for (const name of names) {
-		const definer = definerOf(resolveExport(resolution, 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 resolution - The module facts and the aliases.
-* @param file - The file.
-* @returns The callee text to the definer.
-*/
-function definersOf(resolution, file) {
-	const facts = resolution.modules.get(file);
-	const definers = new Map(facts?.kit);
-	for (const [local, ref] of facts?.imports ?? []) {
-		if (ref.imported === "*") {
-			addNamespace(resolution, file, local, ref.specifier, definers);
-			continue;
-		}
-		const definer = definerOf(resolveBinding(resolution, 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;
-}
-/**
-* Why a name of a flow table cannot be followed: the alias it is imported through reaches no
-* file, or it is declared in no file of the root.
-*
-* @param resolution - The module facts and the aliases.
-* @param file - The flow file.
-* @param node - The key of the entry, `main/home`.
-* @param ref - The name the entry holds.
-* @returns The reason for the unresolved list.
-*/
-function unfollowed(resolution, file, node, ref) {
-	const alias = missedAlias(resolution, file, ref);
-	return alias === void 0 ? `node "${node}": "${ref}" is not declared in a file of the root` : `node "${node}": "${ref}" is imported from "${alias}", which names no file of the root`;
-}
-/**
-* 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
-	};
-	const resolution = {
-		modules: assembly.modules,
-		aliases: assembly.aliases
-	};
-	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(resolution, 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) unresolved.push({
-			path: file,
-			reason: unfollowed(resolution, file, `${table.flow}/${name}`, ref)
-		});
-	}
-}
-/**
-* Adds, to every style key, the files that import its binding by name.
-*
-* @param assembly - The records and module facts.
-* @param symbols - The keys so far.
-*/
-function addStyleUses(assembly, symbols) {
-	const resolution = {
-		modules: assembly.modules,
-		aliases: assembly.aliases
-	};
-	for (const [file, record] of assembly.files) for (const [local, ref] of record.good?.module.imports ?? []) {
-		const target = ref.imported === "*" ? void 0 : resolveBinding(resolution, file, local);
-		(target?.kind === "declared" ? symbols.get(`style:${target.path}#${target.binding}`) : void 0)?.uses.push({
-			path: file,
-			binding: local
-		});
-	}
-}
-/**
-* The component entries by the binding they are rendered as. Two anchors of one name in a
-* conflict share one binding, so a file that renders it is one use.
-*
-* @param symbols - The keys so far.
-* @returns Binding to the component entries bound to it.
-*/
-function componentsByBinding(symbols) {
-	const byBinding = /* @__PURE__ */ new Map();
-	for (const [key, entry] of symbols) {
-		if (!key.startsWith("component:")) continue;
-		const bindings = new Set(entry.def.flatMap((anchor) => anchor.binding ?? []));
-		for (const binding of bindings) byBinding.set(binding, [...byBinding.get(binding) ?? [], entry]);
-	}
-	return byBinding;
-}
-/**
-* The component names one file renders.
-*
-* @param record - The record of the file.
-* @returns The names; none for a broken file.
-*/
-function renderedBy(record) {
-	return record.good === void 0 ? [] : record.extracted?.result.rendered ?? [];
-}
-/**
-* Adds one use of a rendered binding to every component entry bound to it.
-*
-* @param byBinding - Binding to the component entries bound to it.
-* @param file - The file that renders the binding.
-* @param binding - The rendered name.
-*/
-function useComponent(byBinding, file, binding) {
-	for (const entry of byBinding.get(binding) ?? []) entry.uses.push({
-		path: file,
-		binding
-	});
-}
-/**
-* Adds, to every component key, the files that render its binding: one use per file and binding,
-* in path order. A member tag `<ui.RoundButton>` renders `RoundButton`.
-*
-* @param assembly - The records and module facts.
-* @param symbols - The keys so far.
-*/
-function addComponentUses(assembly, symbols) {
-	const byBinding = componentsByBinding(symbols);
-	for (const [file, record] of assembly.files) for (const binding of renderedBy(record)) useComponent(byBinding, file, binding);
-}
-/**
-* The symbols as the index holds them: sorted by key, `uses` only when there are some, and
-* `conflict` on a key other than `jsx:` defined twice.
-*
-* @param symbols - The keys as collected.
-* @returns The symbols of the index.
-*/
-function finishSymbols(symbols) {
-	const finished = {};
-	const sorted = [...symbols].toSorted(([first], [second]) => first < second ? -1 : 1);
-	for (const [key, { def, uses }] of sorted) {
-		const isConflict = !key.startsWith("jsx:") && def.length > 1;
-		finished[key] = {
-			def,
-			...uses.length === 0 ? {} : { uses },
-			...isConflict ? { conflict: true } : {}
-		};
-	}
-	return finished;
-}
-/**
-* Freezes a value and everything it holds.
-*
-* @param value - A plain value.
-* @returns The same value, frozen.
-*/
-function deepFreeze(value) {
-	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
-	Object.freeze(value);
-	for (const child of Object.values(value)) deepFreeze(child);
-	return value;
-}
-/**
-* Assembles the index of a catalog. The index names the tsconfig when the assembly has aliases.
-*
-* @param assembly - The records sorted by path, the module facts of the good files, the aliases.
-* @param manifest - The root-relative manifest path when the file exists.
-* @returns The index, frozen.
-*/
-function assembleIndex(assembly, manifest) {
-	const symbols = /* @__PURE__ */ new Map();
-	const files = {};
-	const unresolved = [];
-	for (const [file, record] of assembly.files) {
-		files[file] = {
-			hash: record.hash,
-			state: record.state,
-			...record.error === void 0 ? {} : { error: record.error }
-		};
-		const extracted = record.extracted?.result;
-		if (record.good === void 0 || extracted === void 0) {
-			unresolved.push({
-				path: file,
-				reason: record.error ?? "the file never parsed"
-			});
-			continue;
-		}
-		for (const { key, anchor } of extracted.definitions) entryOf(symbols, key).def.push(anchor);
-		unresolved.push(...extracted.unresolved);
-		for (const table of extracted.tables) addTable(assembly, symbols, unresolved, file, table);
-	}
-	addStyleUses(assembly, symbols);
-	addComponentUses(assembly, symbols);
-	return deepFreeze({
-		schemaVersion: 1,
-		revision: revisionOf(files),
-		...manifest === void 0 ? {} : { manifest },
-		...assembly.aliases === void 0 ? {} : { tsconfig: assembly.aliases.file },
-		symbols: finishSymbols(symbols),
-		files,
-		unresolved
-	});
-}
-//#endregion
-//#region src/project/extract/definitions.ts
-/** The key prefix of each definer that takes its id as the first argument. */
-const ID_PREFIXES = {
-	defineFlow: "flow",
-	defineFeature: "feature",
-	defineScene: "scene",
-	defineEmitter: "emitter",
-	defineComponent: "component"
-};
-/**
-* The text of a string literal or a template without holes.
-*
-* @param typescript - The TypeScript module.
-* @param node - An expression, if any.
-* @returns The text, or `undefined` for anything else.
-*/
-function literalOf(typescript, node) {
-	const inner = node === void 0 ? void 0 : unwrap(typescript, node);
-	return inner !== void 0 && typescript.isStringLiteralLike(inner) ? inner.text : void 0;
-}
-/**
-* The value of a named property of an object literal; for a shorthand, the name itself.
-*
-* @param typescript - The TypeScript module.
-* @param object - The object literal.
-* @param name - The property name.
-* @returns The value, or `undefined` when the object has no such property.
-*/
-function propertyValue(typescript, object, name) {
-	for (const property of object.properties) {
-		if (propertyNameOf(typescript, property) !== name) continue;
-		if (typescript.isPropertyAssignment(property)) return property.initializer;
-		if (typescript.isShorthandPropertyAssignment(property)) return property.name;
-	}
-}
-/**
-* The object literal an expression is, directly or through a same-file const.
-*
-* @param typescript - The TypeScript module.
-* @param node - An expression, if any.
-* @returns The object literal, or `undefined`.
-*/
-function objectOf(typescript, node) {
-	const inner = node === void 0 ? void 0 : unwrap(typescript, node);
-	if (inner === void 0) return void 0;
-	if (typescript.isObjectLiteralExpression(inner)) return inner;
-	if (!typescript.isIdentifier(inner)) return void 0;
-	const meaning = meaningOf(typescript, inner);
-	const value = meaning?.kind === "const" ? unwrap(typescript, meaning.initializer) : void 0;
-	return value !== void 0 && typescript.isObjectLiteralExpression(value) ? value : void 0;
-}
-/**
-* The const a call is bound to: `export const boardFlow = defineFlow(…)` at the top of the file.
-*
-* @param typescript - The TypeScript module.
-* @param call - The definer call.
-* @returns The binding, or `undefined` when the call is not the initializer of a module const.
-*/
-function bindingOf(typescript, call) {
-	let node = call.parent;
-	while (typescript.isExpression(node)) node = node.parent;
-	if (!typescript.isVariableDeclaration(node) || !typescript.isIdentifier(node.name)) return void 0;
-	if (node.initializer === void 0 || unwrap(typescript, node.initializer) !== call) return void 0;
-	const list = node.parent;
-	return (list.flags & typescript.NodeFlags.Const) !== 0 && typescript.isVariableStatement(list.parent) && typescript.isSourceFile(list.parent.parent) ? node.name.text : void 0;
-}
-/**
-* The definer a call calls, by its callee as written: `defineFlow(…)` or `kit.defineFlow(…)`.
-*
-* @param typescript - The TypeScript module.
-* @param call - The call.
-* @param definers - The definers of the file.
-* @returns The definer, or `undefined` for any other call.
-*/
-function definerOfCall(typescript, call, definers) {
-	const callee = call.expression;
-	if (typescript.isIdentifier(callee)) return definers.get(callee.text);
-	if (!typescript.isPropertyAccessExpression(callee) || !typescript.isIdentifier(callee.expression)) return;
-	return definers.get(`${callee.expression.text}.${callee.name.text}`);
-}
-/**
-* Adds a key bound to the const of a call, or anchored by its id when the call has no const.
-*
-* @param reading - The file being read.
-* @param call - The definer call.
-* @param key - The key.
-* @param id - The literal id, the anchor key when there is no binding.
-* @param bound - What the anchor adds to the binding: the `name` key of a projection.
-*/
-function define(reading, call, key, id, bound = {}) {
-	const binding = bindingOf(reading.typescript, call);
-	const anchor = binding === void 0 ? {
-		path: reading.path,
-		key: id
-	} : {
-		path: reading.path,
-		binding,
-		...bound
-	};
-	reading.definitions.push({
-		key,
-		anchor
-	});
-}
-/**
-* Notes something the file holds that cannot be read.
-*
-* @param reading - The file being read.
-* @param reason - What and why.
-*/
-function unresolve(reading, reason) {
-	reading.unresolved.push({
-		path: reading.path,
-		reason
-	});
-}
-/**
-* The plain name a table entry's value is: `merge` for `{ merge }` and for `{ merge: merge }`.
-*
-* @param typescript - The TypeScript module.
-* @param property - The table entry.
-* @returns The name, or `undefined` for a slot, an inline node or anything else.
-*/
-function refOf(typescript, property) {
-	if (typescript.isShorthandPropertyAssignment(property)) return property.name.text;
-	if (!typescript.isPropertyAssignment(property)) return void 0;
-	const value = unwrap(typescript, property.initializer);
-	return typescript.isIdentifier(value) ? value.text : void 0;
-}
-/**
-* Reads the `nodes` table of a flow into its entries.
-*
-* @param reading - The file being read.
-* @param call - The `defineFlow` call.
-* @param flow - The flow id.
-*/
-function readTable(reading, call, flow) {
-	const { typescript } = reading;
-	const spec = objectOf(typescript, call.arguments[1]);
-	const nodes = spec === void 0 ? void 0 : objectOf(typescript, propertyValue(typescript, spec, "nodes"));
-	if (nodes === void 0) {
-		unresolve(reading, `defineFlow "${flow}" nodes is not an object literal`);
-		return;
-	}
-	const entries = [];
-	for (const property of nodes.properties) {
-		if (typescript.isSpreadAssignment(property)) {
-			unresolve(reading, `defineFlow "${flow}" nodes has a spread`);
-			continue;
-		}
-		const name = propertyNameOf(typescript, property);
-		if (name === void 0) {
-			unresolve(reading, `defineFlow "${flow}" node name is not a literal`);
-			continue;
-		}
-		const ref = refOf(typescript, property);
-		entries.push(ref === void 0 ? { name } : {
-			name,
-			ref
-		});
-	}
-	const binding = bindingOf(typescript, call);
-	reading.tables.push(binding === void 0 ? {
-		flow,
-		entries
-	} : {
-		flow,
-		binding,
-		entries
-	});
-}
-/**
-* Reads a definer that takes its id as the first argument; a flow also brings its table. A
-* component is bound to its const, and the key takes the literal id.
-*
-* @param reading - The file being read.
-* @param call - The call.
-* @param definer - The definer.
-* @param prefix - The key prefix.
-*/
-function readIdCall(reading, call, definer, prefix) {
-	const id = literalOf(reading.typescript, call.arguments[0]);
-	if (id === void 0) {
-		unresolve(reading, `${definer} id is not a string literal`);
-		return;
-	}
-	define(reading, call, `${prefix}:${id}`, id);
-	if (definer === "defineFlow") readTable(reading, call, id);
-}
-/**
-* Reads a projection: its key is its `name`, its line the `name` property.
-*
-* @param reading - The file being read.
-* @param call - The call.
-*/
-function readProjection(reading, call) {
-	const { typescript } = reading;
-	const spec = objectOf(typescript, call.arguments[0]);
-	const name = spec === void 0 ? void 0 : literalOf(typescript, propertyValue(typescript, spec, "name"));
-	if (name === void 0) {
-		unresolve(reading, "projection name is not a string literal");
-		return;
-	}
-	define(reading, call, `projection:${name}`, name, { key: "name" });
-}
-/**
-* Reads a text style table: every literal key is a key.
-*
-* @param reading - The file being read.
-* @param call - The call.
-*/
-function readTextStyles(reading, call) {
-	const { typescript } = reading;
-	const table = call.arguments[0] === void 0 ? void 0 : unwrap(typescript, call.arguments[0]);
-	if (table === void 0 || !typescript.isObjectLiteralExpression(table)) {
-		unresolve(reading, "defineTextStyles argument is not an object literal");
-		return;
-	}
-	const binding = bindingOf(typescript, call);
-	for (const property of table.properties) {
-		const key = propertyNameOf(typescript, property);
-		if (key === void 0) {
-			unresolve(reading, "defineTextStyles key is not a literal");
-			continue;
-		}
-		const anchor = binding === void 0 ? {
-			path: reading.path,
-			key
-		} : {
-			path: reading.path,
-			binding,
-			key
-		};
-		reading.definitions.push({
-			key: `textStyle:${key}`,
-			anchor
-		});
-	}
-}
-/**
-* Adds a style key; the same key and anchor twice in one file is one anchor, since `find`
-* answers every style call of a factory.
-*
-* @param reading - The file being read.
-* @param key - The key.
-* @param anchor - The anchor.
-*/
-function addStyle(reading, key, anchor) {
-	const identity = JSON.stringify({
-		key,
-		anchor
-	});
-	if (reading.styles.has(identity)) return;
-	reading.styles.add(identity);
-	reading.definitions.push({
-		key,
-		anchor
-	});
-}
-/**
-* The key and anchor of a style built in a module-level function: `style:<path>#<function>`, or
-* `style:<path>#<function>.<property>` when the call is the value of an object property there.
-*
-* @param reading - The file being read.
-* @param call - The `defineStyle` call.
-* @param factory - The name of the function the call sits in.
-* @returns The key and its anchor.
-*/
-function styleKeyIn(reading, call, factory) {
-	const { typescript, path } = reading;
-	const property = propertyOfValue(typescript, call);
-	if (property === void 0) return {
-		key: `style:${path}#${factory}`,
-		anchor: {
-			path,
-			binding: factory
-		}
-	};
-	return {
-		key: `style:${path}#${factory}.${property}`,
-		anchor: {
-			path,
-			binding: factory,
-			key: property
-		}
-	};
-}
-/**
-* Reads a style. One bound to a module const is `style:<path>#<binding>`. One built in a
-* module-level function, at any depth, is `style:<path>#<function>`, or
-* `style:<path>#<function>.<property>` when it is the value of an object property there. Any
-* other style is unresolved.
-*
-* @param reading - The file being read.
-* @param call - The call.
-*/
-function readStyle(reading, call) {
-	const { typescript, path } = reading;
-	const binding = bindingOf(typescript, call);
-	if (binding !== void 0) {
-		addStyle(reading, `style:${path}#${binding}`, {
-			path,
-			binding
-		});
-		return;
-	}
-	const factory = enclosingFunction(typescript, call);
-	if (factory !== void 0) {
-		const style = styleKeyIn(reading, call, factory);
-		addStyle(reading, style.key, style.anchor);
-		return;
-	}
-	const around = enclosingName(typescript, call);
-	unresolve(reading, `defineStyle${around === void 0 ? "" : ` in "${around}"`} is not bound to a module-level const`);
-}
-/**
-* Reads one definer call.
-*
-* @param reading - The file being read.
-* @param call - The call.
-* @param definer - The definer it calls.
-*/
-function readCall(reading, call, definer) {
-	const prefix = ID_PREFIXES[definer];
-	if (prefix !== void 0) readIdCall(reading, call, definer, prefix);
-	if (definer === "projection") readProjection(reading, call);
-	if (definer === "defineTextStyles") readTextStyles(reading, call);
-	if (definer === "defineStyle") readStyle(reading, call);
-}
-/**
-* Adds the JSX keys of the file; the same key twice in one file is one anchor, since `find`
-* answers every place of an anchor in its file.
-*
-* @param reading - The file being read.
-* @param source - The parsed file.
-*/
-function readJsx(reading, source) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const hit of collectJsx(reading.typescript, source)) {
-		if (isOpaque(hit)) {
-			unresolve(reading, opaqueReason(hit));
-			continue;
-		}
-		const anchor = anchorOfHit(reading.path, hit);
-		const identity = JSON.stringify(anchor);
-		if (seen.has(identity)) continue;
-		seen.add(identity);
-		reading.definitions.push({
-			key: `jsx:${hit.key}`,
-			anchor
-		});
-	}
-}
-/**
-* Reads the keys one file defines.
-*
-* @param typescript - The TypeScript module.
-* @param source - The parsed file.
-* @param path - The root-relative path of the file.
-* @param definers - The definers the file can call, from `definersOf`.
-* @returns The definitions, the node tables and the unresolved items in source order, and the
-*   component names the file renders.
-*/
-function extractFile(typescript, source, path, definers) {
-	const reading = {
-		typescript,
-		path,
-		definers,
-		definitions: [],
-		tables: [],
-		unresolved: [],
-		styles: /* @__PURE__ */ new Set()
-	};
-	const visit = (node) => {
-		const definer = typescript.isCallExpression(node) ? definerOfCall(typescript, node, definers) : void 0;
-		if (definer !== void 0 && typescript.isCallExpression(node)) readCall(reading, node, definer);
-		typescript.forEachChild(node, visit);
-	};
-	if (definers.size > 0) visit(source);
-	reading.definitions.push(...readComponents(typescript, source, path));
-	readJsx(reading, source);
-	return {
-		definitions: reading.definitions,
-		tables: reading.tables,
-		unresolved: reading.unresolved,
-		rendered: renderedOf(typescript, source)
-	};
-}
-//#endregion
-//#region src/project/typescript.ts
-/**
-* Loads the optional peer `typescript`.
-*
-* @param load - The import; the real dynamic import by default.
-* @returns The TypeScript module.
-* @throws {Error} When the package is not installed.
-*/
-async function loadTypeScript(load = () => import("typescript")) {
-	try {
-		const loaded = await load();
-		return loaded.default ?? loaded;
-	} catch {
-		throw new Error("[game] The project index needs the \"typescript\" package.\n  Install it as a dev dependency of the game.");
-	}
-}
-/**
-* Formats the first parse error of a file as `path:line:col message`, 1-based.
-*
-* @param typescript - The TypeScript module.
-* @param source - The parsed file.
-* @param diagnostic - The parse error.
-* @returns The message.
-*/
-function describeError(typescript, source, diagnostic) {
-	const { line, character } = source.getLineAndCharacterOfPosition(diagnostic.start);
-	const message = typescript.flattenDiagnosticMessageText(diagnostic.messageText, " ");
-	return `${source.fileName}:${line + 1}:${character + 1} ${message}`;
-}
-/**
-* Parses one file with parent links, as TSX for a `.tsx` path and as TS otherwise.
-*
-* @param typescript - The TypeScript module.
-* @param path - The root-relative path; it names the file in the error.
-* @param text - The source text.
-* @returns The tree and the first parse error.
-*/
-function parseFile(typescript, path, text) {
-	const kind = path.endsWith(".tsx") ? typescript.ScriptKind.TSX : typescript.ScriptKind.TS;
-	const source = typescript.createSourceFile(path, text, typescript.ScriptTarget.Latest, true, kind);
-	const [first] = source.parseDiagnostics ?? [];
-	if (first === void 0) return { source };
-	return {
-		source,
-		error: describeError(typescript, source, first)
-	};
-}
-//#endregion
-//#region src/project/catalog.ts
-/** How many parses the cache keeps; the oldest goes first. */
-const PARSE_CACHE_SIZE = 512;
-/**
-* Creates an empty catalog.
-*
-* @param typescript - The TypeScript module.
-* @returns The catalog.
-*/
-function createCatalog(typescript) {
-	return {
-		typescript,
-		records: /* @__PURE__ */ new Map(),
-		parses: /* @__PURE__ */ new Map()
-	};
-}
-/**
-* Parses one version of a file, or takes it from the cache.
-*
-* @param catalog - The catalog.
-* @param path - The root-relative path.
-* @param hash - The sha1 of the bytes.
-* @param text - The text of the bytes.
-* @returns The parse.
-*/
-function parseCached(catalog, path, hash, text) {
-	const id = `${path}\0${hash}`;
-	const cached = catalog.parses.get(id);
-	catalog.parses.delete(id);
-	const parsed = cached ?? parseFile(catalog.typescript, path, text);
-	catalog.parses.set(id, parsed);
-	for (const old of catalog.parses.keys()) {
-		if (catalog.parses.size <= PARSE_CACHE_SIZE) break;
-		catalog.parses.delete(old);
-	}
-	return parsed;
-}
-/**
-* Takes in the bytes of a file. Unchanged bytes change nothing; bytes that parse replace the
-* good version; bytes that do not parse mark the file broken and keep the good version.
-*
-* @param catalog - The catalog.
-* @param path - The root-relative path.
-* @param bytes - The bytes on disk.
-* @returns True when the bytes differ from the ones last read.
-*/
-function putFile(catalog, path, bytes) {
-	const hash = sha1(bytes);
-	const record = catalog.records.get(path);
-	if (record?.hash === hash) return false;
-	const text = new TextDecoder().decode(bytes);
-	const parsed = parseCached(catalog, path, hash, text);
-	if (parsed.error === void 0) {
-		const good = {
-			hash,
-			text,
-			module: readModule(catalog.typescript, parsed.source)
-		};
-		catalog.records.set(path, {
-			hash,
-			state: "ok",
-			good
-		});
-		return true;
-	}
-	catalog.records.set(path, {
-		hash,
-		state: "broken",
-		error: parsed.error,
-		...record?.good === void 0 ? {} : { good: record.good },
-		...record?.extracted === void 0 ? {} : { extracted: record.extracted }
-	});
-	return true;
-}
-/**
-* Drops a file that is gone.
-*
-* @param catalog - The catalog.
-* @param path - The root-relative path.
-* @returns True when the catalog held the file.
-*/
-function dropFile(catalog, path) {
-	return catalog.records.delete(path);
-}
-/**
-* Brings the keys of every good file up to date: a file is read again when its good version or
-* the definers it reaches changed since it was last read. An alias change that moves the
-* definers of a file moves its stamp, so a tsconfig edit re-reads exactly the files it affects.
-*
-* @param catalog - The catalog.
-* @param resolution - The module facts of every good file, and the aliases.
-*/
-function refreshExtractions(catalog, resolution) {
-	for (const [path, record] of catalog.records) {
-		const good = record.good;
-		if (good === void 0) continue;
-		const definers = definersOf(resolution, path);
-		const signature = [...definers].map(([callee, definer]) => `${callee}=${definer}`).join(";");
-		const stamp = `${good.hash}|${signature}`;
-		if (record.extracted?.definers === stamp) continue;
-		const { source } = parseCached(catalog, path, good.hash, good.text);
-		record.extracted = {
-			definers: stamp,
-			result: extractFile(catalog.typescript, source, path, definers)
-		};
-	}
-}
-/**
-* Builds the index of everything the catalog holds.
-*
-* @param catalog - The catalog.
-* @param manifest - The root-relative manifest path when the file exists.
-* @param aliases - The tsconfig aliases when the game declares some.
-* @returns The index, frozen.
-*/
-function buildIndex(catalog, manifest, aliases) {
-	const files = [...catalog.records].toSorted(([first], [second]) => first < second ? -1 : 1);
-	const modules = /* @__PURE__ */ new Map();
-	for (const [path, record] of files) if (record.good !== void 0) modules.set(path, record.good.module);
-	refreshExtractions(catalog, {
-		modules,
-		aliases
-	});
-	return assembleIndex({
-		files,
-		modules,
-		aliases
-	}, manifest);
-}
-//#endregion
 //#region src/project/locate.ts
 /** The kind of a style key. */
 const STYLE_KIND = "style";
@@ -2616,7 +238,7 @@ function patternAnchors(shapes, wanted) {
 */
 function anchorsOf(session, key) {
 	const exact = session.index.symbols[key]?.def ?? [];
-	const reached = key.startsWith("jsx:") && !key.includes("*") && !hasHole(key) ? patternAnchors(shapesOf(session), key.slice(4)) : [];
+	const reached = key.startsWith("jsx:") && !key.includes("*") && !hasHole(key) ? patternAnchors(shapesOf(session), key.slice(JSX.length)) : [];
 	return [.../* @__PURE__ */ new Set([...exact, ...reached])];
 }
 /**
@@ -2647,7 +269,8 @@ async function viewOf(session, file) {
 	const bytes = await readInside(session.root, file);
 	if (bytes === void 0) return void 0;
 	const hash = sha1(bytes);
-	const fresh = parseCached(catalog, file, hash, hash === good?.hash ? good.text : new TextDecoder().decode(bytes));
+	const text = hash === good?.hash ? good.text : new TextDecoder().decode(bytes);
+	const fresh = parseCached(catalog, file, hash, text);
 	if (fresh.error === void 0) return {
 		source: fresh.source,
 		hash,
@@ -2743,384 +366,6 @@ async function findKey(session, key) {
 	return found;
 }
 //#endregion
-//#region src/project/change.ts
-/**
-* The files that define a key, each once, in the order of its anchors.
-*
-* @param entry - The symbol entry.
-* @param entry.def - Its definitions.
-* @returns The paths.
-*/
-function pathsOf(entry) {
-	return [...new Set(entry.def.map((anchor) => anchor.path))];
-}
-/**
-* Compares the index before a batch with the index after it.
-*
-* @param before - The index before the batch.
-* @param after - The index after the batch.
-* @param files - The paths whose bytes changed, appeared or vanished.
-* @returns The change: the new revision, the files sorted, the moves and the removed keys.
-*/
-function diffIndexes(before, after, files) {
-	const moved = [];
-	const removed = [];
-	for (const [key, entry] of Object.entries(before.symbols)) {
-		const now = after.symbols[key];
-		if (now === void 0) {
-			removed.push(key);
-			continue;
-		}
-		const was = pathsOf(entry);
-		const is = pathsOf(now);
-		const left = was.filter((file) => !is.includes(file));
-		const arrived = is.filter((file) => !was.includes(file));
-		for (const [index, from] of left.entries()) {
-			const to = arrived[index];
-			if (to !== void 0) moved.push({
-				key,
-				from,
-				to
-			});
-		}
-	}
-	return {
-		revision: after.revision,
-		files: files.toSorted(),
-		moved,
-		removed
-	};
-}
-//#endregion
-//#region src/project/walk.ts
-/**
-* Reads the stamp of a file.
-*
-* @param file - The absolute path.
-* @returns The stamp, or `undefined` when the file is gone.
-*/
-async function stampOf(file) {
-	try {
-		const stats = await stat(file, { bigint: true });
-		return {
-			ino: stats.ino,
-			size: stats.size,
-			mtimeNs: stats.mtimeNs,
-			ctimeNs: stats.ctimeNs
-		};
-	} catch {
-		return;
-	}
-}
-/**
-* Whether two stamps describe the same write.
-*
-* @param first - One stamp.
-* @param second - The other.
-* @returns True when inode, size and both time stamps are equal.
-* @example
-* ```ts
-* const stamp = { ino: 1n, size: 10n, mtimeNs: 5n, ctimeNs: 5n };
-* sameStamp(stamp, { ...stamp, size: 11n }); // false
-* ```
-*/
-function sameStamp(first, second) {
-	return first.ino === second.ino && first.size === second.size && first.mtimeNs === second.mtimeNs && first.ctimeNs === second.ctimeNs;
-}
-/**
-* Lists one folder, empty when it vanished during the walk.
-*
-* @param folder - The absolute folder.
-* @returns Its entries.
-*/
-async function entriesOf(folder) {
-	return readdir(folder, { withFileTypes: true }).catch(() => []);
-}
-/**
-* Reads one folder of the walk: its sub-folders join the queue, its source files join the list
-* with their stamps.
-*
-* @param root - The real root.
-* @param folder - The folder, root-relative; `""` is the root.
-* @param walk - The files so far, and the queue of folders still to read.
-* @param walk.files - The files so far.
-* @param walk.pending - The folders still to read.
-*/
-async function readFolder(root, folder, walk) {
-	for (const entry of await entriesOf(path.join(root, folder))) {
-		const relative = folder === "" ? entry.name : `${folder}/${entry.name}`;
-		if (entry.isDirectory() && !isSkippedFolder(entry.name)) walk.pending.push(relative);
-		if (!entry.isFile() || !isIndexedFile(relative)) continue;
-		const stamp = await stampOf(path.join(root, relative));
-		if (stamp !== void 0) walk.files.set(relative, stamp);
-	}
-}
-/**
-* Walks a root: every indexed source file with its stamp and every folder outside the skipped
-* ones. Symlinks are skipped, files and folders alike.
-*
-* @param root - The real root.
-* @returns The files and the folders, root-relative POSIX.
-*/
-async function walkRoot(root) {
-	const files = /* @__PURE__ */ new Map();
-	const folders = [];
-	const pending = [""];
-	for (let folder = pending.pop(); folder !== void 0; folder = pending.pop()) {
-		folders.push(folder);
-		await readFolder(root, folder, {
-			files,
-			pending
-		});
-	}
-	return {
-		files,
-		folders
-	};
-}
-//#endregion
-//#region src/project/session.ts
-/**
-* @file project — an open project: the real root, the catalog of its files, the stamps of the last
-* walk, the tsconfig aliases with the stamps of the config files they came from, the current index
-* and a queue that runs one update at a time. `syncWithDisk` is the batch walk of a watch batch:
-* it walks the root, hashes the files whose stamp moved and every new one, drops the vanished
-* ones, reads the aliases again when a config file moved, and rebuilds the index when bytes or
-* aliases changed. `reindexPath` reads one path now for `changed`.
-*/
-/** The dev manifest `moku-game keys` writes. */
-const MANIFEST_FILE = "generated/manifest.json";
-/** The tsconfig whose `paths` are read by default. */
-const TSCONFIG_FILE = "tsconfig.json";
-/**
-* The manifest path to report, when the file exists.
-*
-* @param root - The real root.
-* @param manifest - The root-relative manifest path.
-* @returns The path, or `undefined` when nothing is there.
-*/
-async function presentManifest(root, manifest) {
-	try {
-		if (await resolveInside(root, manifest) !== void 0) return manifest;
-	} catch {}
-}
-/**
-* The stamp of a config file, read through the guard.
-*
-* @param root - The real root.
-* @param file - The root-relative path.
-* @returns The stamp, or `undefined` when nothing is there or the path left the root.
-*/
-async function configStampOf(root, file) {
-	try {
-		const real = await resolveInside(root, file);
-		return real === void 0 ? void 0 : await stampOf(real);
-	} catch {
-		return;
-	}
-}
-/**
-* The stamps of config files.
-*
-* @param root - The real root.
-* @param files - The root-relative config files.
-* @returns Path to stamp, `undefined` for a file that is not there.
-*/
-async function stampConfigs(root, files) {
-	const stamps = /* @__PURE__ */ new Map();
-	for (const file of files) stamps.set(file, await configStampOf(root, file));
-	return stamps;
-}
-/**
-* The config files a read of the tsconfig touched: its sources, or the tsconfig alone when it is
-* missing.
-*
-* @param tsconfig - The root-relative tsconfig path.
-* @param read - The read, `undefined` for a missing tsconfig.
-* @returns The root-relative files to stamp.
-* @example
-* ```ts
-* configsOf("tsconfig.json", undefined); // ["tsconfig.json"]
-* ```
-*/
-function configsOf(tsconfig, read) {
-	return read?.sources ?? [tsconfig];
-}
-/**
-* The aliases the index follows: a tsconfig without patterns maps nothing, as no tsconfig does.
-*
-* @param read - The read, `undefined` for a missing tsconfig.
-* @returns The read when it holds a pattern, else `undefined`.
-* @example
-* ```ts
-* followedAliases({ file: "tsconfig.json", sources: ["tsconfig.json"], patterns: [] }); // undefined
-* ```
-*/
-function followedAliases(read) {
-	return read === void 0 || read.patterns.length === 0 ? void 0 : read;
-}
-/**
-* Whether a config file moved, appeared or vanished since its stamp.
-*
-* @param session - The project.
-* @returns True when a stamp of `configStamps` is not the one on disk now.
-*/
-async function configsMoved(session) {
-	for (const [file, known] of session.configStamps) {
-		const now = await configStampOf(session.root, file);
-		if (known === void 0 || now === void 0 ? known !== now : !sameStamp(known, now)) return true;
-	}
-	return false;
-}
-/**
-* Reads the aliases again and stamps the config files the read touched. A tsconfig that stops
-* parsing keeps the aliases it had until it parses again, as a broken source file keeps its keys,
-* and the files of the last good read are stamped again.
-*
-* @param session - The project.
-* @returns True when the aliases resolve differently now.
-*/
-async function rereadAliases(session) {
-	const before = session.aliases;
-	let configs = [...session.configStamps.keys()];
-	try {
-		const read = await readAliases(session.catalog.typescript, session.root, session.tsconfig);
-		session.aliases = followedAliases(read);
-		configs = configsOf(session.tsconfig, read);
-	} catch {}
-	session.configStamps = await stampConfigs(session.root, configs);
-	return !sameAliases(before, session.aliases);
-}
-/**
-* Reads one file into the catalog, or drops it when it is gone or cannot be read.
-*
-* @param session - The project.
-* @param file - The root-relative path.
-* @returns True when the catalog changed.
-*/
-async function readIntoCatalog(session, file) {
-	const bytes = await readInside(session.root, file);
-	if (bytes === void 0) {
-		session.stamps.delete(file);
-		return dropFile(session.catalog, file);
-	}
-	return putFile(session.catalog, file, bytes);
-}
-/**
-* Rebuilds the index after files changed and says what changed.
-*
-* @param session - The project.
-* @param files - The paths whose bytes changed, appeared or vanished.
-* @returns The change.
-*/
-async function rebuild(session, files) {
-	const before = session.index;
-	const manifest = await presentManifest(session.root, session.manifest);
-	session.index = buildIndex(session.catalog, manifest, session.aliases);
-	return diffIndexes(before, session.index, files);
-}
-/**
-* Opens a project: checks the root, loads TypeScript, reads the tsconfig aliases and every source
-* file, and builds the index.
-*
-* @param options - The root, the manifest, the tsconfig and the debounce.
-* @returns The open project.
-* @throws {Error} When the root is missing or not a directory, the manifest or the tsconfig path
-*   leaves the root, the tsconfig does not parse, or TypeScript is not installed.
-*/
-async function openSession(options) {
-	const root = await openRoot(options.root);
-	const typescript = await loadTypeScript();
-	const manifest = toPosix(options.manifest ?? MANIFEST_FILE);
-	const tsconfig = toPosix(options.tsconfig ?? TSCONFIG_FILE);
-	await resolveInside(root, manifest);
-	await resolveInside(root, tsconfig);
-	const read = await readAliases(typescript, root, tsconfig);
-	const aliases = followedAliases(read);
-	const walk = await walkRoot(root);
-	const catalog = createCatalog(typescript);
-	const session = {
-		root,
-		manifest,
-		tsconfig,
-		aliases,
-		configStamps: await stampConfigs(root, configsOf(tsconfig, read)),
-		catalog,
-		stamps: walk.files,
-		folders: walk.folders,
-		index: buildIndex(catalog, void 0, aliases),
-		shapes: /* @__PURE__ */ new WeakMap(),
-		queue: Promise.resolve()
-	};
-	for (const file of [...walk.files.keys()].toSorted()) await readIntoCatalog(session, file);
-	session.index = buildIndex(catalog, await presentManifest(root, manifest), aliases);
-	return session;
-}
-/**
-* Runs an update after the ones before it, so two never interleave.
-*
-* @param session - The project.
-* @param task - The update.
-* @returns What the update returns.
-*/
-function serialize(session, task) {
-	const result = session.queue.then(task);
-	session.queue = result.catch(() => {});
-	return result;
-}
-/**
-* The batch walk: walks the root, hashes each file whose stamp moved and each new one, drops the
-* vanished ones, reads the aliases again when a config file moved, appeared or vanished, and
-* rebuilds the index when bytes or aliases changed. A save with the same bytes, or a tsconfig
-* edit that leaves the aliases as they were, changes nothing. New aliases list the tsconfig
-* among the changed files.
-*
-* @param session - The project.
-* @returns The change, or `undefined` when the index stayed the same.
-*/
-async function syncWithDisk(session) {
-	const walk = await walkRoot(session.root);
-	const files = [];
-	for (const file of session.catalog.records.keys()) if (!walk.files.has(file) && dropFile(session.catalog, file)) files.push(file);
-	const previous = session.stamps;
-	session.stamps = walk.files;
-	session.folders = walk.folders;
-	for (const [file, stamp] of walk.files) {
-		const known = previous.get(file);
-		if (known !== void 0 && sameStamp(known, stamp)) continue;
-		if (await readIntoCatalog(session, file)) files.push(file);
-	}
-	if (await configsMoved(session) && await rereadAliases(session)) files.push(session.tsconfig);
-	const manifest = await presentManifest(session.root, session.manifest);
-	if (files.length === 0 && manifest === session.index.manifest) return void 0;
-	return rebuild(session, files);
-}
-/**
-* Reads one root-relative path now: a changed or new source file is parsed, a deleted one is
-* dropped, the tsconfig or a file it extends reads the aliases again, and anything else changes
-* nothing.
-*
-* @param session - The project.
-* @param file - The root-relative path.
-* @returns The index after the read.
-* @throws {Error} When the path leaves the root.
-*/
-async function reindexPath(session, file) {
-	const relative = toPosix(file);
-	const real = await resolveInside(session.root, relative);
-	if (path.isAbsolute(relative)) return session.index;
-	if (session.configStamps.has(relative)) {
-		if (await rereadAliases(session)) await rebuild(session, [session.tsconfig]);
-		return session.index;
-	}
-	if (real !== void 0 && real !== path.join(session.root, relative) || !isIndexedFile(relative)) return session.index;
-	const stamp = real === void 0 ? void 0 : await stampOf(real);
-	if (stamp !== void 0) session.stamps.set(relative, stamp);
-	if (!await readIntoCatalog(session, relative)) return session.index;
-	await rebuild(session, [relative]);
-	return session.index;
-}
-//#endregion
 //#region src/project/cli.ts
 /**
 * @file project — the command line `moku-game-index`. It opens the project of `--root` and runs one
@@ -3336,210 +581,18 @@ async function runCommand(session, options, ui) {
 async function runCli(argv, ui = createBrandConsole()) {
 	try {
 		const options = parseArgv(argv);
-		return await runCommand(await openSession({
+		const projectOptions = {
 			root: options.root,
 			...options.manifest === void 0 ? {} : { manifest: options.manifest },
 			...options.tsconfig === void 0 ? {} : { tsconfig: options.tsconfig }
-		}), options, ui);
+		};
+		return await runCommand(await openSession(projectOptions), options, ui);
 	} catch (error) {
 		ui.error(messageOf(error));
 		return 1;
 	}
 }
 //#endregion
-//#region src/project/watch.ts
-/**
-* @file project — the watcher of an open project. A platform event is only a trigger: Bun on macOS
-* reports every edit as `rename`, drops the destination of a move and names the `.tmp` of an
-* atomic save instead of the file. So events only poke a batcher; when the quiet period ends, the
-* batch walks the root (`syncWithDisk`) and finds what really changed. The watcher can also miss a
-* write made as it starts, so the handle walks once when watching starts and then every two
-* seconds as a backstop. The root is watched recursively; where the platform cannot, every folder
-* of the last walk gets its own watcher, re-armed after each walk. Every caller of `watch` shares
-* the one watcher of the handle.
-*/
-/** The longest a burst of events holds a batch back, at the least. */
-const LONGEST_WAIT_MS = 1e3;
-/** The longest wait as a multiple of the quiet period, when that is longer. */
-const LONGEST_WAIT_FACTOR = 10;
-/**
-* How often a watching handle walks the root with no event: the platform watcher can miss a write
-* made as it starts, and drop events under load. A walk that finds the same bytes calls nobody.
-*/
-const BACKSTOP_MS = 2e3;
-/** The error `watch` throws on a closed handle. */
-const CLOSED = "[game] The project is closed.\n  Open it again with openProject().";
-/**
-* Watches every folder of the last walk with its own watcher, for a platform without recursive
-* watching.
-*
-* @param root - The real root.
-* @param listener - Gets every event.
-* @param onError - Called when a folder watcher errors.
-* @param watchFunction - `fs.watch`.
-* @returns The tree watcher.
-*/
-function watchFolders(root, listener, onError, watchFunction) {
-	const watchers = /* @__PURE__ */ new Map();
-	const arm = (folder) => {
-		try {
-			const handle = watchFunction(path.join(root, folder), { recursive: false }, listener);
-			handle.on("error", () => {
-				handle.close();
-				if (watchers.get(folder) === handle) watchers.delete(folder);
-				onError();
-			});
-			watchers.set(folder, handle);
-		} catch {}
-	};
-	return {
-		rearm: (folders) => {
-			for (const [folder, handle] of watchers) {
-				if (folders.includes(folder)) continue;
-				handle.close();
-				watchers.delete(folder);
-			}
-			for (const folder of folders) if (!watchers.has(folder)) arm(folder);
-		},
-		close: () => {
-			for (const handle of watchers.values()) handle.close();
-			watchers.clear();
-		}
-	};
-}
-/**
-* Watches a root: recursively when the platform can, else one watcher per folder. Events under
-* the skipped folders are ignored.
-*
-* @param root - The real root.
-* @param onEvent - Called on every event that may matter.
-* @param watchFunction - `fs.watch` by default.
-* @returns The tree watcher.
-*/
-function watchTree(root, onEvent, watchFunction = watch) {
-	const listener = (_event, file) => {
-		if (file === null || !isSkippedPath(`${file}/`)) onEvent();
-	};
-	try {
-		const handle = watchFunction(root, { recursive: true }, listener);
-		handle.on("error", () => onEvent());
-		return {
-			rearm: () => {},
-			close: () => handle.close()
-		};
-	} catch {
-		return watchFolders(root, listener, onEvent, watchFunction);
-	}
-}
-/**
-* Creates the debounce of a watcher: a batch runs once the events stop for `quietMs`, or after the
-* longest wait during an endless burst. One batch runs at a time; events during a batch queue one
-* more.
-*
-* @param quietMs - The quiet period that closes a batch.
-* @param run - The batch.
-* @returns The batcher.
-*/
-function createBatcher(quietMs, run) {
-	const longestMs = Math.max(LONGEST_WAIT_MS, quietMs * LONGEST_WAIT_FACTOR);
-	let quiet;
-	let longest;
-	let running = false;
-	let pending = false;
-	let cancelled = false;
-	const clear = () => {
-		clearTimeout(quiet);
-		clearTimeout(longest);
-		quiet = void 0;
-		longest = void 0;
-	};
-	const fire = () => {
-		clear();
-		if (running) {
-			pending = true;
-			return;
-		}
-		const settle = () => {
-			running = false;
-			if (pending && !cancelled) poke();
-			pending = false;
-		};
-		running = true;
-		run().then(settle, settle);
-	};
-	const poke = () => {
-		if (cancelled) return;
-		clearTimeout(quiet);
-		quiet = setTimeout(fire, quietMs);
-		longest ??= setTimeout(fire, longestMs);
-	};
-	return {
-		poke,
-		cancel: () => {
-			cancelled = true;
-			clear();
-		}
-	};
-}
-/**
-* Creates the callers' hub of one handle: the watcher starts with the first caller and stops with
-* the last; each batch that changed the index calls every caller once.
-*
-* @param session - The open project.
-* @param debounceMs - The quiet period.
-* @param watchFunction - `fs.watch` by default.
-* @param backstopMs - The period of the walk with no event, two seconds by default.
-* @returns The hub.
-*/
-function createHub(session, debounceMs, watchFunction = watch, backstopMs = BACKSTOP_MS) {
-	const listeners = /* @__PURE__ */ new Set();
-	let tree;
-	let batcher;
-	let backstop;
-	let closed = false;
-	const batch = async () => {
-		const change = await serialize(session, () => syncWithDisk(session));
-		tree?.rearm(session.folders);
-		if (change === void 0 || closed) return;
-		for (const { listener } of [...listeners]) try {
-			listener(session.index, change);
-		} catch {}
-	};
-	const stop = () => {
-		clearInterval(backstop);
-		tree?.close();
-		batcher?.cancel();
-		backstop = void 0;
-		tree = void 0;
-		batcher = void 0;
-	};
-	const start = () => {
-		const started = createBatcher(debounceMs, batch);
-		batcher = started;
-		tree = watchTree(session.root, () => started.poke(), watchFunction);
-		tree.rearm(session.folders);
-		started.poke();
-		backstop = setInterval(() => started.poke(), backstopMs);
-	};
-	return {
-		add: (listener) => {
-			if (closed) throw new Error(CLOSED);
-			const entry = { listener };
-			listeners.add(entry);
-			if (tree === void 0) start();
-			return () => {
-				listeners.delete(entry);
-				if (listeners.size === 0) stop();
-			};
-		},
-		close: () => {
-			closed = true;
-			listeners.clear();
-			stop();
-		}
-	};
-}
-//#endregion
 //#region src/project/open.ts
 /**
 * @file project — `openProject`, the one function of the project index a caller starts from. It