carrick 0.3.115 → 0.3.116

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.115",
+  "version": "0.3.116",
   "carrickCache": {
     "cache_version": 22,
     "intent_cache_version": 2
@@ -113,11 +113,11 @@
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.115",
-    "@carrick-tools/cli-darwin-x64": "0.3.115",
-    "@carrick-tools/cli-linux-arm64": "0.3.115",
-    "@carrick-tools/cli-linux-x64": "0.3.115",
-    "@carrick-tools/cli-win32-x64": "0.3.115"
+    "@carrick-tools/cli-darwin-arm64": "0.3.116",
+    "@carrick-tools/cli-darwin-x64": "0.3.116",
+    "@carrick-tools/cli-linux-arm64": "0.3.116",
+    "@carrick-tools/cli-linux-x64": "0.3.116",
+    "@carrick-tools/cli-win32-x64": "0.3.116"
   },
   "devDependencies": {
     "@types/node": "^24.13.3"

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "carrick",
   "description": "Claude Code plugin for Carrick, which indexes TypeScript codebases across service and repository boundaries. After each edit it adds the file's routes, calls, and cross-service type mismatches to the session, and it registers Carrick's language server. It pairs with the Carrick MCP server, which lets agents search functions by intent rather than name.",
-  "version": "0.3.115",
+  "version": "0.3.116",
   "author": {
     "name": "Carrick",
     "email": "hello@carrick.tools"

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

@@ -2,8 +2,23 @@
  * TypeBundler - the `bundle` action: each requested symbol's declaration text,
  * read from the init'd ts-morph project.
  */
-import { Project } from 'ts-morph';
+import { Project, SourceFile } from 'ts-morph';
 import type { SymbolRequest, BundleResult } from './types.js';
+import { type ExpandOrigin } from './type-structural-expander.js';
+/** Where a requested symbol is declared: the file and the name it has there. */
+interface DeclarationSite {
+    sourceFile: SourceFile;
+    name: string;
+}
+/**
+ * Where `name`, as `sourceFile` exports it, is declared (carrick#1605). A name
+ * the file declares is its own. Otherwise it is followed the way an import of
+ * it is: a model names a type where the consumer imports it from, usually a
+ * barrel that only has `export *`.
+ */
+export declare function declarationSite(sourceFile: SourceFile, name: string, label: string, origin: ExpandOrigin): DeclarationSite | {
+    reason: string;
+};
 /**
  * Options for TypeBundler construction (legacy)
  */
@@ -67,3 +82,4 @@ export declare class TypeBundler {
     private log;
     private logError;
 }
+export {};

package/sidecar/dist/src/bundler.js

@@ -85,7 +85,7 @@ function declaredName(declaration) {
  * it is: a model names a type where the consumer imports it from, usually a
  * barrel that only has `export *`.
  */
-function declarationSite(sourceFile, name, label, origin) {
+export function declarationSite(sourceFile, name, label, origin) {
     if (declaresName(sourceFile, name))
         return { sourceFile, name };
     const declarations = exportedDeclarations(sourceFile, name, new Set());

package/sidecar/dist/src/capture/anchors.js

@@ -10,7 +10,7 @@ import { printTypeForDestination, substituteUndeclaredNames, undeclaredNamesIn,
 import { typeIsOrContainsMachinery } from './machinery.js';
 import { installedPackageSpecifier } from './installed-package.js';
 import { realPath } from './service-config.js';
-import { statusTableBody } from './status-table.js';
+import { statesNoShape, statusTableBody } from './status-table.js';
 import { unresolvedAtAnchor, unresolvedSpecifiersReachableFrom, } from './unresolved.js';
 /**
  * Repo-root-relative source file -> the specifier the surface entry imports
@@ -320,6 +320,13 @@ function finishInferAnchor(program, sourceFile, request, located, placeholder, r
                 type = recovered;
         }
     }
+    // carrick#2116: a narrowed `unknown` (the checker's own empty object type)
+    // and `object` state no shape, at the root or as a member of the root
+    // union. Printed they read `{}` and `object`, and would be judged as a
+    // shape that lacks every field. They are read as the `unknown` they are.
+    if (statesNoShape(checker, type)) {
+        type = checker.getUnknownType();
+    }
     // carrick#766: a LINE-ONLY anchor whose type came back a bare top type has
     // no evidence on either side, so it must abstain.
     //

package/sidecar/dist/src/capture/api.d.ts

@@ -420,7 +420,12 @@ export interface CheckPairSpec {
     consumer: CheckPairEndpoint;
 }
 /**
- * Four-bucket classifier output (pinned decision 7):
+ * Classifier output: the four buckets of pinned decision 7, and one more
+ * (carrick#1538).
+ *  - producer_wider: the published sent type mismatches and the handler's
+ *    return, read with no literal widened, does not. What travels agrees, so
+ *    it is stored as compatible with the class beside it, and it carries no
+ *    diagnostic.
  *  - compatible: no diagnostics; the value-level assignment holds.
  *  - incompatible: an assignment-class diagnostic (TS2322/2741/...) — real
  *    compiler text is the report.
@@ -429,7 +434,7 @@ export interface CheckPairSpec {
  *  - gate_caught_baked_any: a side resolved to `any` (the IsAny probe gate
  *    fired) — the backstop that stops a baked-any reading as compatible.
  */
-export type VerdictBucket = 'compatible' | 'incompatible' | 'unverifiable' | 'gate_caught_baked_any';
+export type VerdictBucket = 'compatible' | 'incompatible' | 'unverifiable' | 'gate_caught_baked_any' | 'producer_wider';
 export interface CheckVerdict {
     /** Deterministic FNV-1a hash of the pair (never a temp path). */
     pair_id: string;

package/sidecar/dist/src/capture/check-classify.d.ts

@@ -1,5 +1,5 @@
 /**
- * Diagnostic parsing + four-bucket classification for the v2 check phase.
+ * Diagnostic parsing + bucket classification for the v2 check phase.
  *
  * The judge is the vendored `tsc` CLI with `--pretty false`, run from the
  * workspace root so file locations print workspace-relative (no temp path in
@@ -16,6 +16,8 @@
  *   raw-text read marked on a side        -> unverifiable (text, even agreeing)
  *   assignment error, sent union taken in part by a weak expected type
  *                                         -> unverifiable (carrick#1995)
+ *   assignment error on the published type that the sent side's unwidened
+ *   reading does not repeat               -> producer_wider (carrick#1538)
  *   assignment-class error                -> incompatible
  *   no diagnostics                        -> compatible     [lowest precedence]
  *

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

@@ -1,5 +1,5 @@
 /**
- * Diagnostic parsing + four-bucket classification for the v2 check phase.
+ * Diagnostic parsing + bucket classification for the v2 check phase.
  *
  * The judge is the vendored `tsc` CLI with `--pretty false`, run from the
  * workspace root so file locations print workspace-relative (no temp path in
@@ -16,6 +16,8 @@
  *   raw-text read marked on a side        -> unverifiable (text, even agreeing)
  *   assignment error, sent union taken in part by a weak expected type
  *                                         -> unverifiable (carrick#1995)
+ *   assignment error on the published type that the sent side's unwidened
+ *   reading does not repeat               -> producer_wider (carrick#1538)
  *   assignment-class error                -> incompatible
  *   no diagnostics                        -> compatible     [lowest precedence]
  *
@@ -25,7 +27,7 @@
  *
  * Seam: node builtins + this bundle only.
  */
-import { decisiveAssignmentLine } from './check-probe.js';
+import { decisiveAssignmentLine, unwidenedAliasOf, } from './check-probe.js';
 import { scrubDiagnostic, scrubPaths } from './check-scrub.js';
 import { describeFieldReport, fieldReportNotes, } from './check-fields.js';
 const PRIMARY_RE = /^(?<file>(?:[a-zA-Z]:)?[^(]*?)\((?<line>\d+),(?<col>\d+)\): error TS(?<code>\d+): (?<msg>.*)$/;
@@ -72,7 +74,11 @@ function endpointAliasFor(side, plan) {
 /** Classify one pair into exactly one bucket, honouring the precedence order. */
 export function classifyPair(input) {
     const { plan, probeDiags, poisonReason, scrubCtx } = input;
-    const codes = [...new Set(probeDiags.map((d) => d.code))].sort((a, b) => a - b);
+    // The lines of the unwidened reading (carrick#1538) answer one question, in
+    // 5b below. Their diagnostics are no part of what the published pair raised.
+    const codes = [
+        ...new Set(probeDiags.filter((d) => !onUnwidenedLines(plan, d)).map((d) => d.code)),
+    ].sort((a, b) => a - b);
     // `notes` sits on `base` so EVERY bucket carries it, including the
     // compatible one (carrick#1341). The two statements it holds are true of a
     // pair that agreed — an optionality gap assigns, and the wire allowance is
@@ -240,6 +246,14 @@ export function classifyPair(input) {
             ...notAFact(`the ${sent} type is a union of bodies and the ${expected} type, every field optional, accepts only some of them`),
         };
     }
+    // 5b. Or the mismatch is the published type's alone (carrick#1538): a
+    //     literal widened where the handler's return was inferred. The handler's
+    //     return read with no literal widened fits what the other side expects,
+    //     so what travels agrees and only the published type is wider. Its own
+    //     bucket, which carries no diagnostic: a reason is read as a mismatch.
+    if (assignDiag && unwidenedReadingFits(input)) {
+        return { ...base, bucket: 'producer_wider', ...factness(input) };
+    }
     if (assignDiag) {
         const text = scrubDiagnostic(assignDiag.message, scrubCtx, plan.sentEndpoint.alias, plan.expectedEndpoint.alias);
         return {
@@ -297,6 +311,36 @@ export function classifyPair(input) {
     // 6. No diagnostics -> compatible.
     return { ...base, bucket: 'compatible', ...factness(input) };
 }
+function onUnwidenedLines(plan, diagnostic) {
+    return plan.unwidenedFromLine !== undefined && diagnostic.line >= plan.unwidenedFromLine;
+}
+/**
+ * Whether the sent side's unwidened reading clears a mismatch on its published
+ * type (carrick#1538). Every condition must hold, and each absence leaves the
+ * published verdict as it is:
+ *
+ * - the probe carries the reading (its stub ships the unwidened alias);
+ * - the compiler raised nothing on its lines: not on the import (the export is
+ *   there), not on its top-type gates, not on its assignment;
+ * - its own declarations typecheck (the alias is not poisoned);
+ * - the member-level walk ran over it and found no `any`/`unknown`, which
+ *   would assign to whatever the other side declares;
+ * - the same walk found none on the two published sides either. A mismatch
+ *   that is not a fact stays the mismatch it was: the reading would be
+ *   clearing it against a member that accepts anything.
+ */
+function unwidenedReadingFits(input) {
+    const { plan, probeDiags, poisonReason } = input;
+    if (plan.unwidenedFromLine === undefined)
+        return false;
+    if (probeDiags.some((d) => onUnwidenedLines(plan, d)))
+        return false;
+    const sent = plan.sentEndpoint;
+    if (poisonReason(sent.service_name, unwidenedAliasOf(sent.alias)))
+        return false;
+    const walked = input.deepFindings?.sentUnwidened;
+    return walked !== undefined && walked.length === 0 && factness(input).resolved;
+}
 /**
  * The field-level sentence appended to a mismatch diagnostic
  * (carrick-tools/carrick-cloud#1118), or `''` when the walk found nothing to

package/sidecar/dist/src/capture/check-deep.d.ts

@@ -14,14 +14,24 @@
  * It is used for exactly one thing: setting `CheckVerdict.resolved`. No bucket
  * changes because of it, so a scan's verdicts are identical with and without
  * it — what changes is whether a reader is told the verdict is a fact.
+ *
+ * One more reading rides the same walk (carrick#1538): the sent side's
+ * unwidened alias, where a probe carries it. A member-level `any` there would
+ * let that reading assign to anything, so the classifier lets it clear a
+ * mismatch only when this walk ran over it and found nothing.
  */
 import ts from 'typescript';
 import type { TypeProvenance } from './api.js';
-import type { ProbePlan } from './check-probe.js';
+import { type ProbePlan } from './check-probe.js';
 /** Deep findings for one pair, per probe side. */
 export interface PairDeepFindings {
     sent: TypeProvenance[];
     expected: TypeProvenance[];
+    /**
+     * Findings on the sent side's unwidened reading (carrick#1538). Absent when
+     * the probe carries none, or when its export could not be resolved.
+     */
+    sentUnwidened?: TypeProvenance[];
 }
 /** The one compiler program over the assembled probes, shared by every
  * post-judge walk (fact-ness, and the field-level report the mismatch text

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

@@ -14,12 +14,18 @@
  * It is used for exactly one thing: setting `CheckVerdict.resolved`. No bucket
  * changes because of it, so a scan's verdicts are identical with and without
  * it — what changes is whether a reader is told the verdict is a fact.
+ *
+ * One more reading rides the same walk (carrick#1538): the sent side's
+ * unwidened alias, where a probe carries it. A member-level `any` there would
+ * let that reading assign to anything, so the classifier lets it clear a
+ * mismatch only when this walk ran over it and found nothing.
  */
 import ts from 'typescript';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { sidecarCompilerOptions } from './compiler-options.js';
 import { findDisqualifyingTopTypes, provenanceOf } from './deep-walk.js';
+import { UNWIDENED_LOCAL_NAME } from './check-probe.js';
 export function openProbeProgram(probesDir, plans) {
     if (plans.length === 0)
         return undefined;
@@ -63,7 +69,14 @@ export function probeDeepFindings(opened, plans) {
         const expected = walkImportedAlias(file, 'Expected', program, checker);
         if (sent === undefined || expected === undefined)
             continue;
-        results.set(plan.pairId, { sent, expected });
+        const sentUnwidened = plan.unwidenedFromLine === undefined
+            ? undefined
+            : walkImportedAlias(file, UNWIDENED_LOCAL_NAME, program, checker);
+        results.set(plan.pairId, {
+            sent,
+            expected,
+            ...(sentUnwidened === undefined ? {} : { sentUnwidened }),
+        });
     }
     return results;
 }

package/sidecar/dist/src/capture/check-probe.d.ts

@@ -84,7 +84,28 @@ export interface ProbePlan {
      * the form that actually travels.
      */
     wireAssignmentLine?: number;
+    /**
+     * 1-based line where the second reading of the sent side starts
+     * (carrick#1538): the import of the producer's UNWIDENED alias, its
+     * top-type gates and one more assignment, all after every other line, so no
+     * line above it moves. Present only when the caller named that alias.
+     *
+     * Nothing from this line on is an import line, a gate line or an assignment
+     * line of the plan. The classifier reads these lines for one question only:
+     * whether a mismatch on the published type holds for the type the handler
+     * sends with no literal widened.
+     */
+    unwidenedFromLine?: number;
 }
+/**
+ * The surface export that carries a response alias's unwidened reading
+ * (carrick#1516). The scanner names it when it asks the capture for one
+ * (`unwidened_alias` in `src/engine/type_compat_v2.rs`); this is the same
+ * name, read back.
+ */
+export declare function unwidenedAliasOf(alias: string): string;
+/** The local name the probe imports the unwidened alias under. */
+export declare const UNWIDENED_LOCAL_NAME = "SentUnwidened";
 /** The assignment line whose diagnostic decides the bucket. */
 /**
  * The JSON wire transform as TypeScript declarations: `JsonWire<T>` is the
@@ -114,5 +135,12 @@ export declare function decisiveAssignmentLine(plan: ProbePlan): number;
  * Build one probe, recording the exact line of every gate and the assignment so
  * the classifier never depends on hard-coded offsets. `packageOf` maps a
  * service name to its workspace package specifier (e.g. `@carrick/orders`).
+ *
+ * `unwidenedAliasFor` answers, for a producer that is the sending side, the
+ * surface export that carries its unwidened reading (carrick#1538), when its
+ * stub ships one. The probe of an `http` response then ends with a second
+ * assignment of that reading, in the wire form. Without an answer the
+ * probe is what it always was, byte for byte. A consumer that sends (a request
+ * body) is never asked: the reading is of a handler's return.
  */
-export declare function buildProbe(spec: CheckPairSpec, packageOf: (serviceName: string) => string): ProbePlan;
+export declare function buildProbe(spec: CheckPairSpec, packageOf: (serviceName: string) => string, unwidenedAliasFor?: (sentProducer: CheckPairEndpoint) => string | undefined): ProbePlan;

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

@@ -74,6 +74,17 @@ export function pairId(spec) {
     ].join('|');
     return fnv1a(key);
 }
+/**
+ * The surface export that carries a response alias's unwidened reading
+ * (carrick#1516). The scanner names it when it asks the capture for one
+ * (`unwidened_alias` in `src/engine/type_compat_v2.rs`); this is the same
+ * name, read back.
+ */
+export function unwidenedAliasOf(alias) {
+    return `${alias}_Unwidened`;
+}
+/** The local name the probe imports the unwidened alias under. */
+export const UNWIDENED_LOCAL_NAME = 'SentUnwidened';
 /** The assignment line whose diagnostic decides the bucket. */
 /**
  * The JSON wire transform as TypeScript declarations: `JsonWire<T>` is the
@@ -114,8 +125,15 @@ export function decisiveAssignmentLine(plan) {
  * Build one probe, recording the exact line of every gate and the assignment so
  * the classifier never depends on hard-coded offsets. `packageOf` maps a
  * service name to its workspace package specifier (e.g. `@carrick/orders`).
+ *
+ * `unwidenedAliasFor` answers, for a producer that is the sending side, the
+ * surface export that carries its unwidened reading (carrick#1538), when its
+ * stub ships one. The probe of an `http` response then ends with a second
+ * assignment of that reading, in the wire form. Without an answer the
+ * probe is what it always was, byte for byte. A consumer that sends (a request
+ * body) is never asked: the reading is of a handler's return.
  */
-export function buildProbe(spec, packageOf) {
+export function buildProbe(spec, packageOf, unwidenedAliasFor) {
     const id = pairId(spec);
     const direction = directionFor(spec.protocol, spec.type_kind);
     const sentEndpoint = direction.sent === 'producer' ? spec.producer : spec.consumer;
@@ -270,6 +288,36 @@ export function buildProbe(spec, packageOf) {
         push(`declare const sentWire: WireSent;`);
         wireAssignmentLine = push(`const expectedWire: Expected = sentWire;`);
     }
+    // The unwidened reading (carrick#1538). A handler that returns
+    // `cond ? 'a' : 'b'` publishes `string`, because a literal widens where it
+    // is inferred, and a consumer that declares `'a' | 'b'` then mismatches a
+    // response it reads correctly. The capture keeps the reading with no literal
+    // widened beside the published alias, and it is assigned here a second time.
+    //
+    // Everything sits after the lines above, the import included, and none of it
+    // is recorded as an import, gate or assignment line: a missing export, a top
+    // type or a mismatch here says only that the second reading did not clear
+    // the pair, and the verdict on the published type stands.
+    //
+    // Only an `http` response gets one. It is the one pair a producer sends on
+    // whose decisive assignment a second reading can mirror, here in the wire
+    // form. A GraphQL pair compares an unwrapped comparand (above), which a
+    // plain assignment of the reading would not mirror, and on every other
+    // protocol the consumer is the sender (the direction table).
+    let unwidenedFromLine;
+    const sentUnwidenedAlias = direction.sent === 'producer' && spec.protocol === 'http'
+        ? unwidenedAliasFor?.(sentEndpoint)
+        : undefined;
+    if (sentUnwidenedAlias !== undefined) {
+        const local = UNWIDENED_LOCAL_NAME;
+        unwidenedFromLine = push(`import type { ${sentUnwidenedAlias} as ${local} } from '${sentPkg}';`);
+        push(`type _G_unwidened_any = Assert<Not<IsAny<${local}>>>;`);
+        push(`type _G_unwidened_unknown = Assert<Not<IsUnknown<${local}>>>;`);
+        push(`type _G_unwidened_never = Assert<Not<IsNever<${local}>>>;`);
+        push(`type WireSentUnwidened = [${local}] extends [Expected] ? ${local} : (JsonWireSame<JsonWire<${local}>, ${local}> extends true ? ${local} : JsonWire<${local}>);`);
+        push(`declare const sentWireUnwidened: WireSentUnwidened;`);
+        push(`const expectedWireUnwidened: Expected = sentWireUnwidened;`);
+    }
     return {
         pairId: id,
         spec,
@@ -282,5 +330,6 @@ export function buildProbe(spec, packageOf) {
         gateLines,
         assignmentLine,
         wireAssignmentLine,
+        ...(unwidenedFromLine === undefined ? {} : { unwidenedFromLine }),
     };
 }

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

@@ -19,7 +19,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import ts from 'typescript';
-import { buildProbe } from './check-probe.js';
+import { buildProbe, unwidenedAliasOf } from './check-probe.js';
 import { classifyPair, parseTscOutput, } from './check-classify.js';
 import { scrubPaths } from './check-scrub.js';
 import { assembleWorkspace, writeProbes, } from './check-workspace.js';
@@ -190,11 +190,12 @@ export async function runCheck(opts, onProgress) {
         packageLabelOf: ws.packageLabelOf,
     };
     // Generate probes. A pair naming a service with no stub is unverifiable.
+    const aliasRecords = readStubAliasRecords(opts.stubs);
     const plans = [];
     const unresolved = [];
     for (const spec of opts.pairs) {
         try {
-            plans.push(buildProbe(spec, ws.packageOf));
+            plans.push(buildProbe(spec, ws.packageOf, unwidenedAliasIn(aliasRecords)));
         }
         catch {
             unresolved.push({
@@ -215,7 +216,6 @@ export async function runCheck(opts, onProgress) {
         const spec = opts.pairs.find((p) => p.pair_key === v.pair_key);
         v.pair_id = fnvOfSpec(spec);
     }
-    const aliasRecords = readStubAliasRecords(opts.stubs);
     const { preGated, probing } = preGate(plans, aliasRecords);
     writeProbes(ws, probing);
     const errors = [];
@@ -386,6 +386,23 @@ function readStubAliasRecords(stubs) {
     }
     return byService;
 }
+/**
+ * The unwidened reading a producer's stub ships beside one of its aliases
+ * (carrick#1538), as `buildProbe` asks for it. Read from the same manifest the
+ * pre-gate reads. A reading the capture already found a member-level
+ * `any`/`unknown` in is not offered: it would assign to whatever the other
+ * side declares.
+ */
+function unwidenedAliasIn(aliasRecords) {
+    return (sentProducer) => {
+        const record = aliasRecords
+            .get(sentProducer.service_name)
+            ?.get(unwidenedAliasOf(sentProducer.alias));
+        if (!record || record.any_provenance?.length)
+            return undefined;
+        return record.alias;
+    };
+}
 /**
  * Capture-time deep-decay pre-gate (adversarial-review finding 1): a
  * member-level `any`/`unknown` recorded by the capture self-check with no

package/sidecar/dist/src/capture/index.d.ts

@@ -60,4 +60,4 @@ export declare function surfaceEntryFileName(): string;
 /** Same normalization intent as bundle_file_stems on the Rust side. */
 export declare function sanitizeServiceName(name: string): string;
 export declare function captureStub(opts: CaptureStubOptions): CaptureStubResult;
-export { classifyStatusCodes, constituents, httpStatus, statesNoBody, statusKeyCode, statusTableBody, statusTableOf, successEntries, } from './status-table.js';
+export { classifyStatusCodes, constituents, httpStatus, statesNoBody, statesNoShape, statusKeyCode, statusTableBody, statusTableOf, successEntries, } from './status-table.js';

package/sidecar/dist/src/capture/index.js

@@ -266,7 +266,11 @@ export function captureStub(opts) {
     // ---- Phase A: analysis program over placeholder entry + anchor sources ----
     let resolved;
     const progress = opts.onProgress ?? (() => { });
-    const analysisCtx = { repoRoot, entryDir: path.dirname(entryPath), entryPath, guard, progress, bound };
+    // The files of a project that declare a module or global augmentation are
+    // roots of both programs below: the one its anchors are read in and the one
+    // that emits the surface (carrick#2317). Read once per project.
+    const augmentations = augmentationReader(bound);
+    const analysisCtx = { repoRoot, entryDir: path.dirname(entryPath), entryPath, guard, progress, bound, augmentations };
     try {
         resolved = ownerGroups && emitProject
             ? resolveAnchorsByOwner(opts, ownerGroups, emitProject, analysisCtx, errors)
@@ -275,8 +279,8 @@ export function captureStub(opts) {
     catch (err) {
         return fail(stubDir, packageName, [err instanceof Error ? err.message : String(err)]);
     }
-    // ---- Augmentation detection over the tsconfig's full file list ----
-    const augmentationSources = [...new Set([...findAugmentationFiles(parsed.fileNames.filter((f) => !f.includes(`${path.sep}node_modules${path.sep}`))), ...(deno?.globals ?? [])])];
+    // ---- Augmentation files of the project that emits the surface ----
+    const augmentationSources = [...new Set([...augmentations(parsed), ...(deno?.globals ?? [])])];
     // ---- Phase B: declaration emit of the final entry ----
     const entryLines = ['// Generated by Carrick capture v2. Deleted after emit.'];
     for (const anchor of resolved) {
@@ -706,6 +710,27 @@ function programHost(options, deno, bound) {
         return deno?.host(options);
     return boundedCompilerHost(deno ? deno.host(options) : ts.createCompilerHost(options), bound);
 }
+/**
+ * The files a project's config lists that declare a module or global
+ * augmentation, for one capture: each project's list is read from disk once,
+ * however many programs are built over it.
+ *
+ * A project's own compile holds these files whether or not anything imports
+ * them, so a program that stands in for that compile must hold them too. A
+ * file under `node_modules` is the package's business, and a file outside the
+ * read bound is not opened, not even to look for the declaration.
+ */
+function augmentationReader(bound) {
+    const byProject = new Map();
+    return (parsed) => {
+        let files = byProject.get(parsed);
+        if (!files) {
+            files = findAugmentationFiles(parsed.fileNames.filter((f) => !f.includes(`${path.sep}node_modules${path.sep}`) && (!bound || bound.allows(f))));
+            byProject.set(parsed, files);
+        }
+        return files;
+    };
+}
 /** Phase A: build the placeholder entry, then resolve every anchor. */
 function resolveAnchors(opts, parsed, ctx, deno) {
     const placeholderLines = ['// Carrick capture v2 analysis placeholder.'];
@@ -723,7 +748,12 @@ function resolveAnchors(opts, parsed, ctx, deno) {
             ...parsed.options,
             noEmit: true,
         });
-        const program = ts.createProgram([ctx.entryPath, ...anchorSources, ...(deno?.globals ?? [])], options, programHost(options, deno, ctx.bound));
+        // The project's augmentation files are roots: its own compile reads a
+        // member one of them declares wherever the member is read, imported or not.
+        const rootNames = [
+            ...new Set([ctx.entryPath, ...anchorSources, ...ctx.augmentations(parsed), ...(deno?.globals ?? [])]),
+        ];
+        const program = ts.createProgram(rootNames, options, programHost(options, deno, ctx.bound));
         // The checker binds every file of the program when it is first asked for,
         // which the first anchor would otherwise do: asked for here, so that the
         // report below says the program is whole before any anchor is read.
@@ -780,4 +810,4 @@ function resolveAnchors(opts, parsed, ctx, deno) {
 }
 // carrick#1841: the response-table reading the inferrer and the v1 bundle
 // share with the capture's symbol anchor.
-export { classifyStatusCodes, constituents, httpStatus, statesNoBody, statusKeyCode, statusTableBody, statusTableOf, successEntries, } from './status-table.js';
+export { classifyStatusCodes, constituents, httpStatus, statesNoBody, statesNoShape, statusKeyCode, statusTableBody, statusTableOf, successEntries, } from './status-table.js';

package/sidecar/dist/src/capture/status-table.d.ts

@@ -44,6 +44,23 @@ export declare function successEntries(entries: StatusTableEntry[]): StatusTable
  * made only of them. A `204: void` row is such a body.
  */
 export declare function statesNoBody(type: ts.Type): boolean;
+/**
+ * Whether a payload type states no shape (carrick#2116): at its root, or as
+ * a member of its root union, it is
+ *
+ *  - the checker's own empty object type, which is what narrowing `unknown`
+ *    yields (`if (cached != null) return cached`). It has no property, no
+ *    signature, no index signature and, unlike every `{}` the source writes,
+ *    no symbol: an empty object literal carries `__object`, a declared `{}`
+ *    carries `__type`, an empty interface carries its own; or
+ *  - the `object` keyword type.
+ *
+ * Printed, the first reads `{}` like an empty object a handler really sends,
+ * so only the source program can tell them apart. A reader answers `unknown`
+ * for such a type, as it does for one that is `unknown` at its root. A
+ * member's own type is not looked at: `meta: {}` stays a member.
+ */
+export declare function statesNoShape(checker: ts.TypeChecker, type: ts.Type): boolean;
 /**
  * What a response table's success rows carry, read for a consumer:
  *  - `body`: the 2xx rows' value types, at least one of which states a body;

package/sidecar/dist/src/capture/status-table.js

@@ -81,6 +81,32 @@ export function statesNoBody(type) {
     const members = type.isUnion() ? type.types : [type];
     return members.every((member) => (member.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never)) !== 0);
 }
+/**
+ * Whether a payload type states no shape (carrick#2116): at its root, or as
+ * a member of its root union, it is
+ *
+ *  - the checker's own empty object type, which is what narrowing `unknown`
+ *    yields (`if (cached != null) return cached`). It has no property, no
+ *    signature, no index signature and, unlike every `{}` the source writes,
+ *    no symbol: an empty object literal carries `__object`, a declared `{}`
+ *    carries `__type`, an empty interface carries its own; or
+ *  - the `object` keyword type.
+ *
+ * Printed, the first reads `{}` like an empty object a handler really sends,
+ * so only the source program can tell them apart. A reader answers `unknown`
+ * for such a type, as it does for one that is `unknown` at its root. A
+ * member's own type is not looked at: `meta: {}` stays a member.
+ */
+export function statesNoShape(checker, type) {
+    const members = type.isUnion() ? type.types : [type];
+    return members.some((member) => (member.flags & ts.TypeFlags.NonPrimitive) !== 0 ||
+        ((member.flags & ts.TypeFlags.Object) !== 0 &&
+            member.symbol === undefined &&
+            checker.getPropertiesOfType(member).length === 0 &&
+            checker.getSignaturesOfType(member, ts.SignatureKind.Call).length === 0 &&
+            checker.getSignaturesOfType(member, ts.SignatureKind.Construct).length === 0 &&
+            checker.getIndexInfosOfType(member).length === 0));
+}
 /**
  * What a response table's success rows carry, read for a consumer:
  *  - `body`: the 2xx rows' value types, at least one of which states a body;

package/sidecar/dist/src/index.js

@@ -322,7 +322,7 @@ function handleInfer(request) {
         const results = [...byProject(request.requests, (item) => item.file_path)].map(([key, items]) => projectComponents(key).typeInferrer.infer(items, request.extraction_config, () => {
             done += 1;
             report();
-        }));
+        }, request.model_symbols));
         const result = results.length === 1
             ? results[0]
             : (() => {