@endora-commerce/cli 0.100.0

package/dist/rules/platform-surface.d.ts

@@ -0,0 +1,479 @@
+import { type BarrelUnreadable, type HostPackage, type PlatformSurface } from '../lib/platform-surface.js';
+import { type ReadCoverage } from '../lib/read-size.js';
+/** The symbol token recorded for a reach that names no symbol at all. */
+export declare const WHOLE_FILE = "*";
+/** The symbol token recorded for a finding that is about the file, not a name. */
+export declare const NO_SYMBOL = "?";
+/** The target token recorded for a source file no module owns. */
+export declare const NO_MODULE = "(unattributed)";
+export type PlatformSurfaceFindingKind = 'unpublished-symbol' | 'whole-file-reach' | 'unresolvable-reach' | 'unattributed-source' | 'unpublished-subpath' | 'host-internal-subpath' | 'relative-host-reach';
+export interface PlatformSurfaceFinding {
+    readonly kind: PlatformSurfaceFindingKind;
+    /** The module file, keyed relative to the source root. */
+    readonly file: string;
+    readonly line: number;
+    /** The module that owns {@link file}, or `null` when nothing does. */
+    readonly moduleId: string | null;
+    /**
+     * The platform file reached, keyed relative to the source root — or, for an
+     * `unresolvable-reach`, the specifier as written, and for an
+     * `unattributed-source`, {@link NO_MODULE}.
+     */
+    readonly target: string;
+    /** The name reached, {@link WHOLE_FILE}, or {@link NO_SYMBOL}. */
+    readonly symbol: string;
+    /** The specifier as written, for the failure message. */
+    readonly specifier: string;
+    /**
+     * The **bare specifier** that carries {@link PlatformSurfaceFinding.target} —
+     * `@endora-commerce/platform/kernel` — or `null` when no barrel carries the
+     * file at all. A `relative-host-reach`'s remedy, and nothing else's.
+     *
+     * It is derived in the analysis rather than in {@link remedyOf} because the
+     * derivation needs the barrels and the `exports` map and a remedy sentence has
+     * neither: {@link PlatformSurface.publishedBy} says which barrel publishes the
+     * file, {@link HostPackage.subpathTargets} says which subpath that barrel is,
+     * and {@link HostPackage.name} says what a consumer writes. All three are read
+     * off the package, so a sixth published directory changes the sentence in the
+     * same run rather than when somebody remembers — which is the property
+     * host-reach-check.md §3 asks for.
+     */
+    readonly publishedAs?: string | null;
+}
+/**
+ * One ledgered reach: which unpublished names this file may take from that
+ * platform file, and why.
+ *
+ * **The symbols are named rather than counted**, which is where this ledger
+ * differs from `check:module-boundary`'s omittable `{ sites, reason }`. There a
+ * count is enough because the verdict is per *target* — a file either may name
+ * another module's directory or it may not, and how often says nothing a
+ * reviewer needs. Here the verdict is per *symbol*: a **P** file publishes some
+ * of its exports and withholds others, so an entry that did not name the symbol
+ * could not be checked against the barrel it disagrees with, and a reach that
+ * swapped one unpublished name for another would inherit the entry in silence.
+ */
+export interface LedgeredReach {
+    /** Every unpublished name this file takes from that target. Order is not read. */
+    readonly symbols: readonly string[];
+    /** Why it stands, and what would retire it. */
+    readonly reason: string;
+}
+/**
+ * The reaches into unpublished platform surface that stand today.
+ *
+ * Keyed `<module file>|<platform file>`, both relative to the repository root —
+ * so moving code inside a file does not invalidate an entry, and re-opening a
+ * closed reach does not silently inherit one.
+ *
+ * The platform half is spelled at `packages/platform/src/…` since the
+ * relocation, which is where the file is. A module still writes the old relative
+ * specifier and still lands on a re-export shim at `backend/src/<subpath>/…`;
+ * {@link PlatformSurfaceInput.canonicalTargetOf} follows the shim, because a
+ * shim publishes nothing and judging one would refuse every reach in the tree.
+ * Forty of these keys were re-spelled by the move and not one entry, symbol or
+ * count moved with them.
+ *
+ * **Two-way and draining**, in the idiom of `PORT_CATCHES_TO_DRAIN`: an
+ * unledgered reach fails the build, a key that no longer describes one fails it,
+ * and a listed symbol the walk no longer sees fails it too. Every entry names
+ * the contract paragraph that classified it and the event that retires it — an
+ * entry is debt with a due date, not a permission.
+ *
+ * **What is left is four files, and none of them is a module's.** The ledger
+ * held 33 keys; 29 of them were `_lifecycle`'s, under five reasons that each
+ * said the same thing in a different register — the ORM bootstrap a
+ * container-less CLI has no other way to reach, the `ModulePlugin` type, the
+ * worker-pause pair, the twelve unpublished targets it was the only consumer
+ * of. All 29 retired together, and **not one of them by editing an import**,
+ * which is what every one of those reasons predicted: D-160.11's second half
+ * moved `_lifecycle`'s platform-safe files into the host package, where the
+ * same specifier crosses no boundary
+ * ({@link PlatformSurfaceInput.platformSourceRoot}), and left its host half —
+ * the manifest registry, the divergence reader and the five `module:*`
+ * commands — outside the module walk, where it is host code like `src/db` and
+ * `src/overlay` and was never this check's subject.
+ *
+ * So no module is blocked by this check, and none is ledgered by it. The three
+ * entries that were questions rather than repairs are all answered:
+ * `REGISTRY_CACHE` went with D-174 — `admin_actions` registers an
+ * `InProcessCacheLayer` and the platform's own state-changed subscriber drops
+ * it, so the module names no channel and no new symbol was published — and the
+ * TOTP shim entry went by **deletion**: its premise turned out to be false (§8's
+ * one-hop rule is scoped to *port* methods, and the barrel applies it that way
+ * in both directions), the two backup-code functions had zero call sites and
+ * zero tests, and the shim itself had zero importers. Nothing was published for
+ * any of them.
+ *
+ * A new entry is therefore a real finding, not a queue position: it is a module
+ * the F4 sweep cannot convert, and the group header it needs has to be written
+ * before it is added.
+ */
+export interface PlatformSurfaceInput {
+    /**
+     * The module sources to judge, keyed relative to the source root.
+     *
+     * Everything the walk opened, including a file no module owns — attributing
+     * it is the analysis' job and failing to is a finding.
+     */
+    readonly sources: ReadonlyMap<string, string>;
+    /** Every file key that exists under the source root, for resolving a specifier. */
+    readonly files: ReadonlySet<string>;
+    /** The published surface, from `lib/platform-surface.ts`. */
+    readonly surface: PlatformSurface;
+    /**
+     * Which module a key belongs to. Defaults to the `modules/<id>/` segment,
+     * which is what the application tree and an overlay tree both carry; a run
+     * over a tree that holds module **packages** passes the layout's own
+     * attribution, which reads a package's declared id instead.
+     */
+    readonly moduleIdOf?: (key: string) => string | null;
+    /**
+     * A resolved target's canonical key — the file a specifier really lands on.
+     *
+     * Identity for every reach but one: the platform relocation left a re-export
+     * shim at each old `backend/src/{kernel,http,tenancy,commands,events}/…` path,
+     * so a module's relative specifier resolves to a file whose whole content is
+     * `export * from` the platform's own. Judging the shim would compare a module's
+     * symbol against a barrel that lives one tree over and publish nothing, turning
+     * all 1642 reaches into findings. Judging the file the shim forwards to is the
+     * effective truth and keeps this check's answer the same across the move — the
+     * ledger's platform half is spelled at the platform, which is where it is.
+     */
+    readonly canonicalTargetOf?: (key: string) => string;
+    /**
+     * The host package, so a **bare** specifier into it is judged like a relative
+     * one (feature 080, T060).
+     *
+     * `null` — the default — is "this workspace declares no platform", which is
+     * true of every fixture workspace and of nothing else. It is not a way to
+     * switch the population off: a run whose workspace *has* a platform passes it,
+     * and `main` exits 2 when it cannot find one.
+     */
+    readonly host?: HostPackage | null;
+    /**
+     * The platform's own source root, repo-relative — so a module whose sources
+     * live **inside** the host package is not judged for reaching it (feature
+     * 080, D-160.11).
+     *
+     * `_lifecycle` merged into `@endora-commerce/platform`, and its files go on
+     * naming `../../kernel/lifecycle/registry-cache.js` exactly as they did in
+     * `backend/src/lifecycle/`. The specifier is unchanged and its meaning is
+     * not: it is now a reach from one directory of a package into another
+     * directory of the *same* package, which crosses no boundary and which no
+     * `exports` map is asked about. This check's whole subject is the reach a
+     * packaged module could not write — D-160.8, and the reason the sixteen
+     * `LIFECYCLE_HOST_HALF` entries said they would *"retire with the merge, not
+     * by editing the import"*. Judging them here would publish twelve kernel and
+     * `http` symbols for one consumer forever, which is what D-160.11 refused.
+     *
+     * It exempts the **reaches**, never the file: the walk still opens it, still
+     * counts it in `read: files=`, and still reports it as `unattributed-source`
+     * if no module owns it — so a module file inside the platform that stopped
+     * resolving to its id is a finding rather than a silence (#215 one layer in).
+     * Every other file in the platform is outside this check's population
+     * already, for the same reason: none of them is a module's.
+     *
+     * `null` — the default — is "this workspace has no platform", which is true
+     * of every fixture and of nothing else; `main` exits 2 before it gets here.
+     */
+    readonly platformSourceRoot?: string | null;
+}
+/** One module package's answer to "does your manifest declare the host?". */
+export interface ModulePackageDeclaration {
+    readonly moduleId: string;
+    /** True when its `dependencies` or `peerDependencies` name the host package. */
+    readonly dependsOnHost: boolean;
+}
+/**
+ * The floor that follows the sweep: every module package whose manifest
+ * declares the host must have contributed a host reach to this walk.
+ *
+ * This is issue #215's predicate over the population T060 restored, and it is
+ * the one derivation that would have caught the defect. The other two cannot:
+ * `manifest-index` counts modules that produced a **file**, and a packaged
+ * module produces plenty; `platform-barrels` counts barrels, which the move
+ * does not touch. What fell was the *reaches*, and the number that recorded
+ * them was a snapshot in `test/helpers/check-read-sizes.ts` whose −10% floor
+ * absorbed one module's worth of the fall without a word.
+ *
+ * The declaration is a second author's, which is what makes it worth
+ * reconciling against: `manifests:generate` renders a module package's
+ * `peerDependencies` from the bare specifiers its sources import, and
+ * `manifests:check` fails on drift. So "the manifest says this package reaches
+ * the host" and "the walk read a reach from this package" are two derivations
+ * of one fact, and a walk that stopped reading bare specifiers makes them
+ * disagree in the same run.
+ *
+ * `null` rather than `expected: 0` for a tree with no module package that
+ * declares the host — every tree in this repository until !910, and every
+ * fixture workspace. An expectation of zero is itself a refusal in this
+ * grammar, and rightly: a floor that expects nothing is switched off.
+ */
+export declare function hostDependentCoverage(packages: readonly ModulePackageDeclaration[], hostReachModules: ReadonlySet<string>): ReadCoverage | null;
+/** `<module file>|<platform file>` — the ledger key and the identity of a reach. */
+export declare function keyOf(finding: PlatformSurfaceFinding): string;
+/** The file a specifier names, or `null` when the walk found no such file. */
+/**
+ * A specifier's target file, or `null`. Exported because both hosts build the
+ * platform's published surface with it and a second resolver would be a second
+ * answer to "which file does this name".
+ */
+export declare function resolveTarget(fromKey: string, specifier: string, files: ReadonlySet<string>): string | null;
+export interface PlatformSurfaceScan {
+    /** Every (specifier, symbol) reach into the platform the walk judged. */
+    readonly reaches: number;
+    readonly findings: readonly PlatformSurfaceFinding[];
+    /**
+     * Modules that named the host package by its **bare** specifier at least once
+     * — published subpath or not.
+     *
+     * The numerator of {@link hostDependentCoverage}. A reach at a subpath the
+     * host does not publish counts here: the question is whether the walk *read*
+     * the package's host specifiers, and a finding is the loudest possible yes.
+     */
+    readonly hostReachModules: ReadonlySet<string>;
+}
+/**
+ * Every module reach into the platform, judged against the published surface.
+ *
+ * Pure over source text, file keys and barrel-derived surface, so a fixture
+ * enters exactly where a run does — including the specifier extraction and the
+ * `.js` → `.ts` resolution, which is where a resolution bug would hide (issue
+ * #130).
+ */
+export declare function scanPlatformSurface(input: PlatformSurfaceInput): PlatformSurfaceScan;
+export interface CheckResult {
+    /** (specifier, symbol) reaches into the platform judged — the `sites=` number. */
+    readonly reaches: number;
+    readonly findings: readonly PlatformSurfaceFinding[];
+    readonly violations: readonly PlatformSurfaceFinding[];
+    readonly ledgered: readonly PlatformSurfaceFinding[];
+    /** Ledger keys that describe no reach at all. */
+    readonly staleKeys: readonly string[];
+    /** `<key>#<symbol>` an entry names and the walk no longer sees. */
+    readonly staleSymbols: readonly string[];
+    /** Barrels the parse could not read in full — a caller exits 2 on any. */
+    readonly unreadable: readonly BarrelUnreadable[];
+    /** Modules that named the host package's own specifier — see the scan. */
+    readonly hostReachModules: ReadonlySet<string>;
+}
+export declare function checkPlatformSurface(input: PlatformSurfaceInput, ledger: Readonly<Record<string, LedgeredReach>>): CheckResult;
+/**
+ * One ledgered application reach into the platform by relative path.
+ *
+ * Keyed `<application file>|<canonical platform file>` — the *canonical* file
+ * and never the specifier, which is the one way this repair could regress in
+ * silence: re-spelling `../../packages/platform/dist/x.js` as
+ * `../../packages/platform/src/x.ts` is the same reach and must not clear an
+ * entry (host-reach-check.md §4).
+ *
+ * `retiredBy` is a field rather than a sentence inside {@link
+ * LedgeredHostReach.reason} because R4.1 requires every entry to name the phase
+ * that retires it, and a requirement carried only by prose is one an author can
+ * satisfy by writing anything. The companion test holds both to being non-empty.
+ *
+ * **No `permanent` member, deliberately** (R4.2/R4.5). Every entry has an
+ * available remedy — a subpath the map already declares, or one this feature
+ * adds — so an entry saying "this reach is correct" would mean the predicate has
+ * outgrown its population. Narrow the predicate; never add the entry.
+ */
+export interface LedgeredHostReach {
+    /** Why it stands. */
+    readonly reason: string;
+    /** The phase or feature that retires it. */
+    readonly retiredBy: string;
+}
+/**
+ * The application's own reaches into the platform, and what they resolve to.
+ *
+ * A second **consumer population** on this check's own rule — *a reach into the
+ * host names a published subpath or a declared host-internal one, never a file
+ * inside the package by relative path* — and not a second rule
+ * (host-reach-check.md §1.1). The four inputs it needs are the four this check
+ * already derives: where the platform's sources are, the name it publishes
+ * under, the subpaths its `exports` map declares, and the barrels. A separate
+ * script would re-derive all four, which is two answers to one population
+ * (D-100).
+ */
+export interface ApplicationReachInput {
+    /**
+     * The application's own sources, keyed relative to the repository root: every
+     * file the layout attributes to no module and that is not inside the platform.
+     *
+     * Module-attributed files stay in {@link PlatformSurfaceInput.sources} and are
+     * judged by the existing rules; nothing about a module reach changes.
+     */
+    readonly sources: ReadonlyMap<string, string>;
+    /**
+     * The platform member's own directory, repo-relative — `packages/platform`,
+     * the directory holding its `package.json`.
+     *
+     * The target side is *anything inside the member*, which is both spellings at
+     * once: `src/**` is what a well-meaning cleanup would write and `dist/**` is
+     * what the tree writes today. Neither directory name appears in this analysis
+     * — see {@link canonicalPlatformFile}.
+     */
+    readonly platformMemberRoot: string;
+    /** The platform's source root, repo-relative — `packages/platform/src`. */
+    readonly platformSourceRoot: string;
+    /** Every source-file key the walk found, for the `.js` → `.ts` resolution. */
+    readonly files: ReadonlySet<string>;
+    /** The published surface, so a remedy can name the subpath that carries a file. */
+    readonly surface: PlatformSurface;
+    /** The host package — its `exports` map is what turns a barrel into a subpath. */
+    readonly host: HostPackage;
+}
+/**
+ * The platform **source** file a specifier landing inside the member names, or
+ * `null`.
+ *
+ * The canonicalisation drops the member-relative path's **first segment** —
+ * whatever it is — and re-roots the remainder at the platform's source root. So
+ * `dist/lifecycle/manifest.js` and `src/lifecycle/manifest.ts` both canonicalise
+ * to `packages/platform/src/lifecycle/manifest.ts`, and the word `dist` appears
+ * nowhere: a build directory renamed in the package's own `tsconfig.build.json`
+ * arrives here by being renamed, not by anybody remembering this file (D-100).
+ *
+ * `null` for a specifier that lands inside the member and resolves to no source
+ * file. That is deliberate and is the contract's own ruling (§3): a relative
+ * specifier resolving to nothing inside the platform is not a host reach at all,
+ * and reporting it here would be this check answering `tsc`'s question. The
+ * risk it carries — a canonicalisation bug silently resolving everything to
+ * `null` — is not silent: the ledger is two-way, so a walk that stopped
+ * resolving reports every entry it holds as stale and exits 1.
+ */
+export declare function canonicalPlatformFile(joined: string, input: Pick<ApplicationReachInput, 'platformMemberRoot' | 'platformSourceRoot' | 'files'>): string | null;
+/** What the application-reach walk read, beside what it found. */
+export interface ApplicationReachScan {
+    /** Relative reaches into the platform judged — this half's `sites=` addend. */
+    readonly reaches: number;
+    readonly findings: readonly PlatformSurfaceFinding[];
+}
+/**
+ * Every application reach into the platform written as a relative path.
+ *
+ * Pure over source text, file keys, barrel-derived surface and the two platform
+ * roots — so a fixture enters exactly where a run does, specifier extraction and
+ * `.js` → `.ts` resolution included (issue #130, and the `check-entry-scope`
+ * fixture that entered below its own classifier is the cautionary example).
+ *
+ * **A bare specifier into the host produces no finding here, and that is the
+ * discrimination the rule turns on.** `@endora-commerce/platform/kernel` and
+ * `@endora-commerce/platform/composition` are both correct from the application:
+ * the first is published and the second is the host-internal address the host is
+ * entitled to (D-160.14). The three-way answer for a bare specifier is a
+ * *module's* — `resolveHostSpecifier` in {@link scanPlatformSurface} — and asking
+ * it twice, with two populations and two verdicts, is two answers waiting to
+ * disagree.
+ */
+export declare function scanApplicationReaches(input: ApplicationReachInput): ApplicationReachScan;
+export interface ApplicationReachResult extends ApplicationReachScan {
+    readonly violations: readonly PlatformSurfaceFinding[];
+    readonly ledgered: readonly PlatformSurfaceFinding[];
+    /** Ledger keys that describe no reach the walk found. */
+    readonly staleKeys: readonly string[];
+}
+/**
+ * The application's reaches, judged against the ledger — both directions
+ * (host-reach-check.md §4 R4.3).
+ *
+ * One reach may appear twice under one key when a file names the same platform
+ * file from two specifiers; the ledger is keyed `(file, target)` and covers
+ * both, which is right: the entry's subject is the coupling, not the line.
+ */
+export declare function checkApplicationReaches(input: ApplicationReachInput, ledger: Readonly<Record<string, LedgeredHostReach>>): ApplicationReachResult;
+/**
+ * The coverage floor for the application half: the ledger's own still-on-disk
+ * file set, against what the walk opened of it.
+ *
+ * host-reach-check.md §5's fourth refusal, and it is `check:module-boundary`'s
+ * admin-host floor one package over — a floor derived from *the ledger* rather
+ * than from a count, so a walk that stopped reaching the files it is ledgered
+ * over is a refusal rather than a drained ledger. The ledger is a second
+ * author's answer to "which application files reach the platform": it was
+ * written by whoever measured the debt, and it goes stale loudly rather than
+ * quietly.
+ *
+ * `null` rather than `expected: 0` once the ledger empties, which is what this
+ * ledger is for: an expectation of zero is itself a refusal in this grammar
+ * (`readSizeRefusal`'s `no-expectation`), and rightly — a floor that expects
+ * nothing is switched off.
+ */
+export declare function hostReachCoverage(ledger: Readonly<Record<string, LedgeredHostReach>>, onDisk: (file: string) => boolean, opened: ReadonlySet<string>): ReadCoverage | null;
+/**
+ * Why this run may not report on the application's reaches, or `null`.
+ *
+ * Two of host-reach-check.md §5's four refusals — the two that are facts about
+ * *this* half's inputs. The first ("no platform root") is already this check's
+ * own first refusal and stays there; the fourth is the ledger-derived coverage
+ * floor and belongs to `read-size.ts`, which is the one place in the estate that
+ * owns a short walk.
+ *
+ * Both fail in the direction that produces a **clean** result, which is why they
+ * are exit 2 and not a finding. An empty canonical-target map reports every
+ * relative reach as reaching nothing; an application walk that opened no file
+ * reports no reach at all — and this check's module half would go on printing
+ * `files=2069` beside it, because 1364 of `backend/src`'s files are a module's
+ * and a broken *application* walk leaves every one of those numbers healthy
+ * (issue #215's shape over this population).
+ */
+export declare function applicationReachRefusal(input: {
+    readonly canonicalTargets: number;
+    readonly applicationFiles: number;
+}): string | null;
+/**
+ * Why this run may not judge a reach against the surface it read, or `null`.
+ *
+ * Pure over the two things that can be silently missing — a barrel that is not
+ * there, and a re-export the parse cannot enumerate — because both fail in the
+ * same direction and it is the wrong one: a **short** published set turns
+ * correct reaches into findings, and the obvious repair for one of those is to
+ * widen the barrel. So it is exit 2, in the idiom of `readSizeRefusal`, and a
+ * proof enters where a run enters (issue #130).
+ */
+export declare function platformSurfaceRefusal(input: {
+    readonly missingBarrels: readonly string[];
+    readonly surface: PlatformSurface;
+}): string | null;
+/**
+ * Every TypeScript source under `dir`, with the rule's own prunes applied.
+ *
+ * Exported because the population is part of the rule: two hosts computing
+ * "which files this check reads" two ways is the shape that lets one of them go
+ * half-blind.
+ */
+export declare function collectPlatformSurfaceSources(dir: string, out?: string[]): string[];
+/**
+ * A module package's own tooling configuration, which is not module source.
+ *
+ * `vitest.config.ts` is the first `.ts` file a module package holds that its
+ * build does not compile (feature 089, Phase 1): `tsconfig.build.json` roots the
+ * emit at `src/`, and the manifest's `files` ships `dist` and the asset
+ * directories, so nothing a consumer installs contains it and no `exports`
+ * subpath can name it. The other configurations a package carries are `.json`
+ * and were therefore never in this walk at all.
+ *
+ * It has to leave the population rather than be made to resolve, because the
+ * file exists to `mergeConfig` the repository root's `vitest.config.base.ts` —
+ * which is where issue #255's foreign-workspace-link refusal lives, so the reach
+ * is mandatory — and that root is in no module walk root and no source root. A
+ * reach the walk cannot resolve is `unresolvable-reach`, deliberately fail-closed
+ * (#215 one layer in), and the honest answer here is that this file is not a
+ * module reach at all.
+ *
+ * Narrow on purpose: only a `*.config.ts` sitting **directly** at a module walk
+ * root, which is a package's own root or a module directory. A `config.ts` under
+ * `src/` stays module source, and a directory named `config/` is untouched.
+ */
+export declare function isPackageToolingConfig(root: string, file: string): boolean;
+/** The remedy sentence a finding gets, by kind. */
+/**
+ * The remedy paragraph for a finding.
+ *
+ * Exported because the remedy is part of the rule and not part of a host: an
+ * author outside this checkout reads the same sentence this repository's run
+ * prints.
+ */
+export declare function remedyOf(finding: PlatformSurfaceFinding): string;
+//# sourceMappingURL=platform-surface.d.ts.map

package/dist/rules/platform-surface.d.ts.map

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