@moku-labs/game 0.14.12 → 0.14.13

package/dist/{watch-CWI_on4T.mjs → watch-BEdrp80i.mjs}

@@ -1,7 +1,8 @@
+import { n as findFeatureUnits } from "./features-DowEilZm.mjs";
 import { watch } from "node:fs";
 import path from "node:path";
-import { readFile, readdir, realpath, stat } from "node:fs/promises";
 import { createHash } from "node:crypto";
+import { readFile, readdir, realpath, stat } from "node:fs/promises";
 //#region src/project/paths.ts
 /**
 * @file project — which files the index reads, and the guard on every path it reads. Paths in and
@@ -1556,17 +1557,22 @@ 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.
+* The revision of an index: the sha1 of the lines `${path}\0${hash}\n`, one per file, and
+* `${dir}/\0${parent}\n`, one per feature unit, all sorted together. Without units the value is
+* the one of the files alone.
 *
 * @param files - Every indexed file with its hash.
+* @param owners - The feature units of the game: owners and code-only sub-features.
 * @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(""));
+function revisionOf(files, owners = []) {
+	const lines = Object.entries(files).map(([file, entry]) => `${file}\0${entry.hash}\n`);
+	const units = owners.map((owner) => `${owner.dir}/\0${owner.parent ?? ""}\n`);
+	return sha1([...lines, ...units].toSorted().join(""));
 }
 //#endregion
 //#region src/project/shapes.ts
@@ -1778,7 +1784,26 @@ function deepFreeze(value) {
 	return value;
 }
 /**
+* The `features` table of the index: one entry per unit, in unit order, the parent only when there
+* is one.
+*
+* @param owners - The feature units.
+* @returns The table.
+* @example
+* ```ts
+* featuresOf([{ name: "home", dir: "features/home", depth: 0, resources: { assets: true, strings: false } }]); // { home: { dir: "features/home" } }
+* ```
+*/
+function featuresOf(owners) {
+	return Object.fromEntries(owners.map((owner) => [owner.name, owner.parent === void 0 ? { dir: owner.dir } : {
+		dir: owner.dir,
+		parent: owner.parent
+	}]));
+}
+/**
 * Assembles the index of a catalog. The index names the tsconfig when the assembly has aliases.
+* With the feature units it carries `features`, a clash adds one unresolved item, and the units
+* join the revision; without them the index has no `features` key.
 *
 * @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.
@@ -1808,14 +1833,20 @@ function assembleIndex(assembly, manifest) {
 	}
 	addStyleUses(assembly, symbols);
 	addComponentUses(assembly, symbols);
+	const owners = assembly.owners;
+	if (owners?.error !== void 0) unresolved.push({
+		path: "features",
+		reason: owners.error
+	});
 	return deepFreeze({
 		schemaVersion: 1,
-		revision: revisionOf(files),
+		revision: revisionOf(files, owners?.owners),
 		...manifest === void 0 ? {} : { manifest },
 		...assembly.aliases === void 0 ? {} : { tsconfig: assembly.aliases.file },
 		symbols: finishSymbols(symbols),
 		files,
-		unresolved
+		unresolved,
+		...owners === void 0 ? {} : { features: featuresOf(owners.owners) }
 	});
 }
 //#endregion
@@ -2369,9 +2400,10 @@ function refreshExtractions(catalog, resolution) {
 * @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.
+* @param owners - The feature units of the game, when the catalog has a root.
 * @returns The index, frozen.
 */
-function buildIndex(catalog, manifest, aliases) {
+function buildIndex(catalog, manifest, aliases, owners) {
 	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);
@@ -2382,7 +2414,8 @@ function buildIndex(catalog, manifest, aliases) {
 	return assembleIndex({
 		files,
 		modules,
-		aliases
+		aliases,
+		owners
 	}, manifest);
 }
 //#endregion
@@ -2398,12 +2431,32 @@ function pathsOf(entry) {
 	return [...new Set(entry.def.map((anchor) => anchor.path))];
 }
 /**
+* The feature names whose entry differs between two `features` tables: added, removed, or with
+* another folder or parent.
+*
+* @param before - The table before the batch, when the index has one.
+* @param after - The table after the batch, when the index has one.
+* @returns The names, sorted.
+* @example
+* ```ts
+* changedFeatures({ a: { dir: "features/a" } }, { b: { dir: "features/b" } }); // ["a", "b"]
+* ```
+*/
+function changedFeatures(before = {}, after = {}) {
+	return [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].filter((name) => {
+		const was = before[name];
+		const is = after[name];
+		return was?.dir !== is?.dir || was?.parent !== is?.parent;
+	}).toSorted();
+}
+/**
 * 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.
+* @returns The change: the new revision, the files sorted, the moves, the removed keys and the
+*   features that moved, when some did.
 */
 function diffIndexes(before, after, files) {
 	const moved = [];
@@ -2427,11 +2480,13 @@ function diffIndexes(before, after, files) {
 			});
 		}
 	}
+	const features = changedFeatures(before.features, after.features);
 	return {
 		revision: after.revision,
 		files: files.toSorted(),
 		moved,
-		removed
+		removed,
+		...features.length === 0 ? {} : { features }
 	};
 }
 //#endregion
@@ -2528,8 +2583,9 @@ async function walkRoot(root) {
 * 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`.
+* ones, reads the aliases again when a config file moved, reads the feature units again, and
+* rebuilds the index when bytes, aliases or units changed. `reindexPath` reads one path now for
+* `changed`.
 */
 /** The dev manifest `moku-game keys` writes. */
 const MANIFEST_FILE = "generated/manifest.json";
@@ -2635,6 +2691,55 @@ async function rereadAliases(session) {
 	return !sameAliases(before, session.aliases);
 }
 /**
+* Reads the feature units of a game: the owners and the code-only sub-features. A name clash keeps
+* the units of the read before, as a tsconfig that stops parsing keeps its aliases.
+*
+* @param root - The real root.
+* @param before - The read before, if any.
+* @returns The read.
+*/
+function readOwners(root, before) {
+	try {
+		return { owners: findFeatureUnits(root) };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			owners: before?.owners ?? [],
+			error: message
+		};
+	}
+}
+/**
+* Whether two reads of the feature units agree: the same names, folders and parents in the same
+* order, and the same clash message.
+*
+* @param before - The read before.
+* @param after - The read now.
+* @returns True when the index would not change by them.
+* @example
+* ```ts
+* sameOwners({ owners: [] }, { owners: [], error: "clash" }); // false
+* ```
+*/
+function sameOwners(before, after) {
+	return before.error === after.error && before.owners.length === after.owners.length && before.owners.every((owner, at) => {
+		const other = after.owners[at];
+		return owner.name === other?.name && owner.dir === other.dir && owner.parent === other.parent;
+	});
+}
+/**
+* Reads the feature units again and keeps the new read.
+*
+* @param session - The project.
+* @returns True when they differ from the read before.
+*/
+function rereadOwners(session) {
+	const read = readOwners(session.root, session.owners);
+	const isMoved = !sameOwners(session.owners, read);
+	session.owners = read;
+	return isMoved;
+}
+/**
 * Reads one file into the catalog, or drops it when it is gone or cannot be read.
 *
 * @param session - The project.
@@ -2659,7 +2764,7 @@ async function readIntoCatalog(session, file) {
 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);
+	session.index = buildIndex(session.catalog, manifest, session.aliases, session.owners);
 	return diffIndexes(before, session.index, files);
 }
 /**
@@ -2682,21 +2787,23 @@ async function openSession(options) {
 	const aliases = followedAliases(read);
 	const walk = await walkRoot(root);
 	const catalog = createCatalog(typescript);
+	const owners = readOwners(root);
 	const session = {
 		root,
 		manifest,
 		tsconfig,
 		aliases,
 		configStamps: await stampConfigs(root, configsOf(tsconfig, read)),
+		owners,
 		catalog,
 		stamps: walk.files,
 		folders: walk.folders,
-		index: buildIndex(catalog, void 0, aliases),
+		index: buildIndex(catalog, void 0, aliases, owners),
 		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);
+	session.index = buildIndex(catalog, await presentManifest(root, manifest), aliases, owners);
 	return session;
 }
 /**
@@ -2713,10 +2820,10 @@ function serialize(session, task) {
 }
 /**
 * 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.
+* vanished ones, reads the aliases again when a config file moved, appeared or vanished, reads
+* the feature units again, and rebuilds the index when bytes, aliases or units 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; moved units list no file.
 *
 * @param session - The project.
 * @returns The change, or `undefined` when the index stayed the same.
@@ -2734,14 +2841,32 @@ async function syncWithDisk(session) {
 		if (await readIntoCatalog(session, file)) files.push(file);
 	}
 	if (await configsMoved(session) && await rereadAliases(session)) files.push(session.tsconfig);
+	const ownersMoved = rereadOwners(session);
 	const manifest = await presentManifest(session.root, session.manifest);
-	if (files.length === 0 && manifest === session.index.manifest) return void 0;
+	if (files.length === 0 && manifest === session.index.manifest && !ownersMoved) return void 0;
 	return rebuild(session, files);
 }
 /**
+* Reads one root-relative path into the project: a config file of the aliases reads them again,
+* an indexed file is parsed or dropped, anything else is skipped.
+*
+* @param session - The project.
+* @param relative - The root-relative POSIX path.
+* @param real - Its real path, `undefined` when nothing is there.
+* @returns The paths to report as changed: the tsconfig for new aliases, the file for new bytes.
+*/
+async function readPath(session, relative, real) {
+	if (session.configStamps.has(relative)) return await rereadAliases(session) ? [session.tsconfig] : [];
+	if (real !== void 0 && real !== path.join(session.root, relative) || !isIndexedFile(relative)) return [];
+	const stamp = real === void 0 ? void 0 : await stampOf(real);
+	if (stamp !== void 0) session.stamps.set(relative, stamp);
+	return await readIntoCatalog(session, relative) ? [relative] : [];
+}
+/**
 * 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.
+* no file. The feature units are read again for every path, so a new door or a new `strings/`
+* folder shows a sub-feature at once.
 *
 * @param session - The project.
 * @param file - The root-relative path.
@@ -2752,15 +2877,9 @@ 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]);
+	const files = await readPath(session, relative, real);
+	const ownersMoved = rereadOwners(session);
+	if (files.length > 0 || ownersMoved) await rebuild(session, files);
 	return session.index;
 }
 //#endregion