@endora-commerce/cli 0.100.0

package/dist/lib/platform-surface.js

@@ -0,0 +1,393 @@
+/**
+ * "What does the platform publish?" — one derivation, read out of the barrels
+ * (feature 080, T042d; D-160.8).
+ *
+ * ## Why the barrel and not a list
+ *
+ * `specs/080-f4-real-scope/contracts/host-package.md` §1.3 classifies every
+ * platform file a module reaches as **P** (published API), **A** (accidental
+ * reach) or **O** (the module is reaching for a class where a port exists).
+ * §2.1 turns that classification into an `exports` map with five enumerated
+ * subpaths, one per publishable directory, each resolving to that directory's
+ * barrel (D-160.7). So the barrel *is* the classification, expressed as source
+ * the compiler reads rather than as prose.
+ *
+ * Two consumers need that answer and they must never be able to disagree:
+ *
+ *   * `test/unit/kernel/published-surface.test.ts` holds each barrel to §1.3's
+ *     symbol column, in both directions (MR !883);
+ *   * `scripts/check-platform-surface.ts` refuses a module reach into a
+ *     platform symbol the barrel does not carry.
+ *
+ * Before this file the first of them parsed the barrel with a regular
+ * expression of its own. A second, independently written parse in the check
+ * would be two answers to "what does `kernel/index.ts` export" — and the shape
+ * one of them forgot would be the shape the next unpublished reach travelled
+ * through. There is one parse, it is the TypeScript compiler's, and both read
+ * it.
+ *
+ * ## What a barrel says, and the two things it says
+ *
+ * A published re-export carries **a name and the file it came from**:
+ *
+ * ```ts
+ * export { HttpError } from './error-envelope.js';
+ * ```
+ *
+ * — publishes `HttpError`, and publishes it *of* `http/error-envelope.ts`. Both
+ * halves matter. §1.3's verdict is per file and its symbol column is per
+ * symbol, and !883 found the gap materially: sixteen symbols of **P** files are
+ * reached by nobody and are deliberately not published, so "the file is P" does
+ * not license every export of it. Keying the answer on the pair is what lets a
+ * consumer ask the question the classification actually answers — *may this
+ * module take **this symbol** of **that file***.
+ *
+ * ## Which directories are published, and why that is declared here
+ *
+ * {@link PUBLISHED_SUBPATHS} is the one thing in this file that is written down
+ * rather than derived, and it is a **ruling** (D-160.7) rather than a fact about
+ * the tree: five enumerated subpaths, no root export, no wildcard, with `db`,
+ * `overlay` and `packages` deliberately unpublishable (§1.4f, §1.4l). It cannot
+ * be derived from "a directory with an `index.ts`", because the platform's own
+ * `db/index.ts` exists and is the single hardest **A** in the contract —
+ * publishing it would make the host import all 219 module-owned entity
+ * references.
+ *
+ * It stops being written down the day the host `package.json` exists: its
+ * `exports` map is the same five subpaths, authored once, and this constant is
+ * replaced by a read of it. Until then every *consequence* of the list is
+ * derived — which symbols, of which files, and what a reach into a directory
+ * that is not on it means — and a directory named here whose barrel is missing
+ * or empty is an error rather than a silently narrower surface.
+ */
+import { posix } from 'node:path';
+import ts from 'typescript';
+/**
+ * The platform directories the host publishes, in the order §2.1 lists them.
+ *
+ * A ruling (D-160.7), not a measurement — see the header. `db`, `overlay` and
+ * `packages` are absent on purpose and `db`'s absence is the whole of §1.4f: a
+ * reach into it is not public API. All three are now **declared and
+ * host-internal** (`specs/110-instance-repository/` T113, T114 and T116): the
+ * code moved into the package, so the application needed an address for it, and
+ * the answer to "may a module name it" is still no — see
+ * {@link HOST_INTERNAL_SUBPATHS}, which is where that judgement is recorded.
+ */
+export const PUBLISHED_SUBPATHS = [
+    'kernel',
+    'http',
+    'tenancy',
+    'commands',
+    'events',
+];
+/**
+ * The subpaths the `exports` map declares and **no published barrel carries**
+ * (D-160.14), each with the reason it is on this side of the line.
+ *
+ * A subpath here is declared, so `node` and `tsc` resolve it for the host, the
+ * test kit and the composition root — and it is not public API, so
+ * {@link resolveHostSpecifier} answers a module's reach into one with
+ * `host-internal-subpath` rather than with a pass. **The reason is the member**:
+ * a set of bare names is a list somebody grows, and this whole class is a
+ * judgement about who may name a surface, which no name records.
+ *
+ * It is kept apart from {@link PUBLISHED_SUBPATHS} rather than appended to it
+ * because the two answer different questions, and `host-package.md` §2.7.5(a) is
+ * that merging them is the mistake: the published list is what a **symbol** is
+ * judged against, and an entry there would publish `composeModules` out of
+ * `kernel/compose.ts` for every reach at that file — a module's relative one
+ * included — while changing nothing `check:platform-surface` prints.
+ *
+ * It lives here rather than in a test because by the time it had two members it
+ * had two copies, in two test files, neither carrying a per-member reason. Two
+ * independently written answers to "which subpaths are host-internal" are two
+ * answers waiting to disagree, in the estate whose own rule that is (D-100).
+ */
+export const HOST_INTERNAL_SUBPATHS = {
+    composition: 'the host composition surface (D-160.14, feature 109 T010): the symbols a composition ' +
+        'root needs — build the server, open the container, register the ORM, compose the ' +
+        'sub-kernels, prime the registry cache, establish a tenant context. Reachable by a ' +
+        'package that is not a module and nameable by no module at all, because a module that ' +
+        'could name it could compose the platform that composes it.',
+    db: 'the ORM configuration, the migration ordering and the bootstrap ' +
+        '(`specs/110-instance-repository/` T116, FR-013): the naming strategy Principle VI is ' +
+        'enforced by, the order a migration corpus runs in, the two merges that fold an ' +
+        "installed package's entities and migrations into the committed core ones, the cached " +
+        "`MikroORM` bootstrap and the four migration verbs. Host-internal for `./composition`'s " +
+        'own reason one surface over: this is the code that decides which entity classes the ORM ' +
+        'registers and which migrations run at all, so a module that could name it could ' +
+        "configure — and eventually re-order — its siblings' schema. A module reaches its own " +
+        'schema through its own `./migrations` subpath and its entities through `./backend`, and ' +
+        'the committed registries it is configured over stay the host\'s (R7.4).',
+    migrations: 'the frozen historical prefix an execution order is computed from ' +
+        '(`specs/110-instance-repository/contracts/instance-migration-order.md` R1.5). It is the ' +
+        "platform's own claim about its schema history, which a client receives by installing " +
+        'the platform and corrects by `pnpm update` — never by writing a migration into it.',
+    lifecycle: "`_lifecycle`'s operator surface (D115-4, `specs/115-lifecycle-container-move/`): the " +
+        'orchestrator, the dependency and gating graphs, the lifecycle lock, the manifest loader ' +
+        "and the module plugin. Host-internal for `./composition`'s own reason — this surface " +
+        '*drives* the presence axis, so a module that could name it could install, uninstall, ' +
+        'enable or disable its siblings. D-160.11 refused to **publish** `_lifecycle`, and that ' +
+        'is an argument against publishing a surface rather than against giving it an address: ' +
+        'without one the application reaches it by relative path into ' +
+        "`packages/platform/dist/`, which resolves in this checkout and in no client's.",
+    env: 'the environment-input declaration (feature 117, FR-001): the inputs the host and the ' +
+        'platform read, with what each configures, whether it is required and what is lost ' +
+        'without it. Its readers are the scaffolding commands, `endora doctor` and the ' +
+        "reconciliation check \u2014 none of them a module. Host-internal for `./composition`'s own " +
+        'reason, one surface over: a module declares its **own** inputs in its manifest, so a ' +
+        'module that could name this one could read, and would eventually copy, a population it ' +
+        'does not own. The shape it is written in is public API and lives in ' +
+        '`@endora-commerce/contracts`, which is where a module takes it from.',
+    packages: 'installed extension-package discovery (`specs/110-instance-repository/` T113, FR-013): the ' +
+        '`node_modules` scan, the classification that tells a tarball install from a workspace link, ' +
+        'and the manifest, `ModuleEntry` and schema readers a composition root appends to its one ' +
+        "`composeModules` call. Host-internal for `./composition`'s own reason one surface over — this " +
+        'is the code that decides which packages are composed at all, so a module that could name it ' +
+        'could enumerate, and eventually judge, its siblings. What it finds is merged into the ORM ' +
+        "configuration by the host, which is where a module's own schema reaches it from.",
+    overlay: "the loader that composes a deployment's client-only modules " +
+        '(`specs/110-instance-repository/` T114, FR-013): the listing of an overlay root, the ' +
+        'unit resolution a compiled tree needs, the id-collision seam both overlay readers go ' +
+        'through, and the two loaders a composition root appends to its core list. ' +
+        "Host-internal for `./composition`'s own reason — an overlay module is the deployment's " +
+        'answer to customising without forking, and the loader that composes one decides which ' +
+        'modules a deployment runs at all. It derives no path: the overlay root and the claims ' +
+        'already made on a module id are parameters the application supplies.',
+    cli: "the host's side of a module-declared operator command " +
+        '(`specs/110-instance-repository/` T117, FR-013): the enumeration of every command the ' +
+        'resolved manifest set declares, the two refusals a declaration can earn, the ' +
+        '`<module id> <command name>` lookup, the `--list` and `--help` renderings, and the ' +
+        "find-gate-invoke that ends in the module's own `run`. Host-internal for " +
+        "`./composition`'s own reason one surface over: this is the code that decides which " +
+        'command runs and whether the module that declared it is present at all, so a module ' +
+        "that could name it could enumerate its siblings' operator commands and invoke one. A " +
+        'module declares its commands in its own `manifest.ts` and receives a `ModuleContext`; ' +
+        'that is the whole of the surface it is entitled to. The process around it — argv, the ' +
+        'demo verbs, the system scope over the composed container and the exit code — joined it ' +
+        'with `specs/123-oss-install-experience/` G2, because a scaffolded instance needs the same ' +
+        'one and rendering ~170 lines of it into a client tree is the copy R7.1 refuses. What ' +
+        'stays in an application is what names a path in the tree that installs the platform: its ' +
+        'generated core index, its own `composeApp`, its demo-composition probe and the directory ' +
+        'holding `apps/` — four parameters of `runCli`, three of them with defaults an instance ' +
+        'takes, which is why the file `endora new instance` renders is five lines.',
+    demo: 'the demo-data layer (feature 113 Phase 0, D-209; `specs/110-instance-repository/` T119b): ' +
+        'the production refusal, the scope reasons a demo run carries, the plan of which modules ' +
+        'contribute and in what order, the runner and the report an operator reads. It is the one ' +
+        'platform directory that had a barrel and no address at all, so five application consumers ' +
+        'reached it by relative path into `packages/platform/dist/`, which resolves in this ' +
+        "checkout and in no client's — and a demo an instance cannot run is the whole problem that " +
+        "feature exists for. Host-internal for `./composition`'s own reason: a module *declares* " +
+        'its demo data through `@endora-commerce/contracts` and never names the runner, while the ' +
+        'thing that runs one has already composed the platform, so a module that could name this ' +
+        "could seed — and reset — its siblings' data. What the barrel carries is a consequence " +
+        'rather than a ruling, so it is held to its consumers and not to a written table.',
+};
+/** The file a published directory's surface is written in. */
+export function barrelKeyOf(subpath) {
+    return posix.join(subpath, 'index.ts');
+}
+/** The `.js` → `.ts` rewrite, with no filesystem behind it. */
+export const firstCandidate = (fromKey, specifier) => {
+    const joined = resolveRelative(fromKey, specifier);
+    if (joined === null)
+        return null;
+    return resolutionCandidates(joined)[0] ?? null;
+};
+/** The exported name of one `export { … }` element, after any `as` rename. */
+function exportedName(element) {
+    return element.name.text;
+}
+/** Names a statement exports by declaring them, or `[]`. */
+function locallyExportedNames(node) {
+    const modifiers = ts.canHaveModifiers(node) ? (ts.getModifiers(node) ?? []) : [];
+    if (!modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword))
+        return [];
+    if (ts.isVariableStatement(node)) {
+        return node.declarationList.declarations.flatMap((declaration) => ts.isIdentifier(declaration.name) ? [declaration.name.text] : []);
+    }
+    if ((ts.isFunctionDeclaration(node) ||
+        ts.isClassDeclaration(node) ||
+        ts.isEnumDeclaration(node)) &&
+        node.name !== undefined) {
+        return [node.name.text];
+    }
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+        return [node.name.text];
+    }
+    return [];
+}
+/**
+ * Everything one barrel publishes, and everything about it this parse could not
+ * read.
+ *
+ * Pure over the source text, so both consumers — and every fixture — enter
+ * where a real run enters.
+ *
+ * The three shapes it refuses to guess at are the three that would make the
+ * published set come back **short**, which is the direction that turns a
+ * correct reach into a finding and, worse, lets an author "repair" it by
+ * widening the barrel:
+ *
+ *   * `export * from './x.js'` — the names are in another file;
+ *   * `export * as ns from './x.js'` — a namespace object, whose members no
+ *     `exports` map can enumerate;
+ *   * `export { X }` with no `from` — a re-export of a local binding whose own
+ *     origin this parse does not follow.
+ *
+ * None of the three occurs in the five barrels today. Each is reported rather
+ * than skipped, because a barrel this file reads *partially* is exactly the
+ * "green while not looking" shape issue #113 is about.
+ */
+export function parseBarrel(source, barrel, resolve = firstCandidate) {
+    const sf = ts.createSourceFile(barrel, source, ts.ScriptTarget.Latest, true);
+    const published = [];
+    const unreadable = [];
+    const lineOf = (node) => sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+    sf.forEachChild((node) => {
+        if (ts.isExportDeclaration(node)) {
+            const specifier = node.moduleSpecifier;
+            if (specifier === undefined || !ts.isStringLiteral(specifier)) {
+                unreadable.push({
+                    barrel,
+                    line: lineOf(node),
+                    reason: '`export { … }` with no `from` — the names are re-exports of local bindings ' +
+                        'whose origin this parse does not follow',
+                });
+                return;
+            }
+            const target = resolve(barrel, specifier.text);
+            if (node.exportClause === undefined) {
+                unreadable.push({
+                    barrel,
+                    line: lineOf(node),
+                    reason: `\`export * from '${specifier.text}'\` — the published names are in another file`,
+                });
+                return;
+            }
+            if (ts.isNamespaceExport(node.exportClause)) {
+                unreadable.push({
+                    barrel,
+                    line: lineOf(node),
+                    reason: `\`export * as ${node.exportClause.name.text} from '${specifier.text}'\` — a ` +
+                        'namespace object, whose members no `exports` map can enumerate',
+                });
+                return;
+            }
+            for (const element of node.exportClause.elements) {
+                published.push({ name: exportedName(element), target: target ?? barrel });
+            }
+            return;
+        }
+        for (const name of locallyExportedNames(node))
+            published.push({ name, target: barrel });
+    });
+    return { barrel, published, unreadable };
+}
+/**
+ * A relative specifier from `fromKey`, as a key relative to the same root.
+ *
+ * The `.js` an ESM specifier carries is rewritten to `.ts`, an extensionless
+ * specifier gains one, and a directory specifier gains `/index.ts` — the three
+ * shapes this tree writes. `null` for a specifier that is not relative, or that
+ * climbs out of the root.
+ */
+export function resolveRelative(fromKey, specifier) {
+    if (!specifier.startsWith('.'))
+        return null;
+    const joined = posix.normalize(posix.join(posix.dirname(fromKey), specifier));
+    if (joined.startsWith('..'))
+        return null;
+    return joined;
+}
+/**
+ * The host file a bare specifier names, or `null` when it does not name the
+ * host at all.
+ *
+ * The match is on a **segment boundary**, which is the same care
+ * `check-module-boundary`'s `resolveModulePackage` takes and for the same
+ * reason: `@endora-commerce/platform-extras` is a different package, and a bare
+ * `startsWith` reads it as this one.
+ *
+ * `null` for a relative specifier, for a third party's, and for every specifier
+ * at all when the workspace declares no platform — a fixture workspace
+ * legitimately has none, and "no host reach" is the only honest answer there.
+ *
+ * **Three answers, not two** (D-160.14). A subpath the `exports` map declares
+ * and no barrel carries is `host-internal-subpath`, between the published one
+ * and the one that does not exist. Collapsing it into either is wrong in a
+ * different way: as *published* it would license the reach, and as *undeclared*
+ * it would tell the author their specifier does not resolve, which it does.
+ */
+export function resolveHostSpecifier(specifier, host) {
+    if (host === null || specifier.startsWith('.'))
+        return null;
+    if (specifier !== host.name && !specifier.startsWith(`${host.name}/`))
+        return null;
+    const subpath = specifier.slice(host.name.length).replace(/^\//, '');
+    const target = host.subpathTargets.get(subpath);
+    if (target !== undefined)
+        return { kind: 'published-subpath', subpath, target };
+    if (host.declaredSubpaths.has(subpath))
+        return { kind: 'host-internal-subpath', subpath };
+    return { kind: 'undeclared-subpath', subpath };
+}
+/**
+ * Every candidate file a relative specifier could name, most specific first.
+ *
+ * `.tsx` is here beside `.ts` because a module's sources are no longer only
+ * Node code: a module package's `./admin` layer (feature 091) is React
+ * components, and a `./pages/Screen.js` specifier inside one resolves to a
+ * `.tsx` file or to nothing. Nothing is the fail-closed answer this check gives
+ * an unresolvable reach — correct as a default, and wrong here, where the file
+ * is there and the candidate list had never heard of its extension.
+ */
+export function resolutionCandidates(joined) {
+    const stem = joined.endsWith('.js') ? joined.slice(0, -'.js'.length) : null;
+    const candidates = [
+        stem === null ? null : `${stem}.ts`,
+        stem === null ? null : `${stem}.tsx`,
+        joined.endsWith('.ts') || joined.endsWith('.tsx') ? joined : null,
+        `${joined}.ts`,
+        `${joined}.tsx`,
+        posix.join(joined, 'index.ts'),
+        posix.join(joined, 'index.tsx'),
+    ];
+    return candidates.filter((candidate) => candidate !== null);
+}
+/**
+ * The surface, from the barrel sources.
+ *
+ * `barrels` is keyed by the barrel's own path relative to the source root, so a
+ * caller that hands in fewer than {@link PUBLISHED_SUBPATHS} gets a surface that
+ * says so through {@link PlatformSurface.barrelsWithExports} rather than a
+ * quietly narrower answer.
+ */
+export function publishedSurface(barrels, resolve = firstCandidate) {
+    const published = new Map();
+    const publishedBy = new Map();
+    const unreadable = [];
+    let barrelsWithExports = 0;
+    for (const [barrel, source] of barrels) {
+        const parsed = parseBarrel(source, barrel, resolve);
+        unreadable.push(...parsed.unreadable);
+        if (parsed.published.length > 0)
+            barrelsWithExports += 1;
+        for (const symbol of parsed.published) {
+            const names = published.get(symbol.target) ?? new Set();
+            names.add(symbol.name);
+            published.set(symbol.target, names);
+            const carriers = publishedBy.get(symbol.target) ?? new Set();
+            carriers.add(barrel);
+            publishedBy.set(symbol.target, carriers);
+        }
+    }
+    return {
+        published,
+        publishedBy,
+        barrels: new Set(barrels.keys()),
+        unreadable,
+        barrelsWithExports,
+    };
+}
+//# sourceMappingURL=platform-surface.js.map

package/dist/lib/platform-surface.js.map

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

package/dist/lib/port-registrations.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Container registrations and port resolutions, read out of TypeScript sources
+ * through the compiler API.
+ *
+ * `check:port-dependencies` and `check:port-shape` both have to answer the same
+ * three questions of a module's sources — *which names does it register*, *which
+ * ports does it provide* and *which names does it resolve* — and one of those two
+ * rules now has two hosts (`specs/101-endora-check/contracts/package-scope-layout.md`
+ * §6: `backend/scripts/check-port-shape.ts` over this repository, `endora check`
+ * over one module package). A predicate three callers share has to live where
+ * all three can reach it, which is the package.
+ *
+ * Everything here is **syntactic only**, deliberately. Whether a name is owned,
+ * whether an edge is declared and whether a capture is allowed are questions
+ * about a *composition*, and they stay with the checks that know what a
+ * composition is: this file says only what a source text spells.
+ *
+ * Attribution keys on `/src/apps/<deployment>/modules/<id>/`, then on
+ * `/src/modules/<id>/`, then on `lib/module-population.ts`' `moduleIdOf` — the
+ * same segment reader the population floor uses, with the `hostResident` map for
+ * a module whose sources the host owns. A file the walk reads and cannot name is
+ * a file every consumer here judges as nobody's and reports clean about, which
+ * is issue #215's failure one layer in.
+ */
+import ts from 'typescript';
+import { type HostResidentModules } from './module-population.js';
+/**
+ * Stand-in recorded when a `lazyPort` name is not a string literal. It is owned
+ * by nobody on purpose, so it surfaces as an `unowned-name` violation naming the
+ * file and line — the same way a genuinely unregistered name does.
+ */
+export declare const NON_LITERAL_PORT_NAME = "<computed>";
+/**
+ * *When* a resolution happens, which is what the gated-port rule below keys on
+ * (feature 072, D-39).
+ *
+ * `kind` answers "once or per call"; this answers "before or after the platform
+ * serves its first request". They are independent — a boot-hook read is
+ * genuinely deferred and still fatal — and only this one sees the failure that
+ * took the backend down twice:
+ *
+ *  - `boot` — lexically inside a `ctx.onBoot` hook. `runBootHooks()` does not
+ *    consult module presence, so the hook runs whatever the module's effective
+ *    state is.
+ *  - `wiring` — the body of the `ctx.routes` callback itself. It runs inside
+ *    `buildServer`, unconditionally: `defineModuleRoutes` gates *requests*, not
+ *    the registration. A read inside a handler is not this — that is `call`.
+ *  - `call` — everything else: a request handler, a subscriber, a worker
+ *    processor, a method on a service.
+ */
+export type ResolutionSite = 'boot' | 'wiring' | 'call';
+export interface PortResolution {
+    readonly moduleId: string;
+    readonly name: string;
+    readonly file: string;
+    readonly line: number;
+    /**
+     * How the name is read, which is the whole point of the capture rule below.
+     *
+     *  - `captured` — destructured from a factory's cradle parameter, so Awilix
+     *    resolves it once, when the registration is first constructed.
+     *  - `deferred` — read through `ctx.cradle<C>()`, so it resolves at the
+     *    moment of use.
+     */
+    readonly kind: 'captured' | 'deferred';
+    /** See {@link ResolutionSite}. */
+    readonly site: ResolutionSite;
+    /**
+     * **Which seam the name was written into**, which is a different question
+     * from `kind` and from `site` and is the one `check-port-shape`'s third
+     * signal keys on (issue #196, D-98.2).
+     *
+     *  - `lazyPort` — `lazyPort<T>(ctx, 'name')`, the shape a module uses to
+     *    reach a *published* port. The name is a literal a developer copied out
+     *    of a contract's doc block, which is exactly why it is checkable against
+     *    one.
+     *  - `cradle` — every other shape this function reads: a factory's cradle
+     *    parameter, `ctx.cradle<C>()`, a module-local alias of either. Those are
+     *    **contribution seams**, where a module reads a name a composition root
+     *    or the kernel supplies, and where naming a published contract would be
+     *    the wrong requirement — four of the five names the two populations
+     *    disagree on are of that kind.
+     *
+     * Recorded here rather than re-derived by the consumer so that "this
+     * resolution is a `lazyPort`" is decided in the one place that already
+     * decides it. A predicate that exists twice can go half-missing while the
+     * check still prints `violations=0`.
+     */
+    readonly via: 'lazyPort' | 'cradle';
+}
+/**
+ * The owning module id of a source file, over every root a module can live in.
+ *
+ * Three shapes, in order. The two anchored regexes answer for the application's
+ * own trees — a deployment overlay first, then the core module tree — and both
+ * key on `/src/`, so they say nothing about a module that has become a
+ * **package** (feature 080, T040a). The third is `lib/module-population.ts`'
+ * `moduleIdOf`, the same segment reader the population floor uses, and it is
+ * what makes a path like `packages/modules/blog/src/services/x.ts` attribute to
+ * `blog` instead of to nobody.
+ *
+ * That fallback is not cosmetic. Without it a package's files are read by the
+ * walk, satisfy the floor, and are then attributed to `null` — which for every
+ * consumer here means *not a module*, so the check judges none of them and
+ * reports clean. That is issue #215's failure one layer in, and it is why
+ * `resolveModuleLayout` refuses a package root whose location the segment
+ * reader cannot attribute rather than letting it through unnamed.
+ *
+ * The fourth answer is `hostResident`, the map the layout derives from the
+ * manifest index for a module whose sources the host owns and whose directory
+ * therefore carries no `modules/<id>/` segment (feature 080, T040b). It is
+ * threaded from `main` rather than left to default, for exactly the reason the
+ * third shape exists: a file the walk reads and cannot name is a file this
+ * check judges as nobody's and reports clean about.
+ */
+export declare function moduleOf(file: string, hostResident?: HostResidentModules): string | null;
+/** `ctx.di.register` → `di.register`; used to match on the tail, not the receiver name. */
+export declare function calleeTail(node: ts.CallExpression): string;
+/** Every registration name a module claims: `di.register` keys plus `di.providePort`. */
+export declare function registeredNames(source: string, file: string): string[];
+/**
+ * The names a module registers as **gated ports** (`di.providePort`), which is
+ * the subset a composition root must never re-register.
+ *
+ * The distinction is the whole of the shadowing rule below. `di.register` is
+ * how a module declares a *contribution point* — a name it defaults, expecting
+ * a root that has something better to override it — so a root registering one
+ * of those is the design working. `di.providePort` wraps the resolver in the
+ * presence gate, and a root registration replaces the gate with a plain value.
+ */
+export declare function providedPortNames(source: string, file: string): string[];
+/** One `ctx.di.providePort<T>('name', …)` call, with the contract it names. */
+export interface ProvidedPort {
+    /** The container name, always a string literal (a computed one is skipped). */
+    readonly name: string;
+    /**
+     * The published contract the registration is checked against, when the call
+     * carries a type argument. `null` for the 53 that do not — those compare
+     * nothing (Phase-P unreached-port audit, A12).
+     */
+    readonly typeName: string | null;
+    readonly line: number;
+}
+/**
+ * Every gated registration a file makes, with its type argument.
+ *
+ * The single expression of "this call is a `providePort`" in the tree.
+ * `providedPortNames` above and `check-port-shape`'s container-name signal both
+ * come through here rather than each writing the predicate again: a check whose
+ * decision exists in two places can go half-missing without its red proof
+ * noticing, which is how `check:nul-bytes` kept printing `violations=0` with its
+ * rule mutated.
+ */
+export declare function providedPorts(source: string, file: string): ProvidedPort[];
+/**
+ * Where in the module's lifecycle this read happens — see {@link ResolutionSite}.
+ *
+ * `boot` is lexical and deliberately wide: `lazyPort` defers to the method
+ * call, and inside a boot hook that call is two lines down. All seven
+ * `emailDefaultsPort` contributors had exactly that shape, and every one of
+ * them would have failed the boot had the port stayed gated.
+ *
+ * `wiring` is narrow on purpose: only the `ctx.routes` callback's own body,
+ * because that is what runs during `buildServer`. Anything nested one function
+ * deeper — a route handler, an `onRequest` hook, a preHandler — runs per
+ * request, where a gate is exactly what should be asked.
+ */
+export declare function siteAt(node: ts.Node): ResolutionSite;
+/**
+ * Every registration name a module resolves.
+ *
+ * Three shapes, because those are the ones the kernel offers: the cradle
+ * parameter of a factory (`ctx.asFunction(({ a, b }: C) => …)`, destructured or
+ * named), the deferred surface (`ctx.cradle<C>()`) read by destructuring or by
+ * property access, and either of those bound to a local first — see
+ * {@link collectCradleAliases}.
+ *
+ * **Each shape is read both ways round.** The alias and the destructuring are
+ * independent axes, and the check used to see only five of their six
+ * combinations: `cradle().a` yes, `const { a } = ctx.cradle<C>()` yes,
+ * `const { a } = cradle()` no. That last one is what `catalog`'s
+ * asset-reference boot hook is written as, so its two reads were invisible
+ * until issue #127 — the eighth time this scanner's *reach*, rather than the
+ * rules under it, turned out to be the defect.
+ */
+export declare function resolvedNames(source: string, file: string, hostResident?: HostResidentModules): PortResolution[];
+/**
+ * Every registration name a **composition root** writes into the container.
+ *
+ * A different spelling from {@link registeredNames} and that is the whole reason
+ * it exists: a module writes `ctx.di.register({ … })`, and a root writes
+ * `registerValues(container, { … })`, `container.register({ … })` or
+ * `composedModules.contribute({ … })` — D-45's contribution window as a method
+ * (issue #52). Missing the third would drop nearly every name a root supplies.
+ *
+ * ## Why the CLI needs it
+ *
+ * `specs/110-instance-repository/` T138a. The divergence report's second host is
+ * a client's instance, where `composeApp` **is** the composition root and comes
+ * out of `node_modules`, and `registration-owners.ts`' `rootSuppliedNames` is
+ * what tells *"a root registers it"* from *"nobody registers it"*. Its own doc
+ * block says what happens without it, and it was measured happening: an overlay
+ * module decorating `commandBus` in a real scaffolded instance was reported
+ * `unowned-subject` — a finding about the run dressed as one about the tree —
+ * because the platform registers it in a root spelling this file did not read.
+ *
+ * ## It is a **second copy**, knowingly, and here is the whole of that decision
+ *
+ * `backend/scripts/check-port-dependencies.ts` exports a `rootRegisteredNames`
+ * this one is taken from, unchanged. Two derivations of one predicate is the
+ * shape this estate refuses, so the copy is **not** the end state: that file's
+ * should become an import of this one, which is a one-line change and is
+ * deliberately not made in the merge request that adds this, feature 117's
+ * Phase 6 holding that file open at the time. Until it is,
+ * `backend/test/unit/scripts/check-divergence.test.ts` holds the two to each
+ * other over the shapes a root really writes — a divergence between them is red
+ * rather than silent, which is what a duplicated predicate otherwise costs.
+ *
+ * Spread elements are ignored: a name that only exists inside a spread is not a
+ * name this analysis can reason about.
+ */
+export declare function rootRegisteredNames(source: string, file: string): string[];
+//# sourceMappingURL=port-registrations.d.ts.map

package/dist/lib/port-registrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port-registrations.d.ts","sourceRoot":"","sources":["../../src/lib/port-registrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,wBAAwB,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,eAAe,CAAC;AAElD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;AAExD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC;IACvC,kCAAkC;IAClC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,QAAQ,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,YAAY,GAAE,mBAA8C,GAC3D,MAAM,GAAG,IAAI,CAMf;AAED,2FAA2F;AAC3F,wBAAgB,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,CAM1D;AAED,yFAAyF;AACzF,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAqBtE;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAExE;AAED,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CAuB1E;AA4BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,cAAc,CAQpD;AA8GD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,YAAY,GAAE,mBAA8C,GAC3D,cAAc,EAAE,CAsMlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CA+B1E"}