@endora-commerce/cli 0.100.0

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

@@ -0,0 +1,473 @@
+import { type WorkspaceMember } from './workspace-packages.js';
+/**
+ * The directory under the site's content root that holds a module's pages.
+ *
+ * The one name this feature owns rather than derives. It is declared here so
+ * that the generator and the check cannot come to disagree about it, and so a
+ * reader looking for "where does `modules/` come from" finds one answer.
+ */
+export declare const MODULES_CATEGORY = "modules";
+/** The page every reader of a module's category lands on. */
+export declare const CATEGORY_INDEX = "index";
+/**
+ * The generated sidebar fragment, at the site's root beside `sidebars.js`.
+ *
+ * Named here rather than in the generator so that the generator, `overlay:check`
+ * and `check:module-docs` cannot come to disagree about which file they mean.
+ */
+export declare const DOCS_SIDEBAR_ARTEFACT = "sidebars.modules.generated.js";
+/** The generated module map, inside the modules category it indexes. */
+export declare const MODULE_MAP_ARTEFACT = "module-map.generated.md";
+/**
+ * The category holding one generated reference page per module (Phase 3,
+ * FR-022/FR-024).
+ *
+ * A category of its own, **outside** {@link MODULES_CATEGORY}, and the
+ * separation is the design rather than a filing preference. Three things follow
+ * from it, none of which would if the pages sat beside the prose:
+ *
+ *   * **a generated page can never collide with a hand-written one.** A module's
+ *     prose page is `modules/<slug>`, its reference page `module-reference/<slug>`.
+ *     There is no name a page author can choose that takes an address the
+ *     generator writes, and no rule anybody has to remember;
+ *   * **the attribution walk's population does not move.** `undocumented-module`
+ *     asks whether anybody *wrote* about a module, and a generated table is not
+ *     an answer to it — a reference page inside the modules category would have
+ *     made every registered module documented and retired that whole ledger in
+ *     the merge request that added the generator;
+ *   * **it is committed on ordinary terms.** `docs/docs/modules/**` is
+ *     git-ignored, because the module-owned pages are copied there at build
+ *     time, so a committed artefact under that tree would need `git add -f` for
+ *     ever after.
+ *
+ * The pages are still *reached* from the Modules category: the generated
+ * sidebar fragment names each module's reference page beside its prose, so a
+ * reader never has to know that the two live in different directories.
+ */
+export declare const MODULE_REFERENCE_CATEGORY = "module-reference";
+/**
+ * The documentation slug that names a module — {@link slugNamesModule}'s
+ * inverse, and the one place that choice is made.
+ *
+ * A slug is hyphenated where an id is snake_case, and a **leading underscore is
+ * dropped**: Docusaurus excludes an underscore-prefixed file from routing by
+ * design, so `_i18n` is documented at `i18n` and `_lifecycle` at `lifecycle`
+ * (D-200). Both transformations are {@link slugNamesModule}'s applied the other
+ * way round, so a page this names is a page that derivation attributes back —
+ * asserted as a round trip over every registered id rather than left to the two
+ * staying in step by inspection.
+ */
+export declare function slugForModule(moduleId: string): string;
+/** Extensions Docusaurus reads as a documentation page. */
+export declare const PAGE_EXTENSIONS: readonly string[];
+/** Raised when the documentation layout cannot be resolved; a caller exits 2. */
+export declare class DocsLayoutUnresolvableError extends Error {
+    readonly name = "DocsLayoutUnresolvableError";
+}
+/** Where the documentation site is and what it holds. */
+export interface DocsLayout {
+    /** The workspace member that is the Docusaurus site. */
+    readonly member: WorkspaceMember;
+    /** Absolute path of the site's docs content root — `docs/docs`. */
+    readonly contentRoot: string;
+    /** Absolute path of `<contentRoot>/modules`. */
+    readonly modulesRoot: string;
+    /** Absolute path of the site's `sidebars.js`. */
+    readonly sidebarPath: string;
+}
+/**
+ * The docs content root the config declares, or Docusaurus's own default.
+ *
+ * Read as a literal `path:` inside the docs preset options. A computed value is
+ * not followed — it is reported as absent, which lands on the default, and the
+ * bound is stated here rather than discovered later.
+ */
+export declare function contentPathOf(configText: string): string;
+/**
+ * Where the site is, from this repository's own workspace declaration.
+ *
+ * Zero members holding a Docusaurus config and more than one are both
+ * refusals, for `lib/module-roots.ts`' reason: an ambiguous root narrows the
+ * walk to whichever sorted first and says nothing about having done so.
+ */
+export declare function resolveDocsLayout(repoRoot: string): DocsLayout;
+/** Docusaurus front matter, as much of it as this feature reads. */
+export interface FrontMatter {
+    readonly title: string | null;
+    readonly sidebarLabel: string | null;
+    readonly sidebarPosition: number | null;
+    readonly description: string | null;
+}
+/**
+ * The leading `---`-delimited block, read as top-level `key: value` lines.
+ *
+ * Deliberately not a YAML parser: a direct dependency on one would be a new
+ * runtime edge in the package that runs the check estate (`plan.md` §
+ * Complexity Tracking), and the four fields this feature reads are scalars. The
+ * bound is that a nested or multi-line value is read as its first line, which is
+ * stated rather than discovered later.
+ */
+export declare function parseFrontMatter(source: string): FrontMatter;
+/** One documentation page under the modules category. */
+export interface DocPage {
+    /**
+     * The page's Docusaurus doc id — `modules/catalog/attributes`. The site's own
+     * identity for it, and what a sidebar entry names.
+     */
+    readonly docId: string;
+    /** Absolute path of the file. */
+    readonly path: string;
+    /**
+     * The file's path relative to the modules category — `catalog/attributes.md`.
+     *
+     * Carried beside the doc id because a **link** and an **id** are not the same
+     * string: `assets-library/index` is the doc id and `/modules/assets-library/`
+     * is the route, so a markdown link written from the id 404s under
+     * `onBrokenLinks: 'throw'`. Docusaurus resolves a link that names the `.md`
+     * file to that file's permalink, whatever the permalink turns out to be, so
+     * the file path is the spelling that cannot go wrong.
+     */
+    readonly relativePath: string;
+    /**
+     * The module slug this page sits under: its own basename for a top-level
+     * page, its directory's name for a page inside one.
+     */
+    readonly slug: string;
+    /** True when the page is the one a reader of this slug lands on. */
+    readonly isEntry: boolean;
+    /** True when the page sits inside a directory of its own slug's name. */
+    readonly inDirectory: boolean;
+    readonly frontMatter: FrontMatter;
+    /** Which tree the walk found it in — see {@link DocPageOrigin}. */
+    readonly origin: DocPageOrigin;
+}
+/**
+ * A module's own position in the Modules category, or `null` for alphabetical.
+ *
+ * Read from the entry page's `sidebar_position` **only when that page is not a
+ * directory index**, and the distinction is Docusaurus's own rather than this
+ * feature's: `sidebar_position` orders a page among its *siblings*, so an
+ * `index.md`'s is its place inside its own directory and says nothing about
+ * where its module belongs among 65 others. Every such value in the tree today
+ * is `1` — an intra-directory ordering that has been inert under a manual
+ * sidebar — and reading it would have hoisted five modules to the top of the
+ * category for a reason nobody wrote.
+ */
+export declare function categoryPositionOf(entry: DocPage): number | null;
+/**
+ * Where a page came from, which is not the same question as which module it
+ * documents.
+ *
+ * `'site'` is a page in the documentation site's own tree — the state every
+ * page was in through Phase 1 and the state `_lifecycle`'s page is still in,
+ * because its manifest resolves inside the platform package's **build output**
+ * and documentation is not a compiled asset (`scripts/lib/runtime-assets.mjs`).
+ * `'module'` is a page a module ships in its own `docs/` layer.
+ *
+ * Attribution is the *slug's* answer and stays so; this is the *shipper's*.
+ * They are kept apart because they can disagree, and a module publishing under
+ * a sibling's slug is a finding rather than a silent re-attribution.
+ */
+export interface DocPageOrigin {
+    readonly kind: 'site' | 'module';
+    /** The module that ships the page, or `null` for a page in the site's tree. */
+    readonly moduleId: string | null;
+    /** The directory the walk that produced the page was rooted at. */
+    readonly root: string;
+}
+/** A module's own documentation layer, resolved. */
+export interface ModuleDocsSource {
+    readonly moduleId: string;
+    /** Absolute path of `dirname(manifestPath)/<docs.dir>`. */
+    readonly root: string;
+}
+/**
+ * Every page one fragment of the modules category holds, sorted by doc id.
+ *
+ * The **fragment** is the unit, and that is the mechanism rather than an
+ * implementation detail: a module's `docs/` directory is its own fragment of
+ * this category, laid out exactly as the category lays it out, so one walk
+ * reads the site's tree and a module's alike and the two produce identical doc
+ * ids for the same page. It is what makes the Phase 2 move invisible — no URL
+ * changes, no doc id changes, and no ledger key keyed on `(module id, page
+ * slug)` goes stale (`contracts/docs-registry.md` R4.1).
+ *
+ * It also lets a module own **more than one slug** (`organizations` ships both
+ * `organizations.md` and `organization-hierarchy.md`) and publish under a slug
+ * that is not its id (`_i18n` ships `admin-i18n.md`), neither of which a
+ * one-directory-per-module rule can express without renaming a public URL —
+ * which is `spec.md` Q2 and nobody's to decide here.
+ */
+export declare function collectPagesUnder(root: string, origin: DocPageOrigin): DocPage[];
+/**
+ * Every page the site's own tree holds, sorted by doc id.
+ *
+ * `copies` is the set of absolute paths the collection step writes into this
+ * tree, and it is excluded rather than judged. The copies are **not committed**
+ * — one editable page and one that looks editable and is not is the state this
+ * feature exists to end — but a developer who has run the docs build has them
+ * on disk, and a walk that counted them would report every module's page as
+ * claimed by two sources: a finding about the copy step dressed as one about
+ * the tree.
+ *
+ * Passing an empty set is the fresh-checkout state and reads the tree as it is.
+ */
+export declare function collectDocPages(modulesRoot: string, copies?: ReadonlySet<string>): DocPage[];
+/** Every page the modules ship, sorted by doc id. */
+export declare function collectModuleDocPages(sources: readonly ModuleDocsSource[]): DocPage[];
+/**
+ * Two pages claiming one doc id — the site's tree and a module's, or two
+ * modules'.
+ *
+ * A **mixed** tree is the supported state (`plan.md` § Phasing: the check
+ * accepts a page in the site tree and a page in a package on the same terms),
+ * so a batch that has moved half the pages is not a defect. Two sources for one
+ * id is, and it is not a silent one: the copy would write one over the other
+ * and whichever ran second would win, which is a build whose output depends on
+ * a directory read order.
+ */
+export declare function duplicateDocIds(pages: readonly DocPage[]): {
+    docId: string;
+    paths: string[];
+}[];
+/**
+ * Does this slug name this module? — **D-200**, and the one place the rule
+ * lives.
+ *
+ * Two steps, and both are derivations rather than a table:
+ *
+ *   * a URL segment is conventionally hyphenated and a module id is
+ *     snake_case, so one is folded into the other;
+ *   * a **leading underscore is stripped**, because an infrastructure module's
+ *     id carries one and a documentation page's file name may not:
+ *     **Docusaurus excludes an underscore-prefixed file from routing by
+ *     design** — it becomes a *partial* for import into another page, generates
+ *     no route, and cannot be found from `sidebars.js` at all. So `_i18n` is
+ *     documented at `i18n` and `_lifecycle` at `lifecycle`.
+ *
+ * The underscore stays where it means something — in the module id, where
+ * `check:naming` enforces the convention — instead of leaking into a public URL.
+ * The rule covers every future infrastructure module with nothing to add, which
+ * is what retired the alias table Phase 1 shipped: a four-entry table of
+ * hand-declared attributions, in the feature whose whole subject is that three
+ * hand-maintained lists disagreed with one population and with each other.
+ *
+ * It is not a heuristic that guesses. Only these two transformations are
+ * applied, and the result must equal a registered id exactly.
+ */
+export declare function slugNamesModule(slug: string, moduleId: string): boolean;
+/**
+ * The module a slug names, or `null`, over the registered set.
+ *
+ * {@link slugNamesModule} in the direction a walk needs it: the candidates are
+ * derived from the slug rather than by scanning every registered id, so the
+ * cost does not grow with the platform.
+ */
+export declare function moduleOfSlug(slug: string, registered: ReadonlySet<string>): string | null;
+/** One module's documentation, as the site holds it today. */
+export interface ModuleDocs {
+    readonly moduleId: string;
+    /** The slug its pages sit under. */
+    readonly slug: string;
+    /** The page a reader lands on. */
+    readonly entry: DocPage;
+    /** Sub-pages, sorted by their own position then label. */
+    readonly children: readonly DocPage[];
+}
+/** The label a navigation entry carries, from the page's own front matter. */
+export declare function labelOf(page: DocPage, fallback: string): string;
+/** Ordering: a declared `sidebar_position` first, then alphabetical by label. */
+export declare function comparePages(a: {
+    position: number | null;
+    label: string;
+}, b: {
+    position: number | null;
+    label: string;
+}): number;
+/** What the walk produced, split into what it could place and what it could not. */
+export interface DocsAttribution {
+    /** One entry per module that has documentation, sorted by module id. */
+    readonly documented: readonly ModuleDocs[];
+    /** Registered modules no page documents, sorted. */
+    readonly undocumented: readonly string[];
+    /**
+     * Pages with no shipper whose slug names no registered module.
+     *
+     * A page in the **site's own tree** only. A page a module ships has a
+     * shipper, so it is attributed whatever its slug says; where its slug names a
+     * *different* module that is {@link DocsAttribution.misowned}, and where it
+     * names none it is simply a second slug that module owns.
+     */
+    readonly unlocated: readonly DocPage[];
+    /**
+     * Pages a module ships under a **different** registered module's slug.
+     *
+     * Shipper and subject are two questions (see {@link DocPageOrigin}) and this
+     * is the state where they disagree. It is Constitution I applied to prose,
+     * and the same shape `check:admin-zones` refuses as `foreign-module-id`: a
+     * module publishing under a sibling's slug takes an address the sibling owns,
+     * and if the sibling ever ships that page too the copy step has two sources
+     * for one target. The page stays attributed to its **shipper** — the module's
+     * own declaration outranks a derivation from a file name — and the
+     * disagreement is reported rather than resolved.
+     */
+    readonly misowned: readonly {
+        page: DocPage;
+        namesModule: string;
+    }[];
+    /**
+     * Pages Docusaurus will not route: a path segment beginning with `_`.
+     *
+     * An underscore-prefixed file is a **partial** by design — intended for
+     * import into another page, generating no route, and unfindable from
+     * `sidebars.js`. D-200 is what keeps a module id's leading underscore out of
+     * its slug; this is the refusal that makes the rule hold for a page nobody
+     * ran that derivation over.
+     */
+    readonly unroutable: readonly DocPage[];
+    /** Every page the walk opened. */
+    readonly pages: readonly DocPage[];
+}
+/**
+ * Place every page against the registered module set.
+ *
+ * Pure over the two inputs, so a red proof enters where a real run enters
+ * (issue #130): the pages a walk produced and the ids the index registers.
+ */
+export declare function attributeDocs(pages: readonly DocPage[], registered: readonly string[]): DocsAttribution;
+/**
+ * Where a module ships its own documentation, or `null` when it declares none.
+ *
+ * The anchor is `dirname(manifestPath)` — the same one the `_i18n` boot
+ * reconciler joins `bundlesDir` to, which `resolveManifestPath` already makes
+ * correct for a core-relative module, a workspace package and an installed
+ * package alike (`contracts/module-documentation-layer.md` R2.2). Nothing in a
+ * module names a package, a repository root or a build directory to find its own
+ * pages; the platform supplies the anchor.
+ *
+ * `false` and absent are **not** the same state and this returns the same
+ * `null` for both deliberately: the distinction is the *manifest's*, and the
+ * consumer that needs it (`undocumented-module`) reads the declaration itself.
+ */
+export declare function declaredDocsDirectory(manifestPath: string, declaration: {
+    dir: string;
+} | false | undefined): string | null;
+/** True when `path` is a directory that exists. */
+export declare function isDirectory(path: string): boolean;
+/** Raised when a module declares a documentation directory that is not there. */
+export declare class DeclaredDocsDirectoryMissingError extends Error {
+    readonly name = "DeclaredDocsDirectoryMissingError";
+}
+/** One module, as a caller of {@link moduleDocsSources} describes it. */
+export interface ModuleDocsDeclarant {
+    readonly moduleId: string;
+    /** The module's entry in the generated manifest index. */
+    readonly manifestPath: string;
+    /** What the manifest declares — `{ dir }`, `false`, or absent. */
+    readonly declaration: {
+        dir: string;
+    } | false | undefined;
+}
+/**
+ * Where every module that declares documentation keeps it.
+ *
+ * **A declared directory that is not on disk is a refusal, naming the module**
+ * (FR-017, `module-documentation-layer.md` R2.4). It must not read as "this
+ * module ships no documentation", and the reason is a measured one rather than
+ * a stylistic preference: `backend/src/manifest-locations.ts`' header records
+ * that the `_i18n` boot reconciler *logs and skips* an absent bundles
+ * directory, so a packaged module would have rendered every command-palette
+ * entry as its raw i18n key with no error anywhere. The distinction between
+ * *declared and absent* and *not declared* is the whole of that repair.
+ */
+export declare function moduleDocsSources(modules: readonly ModuleDocsDeclarant[]): readonly ModuleDocsSource[];
+/**
+ * Where the site keeps the copy of a page a module ships.
+ *
+ * The module's fragment lands at the same relative path inside the category, so
+ * the copy preserves the page's doc id, its permalink and every relative link
+ * written against it (`module-documentation-layer.md` R5.2).
+ */
+export declare function copyTargetOf(page: DocPage, modulesRoot: string): string;
+/** One relative markdown link, as written. */
+export interface RelativeLink {
+    /** The target exactly as the page spells it — `./payments.md`, `../catalog.md`. */
+    readonly target: string;
+    /** The doc id the target resolves to, or `null` when it leaves the category. */
+    readonly docId: string | null;
+    /**
+     * The target climbs **above** the modules category — `../architecture/…`
+     * written on a page sitting at the category root.
+     *
+     * `docId === null` alone does not say this, and the difference is a finding.
+     * Two states arrive at a null doc id: a link that **leaves** the category,
+     * which names a page only the host repository's own site tree has and which
+     * no reader's instance can resolve whatever module set they installed; and a
+     * link that resolves to the category **root** itself, which every instance
+     * has because the generator writes it. Collapsing the two would let a
+     * consumer report the second as the first, so the resolution says what it saw
+     * rather than leaving a reader to infer it from an absence.
+     */
+    readonly leavesCategory: boolean;
+}
+/**
+ * Every relative markdown link a page writes, resolved to a doc id.
+ *
+ * Read as `](…)` with a `./` or `../` prefix, in the literal-text discipline
+ * the rest of the estate uses. The bounds are stated here rather than
+ * discovered later (`docs-registry.md` R3.10): a link built by an MDX
+ * expression or a component is invisible, a raw `<a href>` is invisible, and a
+ * `@site/`-prefixed absolute link is not a relative sibling link and is outside
+ * the population by construction.
+ *
+ * An anchor or a query is stripped, and a target that resolves outside the
+ * modules category resolves to `null` — a link into `../operations/runbooks/…`
+ * is a link to the site, not to a sibling module. Such a link carries
+ * `leavesCategory: true`, which is what lets a consumer tell it apart from a
+ * link to the category root; see {@link RelativeLink}.
+ */
+export declare function relativeLinksIn(page: DocPage, source: string): RelativeLink[];
+/**
+ * What a manifest's **source text** declares for `docs`.
+ *
+ * The generator reads the tree and the check reads the emitted manifest, so the
+ * two answer this question from two different artefacts — which is the estate's
+ * independent-author pattern rather than a duplication: a generator that
+ * imported the index it is about to render would be reading its own previous
+ * answer.
+ *
+ * `'unreadable'` is a **finding and never a skip** (issue #113). A computed
+ * `dir` is a directory this walk cannot place, and treating it as "declares
+ * nothing" is the direction that agrees with the defect — the module's pages
+ * would simply not be collected, with no error anywhere, which is the failure
+ * `manifest-locations.ts` was written to end.
+ */
+export declare function docsDeclarationIn(source: string): {
+    dir: string;
+} | false | undefined | 'unreadable';
+/**
+ * The `docs` declaration of every module the generated index registers.
+ *
+ * The index is **imported**, because a module package resolves through its own
+ * `exports` map at its build output and the declaration a running platform sees
+ * is the emitted one. Every reader that needs "where does each module keep its
+ * pages" starts here, so the population is derived once: two walks over one
+ * population are two answers waiting to disagree, which is the state this whole
+ * feature ends.
+ */
+export declare function moduleDocsDeclarantsFrom(manifestIndexPath: string): Promise<ModuleDocsDeclarant[]>;
+/**
+ * Every page a module owns, and where the site keeps its copy.
+ *
+ * `copies` is the set every walk over the site's tree has to leave alone: the
+ * copies are not committed, so a fresh checkout has none and a developer who
+ * has run the site build has all of them — and a population that counted them
+ * would be a different size on the two machines.
+ */
+export declare function resolveModuleDocs(repoRoot: string, manifestIndexPath: string): Promise<{
+    readonly docs: DocsLayout;
+    readonly sources: readonly ModuleDocsSource[];
+    readonly modulePages: readonly DocPage[];
+    readonly copies: ReadonlySet<string>;
+}>;
+//# sourceMappingURL=module-docs.d.ts.map

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

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