@moku-labs/game 0.14.12 → 0.14.13

package/dist/lint.mjs

@@ -1,4 +1,5 @@
-import { readFileSync, statSync } from "node:fs";
+import { n as findFeatureUnits, r as ownerOf } from "./features-DowEilZm.mjs";
+import { readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 //#region src/lint.ts
 /**
@@ -8,8 +9,9 @@ import path from "node:path";
 * use the ESLint rule API, so ESLint 9 loads the same object. Every rule takes
 * `[{ files, ignores }]`: globs relative to the directory oxlint runs in; a key given replaces the
 * default. The layout rules also take the folder of the game's layers (`root`) and the tsconfig
-* whose `paths` name the aliases (`tsconfig`). Only `node:path` and `node:fs` are imported; the
-* file is erasable TypeScript, so Node loads it unbuilt.
+* whose `paths` name the aliases (`tsconfig`). Only `node:path`, `node:fs` and
+* `./project/features.ts` (itself `node:` only) are imported; the file is erasable TypeScript, so
+* Node loads it unbuilt.
 */
 /** Tests and test helpers: no rule checks them by default. */
 const TESTS = [
@@ -139,6 +141,17 @@ const MISSING = -1;
 const INDEX_FILE = /^index(?:\.[jt]sx?)?$/;
 /** The root flow of a game, with or without its extension. */
 const GAME_FILE = /^game(?:\.[jt]sx?)?$/;
+/** The folders that hold one kind of code or resource of a feature: the list of `src/project/features.ts`. */
+const KIND_FOLDER = /^(?:flow|views|rules|styles|motion|world|effects|nodes|assets|strings|content|__tests__)$/;
+/** A source naming a folder beside the door: `./<folder>`, `./<folder>/index`, either with `.ts`, `.tsx` or `.js`. */
+const FOLDER_SOURCE = /^\.\/([^/]+?)(?:\/index)?(?:\.(?:tsx?|js))?$/;
+/** The default scope of sub-features: the `index` files below `features/`. */
+const DOOR_FILES = {
+	files: ["**/features/**/index.{ts,tsx}"],
+	ignores: TESTS
+};
+/** What sub-features says about an entry of `features: [...]` that is not a name. */
+const ENTRY_SHAPE_MESSAGE = "Sub-features: list each sub-feature by the name it is imported under from \"./<folder>\".";
 /** The place of every path outside the layout. */
 const OTHER = {
 	layer: "other",
@@ -1014,18 +1027,61 @@ function isDoor(inner) {
 	return inner.length === 0 || inner.length === 1 && INDEX_FILE.test(inner[0] ?? "");
 }
 /**
+* The units of the features a unit lives in, nearest first: the folders above it, one per depth.
+*
+* @param dir - The unit's root-relative folder.
+* @param depth - The unit's depth: 0 for a folder of `features/`.
+* @returns The folders of its ancestors.
+* @example
+* ```ts
+* ancestorsOf("features/episodes/ep01/scene1", 2); // ["features/episodes/ep01", "features/episodes"]
+* ```
+*/
+function ancestorsOf(dir, depth) {
+	const parts = dir.split("/");
+	return Array.from({ length: depth }, (_, index) => parts.slice(0, -1 - index).join("/"));
+}
+/**
+* The place of a path inside a feature unit: the unit, its door, and the units it lives in.
+*
+* @param owner - The deepest unit that holds the path.
+* @param below - The parts of the path below the `features` folder.
+* @returns The place.
+* @example
+* ```ts
+* unitPlace({ name: "ep01", dir: "features/episodes/ep01", depth: 1, resources: { assets: false, strings: true } }, ["episodes", "ep01", "index.ts"]);
+* // { layer: "features", unit: "features/episodes/ep01", door: true, ancestors: ["features/episodes"] }
+* ```
+*/
+function unitPlace(owner, below) {
+	const door = isDoor(below.slice(owner.dir.split("/").length - 1));
+	if (owner.depth === 0) return {
+		layer: "features",
+		unit: owner.dir,
+		door
+	};
+	return {
+		layer: "features",
+		unit: owner.dir,
+		door,
+		ancestors: ancestorsOf(owner.dir, owner.depth)
+	};
+}
+/**
 * The place of a path under `features/` or `plugins/`: the barrel, a unit and its door, or a
-* file that lies directly in the folder, which is outside the layout.
+* file that lies directly in the folder, which is outside the layout. The unit of a features path
+* is the deepest feature unit that holds it; with none on disk, the folder of `features/` it lies in.
 *
 * @param layer - `features` or `plugins`.
 * @param below - The parts of the path below the layer folder.
+* @param owners - The feature units of the game.
 * @returns The place.
 * @example
 * ```ts
-* unitOf("features", ["orders", "index.ts"]); // { layer: "features", unit: "features/orders", door: true }
+* unitOf("features", ["orders", "index.ts"], []); // { layer: "features", unit: "features/orders", door: true }
 * ```
 */
-function unitOf(layer, below) {
+function unitOf(layer, below, owners) {
 	const [name, ...inner] = below;
 	if (name === void 0 || inner.length === 0 && INDEX_FILE.test(name)) return {
 		layer,
@@ -1033,6 +1089,8 @@ function unitOf(layer, below) {
 		door: true
 	};
 	if (inner.length === 0 && path.extname(name) !== "") return OTHER;
+	const owner = layer === "features" ? ownerOf(owners, [layer, ...below].join("/")) : void 0;
+	if (owner !== void 0) return unitPlace(owner, below);
 	return {
 		layer,
 		unit: `${layer}/${name}`,
@@ -1044,13 +1102,14 @@ function unitOf(layer, below) {
 *
 * @param root - The absolute folder of the layers.
 * @param file - The absolute path, with or without its extension.
+* @param owners - The feature units of the game; none puts a features path in its top-level folder.
 * @returns The place; `other` for a path outside the layout.
 * @example
 * ```ts
 * placeOf("/game", "/game/shared/index.ts"); // { layer: "shared", unit: "shared", door: true }
 * ```
 */
-function placeOf(root, file) {
+function placeOf(root, file, owners = []) {
 	const relative = insideOf(root, file);
 	if (relative === void 0) return OTHER;
 	const [head = "", ...below] = relative.split("/");
@@ -1066,7 +1125,7 @@ function placeOf(root, file) {
 			door: isDoor(below)
 		};
 		case "features":
-		case "plugins": return unitOf(head, below);
+		case "plugins": return unitOf(head, below, owners);
 		case "generated":
 		case "tests": return {
 			layer: head,
@@ -1092,14 +1151,35 @@ function isBarrel(place) {
 	return (place.layer === "features" || place.layer === "plugins") && place.unit === place.layer;
 }
 /**
+* The feature units of a game. A name clash leaves none, and says why.
+*
+* @param root - The absolute folder of the layers.
+* @returns The units, or none and the report of the clash.
+*/
+function readUnits(root) {
+	try {
+		return {
+			owners: findFeatureUnits(root),
+			problem: void 0
+		};
+	} catch (error) {
+		const [first = ""] = (error instanceof Error ? error.message : "").split("\n");
+		return {
+			owners: [],
+			problem: `Lint: ${first.replace(/^\[game\] /, "")} The layout rules read the top-level features only until it is fixed.`
+		};
+	}
+}
+/**
 * What a layout rule knows about the file the context lints: the layers, the aliases and where
 * the file lies.
 *
 * @param context - The rule context.
 * @param reads - The tsconfig reads of the rule, by absolute path.
+* @param units - True to read the feature units, once per file.
 * @returns The layout.
 */
-function layoutOf(context, reads) {
+function layoutOf(context, reads, units) {
 	const [given] = context.options;
 	const root = path.resolve(context.cwd, given?.root ?? ".");
 	const tsconfig = path.resolve(context.cwd, given?.tsconfig ?? "tsconfig.json");
@@ -1110,12 +1190,19 @@ function layoutOf(context, reads) {
 		reads.set(tsconfig, read);
 	}
 	const broken = read.broken === void 0 ? void 0 : path.relative(context.cwd, read.broken);
+	const owners = units ? readUnits(root) : {
+		owners: [],
+		problem: void 0
+	};
+	const importer = placeOf(root, file, owners.owners);
 	return {
 		root,
 		folder: path.dirname(file),
-		importer: placeOf(root, file),
+		importer,
 		patterns: read.patterns ?? patternsOf(root, V15_PATHS),
-		problem: broken === void 0 ? void 0 : `Lint: ${toPosix(broken)} does not parse. The layout rules read the v15 aliases until it does.`
+		problem: broken === void 0 ? void 0 : `Lint: ${toPosix(broken)} does not parse. The layout rules read the v15 aliases until it does.`,
+		owners: owners.owners,
+		ownersProblem: importer.layer === "features" ? owners.problem : void 0
 	};
 }
 /**
@@ -1138,9 +1225,10 @@ function targetOf(layout, specifier) {
 * @param description - What the rule enforces.
 * @param defaults - The rule's default globs.
 * @param judge - The message for one import, or undefined when it passes.
+* @param units - True for a rule that reads the feature units and reports a name clash.
 * @returns The rule.
 */
-function layoutRule(description, defaults, judge) {
+function layoutRule(description, defaults, judge, units = false) {
 	const reads = /* @__PURE__ */ new Map();
 	return {
 		meta: {
@@ -1156,7 +1244,7 @@ function layoutRule(description, defaults, judge) {
 		*/
 		create(context) {
 			if (!inScope(context, defaults)) return {};
-			const layout = layoutOf(context, reads);
+			const layout = layoutOf(context, reads, units);
 			const check = (node) => {
 				const specifier = specifierOf(node);
 				const message = specifier === void 0 ? void 0 : judge(layout, specifier);
@@ -1171,6 +1259,10 @@ function layoutRule(description, defaults, judge) {
 						node,
 						message: layout.problem
 					});
+					if (layout.ownersProblem !== void 0) context.report({
+						node,
+						message: layout.ownersProblem
+					});
 				},
 				ImportDeclaration: check,
 				ExportAllDeclaration: check,
@@ -1205,7 +1297,7 @@ function layerMessage(layout, specifier) {
 	const reach = LAYER_REACH[layout.importer.layer];
 	const target = targetOf(layout, specifier);
 	if (reach === void 0 || target === void 0) return void 0;
-	const { layer } = placeOf(layout.root, target);
+	const { layer } = placeOf(layout.root, target, layout.owners);
 	if (layer === "other" || reach.includes(layer)) return void 0;
 	const name = layer === "game" ? "game.ts" : layer;
 	return `Layers: ${layout.importer.layer} does not import ${name}. ${LAYER_ORDER}`;
@@ -1258,6 +1350,22 @@ function escapeMessage(importer) {
 	return `Door: an import that leaves ${importer.unit ?? importer.layer} is written as an alias: @features/<f>, @shared, @core/<file>.`;
 }
 /**
+* What feature-door says about a sub-feature that imports a feature it lives in: the fix is a
+* sibling kit of the feature it imported.
+*
+* @param importer - The unit of the importing file.
+* @param ancestor - The unit of the feature it imports.
+* @returns The report.
+* @example
+* ```ts
+* ancestorMessage("features/episodes/ep01", "features/episodes");
+* // "Door: a sub-feature does not import the feature it lives in: features/episodes/ep01 imports features/episodes. Move what they share into a sibling sub-feature, such as features/episodes/episodes-kit, and import it from its door."
+* ```
+*/
+function ancestorMessage(importer, ancestor) {
+	return `Door: a sub-feature does not import the feature it lives in: ${importer} imports ${ancestor}. Move what they share into a sibling sub-feature, such as ${`${ancestor}/${path.posix.basename(ancestor)}-kit`}, and import it from its door.`;
+}
+/**
 * What feature-door says about an import of shared, a feature, a plugin or a barrel that lands in
 * the layout outside the barrels.
 *
@@ -1274,13 +1382,14 @@ function unitDoorMessage(importer, place, isRelative) {
 	const deep = deepMessage(importer, place);
 	if (deep !== void 0) return deep;
 	if (place.unit === importer.unit) return place.door && !importer.door ? ownDoorMessage(importer) : void 0;
+	if (place.door && place.ancestors?.includes(importer.unit ?? "") === true) return void 0;
 	const staysInBarrel = isBarrel(importer) && place.layer === importer.layer;
 	return isRelative && !staysInBarrel ? escapeMessage(importer) : void 0;
 }
 /**
-* What feature-door says about one import of a unit: the barrels belong to game.ts, a unit does
-* not import its own door, another feature is reached through its door, and an import that
-* leaves the unit is written as an alias.
+* What feature-door says about one import of a unit: the barrels belong to game.ts, a sub-feature
+* does not import a feature it lives in, a unit does not import its own door, another feature is
+* reached through its door, and an import that leaves the unit is written as an alias.
 *
 * @param layout - The layout of the importing file.
 * @param specifier - The module specifier as written.
@@ -1290,11 +1399,12 @@ function doorMessage(layout, specifier) {
 	const { importer } = layout;
 	const target = targetOf(layout, specifier);
 	if (importer.unit === void 0 || target === void 0) return void 0;
-	const place = placeOf(layout.root, target);
+	const place = placeOf(layout.root, target, layout.owners);
 	const isRelative = RELATIVE.test(specifier);
 	if (place.layer === "other") return void 0;
 	if (isBarrel(place)) return place.unit === importer.unit ? void 0 : BARREL_MESSAGE;
 	if (importer.layer === "core") return isRelative && place.layer !== "core" ? escapeMessage(importer) : void 0;
+	if (place.unit !== void 0 && importer.ancestors?.includes(place.unit) === true) return ancestorMessage(importer.unit, place.unit);
 	return unitDoorMessage(importer, place, isRelative);
 }
 /** L4: a rule imports only its siblings, the types of core and the rules of shared. */
@@ -1308,10 +1418,311 @@ const layerImports = layoutRule("A layer imports only the layers below it: core
 	ignores: [...TESTS, "**/generated/**"]
 }, layerMessage);
 /** Doors: a feature is imported from its index.ts, and the barrels only by game.ts. */
-const featureDoor = layoutRule("A feature is imported from its index.ts; the barrels only by game.ts; an import that leaves a feature is an alias.", {
+const featureDoor = layoutRule("A feature is imported from its index.ts at any depth; a sub-feature never imports a feature it lives in; the barrels only by game.ts; an import that leaves a feature is an alias.", {
 	files: ["**/{core,shared,features,plugins}/**"],
 	ignores: TESTS
-}, doorMessage);
+}, doorMessage, true);
+/**
+* The folder a source names beside the importing door.
+*
+* @param source - The module specifier as written.
+* @returns The folder for `./<folder>`, `./<folder>/index` and either with an extension; else undefined.
+* @example
+* ```ts
+* importedFolder("./ep01/index.ts"); // "ep01"
+* ```
+*/
+function importedFolder(source) {
+	return FOLDER_SOURCE.exec(source)?.[1];
+}
+/**
+* Whether a source imports a folder beside the door: `./<folder>`, `./<folder>/index`, either with
+* `.ts`, `.tsx` or `.js`.
+*
+* @param source - The module specifier as written.
+* @param folder - The folder name.
+* @returns True when the source names the folder's door.
+* @example
+* ```ts
+* isFolderImport("./ep03/index.js", "ep03"); // true
+* ```
+*/
+function isFolderImport(source, folder) {
+	return importedFolder(source) === folder;
+}
+/**
+* Whether a unit brings resources of its own: a feature owner rather than a code-only sub-feature.
+*
+* @param unit - A feature unit.
+* @returns True with `assets/`, `assets.ts` or `strings/`.
+* @example
+* ```ts
+* hasResources({ name: "kit", dir: "features/a/kit", depth: 1, resources: { assets: true, strings: false } }); // true
+* ```
+*/
+function hasResources(unit) {
+	return unit.resources.assets || unit.resources.strings;
+}
+/**
+* Whether a folder on disk is a feature owner: a door and resources of its own.
+*
+* @param folder - The absolute folder.
+* @returns True with an `index.ts` or `index.tsx` and `assets/`, `assets.ts` or `strings/`.
+*/
+function isOwnerFolder(folder) {
+	const has = (name, isFolder) => {
+		const stat = statSync(path.join(folder, name), { throwIfNoEntry: false });
+		return isFolder ? stat?.isDirectory() === true : stat?.isFile() === true;
+	};
+	return (has("index.ts", false) || has("index.tsx", false)) && (has("assets", true) || has("assets.ts", false) || has("strings", true));
+}
+/**
+* Whether a folder holds a feature owner directly: a child folder, not a kind folder, with a door
+* and resources.
+*
+* @param folder - The absolute folder of a unit, which exists: its door is being linted.
+* @returns True when one child folder is an owner.
+*/
+function hasOwnerChild(folder) {
+	return readdirSync(folder, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !KIND_FOLDER.test(entry.name)).some((entry) => isOwnerFolder(path.join(folder, entry.name)));
+}
+/**
+* The names the `features: [...]` arrays of a door list.
+*
+* @param lists - The arrays.
+* @returns The identifiers among their elements.
+*/
+function listedNames(lists) {
+	const names = /* @__PURE__ */ new Set();
+	for (const { elements } of lists) for (const element of elements) {
+		const name = element?.type === "Identifier" ? nameOf(element) : void 0;
+		if (name !== void 0) names.add(name);
+	}
+	return names;
+}
+/**
+* The elements of a `features: [...]` property.
+*
+* @param node - A Property.
+* @returns The elements, or undefined for any other property.
+*/
+function listingOf(node) {
+	const { key } = node;
+	const isName = key?.type === "Identifier" && !node.computed && nameOf(key) === "features";
+	const isString = key?.type === "Literal" && key.value === "features";
+	const value = isNode(node.value) ? node.value : void 0;
+	return (isName || isString) && value?.type === "ArrayExpression" ? value.elements ?? [] : void 0;
+}
+/**
+* Whether a callee is `defineFeature` or a member `<x>.defineFeature`.
+*
+* @param callee - The callee of a CallExpression.
+* @returns True for the definer.
+*/
+function isDefiner(callee) {
+	if (callee?.type === "Identifier") return nameOf(callee) === "defineFeature";
+	return callee?.type === "MemberExpression" && propertyName(callee) === "defineFeature";
+}
+/**
+* The checks of a parent door: every child owner is imported from `./<child>` and listed.
+*
+* @param door - The door.
+* @param read - What the door holds.
+* @param program - The Program node, for a missing import.
+* @returns The reports.
+*/
+function childReports(door, read, program) {
+	const listed = listedNames(read.lists);
+	const reports = [];
+	for (const child of door.units) {
+		if (child.parent !== door.unit.name || !hasResources(child)) continue;
+		const imported = read.imports.filter((item) => isFolderImport(item.source, child.name));
+		const [first] = imported;
+		if (first === void 0) reports.push({
+			node: program,
+			message: `Sub-features: ${child.dir} is a sub-feature of ${door.unit.name}, and this door does not import it. Import it from "./${child.name}" and list it in features: [...].`
+		});
+		else if (!imported.some((item) => item.locals.some((name) => listed.has(name)))) {
+			const shown = first.locals.find((name) => name.endsWith("Feature")) ?? first.locals[0] ?? "<feature>";
+			reports.push({
+				node: first.node,
+				message: `Sub-features: "${first.source}" is imported but not listed in features: [...]. List the sub-feature: features: [..., ${shown}].`
+			});
+		}
+	}
+	return reports;
+}
+/**
+* The checks of each `features: [...]` entry: a name imported from a sub-feature folder of the door.
+*
+* @param door - The door.
+* @param read - What the door holds.
+* @returns The reports.
+*/
+function entryReports(door, read) {
+	const reports = [];
+	for (const list of read.lists) for (const element of list.elements) {
+		if (element?.type !== "Identifier") {
+			reports.push({
+				node: element ?? list.node,
+				message: ENTRY_SHAPE_MESSAGE
+			});
+			continue;
+		}
+		const name = nameOf(element) ?? "";
+		const from = read.imports.find((item) => item.locals.includes(name));
+		const folder = from === void 0 ? void 0 : importedFolder(from.source);
+		const isSubFeature = door.units.some((unit) => unit.dir === `${door.unit.dir}/${folder}`);
+		if (folder === void 0 || !isSubFeature) reports.push({
+			node: element,
+			message: `Sub-features: features: [...] lists ${name}, which is not imported from a sub-feature folder of ${door.unit.name}. A sub-feature lives in ${door.unit.dir}/<name> and is imported from "./<name>".`
+		});
+	}
+	return reports;
+}
+/**
+* The check of a sub-feature's door: it registers a feature named like its folder.
+*
+* @param door - The door.
+* @param read - What the door holds.
+* @param program - The Program node, for a door that registers none.
+* @returns The reports.
+*/
+function nameReports(door, read, program) {
+	const { name } = door.unit;
+	if (door.unit.depth === 0 || read.calls.some((call) => call.name === name)) return [];
+	const others = read.calls.filter((call) => call.defines);
+	if (others.length > 0) return others.map((call) => ({
+		node: call.node,
+		message: `Sub-features: ${door.file} registers the feature "${call.name}"; a sub-feature is named like its folder: "${name}".`
+	}));
+	return [{
+		node: program,
+		message: `Sub-features: the door of ${door.unit.dir} registers no feature named "${name}". A sub-feature is named like its folder: defineFeature("${name}", { … }).`
+	}];
+}
+/**
+* The check of a code-only sub-feature: it declares no sub-features, neither listed nor on disk.
+*
+* @param door - The door.
+* @param read - What the door holds.
+* @param program - The Program node.
+* @returns The report, or undefined for an owner or a code-only door without sub-features.
+*/
+function codeOnlyReport(door, read, program) {
+	const { unit } = door;
+	if (unit.depth === 0 || hasResources(unit)) return void 0;
+	return read.lists.length > 0 || hasOwnerChild(path.join(door.root, unit.dir)) ? {
+		node: program,
+		message: `Sub-features: ${unit.dir} has no assets/, assets.ts or strings/, so its sub-features are invisible to the scanner and the compiler. Give it a resource of its own, or move them to ${unit.parent ?? "its parent"}.`
+	} : void 0;
+}
+/**
+* Every finding of sub-features on one door.
+*
+* @param door - The door.
+* @param read - What the door holds.
+* @param program - The Program node.
+* @returns The reports: the declaration, then the name.
+*/
+function doorReports(door, read, program) {
+	const codeOnly = codeOnlyReport(door, read, program);
+	return [...codeOnly === void 0 ? [...childReports(door, read, program), ...entryReports(door, read)] : [codeOnly], ...nameReports(door, read, program)];
+}
+/**
+* The door the context lints: the unit whose `index.ts` or `index.tsx` the file is.
+*
+* @param context - The rule context.
+* @returns The door, or undefined for any other file and for a feature name clash.
+*/
+function doorOf(context) {
+	const [given] = context.options;
+	const root = path.resolve(context.cwd, given?.root ?? ".");
+	const file = insideOf(root, path.resolve(context.cwd, context.filename));
+	const units = file === void 0 ? [] : readUnits(root).owners;
+	const unit = units.find((item) => `${item.dir}/index.ts` === file || `${item.dir}/index.tsx` === file);
+	return unit === void 0 || file === void 0 ? void 0 : {
+		root,
+		unit,
+		units,
+		file
+	};
+}
+/**
+* The node visitors that collect a door: value imports, `features: [...]` arrays and calls with a
+* literal first argument.
+*
+* @param read - Where they collect to.
+* @returns The visitors.
+*/
+function doorCollectors(read) {
+	return {
+		ImportDeclaration: (node) => {
+			const source = specifierOf(node);
+			const locals = (node.specifiers ?? []).map((specifier) => nameOf(specifier.local)).filter((name) => name !== void 0);
+			if (source !== void 0 && node.importKind !== "type") read.imports.push({
+				node,
+				source,
+				locals
+			});
+		},
+		Property: (node) => {
+			const elements = listingOf(node);
+			if (elements !== void 0) read.lists.push({
+				node,
+				elements
+			});
+		},
+		CallExpression: (node) => {
+			const [first] = node.arguments ?? [];
+			if (first?.type === "Literal" && typeof first.value === "string") read.calls.push({
+				node,
+				name: first.value,
+				defines: isDefiner(node.callee)
+			});
+		}
+	};
+}
+/**
+* Keeps a feature's declaration and its folders equal: a door imports every sub-feature owner from
+* `./<folder>` and lists it in `features: [...]`, lists nothing that does not come from a
+* sub-feature folder, and a sub-feature's door registers a feature named like its folder. Owners
+* are found by `src/project/features.ts` from folders; a code-only sub-feature is one because its
+* parent's door lists it.
+*
+* @example
+* ```json
+* "moku-game/sub-features": ["error", { "root": "src" }]
+* ```
+*/
+const subFeatures = {
+	meta: {
+		type: "problem",
+		docs: { description: "A feature's door imports every sub-feature owner from ./<folder> and lists it in features: [...], lists only sub-feature folders, and a sub-feature's door registers a feature named like its folder." },
+		schema: LAYOUT_SCHEMA
+	},
+	/**
+	* Visit a door of a feature unit when the rule's globs match it.
+	*
+	* @param context - The rule context.
+	* @returns The node visitors, none for a file out of scope or that is no door.
+	*/
+	create(context) {
+		const door = inScope(context, DOOR_FILES) ? doorOf(context) : void 0;
+		if (door === void 0) return {};
+		const read = {
+			imports: [],
+			lists: [],
+			calls: []
+		};
+		return {
+			...doorCollectors(read),
+			"Program:exit": (program) => {
+				for (const report of doorReports(door, read, program)) context.report(report);
+			}
+		};
+	}
+};
 /**
 * The key of a suffix table as a folder: with a trailing `/`.
 *
@@ -1414,6 +1825,7 @@ const plugin = {
 		"static-keys": staticKeys,
 		"layer-imports": layerImports,
 		"feature-door": featureDoor,
+		"sub-features": subFeatures,
 		"test-suffix": {
 			meta: {
 				type: "problem",

package/dist/project.d.mts

@@ -78,6 +78,8 @@ type Anchor = {
  * index.files["nodes/count.ts"]?.state; // "ok"
  * // A game whose tsconfig.json holds paths, such as tests/fixtures/layout-game.
  * index.tsconfig; // "tsconfig.json"
+ * // A game with sub-features, such as tests/fixtures/episodes-game.
+ * index.features?.["ep01"]; // { dir: "features/episodes/ep01", parent: "episodes" }
  * ```
  */
 type ProjectIndex = {
@@ -103,6 +105,17 @@ type ProjectIndex = {
     path: string;
     reason: string;
   }[];
+  /**
+   * Every feature of the game by name: its root-relative folder and, for a sub-feature, the feature it lives in.
+   * Found by `findFeatureUnits` (`src/project/features.ts`): each folder of `features/`, a folder inside a feature
+   * with a door `index.ts` and `assets/`, `assets.ts` or `strings/` of its own, and a code-only folder the feature's
+   * door imports from `./<folder>` and lists in `features: [...]`. Present in every index `openProject` builds; `{}`
+   * for a game without a features folder.
+   */
+  features?: Record<string, {
+    dir: string;
+    parent?: string;
+  }>;
 };
 /**
  * What one watch batch changed: the new revision, the files whose bytes changed, the keys that
@@ -124,7 +137,8 @@ type ProjectChange = {
     from: string;
     to: string;
   }[]; /** Keys gone from every file. */
-  removed: string[];
+  removed: string[]; /** The feature names whose entry in `features` appeared, vanished, or changed folder or parent; sorted. Absent when none. */
+  features?: string[];
 };
 /**
  * One answer of `find`: the anchor with its line read from the file now. Lines and columns are

package/dist/project.mjs

@@ -1,4 +1,4 @@
-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 { 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-BEdrp80i.mjs";
 import { createBrandConsole } from "@moku-labs/common/cli";
 //#region src/project/locate.ts
 /** The kind of a style key. */