@endora-commerce/cli 0.100.0

package/dist/lib/module-population.d.ts

@@ -0,0 +1,129 @@
+export { ManifestIndexUnreadableError } from './switchable-modules.js';
+export interface ModulePopulationInput {
+    /** Module ids the generated manifest index registers. */
+    readonly registered: readonly string[];
+    /**
+     * Every path the walk produced. Absolute or relative, either separator: the
+     * module id is read out of the `modules/<id>/` segment, which every caller's
+     * paths carry whichever root they were made relative to.
+     */
+    readonly files: readonly string[];
+    /**
+     * Registered modules this check excludes from its own scan by design, so its
+     * floor asks for the population it actually reads. Every entry is a claim the
+     * check makes in its header, not a convenience.
+     */
+    readonly excluded?: readonly string[];
+    /**
+     * How a path is attributed to a module, where the `modules/<id>/` segment is
+     * not the answer (feature 080, T040a).
+     *
+     * A module that has become a **package** lives at a path of its own choosing
+     * — `packages/modules/blog/src/…` today, whatever the workspace globs allow
+     * tomorrow — and its id is read from its manifest's `endora.id` rather than
+     * from a directory name. `lib/module-roots.ts` supplies the function; the
+     * default is {@link moduleIdOf}, so a caller with only an application tree
+     * gets exactly the behaviour it had before this field existed.
+     */
+    readonly moduleIdOf?: (path: string) => string | null;
+}
+/**
+ * Directories whose files belong to one module although no `modules/<id>/`
+ * segment says so — keyed by the directory's path under the application's own
+ * source root, mapped to the module id (feature 080, T040b).
+ *
+ * There is one, and it is `_lifecycle` at `src/lifecycle/`. D-160.11 keeps the
+ * lifecycle subsystem out of the package sweep — it is the platform's operator
+ * half — so it is the one registered module whose sources the host owns, and
+ * the directory is deliberately not named after its id (a `src/_lifecycle/`
+ * would make `backend/src` itself a module root, see
+ * `scripts/lib/module-roots.ts`). Nothing here is written down: the map is
+ * derived per run from the manifest index's own `manifestPath`, which is the
+ * artefact that records where each module's manifest actually is.
+ */
+export type HostResidentModules = ReadonlyMap<string, string>;
+/** The default: every path attributes by its `modules/<id>/` segment alone. */
+export declare const NO_HOST_RESIDENT_MODULES: HostResidentModules;
+/**
+ * The module a path belongs to, or `null` for a file outside the module tree.
+ *
+ * Reads the **first** `modules/<id>/` segment, so an overlay module under
+ * `apps/<deployment>/modules/<id>/` resolves to its own id rather than to the
+ * deployment. `node_modules/` cannot match: the segment must start the path or
+ * follow a separator.
+ *
+ * `hostResident` is the second answer, and it is a **map rather than a shape**
+ * because there is no shape to read: a host-resident module's directory says
+ * nothing about which module it is, so the id comes from the index. Omitting it
+ * is not a neutral default — a file the walk read and attributed to `null` is a
+ * file every consumer treats as *not a module's*, which is the check judging
+ * nothing and reporting clean (issue #215 one layer in). Every caller that
+ * attributes inside its analysis therefore takes it from the layout and passes
+ * it down; the default exists for a fixture that has no such module.
+ *
+ * The comparison is made on the path's tail after the last `/src/`, so it
+ * answers the same for the three key shapes this repository uses — a layout
+ * key, an absolute path, and the synthetic `/src/<key>` several checks build —
+ * and cannot be fooled by a directory of that name deeper in another tree
+ * (`packages/platform/src/kernel/lifecycle/` is the live example).
+ */
+export declare function moduleIdOf(path: string, hostResident?: HostResidentModules): string | null;
+/** Registered modules the walk produced no file for. */
+export declare function modulesWithoutSources(input: ModulePopulationInput): string[];
+/**
+ * What the index expected of the walk and what the walk delivered, in the shape
+ * `scripts/lib/read-size.ts` prints (issue #244).
+ *
+ * The floor below already computes both numbers to decide whether to refuse;
+ * returning them is what lets the check *print* them, so a run that was never
+ * short still says which population it covered. A number nothing prints is a
+ * number nobody can see going wrong.
+ */
+export interface ModulePopulationCoverage {
+    readonly source: 'manifest-index';
+    /** Registered modules this check is expected to read, exclusions removed. */
+    readonly expected: number;
+    /** How many of them the walk produced at least one file for. */
+    readonly covered: number;
+}
+/** The two numbers, without the refusal — the same derivation, printed. */
+export declare function modulePopulationCoverage(input: ModulePopulationInput): ModulePopulationCoverage;
+/**
+ * The sentence a check prints before `process.exit(2)`, or `null` when the walk
+ * covered every module the index registers.
+ *
+ * An index that registers nothing is refused too: "no module is registered" and
+ * "the index did not load" would otherwise be the same answer, and the second
+ * silently turns the floor off while looking like a normal run.
+ */
+export declare function vacuousModulePopulation(input: ModulePopulationInput): string | null;
+/**
+ * Ids of every module the generated index at `indexPath` registers.
+ *
+ * Throws `ManifestIndexUnreadableError` when the index is missing or empty; a
+ * caller turns that into exit 2, never into a pass.
+ */
+export declare function loadRegisteredModuleIds(indexPath: string): Promise<readonly string[]>;
+/**
+ * The CLI half: read the index, compare it against what the walk produced, and
+ * exit 2 rather than report on a residue.
+ *
+ * One function rather than nine copies, because nine copies of an exit-2 guard
+ * is nine chances to write the one that returns instead — and a check whose
+ * guard is subtly wrong is invisible by construction, since it reports green
+ * either way.
+ *
+ * Returns the coverage it just enforced, so the caller can hand it to
+ * `reportReadSize` and print the corroboration rather than only its own count
+ * of files (issue #244).
+ */
+export declare function refuseVacuousModulePopulation(input: {
+    /** The check's log prefix, e.g. `[subscribe-seam]`. */
+    readonly prefix: string;
+    /** The generated manifest index, as `lib/module-roots.ts` resolved it. */
+    readonly manifestIndexPath: string;
+    readonly files: readonly string[];
+    readonly excluded?: readonly string[];
+    readonly moduleIdOf?: (path: string) => string | null;
+}): Promise<ModulePopulationCoverage>;
+//# sourceMappingURL=module-population.d.ts.map

package/dist/lib/module-population.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-population.d.ts","sourceRoot":"","sources":["../../src/lib/module-population.ts"],"names":[],"mappings":"AAyCA,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAKvE,MAAM,WAAW,qBAAqB;IACpC,yDAAyD;IACzD,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CACvD;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9D,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB,EAAE,mBAA+B,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,YAAY,GAAE,mBAA8C,GAC3D,MAAM,GAAG,IAAI,CAUf;AAED,wDAAwD;AACxD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,EAAE,CAS5E;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,2EAA2E;AAC3E,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,qBAAqB,GAC3B,wBAAwB,CAQ1B;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,GAAG,IAAI,CAcnF;AAED;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAE3F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,6BAA6B,CAAC,KAAK,EAAE;IACzD,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CACvD,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAwBpC"}

package/dist/lib/module-population.js

@@ -0,0 +1,172 @@
+/**
+ * "Did the walk read the module tree, or a residue of it?" — the one derivation
+ * (issue #215).
+ *
+ * Fourteen of the twenty `check-*` scripts are filesystem walks whose whole
+ * population is `backend/src/modules`: 1364 of the 1469 `.ts` files under
+ * `backend/src` live there. Eight of them guarded that walk with
+ * `files.length === 0`, which is the wrong predicate. It catches only the case
+ * where the walk finds **nothing at all**; it cannot catch the case that
+ * actually happens when the tree moves, which is that the walk finds the
+ * remaining 105 files — `src/kernel`, `src/db`, `src/apps`, `src/http` — reads
+ * them, finds nothing wrong in them, and reports a clean tree. That is issue
+ * #113's failure mode, in eight checks at once, at the moment the repository is
+ * most disturbed.
+ *
+ * So the guard has to assert the walk found **the population it expects**, not
+ * merely a non-empty list. The expectation is derived from the generated
+ * manifest index, never written down: a hand-written count is a copy of a
+ * derived fact and goes stale in silence, which is what D-100 was written
+ * about. Two properties fall out of reading it, and the check needs both:
+ *
+ *   1. **The index is a path that must resolve.** Where it lives is
+ *      `lib/module-roots.ts`' answer since feature 080's T040a — searched for
+ *      over the workspace members rather than joined onto a source root — so a
+ *      tree that moved without it is an error rather than an empty result, and
+ *      the whole module directory going missing is refused before a single file
+ *      is analysed.
+ *   2. **Every module it registers must contribute a source.** A *partial*
+ *      move — the one a package split actually performs, index regenerated and
+ *      pointing at the new home — leaves the index readable and the walk
+ *      short. Only a per-module floor sees that, and it sees it without
+ *      anybody choosing a number.
+ *
+ * The pure half takes the file list and the ids, so a red proof can drive it
+ * from a residue the tree does not contain, entering where a real run enters
+ * (issues #113, #130). {@link loadRegisteredModuleIds} is the only part that
+ * knows where the index lives, and it is `switchable-modules.ts`' reader — the
+ * two derivations cannot disagree about which modules exist.
+ */
+import { loadManifestActivations } from './switchable-modules.js';
+export { ManifestIndexUnreadableError } from './switchable-modules.js';
+/** How many missing ids the message names before it counts the rest. */
+const NAMED_IN_MESSAGE = 8;
+/** The default: every path attributes by its `modules/<id>/` segment alone. */
+export const NO_HOST_RESIDENT_MODULES = new Map();
+/**
+ * The module a path belongs to, or `null` for a file outside the module tree.
+ *
+ * Reads the **first** `modules/<id>/` segment, so an overlay module under
+ * `apps/<deployment>/modules/<id>/` resolves to its own id rather than to the
+ * deployment. `node_modules/` cannot match: the segment must start the path or
+ * follow a separator.
+ *
+ * `hostResident` is the second answer, and it is a **map rather than a shape**
+ * because there is no shape to read: a host-resident module's directory says
+ * nothing about which module it is, so the id comes from the index. Omitting it
+ * is not a neutral default — a file the walk read and attributed to `null` is a
+ * file every consumer treats as *not a module's*, which is the check judging
+ * nothing and reporting clean (issue #215 one layer in). Every caller that
+ * attributes inside its analysis therefore takes it from the layout and passes
+ * it down; the default exists for a fixture that has no such module.
+ *
+ * The comparison is made on the path's tail after the last `/src/`, so it
+ * answers the same for the three key shapes this repository uses — a layout
+ * key, an absolute path, and the synthetic `/src/<key>` several checks build —
+ * and cannot be fooled by a directory of that name deeper in another tree
+ * (`packages/platform/src/kernel/lifecycle/` is the live example).
+ */
+export function moduleIdOf(path, hostResident = NO_HOST_RESIDENT_MODULES) {
+    const normalised = path.split('\\').join('/');
+    const match = /(?:^|\/)modules\/([^/]+)\//.exec(normalised);
+    if (match)
+        return match[1] ?? null;
+    const marker = normalised.lastIndexOf('/src/');
+    const tail = marker === -1 ? normalised : normalised.slice(marker + '/src/'.length);
+    for (const [directory, moduleId] of hostResident) {
+        if (tail === directory || tail.startsWith(`${directory}/`))
+            return moduleId;
+    }
+    return null;
+}
+/** Registered modules the walk produced no file for. */
+export function modulesWithoutSources(input) {
+    const excluded = new Set(input.excluded ?? []);
+    const idOf = input.moduleIdOf ?? moduleIdOf;
+    const seen = new Set();
+    for (const file of input.files) {
+        const id = idOf(file);
+        if (id !== null)
+            seen.add(id);
+    }
+    return input.registered.filter((id) => !excluded.has(id) && !seen.has(id)).sort();
+}
+/** The two numbers, without the refusal — the same derivation, printed. */
+export function modulePopulationCoverage(input) {
+    const excluded = new Set(input.excluded ?? []);
+    const expected = input.registered.filter((id) => !excluded.has(id)).length;
+    return {
+        source: 'manifest-index',
+        expected,
+        covered: expected - modulesWithoutSources(input).length,
+    };
+}
+/**
+ * The sentence a check prints before `process.exit(2)`, or `null` when the walk
+ * covered every module the index registers.
+ *
+ * An index that registers nothing is refused too: "no module is registered" and
+ * "the index did not load" would otherwise be the same answer, and the second
+ * silently turns the floor off while looking like a normal run.
+ */
+export function vacuousModulePopulation(input) {
+    if (input.registered.length === 0) {
+        return 'the manifest index registers no module — refusing to report a vacuous pass';
+    }
+    const missing = modulesWithoutSources(input);
+    if (missing.length === 0)
+        return null;
+    const named = missing.slice(0, NAMED_IN_MESSAGE).join(', ');
+    const rest = missing.length > NAMED_IN_MESSAGE ? `, +${missing.length - NAMED_IN_MESSAGE} more` : '';
+    return (`the walk read ${input.files.length} file(s) but produced none for ` +
+        `${missing.length} of the ${input.registered.length} registered modules ` +
+        `(${named}${rest}) — it is reading a residue of the module tree, not the tree; ` +
+        'refusing to report a vacuous pass');
+}
+/**
+ * Ids of every module the generated index at `indexPath` registers.
+ *
+ * Throws `ManifestIndexUnreadableError` when the index is missing or empty; a
+ * caller turns that into exit 2, never into a pass.
+ */
+export async function loadRegisteredModuleIds(indexPath) {
+    return (await loadManifestActivations(indexPath)).map((manifest) => manifest.id);
+}
+/**
+ * The CLI half: read the index, compare it against what the walk produced, and
+ * exit 2 rather than report on a residue.
+ *
+ * One function rather than nine copies, because nine copies of an exit-2 guard
+ * is nine chances to write the one that returns instead — and a check whose
+ * guard is subtly wrong is invisible by construction, since it reports green
+ * either way.
+ *
+ * Returns the coverage it just enforced, so the caller can hand it to
+ * `reportReadSize` and print the corroboration rather than only its own count
+ * of files (issue #244).
+ */
+export async function refuseVacuousModulePopulation(input) {
+    let registered;
+    try {
+        registered = await loadRegisteredModuleIds(input.manifestIndexPath);
+    }
+    catch (error) {
+        console.error(`${input.prefix} the module index at ${input.manifestIndexPath} could not be read ` +
+            `(${String(error)}) — the expected population is derived from it, so there is ` +
+            'nothing to compare the walk against; refusing to report a vacuous pass');
+        process.exit(2);
+    }
+    const population = {
+        registered,
+        files: input.files,
+        ...(input.excluded === undefined ? {} : { excluded: input.excluded }),
+        ...(input.moduleIdOf === undefined ? {} : { moduleIdOf: input.moduleIdOf }),
+    };
+    const reason = vacuousModulePopulation(population);
+    if (reason !== null) {
+        console.error(`${input.prefix} ${reason}`);
+        process.exit(2);
+    }
+    return modulePopulationCoverage(population);
+}
+//# sourceMappingURL=module-population.js.map

package/dist/lib/module-population.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-population.js","sourceRoot":"","sources":["../../src/lib/module-population.ts"],"names":[],"mappings":"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"}

package/dist/lib/module-roots.d.ts

@@ -0,0 +1,337 @@
+import type { AdminSurfaceLayout } from './admin-surfaces.js';
+import { type WorkspaceFs } from './workspace-packages.js';
+/** The file the composer generates and every module walk derives its floor from. */
+export declare const MANIFEST_INDEX_FILENAME = "manifest-index.generated.ts";
+/**
+ * Directories that are not this repository's own source and would either slow
+ * the search to no purpose or answer it with somebody else's copy.
+ *
+ * The same list the shell twin (`scripts/lib/module-root.sh`) prunes, kept in
+ * step with it by `test/unit/scripts/module-roots.test.ts`.
+ */
+export declare const PRUNED_DIRECTORIES: readonly string[];
+/** Raised when the module layout cannot be resolved; a caller turns it into exit 2. */
+export declare class ModuleLayoutUnresolvableError extends Error {
+    readonly name = "ModuleLayoutUnresolvableError";
+}
+/** One place backend module sources live. */
+export interface ModuleSourceRoot {
+    /** Absolute directory to walk. */
+    readonly directory: string;
+    /**
+     * The module every file under {@link directory} belongs to, or `null` when
+     * the directory holds several and attribution is read from the path.
+     */
+    readonly moduleId: string | null;
+    readonly origin: 'application' | 'workspace-package' | 'host-resident' | 'platform-resident';
+}
+export interface ModuleTreeLayout {
+    /** The checkout, fully resolved. */
+    readonly repoRoot: string;
+    /** The workspace member holding the manifest index — the application. */
+    readonly applicationRoot: string;
+    /** Its source root, derived from where the index sits. */
+    readonly srcRoot: string;
+    /** The generated manifest index, absolute. */
+    readonly manifestIndexPath: string;
+    /** Module ids that index registers. */
+    readonly registeredIds: readonly string[];
+    /** Every root holding module sources — application trees first, then packages. */
+    readonly moduleRoots: readonly ModuleSourceRoot[];
+    /** The per-deployment overlay tree (`<src>/apps`), which the index never lists. */
+    readonly overlayRoot: string;
+    /**
+     * The platform's own source directory, or `null` when this workspace has no
+     * member declaring `endora.type: "platform"` (every fixture tree).
+     *
+     * It is a root of its own because it is not the application's and not a
+     * module's: `packages/platform/src/{kernel,http,tenancy,commands,events}` is
+     * what `backend/src` reached relatively until the relocation, and what it now
+     * reaches through re-export shims. A check whose population *is* the platform
+     * refuses on `null` itself.
+     */
+    readonly platformRoot: string | null;
+    /**
+     * The npm name that platform publishes under — `null` on the same workspaces
+     * {@link ModuleTreeLayout.platformRoot} is `null` on.
+     *
+     * It is the other half of the same answer (feature 080, T060): a module in the
+     * application tree reaches the platform by relative path and a module in a
+     * package reaches it by this name, so a check whose population is *module
+     * reaches into the platform* needs both spellings or it loses the second set
+     * as the sweep converts them.
+     */
+    readonly platformPackageName: string | null;
+    /**
+     * Every directory a check that reads the whole application source tree must
+     * walk: the source root, the platform's, plus each package root — all three
+     * outside one another.
+     *
+     * The platform is here so that the twelve checks reading this keep the
+     * population they had before the relocation. Its five directories were under
+     * `src/` and every one of these walks covered them; leaving them out would
+     * have dropped six entity classifications from
+     * `check-entity-tenant-classification`, four repeating timers from
+     * `check:entry-scope` and the whole of `check:kernel-boundary`'s subject —
+     * each of which keeps printing a number and exiting 0, which is issue #215.
+     */
+    readonly sourceRoots: readonly string[];
+    /** Every directory a check that reads only module sources must walk. */
+    readonly moduleWalkRoots: readonly string[];
+    /** `modules/blog/x.ts` for the application, repo-relative for a package. */
+    readonly keyOf: (absolutePath: string) => string;
+    /** The same, with the application's own prefix: `src/modules/blog/x.ts`. */
+    readonly displayOf: (absolutePath: string) => string;
+    /**
+     * {@link ModuleTreeLayout.keyOf} inverted — the absolute path a key names.
+     *
+     * The two bases a key can be relative to are tried in the order that keeps
+     * the application's own spelling authoritative, because that is the one a
+     * ledger and a message already use.
+     */
+    readonly absolutePathOf: (key: string) => string;
+    /** The module a path belongs to, over every root, or `null`. */
+    readonly moduleIdOfPath: (absolutePath: string) => string | null;
+    /**
+     * Every module's own directory, by id — the enumeration half of
+     * {@link ModuleTreeLayout.moduleDirectoryOf}.
+     *
+     * A walk that has to visit *each* module (a bundle sweep, an i18n reconcile)
+     * reads this instead of listing a directory, because listing one answers for
+     * one root and there is now more than one.
+     */
+    readonly moduleDirectories: ReadonlyMap<string, string>;
+    /**
+     * The directory holding a module's own sources, or `null`.
+     *
+     * For an application root it is `<root>/<id>`; for a package it is the
+     * member directory. What it does **not** answer is where inside a package a
+     * named file lives — a package declares its entry points in its `exports`
+     * map, and reading that is the host package's business (T042a), not this
+     * one's. A caller that needs `backend.ts` therefore asks for the directory
+     * and looks in the two places a workspace member can keep it.
+     */
+    readonly moduleDirectoryOf: (moduleId: string) => string | null;
+    /**
+     * The npm name each module package publishes, mapped to the module id it
+     * declares — `@endora-commerce/mod-blog` → `blog`.
+     *
+     * It exists because a bare specifier can now reach a module, which is a thing
+     * this repository had never been able to say. `check-module-boundary`'s
+     * predicate 1 resolved relative specifiers only, on the stated premise that
+     * "there is no `@endora-commerce/mod-*` package yet"; !910 falsified that
+     * premise and the premise stayed. `blog` shipped with no ledger shard, so the
+     * hole cost nothing and showed nothing.
+     *
+     * The direction is name → id, and it is the only direction that is safe to
+     * key a ledger on (D-142): the npm name is npm's namespace, the manifest id is
+     * identity of record, and an edge that was `../blog/entities/blog-post.entity`
+     * before the move has to stay one key after it. Nothing here reads the name's
+     * spelling — a `mod-` prefix rule would be a derived fact written down (D-100)
+     * and would answer wrongly for the first package that is not named that way.
+     */
+    readonly modulePackageNames: ReadonlyMap<string, string>;
+    /**
+     * The directories of every **host-resident** module, keyed as
+     * {@link ModuleTreeLayout.keyOf} keys them, mapped to the module id.
+     *
+     * It is what a check hands to `moduleIdOf` / `moduleOf` so that its analysis
+     * attributes those files to their module. Empty on a tree that has none, in
+     * which case every attributor answers exactly as it did before this existed.
+     */
+    readonly hostResidentModules: ReadonlyMap<string, string>;
+    /**
+     * The admin application's module surfaces, or `null` when this workspace has
+     * no member declaring the source alias (feature 091, FR-017).
+     *
+     * It is a field of its own and deliberately **not** a member of
+     * {@link ModuleTreeLayout.moduleWalkRoots}: fifteen checks read that list and
+     * every one of them would acquire a population of `.ts`/`.tsx` files under
+     * `admin/` that it was never written to judge. `check:module-boundary` is the
+     * one check FR-017 names, and it is the one that calls this.
+     *
+     * **A function, and awaited, because the derivation parses TypeScript.**
+     * `admin-surfaces.ts` imports the compiler — the route table and the nav are
+     * read as AST nodes, not as text — and every consumer of this layout would
+     * otherwise load it. `test/helpers/lock-claims-check-fixture.ts` builds a
+     * spawnable tree out of a named list of libs and no `node_modules`, so an
+     * eager import there is `ERR_MODULE_NOT_FOUND` for `typescript` and every
+     * proof in that file fails for a reason that has nothing to do with a lock
+     * claim — measured, six of them.
+     *
+     * `null` is the tree with no frontend, and it is the behaviour that shipped.
+     * It is not a silent floor: `check:module-boundary` refuses a run whose
+     * ledger holds admin keys and whose layout answered `null` here.
+     *
+     * Since feature 091's Phase 5 it no longer answers `null` for an admin
+     * application whose module surfaces have all moved into their packages —
+     * that is {@link AdminSurfaceLayout.moduleRoot} being `null`, which is a
+     * measurement rather than a refusal (R16).
+     */
+    readonly adminSurfaces: () => Promise<AdminSurfaceLayout | null>;
+    /**
+     * Why {@link ModuleTreeLayout.adminSurfaces} answered `null`, or `null` when
+     * it did not (feature 091, Phase 5 T2; `admin-kit-surface.md` §7.3 R17).
+     *
+     * `resolveAdminSurfaces` refuses for four distinct causes — no member
+     * declares the alias, two do, the alias target is not on disk, and `App.tsx`
+     * or `components/AppShell.tsx` could not be read — and every one of them used
+     * to arrive at a caller as the same bare `null`, whereupon the caller printed
+     * a sentence of its own choosing. Measured: the tree refused on the module
+     * root and both callers reported the alias, which sends a reader to repair a
+     * file that is correct.
+     *
+     * **The reason travels with the answer.** It is memoised on the same call, so
+     * the two accessors cannot come to disagree, and it is non-null *exactly*
+     * when the layout is `null`. A check printing an admin refusal prints this
+     * string; the only case it may word itself is a workspace with no frontend at
+     * all, which is what the string then says.
+     */
+    readonly adminSurfacesRefusal: () => Promise<string | null>;
+}
+/**
+ * The nearest ancestor of `from` that declares a pnpm workspace.
+ *
+ * Nearest, so a worktree parked *inside* the main tree — which is where this
+ * repository's agents work — answers with itself rather than with its host.
+ * This is the same judgement `scripts/workspace-resolution.ts` makes, and the
+ * shell twin makes it through the `.git` marker instead, because a sourced
+ * library cannot assume a node toolchain.
+ */
+export declare function findRepoRoot(from: string): string | null;
+/**
+ * The one manifest index this repository owns.
+ *
+ * Searched over the workspace members rather than under a named source root: a
+ * search rooted at `backend/src` would answer "gone" for an index that merely
+ * moved one level up, which is the event this whole file exists for.
+ */
+export declare function findManifestIndex(repoRoot: string, fs?: WorkspaceFs): string;
+/**
+ * The application's source root: the index's ancestor that is an immediate
+ * child of the workspace member holding it.
+ *
+ * `backend/src/modules/_lifecycle/<index>` and `backend/src/<index>` both
+ * answer `backend/src`, which is what makes the owner's ruling about where the
+ * index lives a change this derivation does not have to be told about.
+ */
+export declare function sourceRootOfIndex(indexPath: string, memberDir: string): string;
+/**
+ * Application module roots: the parents of registered-id directories that hold
+ * a `manifest.ts`.
+ *
+ * Both halves of that predicate are load-bearing. The id filter is what keeps
+ * an overlay tree (`src/apps/<deployment>/modules/<id>`) and the test
+ * fixtures' module-shaped directories out — neither is in the bare-core index.
+ * The `manifest.ts` filter is what keeps a directory that merely shares a
+ * module's name out: `test/unit/orders` is not a module root's child, and a
+ * derivation that took the name alone would say it was.
+ */
+export declare function applicationModuleRoots(srcRoot: string, registered: ReadonlySet<string>): readonly string[];
+/**
+ * The module roots the two derivations above cannot see: a module whose sources
+ * the **host application** owns (feature 080, T040b).
+ *
+ * There is one, `_lifecycle`, and it is one by D-160.11 — the lifecycle
+ * subsystem is the platform's operator half, so it never became a package the
+ * way the other 66 modules did. It is still a registered module with a
+ * manifest, permissions, an activation declaration and its own i18n bundles, so
+ * every module walk has to keep reading it; what changed is only where its
+ * directory sits.
+ *
+ * It cannot be found the way {@link applicationModuleRoots} finds a module,
+ * because that predicate is *"a directory named after a registered id"* and
+ * this directory is deliberately **not**: a `src/_lifecycle/` would make
+ * `backend/src` itself a module root, and every kernel, `db/` and `http/` file
+ * under it a module's source with no module to attribute it to. So it is read
+ * from the index's own `manifestPath` — the artefact that already records where
+ * each module's manifest is, for all three origins — and a module whose
+ * manifest sits under the application source root but is not an immediate child
+ * of a module root is one of these.
+ *
+ * Nothing is written down and the derivation fails closed in both directions
+ * (D-100, issue #215). A module whose directory disappeared cannot arrive here
+ * as "host-resident": its manifest specifier would resolve to nothing and the
+ * index would not import at all, which is exit 2 at the reader. And a candidate
+ * that is the source root itself, or an ancestor of a root already found, is
+ * refused rather than walked — a root that swallows the tree reports every file
+ * in it as one module's.
+ */
+export declare function hostResidentModuleRoots(srcRoot: string, found: readonly ModuleSourceRoot[], manifestPaths: ReadonlyMap<string, string>): ModuleSourceRoot[];
+/**
+ * Module roots inside the **platform package** (feature 080, D-160.11's second
+ * half).
+ *
+ * `_lifecycle` moved from `backend/src/lifecycle/` into
+ * `packages/platform/src/lifecycle/`, which is neither an application module
+ * root nor a module package: the platform declares `endora.type: "platform"`,
+ * so `declaredModuleId` answers `null` for it and the package half of the
+ * derivation never sees the module inside. Without this the one registered
+ * module living there produces no file for any module walk and the #215 floor
+ * refuses all sixteen of them — the correct failure, and not a useful one.
+ *
+ * **It cannot be derived from the index's `manifestPath` the way
+ * {@link hostResidentModuleRoots} is**, and that is a fact about the package
+ * rather than a shortcut taken here. A platform-resident module is imported by
+ * the generated index at the package's **built** file — the host publishes five
+ * subpaths and no more (D-160.7), and naming the source would evaluate the
+ * platform twice — so `manifestPath` resolves under `dist/`, which is where the
+ * module's i18n bundles are and is not where its sources are. Mapping one to
+ * the other would be a `dist`↔`src` convention written into a derivation
+ * (D-100), and the package's own emit layout is free to change it.
+ *
+ * So the module is found by the **same marker core discovery uses** — a
+ * directory holding a `manifest.ts` that declares a registered id — with the id
+ * read out of the manifest rather than off the directory name, because
+ * `_lifecycle` deliberately lives in `lifecycle/`: a directory named after a
+ * registered id makes its *parent* a module root, and `src/_lifecycle/` would
+ * make the whole platform source root one.
+ */
+export declare function platformResidentModuleRoots(platformRoot: string | null, found: readonly ModuleSourceRoot[], registered: ReadonlySet<string>): ModuleSourceRoot[];
+/**
+ * The whole layout, resolved once.
+ *
+ * Async because the registered ids come out of the generated index, which is a
+ * TypeScript module the checks import rather than a file they parse — the same
+ * reader `lib/switchable-modules.ts` uses, so the two derivations cannot
+ * disagree about which modules exist.
+ */
+export declare function resolveModuleLayout(from?: string, fs?: WorkspaceFs): Promise<ModuleTreeLayout>;
+/**
+ * The CLI half: resolve the layout, or print the refusal and exit 2.
+ *
+ * One function rather than a copy per check, for the reason
+ * `refuseVacuousModulePopulation` is one function: a copy per check is a chance
+ * per check to write the one that returns instead of exiting, and a check whose
+ * guard is subtly wrong is invisible by construction.
+ */
+export declare function requireModuleLayout(prefix: string): Promise<ModuleTreeLayout>;
+/**
+ * Does this source file compose a module — i.e. is it the module's entry point?
+ *
+ * **The marker, never a filename** (feature 080, T040b). A module in the
+ * application's tree keeps `registerModule` in `backend.ts`; a module package
+ * keeps it wherever its `exports` map's `./backend` subpath leads, which for
+ * both packages in this repository is `src/backend/index.ts`. A predicate
+ * spelled as a filename therefore answers `false` for a packaged module, and
+ * the answer is not merely incomplete — it is fail-*open* at the place it is
+ * asked. `check-port-dependencies` matched `'/backend.ts'` and so could not see
+ * a packaged module's `di.providePort` calls: every consumer of one of those
+ * ports read as *resolving an ungated registration*, and was told to write an
+ * absent-owner policy for a gate that was right there. `blog` hid it by owning
+ * no port another module resolves; `quote_requests` owns two, resolved by six
+ * modules, and reported six findings the moment it moved.
+ *
+ * One expression, shared by `generate-composer.ts` — which locates a module's
+ * entry point this way for both origins — and by every check that needs the
+ * same file. A check whose decision exists in two places can go half-missing
+ * without either red proof noticing.
+ *
+ * It reads the **export**, not an import or a call, so a file that merely
+ * mentions `registerModule` is not one; and it does not follow a re-export, so
+ * a barrel that forwards `registerModule` from a neighbour is not recognised
+ * here. The composer refuses a package with zero or two such files with a
+ * message that says so, which is where that shape is caught.
+ */
+export declare function declaresRegisterModule(source: string): boolean;
+//# sourceMappingURL=module-roots.d.ts.map

package/dist/lib/module-roots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-roots.d.ts","sourceRoot":"","sources":["../../src/lib/module-roots.ts"],"names":[],"mappings":"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"}