carrick 0.3.85 → 0.3.87

package/sidecar/dist/src/capture/repair-dangling.js

@@ -0,0 +1,162 @@
+/**
+ * Repair an emitted declaration whose own import does not resolve
+ * (carrick#1397).
+ *
+ * A `symbol` anchor prints nothing: its surface line is
+ * `import('./m').RenderRequest` and the shape lives in the `.d.ts` the
+ * compiler emitted for `m`. When that file imports a module the scanned
+ * checkout does not have — a dependency that was not installed, a generated
+ * module that was never generated — the stub reports the module missing, the
+ * self-check records a dangling internal specifier, and the scanner's publish
+ * gate refuses the alias whole. Twenty resolved members are thrown away with
+ * the one that did not resolve, which is exactly the loss carrick#1377 named
+ * for the two PRINT paths.
+ *
+ * So the declaration is repaired: the import that did not resolve is dropped
+ * and every type it bound is written `unknown` at its own position. This is
+ * file-granular — the same emitted file backs every alias whose closure
+ * reaches it — and it says nothing the source program did not already say:
+ * those names were TypeScript's unresolved-reference placeholder there too,
+ * which is why the anchor recorded their member paths as unresolved.
+ *
+ * Fail-closed in two places. A name used where `unknown` is not a type — a
+ * heritage clause, a type-parameter position — leaves the file untouched, so
+ * the alias keeps its honest refusal rather than gaining a broken declaration.
+ * And the caller re-checks the repaired tree: a name the rewrite did not reach
+ * turns into a `Cannot find name` diagnostic, which the self-check reads back
+ * as the same dangling specifier.
+ *
+ * Seam: node builtins + `typescript`, like the rest of this directory.
+ */
+import ts from 'typescript';
+import * as fs from 'node:fs';
+/**
+ * Drop every import of a failing specifier from each file and write `unknown`
+ * where its names were used.
+ *
+ * `failing` maps an absolute file path to the specifiers the stub could not
+ * resolve from it. Returns the files actually rewritten; a file whose names
+ * cannot all be replaced by `unknown` is left exactly as it was.
+ */
+export function repairDanglingImports(failing) {
+    const repaired = new Map();
+    for (const [file, specifiers] of failing) {
+        const result = repairFile(file, specifiers);
+        if (result)
+            repaired.set(file, result);
+    }
+    return repaired;
+}
+function repairFile(file, specifiers) {
+    let text;
+    try {
+        text = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const names = new Set();
+    const edits = [];
+    const removedSpecifiers = new Set();
+    // A re-export of the failing module binds nothing in THIS file and is what
+    // another file reads through: dropping it would turn "cannot find module"
+    // into "has no exported member" over there, which is neither diagnostic the
+    // re-check reads, and the importer's member would publish as clean. There is
+    // no `unknown` to write for an export, so the file keeps its refusal.
+    let unreplaceable = false;
+    for (const statement of source.statements) {
+        const specifier = importSpecifierOf(statement);
+        if (specifier === undefined || !specifiers.has(specifier))
+            continue;
+        if (ts.isExportDeclaration(statement)) {
+            unreplaceable = true;
+            break;
+        }
+        for (const name of boundNames(statement))
+            names.add(name);
+        removedSpecifiers.add(specifier);
+        edits.push({ start: statement.getFullStart(), end: statement.getEnd(), text: '' });
+    }
+    // An `import(...)` type written inline carries its own specifier and has no
+    // statement to drop; the whole node becomes `unknown`.
+    const visit = (node) => {
+        if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
+            const literal = node.argument.literal;
+            if (ts.isStringLiteral(literal) && specifiers.has(literal.text)) {
+                removedSpecifiers.add(literal.text);
+                edits.push({ start: node.getStart(source), end: node.getEnd(), text: 'unknown' });
+                return;
+            }
+        }
+        if (ts.isTypeReferenceNode(node) && names.has(leftmostName(node.typeName))) {
+            edits.push({ start: node.getStart(source), end: node.getEnd(), text: 'unknown' });
+            return;
+        }
+        if (ts.isTypeQueryNode(node) && names.has(leftmostName(node.exprName))) {
+            edits.push({ start: node.getStart(source), end: node.getEnd(), text: 'unknown' });
+            return;
+        }
+        // Positions where `unknown` is not a type: what a declaration EXTENDS or
+        // IMPLEMENTS, and a type parameter's own name. Leave the file alone rather
+        // than emit a declaration that does not parse as it used to read.
+        if (ts.isExpressionWithTypeArguments(node) &&
+            ts.isIdentifier(node.expression) &&
+            names.has(node.expression.text)) {
+            unreplaceable = true;
+            return;
+        }
+        node.forEachChild(visit);
+    };
+    visit(source);
+    if (unreplaceable || removedSpecifiers.size === 0)
+        return undefined;
+    edits.sort((a, b) => b.start - a.start);
+    let out = text;
+    for (const edit of edits) {
+        out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+    }
+    fs.writeFileSync(file, out);
+    return { specifiers: [...removedSpecifiers].sort(), names: [...names].sort() };
+}
+/** The module specifier an import STATEMENT names, if it names one. */
+function importSpecifierOf(statement) {
+    let expression;
+    if (ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)) {
+        expression = statement.moduleSpecifier;
+    }
+    else if (ts.isImportEqualsDeclaration(statement) &&
+        ts.isExternalModuleReference(statement.moduleReference)) {
+        expression = statement.moduleReference.expression;
+    }
+    return expression && ts.isStringLiteral(expression) ? expression.text : undefined;
+}
+/** Every local name an import statement binds. */
+function boundNames(statement) {
+    const out = [];
+    if (ts.isImportDeclaration(statement)) {
+        const clause = statement.importClause;
+        if (!clause)
+            return out;
+        if (clause.name)
+            out.push(clause.name.text);
+        const bindings = clause.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings))
+            out.push(bindings.name.text);
+        if (bindings && ts.isNamedImports(bindings)) {
+            for (const element of bindings.elements)
+                out.push(element.name.text);
+        }
+    }
+    else if (ts.isImportEqualsDeclaration(statement)) {
+        out.push(statement.name.text);
+    }
+    return out;
+}
+/** The leftmost identifier of `A`, `A.B` or `A.B.C`. */
+function leftmostName(name) {
+    let current = name;
+    while (ts.isQualifiedName(current))
+        current = current.left;
+    return current.text;
+}

package/sidecar/dist/src/capture/self-check.js

@@ -33,6 +33,7 @@ import ts from 'typescript';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { collectSpecifiers, isRelative, packageNameOf } from './specifiers.js';
+import { repairDanglingImports } from './repair-dangling.js';
 import { findDisqualifyingTopTypes, provenanceOf, } from './deep-walk.js';
 export function selfCheckStub(args) {
     const typesDir = path.join(args.stubDir, 'types');
@@ -56,7 +57,18 @@ export function selfCheckStub(args) {
         linked = true;
     }
     try {
-        return runSelfCheck(args, treeFiles);
+        const first = runSelfCheck(args, treeFiles);
+        // carrick#1397: an emitted declaration that imports a module the checkout
+        // does not have makes every alias reaching that file unpublishable, however
+        // much of it resolved. Repair the file — drop the import, write `unknown`
+        // where its names were used — and check the tree again. The second pass is
+        // the verdict: it reads the repaired text, and a name the rewrite did not
+        // reach comes back as a `Cannot find name` diagnostic that
+        // `repairedNameFailures` folds back into the same dangling specifier.
+        const repaired = repairDanglingImports(first.internalFailuresByFile);
+        if (repaired.size === 0)
+            return first.records;
+        return runSelfCheck(args, treeFiles, repaired).records;
     }
     finally {
         // unlinkSync, not rmSync: the link target is a directory and rmSync
@@ -65,7 +77,7 @@ export function selfCheckStub(args) {
             fs.unlinkSync(linkPath);
     }
 }
-function runSelfCheck(args, treeFiles) {
+function runSelfCheck(args, treeFiles, repaired) {
     const options = {
         noEmit: true,
         strict: true,
@@ -102,14 +114,25 @@ function runSelfCheck(args, treeFiles) {
         return entry;
     };
     for (const d of diagnostics) {
-        if ((d.code !== 2307 && d.code !== 2792) || !d.file)
+        if (!d.file)
             continue;
+        const abs = path.resolve(d.file.fileName);
         const msg = ts.flattenDiagnosticMessageText(d.messageText, ' ');
+        // A name the repair did not reach: the import that bound it is gone, so
+        // the module is no longer reported missing and only this diagnostic is
+        // left to say the tree is incomplete. Blamed on the specifier that bound
+        // the name, which is the sentence a reader can act on (carrick#1397).
+        const orphaned = repairedNameFailure(repaired, abs, d, msg);
+        if (orphaned) {
+            bucketIn(failuresByFile, abs).internal.add(orphaned);
+            continue;
+        }
+        if (d.code !== 2307 && d.code !== 2792)
+            continue;
         const m = /Cannot find module '([^']+)'/.exec(msg);
         if (!m)
             continue;
         const spec = m[1];
-        const abs = path.resolve(d.file.fileName);
         // A surface diagnostic outside every alias statement (a file-level import,
         // a reference directive) is attributable to no alias and keeps the
         // service-wide file bucket: soundness over precision, the same fallback
@@ -158,7 +181,40 @@ function runSelfCheck(args, treeFiles) {
                 surfaceFailuresByAlias,
             }));
     }
-    return records;
+    const internalFailuresByFile = new Map();
+    for (const [file, failures] of failuresByFile) {
+        // The surface's own failures are a literal anchor's pasted text
+        // (carrick#1361), not a declaration with an import to drop.
+        if (file === surfaceAbs || failures.internal.size === 0)
+            continue;
+        // A file already repaired has had its turn: repairing it again would chase
+        // its own leftover diagnostics.
+        if (repaired?.has(file))
+            continue;
+        internalFailuresByFile.set(file, failures.internal);
+    }
+    return { records, internalFailuresByFile };
+}
+/**
+ * The specifier to blame for a `Cannot find name` diagnostic in a file this
+ * capture repaired, when the name is one the dropped import bound.
+ *
+ * The rewrite writes `unknown` at every type position it can reach; a use it
+ * cannot — and there should be none, since a position where `unknown` is not a
+ * type leaves the whole file untouched — would otherwise read as a clean tree,
+ * because the module that is missing is no longer imported to be reported.
+ * Fail closed: the alias keeps the refusal it had before the repair.
+ */
+function repairedNameFailure(repaired, file, diagnostic, message) {
+    if (!repaired || diagnostic.code !== 2304)
+        return undefined;
+    const entry = repaired.get(file);
+    if (!entry)
+        return undefined;
+    const named = /Cannot find name '([^']+)'/.exec(message);
+    if (!named || !entry.names.includes(named[1]))
+        return undefined;
+    return entry.specifiers[0];
 }
 /**
  * Position -> the alias whose `export type` statement span covers it, for

package/sidecar/dist/src/definition-resolver.d.ts

@@ -12,6 +12,13 @@
  *  - `expanded`: the fully *structural* form, with every named member type
  *    inlined to its member structure, recursively.
  *
+ * An alias whose own type did not resolve produces neither: the tree is read
+ * with nothing installed, so a reference that leaves it lands on TypeScript's
+ * unresolved-reference placeholder, which the compiler prints as the reference
+ * text rather than as `any` (see `isUnresolvedReference`). Both forms are then
+ * the top type, which is what every downstream rule about an empty answer is
+ * written to refuse.
+ *
  * `type.getText(node, NoTruncation)` does NOT inline named members — the
  * compiler prints a referenced type by its symbol name when that symbol is in
  * scope (`total: Money`, not `total: { amountCents: number; currency: string }`).

package/sidecar/dist/src/definition-resolver.js

@@ -12,6 +12,13 @@
  *  - `expanded`: the fully *structural* form, with every named member type
  *    inlined to its member structure, recursively.
  *
+ * An alias whose own type did not resolve produces neither: the tree is read
+ * with nothing installed, so a reference that leaves it lands on TypeScript's
+ * unresolved-reference placeholder, which the compiler prints as the reference
+ * text rather than as `any` (see `isUnresolvedReference`). Both forms are then
+ * the top type, which is what every downstream rule about an empty answer is
+ * written to refuse.
+ *
  * `type.getText(node, NoTruncation)` does NOT inline named members — the
  * compiler prints a referenced type by its symbol name when that symbol is in
  * scope (`total: Money`, not `total: { amountCents: number; currency: string }`).
@@ -26,7 +33,7 @@
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { Project, Node } from 'ts-morph';
-import { expandTypeStructural } from './type-structural-expander.js';
+import { expandTypeStructural, } from './type-structural-expander.js';
 export class DefinitionResolver {
     project;
     constructor(options) {
@@ -71,7 +78,10 @@ export class DefinitionResolver {
             }
             const results = [];
             for (const alias of aliases) {
-                const result = this.resolveAlias(surface, alias);
+                const result = this.resolveAlias(surface, alias, {
+                    program: stubProject.getProgram().compilerObject,
+                    repoRoot: stubDir,
+                });
                 if (result) {
                     results.push(result);
                 }
@@ -89,7 +99,7 @@ export class DefinitionResolver {
     /**
      * Resolve a single alias: the original text and the structural form.
      */
-    resolveAlias(sourceFile, alias) {
+    resolveAlias(sourceFile, alias, origin) {
         const decl = sourceFile.getTypeAlias(alias) ??
             sourceFile.getInterface(alias) ??
             sourceFile.getClass(alias) ??
@@ -98,6 +108,12 @@ export class DefinitionResolver {
             return null;
         try {
             const type = decl.getType();
+            // An alias whose own type did not resolve answers the top type it IS,
+            // not the reference the compiler echoes for it (carrick#1444).
+            if (isUnresolvedReference(type)) {
+                this.log(`${alias} names a type this tree cannot resolve; answering any`);
+                return { type_alias: alias, definition: 'any', expanded: 'any' };
+            }
             // As-written form: prefer the alias target's own declaration (the real
             // `interface Order {...}` in the tree) over the surface's import-type
             // line, so named shapes read naturally. Fall back to the alias line for
@@ -118,7 +134,7 @@ export class DefinitionResolver {
                 }
             }
             // Structural form — every named member inlined to its shape.
-            const expanded = expandTypeStructural(type);
+            const expanded = expandTypeStructural(type, origin);
             return { type_alias: alias, definition, expanded };
         }
         catch (err) {
@@ -133,6 +149,29 @@ export class DefinitionResolver {
         console.error(`[sidecar:definition-resolver:error] ${message}`);
     }
 }
+/**
+ * True when a type is TypeScript's unresolved-reference placeholder:
+ * `TypeFlags.Any` carrying the internal `intrinsicName === 'error'` (stable
+ * since TS 1.x). `capture/deep-walk.ts` tests the same two facts for the same
+ * reason; the seam forbids importing it from here, so the pin is that both read
+ * the flag and the intrinsic name and nothing else.
+ *
+ * The compiler prints this placeholder as the reference text it FAILED to
+ * resolve, never as `any`. That print is what makes an unresolvable alias read
+ * as a confident name: an instantiation over a dependency's internal generics
+ * has no members in it and resolves nowhere, and every scanner-side rule that
+ * refuses an empty answer asks the TEXT (`text_is_bare_top_type`), so nothing
+ * downstream can tell the difference (carrick#1444).
+ *
+ * Asked only of the alias's own type. At a member position the same echo is
+ * the producer's own vocabulary (`status: OrderStatus`) inside a shape that
+ * otherwise resolved, and replacing it with `any` would remove a name a reader
+ * can look up in the producing repo.
+ */
+function isUnresolvedReference(type) {
+    return (type.isAny() &&
+        type.compilerType.intrinsicName === 'error');
+}
 /** All .d.ts files under a directory, depth-first, deterministic order. */
 function walkDtsFiles(dir) {
     const out = [];

package/sidecar/dist/src/origin.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Where a declaration comes from: the user's own source, or the runtime and
+ * the packages it installed.
+ *
+ * One module because more than one layer asks the question — the inference
+ * path (`type-inferrer.ts`, deciding whether a type is framework machinery)
+ * and the structural printer (`type-structural-expander.ts`, deciding whether
+ * to inline a type's members or keep it by name). They must answer it the same
+ * way or one layer inlines what the other suppresses.
+ *
+ * The capture side keeps its own copy in `capture/machinery.ts`: that seam
+ * forbids importing anything but node builtins, `typescript` and its own
+ * bundle, so the two are kept in lockstep by `machinery-indicator-mirror.test.ts`
+ * rather than by sharing this module.
+ */
+import type { ts } from 'ts-morph';
+/**
+ * True when a declaration's source file is runtime/library origin rather than
+ * user source. Four answers, in order:
+ *
+ *  1. The runtime declarations Carrick materialises for a non-Node runtime
+ *     under `.carrick/deno/` (carrick#1017), and the remote (JSR, `https:`)
+ *     modules it copies beside them. Carrick's own artefact layout, not a
+ *     guess about anyone else's.
+ *  2. A TypeScript default library (`lib.dom.d.ts`, ...), as the program
+ *     classifies it; on a bare checkout the DOM `Response` resolves from here.
+ *  3. An install under a `node_modules` segment, however it entered the
+ *     program (an import, or a root the loader registered).
+ *  4. A file the PROGRAM'S RESOLVER marked as an external library import.
+ *     This is the graph-backed answer for a project whose resolution does not
+ *     go through `node_modules` (carrick#1264): Deno serves an npm dependency's
+ *     types from its own cache, a path with no `node_modules` segment, and
+ *     `DenoProject.resolve` hands the compiler `isExternalLibraryImport` from
+ *     the graph, which the compiler records on the file. Nothing crosses the
+ *     capture seam; both programs are built with that host. One exclusion: a
+ *     workspace package reached through a `node_modules` symlink is also
+ *     marked external by the compiler but is the user's own source, so a file
+ *     inside the checkout (the nearest `.git` above the service root) that
+ *     carries no `node_modules` segment stays user source.
+ *
+ * Lockstep mirror of `isExternalOrigin` in `capture/machinery.ts` (the capture
+ * seam forbids sharing a module); `machinery-indicator-mirror.test.ts` guards
+ * the pair on a real program.
+ */
+export declare function isExternalOrigin(program: ts.Program, sourceFile: ts.SourceFile, repoRoot: string): boolean;

package/sidecar/dist/src/origin.js

@@ -0,0 +1,86 @@
+/**
+ * Where a declaration comes from: the user's own source, or the runtime and
+ * the packages it installed.
+ *
+ * One module because more than one layer asks the question — the inference
+ * path (`type-inferrer.ts`, deciding whether a type is framework machinery)
+ * and the structural printer (`type-structural-expander.ts`, deciding whether
+ * to inline a type's members or keep it by name). They must answer it the same
+ * way or one layer inlines what the other suppresses.
+ *
+ * The capture side keeps its own copy in `capture/machinery.ts`: that seam
+ * forbids importing anything but node builtins, `typescript` and its own
+ * bundle, so the two are kept in lockstep by `machinery-indicator-mirror.test.ts`
+ * rather than by sharing this module.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * True when a declaration's source file is runtime/library origin rather than
+ * user source. Four answers, in order:
+ *
+ *  1. The runtime declarations Carrick materialises for a non-Node runtime
+ *     under `.carrick/deno/` (carrick#1017), and the remote (JSR, `https:`)
+ *     modules it copies beside them. Carrick's own artefact layout, not a
+ *     guess about anyone else's.
+ *  2. A TypeScript default library (`lib.dom.d.ts`, ...), as the program
+ *     classifies it; on a bare checkout the DOM `Response` resolves from here.
+ *  3. An install under a `node_modules` segment, however it entered the
+ *     program (an import, or a root the loader registered).
+ *  4. A file the PROGRAM'S RESOLVER marked as an external library import.
+ *     This is the graph-backed answer for a project whose resolution does not
+ *     go through `node_modules` (carrick#1264): Deno serves an npm dependency's
+ *     types from its own cache, a path with no `node_modules` segment, and
+ *     `DenoProject.resolve` hands the compiler `isExternalLibraryImport` from
+ *     the graph, which the compiler records on the file. Nothing crosses the
+ *     capture seam; both programs are built with that host. One exclusion: a
+ *     workspace package reached through a `node_modules` symlink is also
+ *     marked external by the compiler but is the user's own source, so a file
+ *     inside the checkout (the nearest `.git` above the service root) that
+ *     carries no `node_modules` segment stays user source.
+ *
+ * Lockstep mirror of `isExternalOrigin` in `capture/machinery.ts` (the capture
+ * seam forbids sharing a module); `machinery-indicator-mirror.test.ts` guards
+ * the pair on a real program.
+ */
+export function isExternalOrigin(program, sourceFile, repoRoot) {
+    const file = sourceFile.fileName.replace(/\\/g, '/');
+    if (file.includes('/.carrick/deno/')) {
+        return true;
+    }
+    if (program.isSourceFileDefaultLibrary(sourceFile)) {
+        return true;
+    }
+    if (file.includes('/node_modules/')) {
+        return true;
+    }
+    return program.isSourceFileFromExternalLibrary(sourceFile) && !isInsideCheckout(file, repoRoot);
+}
+const checkoutRoots = new Map();
+/** The checkout the service root sits in: the nearest ancestor holding a
+ * `.git` entry (a directory, or the file a worktree carries), else the service
+ * root itself. */
+function checkoutRootOf(repoRoot) {
+    const key = path.resolve(repoRoot);
+    const cached = checkoutRoots.get(key);
+    if (cached)
+        return cached;
+    let dir = key;
+    let root = key;
+    for (;;) {
+        if (fs.existsSync(path.join(dir, '.git'))) {
+            root = dir;
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    checkoutRoots.set(key, root);
+    return root;
+}
+function isInsideCheckout(file, repoRoot) {
+    const root = checkoutRootOf(repoRoot).replace(/\\/g, '/');
+    return file === root || file.startsWith(root.endsWith('/') ? root : root + '/');
+}

package/sidecar/dist/src/type-inferrer.d.ts

@@ -17,7 +17,7 @@
  * (redirects, 204s), the LLM emits null and we fall back to the containing
  * function's return type.
  */
-import { Project, ts } from 'ts-morph';
+import { Project } from 'ts-morph';
 import type { InferRequestItem, InferResult, ExtractionConfig } from './types.js';
 /**
  * Strongly-discriminating member names of HTTP transport machinery — the
@@ -38,35 +38,6 @@ import type { InferRequestItem, InferResult, ExtractionConfig } from './types.js
  * test (`machinery-indicator-mirror.test.ts`) asserts the two sets stay equal.
  */
 export declare const MACHINERY_MEMBER_INDICATORS: Set<string>;
-/**
- * True when a declaration's source file is runtime/library origin rather than
- * user source. Four answers, in order:
- *
- *  1. The runtime declarations Carrick materialises for a non-Node runtime
- *     under `.carrick/deno/` (carrick#1017), and the remote (JSR, `https:`)
- *     modules it copies beside them. Carrick's own artefact layout, not a
- *     guess about anyone else's.
- *  2. A TypeScript default library (`lib.dom.d.ts`, ...), as the program
- *     classifies it; on a bare checkout the DOM `Response` resolves from here.
- *  3. An install under a `node_modules` segment, however it entered the
- *     program (an import, or a root the loader registered).
- *  4. A file the PROGRAM'S RESOLVER marked as an external library import.
- *     This is the graph-backed answer for a project whose resolution does not
- *     go through `node_modules` (carrick#1264): Deno serves an npm dependency's
- *     types from its own cache, a path with no `node_modules` segment, and
- *     `DenoProject.resolve` hands the compiler `isExternalLibraryImport` from
- *     the graph, which the compiler records on the file. Nothing crosses the
- *     capture seam; both programs are built with that host. One exclusion: a
- *     workspace package reached through a `node_modules` symlink is also
- *     marked external by the compiler but is the user's own source, so a file
- *     inside the checkout (the nearest `.git` above the service root) that
- *     carries no `node_modules` segment stays user source.
- *
- * Lockstep mirror of `isExternalOrigin` in `capture/machinery.ts` (the capture
- * seam forbids sharing a module); `machinery-indicator-mirror.test.ts` guards
- * the pair on a real program.
- */
-export declare function isExternalOrigin(program: ts.Program, sourceFile: ts.SourceFile, repoRoot: string): boolean;
 /**
  * Options for TypeInferrer construction
  */
@@ -99,6 +70,13 @@ export declare class TypeInferrer {
     private readonly packageOf;
     private readonly repoRoot;
     constructor(options: TypeInferrerOptions);
+    /**
+     * What the structural printer needs to tell the user's own declarations from
+     * the runtime's and its packages' — the same program and service root this
+     * class asks `isExternalOrigin` about machinery, so the two layers cannot
+     * classify one declaration two ways.
+     */
+    private expandOrigin;
     /**
      * Infer types for the given requests
      *
@@ -708,7 +686,16 @@ export declare class TypeInferrer {
      * True when an object literal argument is response INIT rather than a body:
      * every property it declares is one the standard `ResponseInit` declares
      * (`status`, `statusText`, `headers`), and it states at least one of them as
-     * init really does — a numeric status in the HTTP range, or headers.
+     * init really does — a status in the HTTP range, or headers.
+     *
+     * The status does NOT have to be a literal code. A route that carries its
+     * outcome in a value writes `new Response(body, { status: result.status })`,
+     * where the source fixes no code and `statedStatusCodes` answers
+     * `'variable'` — status-shaped, just not pinned. Requiring a literal there
+     * left the whole init object reading as a body, so an endpoint whose payload
+     * this layer does not publish (a string body) published `{ status: number }`
+     * as its response contract instead: a wrong contract, served, where an
+     * abstention was the honest answer.
      *
      * A payload that merely has a `status` member of its own (`{ status: "ok",
      * service: "ledger" }`) declares members init does not, or states `status` as