carrick 0.3.105 → 0.3.106

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.105",
+  "version": "0.3.106",
   "description": "Maps your entire TypeScript codebase across services and repositories, giving AI agents full context on existing types, routes, and function behaviours over MCP before they write duplicate or breaking code.",
   "keywords": [
     "typescript",
@@ -58,11 +58,11 @@
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.105",
-    "@carrick-tools/cli-darwin-x64": "0.3.105",
-    "@carrick-tools/cli-linux-arm64": "0.3.105",
-    "@carrick-tools/cli-linux-x64": "0.3.105",
-    "@carrick-tools/cli-win32-x64": "0.3.105"
+    "@carrick-tools/cli-darwin-arm64": "0.3.106",
+    "@carrick-tools/cli-darwin-x64": "0.3.106",
+    "@carrick-tools/cli-linux-arm64": "0.3.106",
+    "@carrick-tools/cli-linux-x64": "0.3.106",
+    "@carrick-tools/cli-win32-x64": "0.3.106"
   },
   "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.105",
+  "version": "0.3.106",
   "author": {
     "name": "Carrick",
     "email": "hello@carrick.tools"

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

@@ -73,6 +73,13 @@ export declare function resolveAnchor(program: ts.Program, request: CaptureAncho
      * these resolves through that module instead of dangling in the entry.
      */
     siblingSymbolSpecs?: Map<string, string>;
+    /**
+     * The file a module specifier resolves to from the surface entry, under
+     * the analysis program's own resolution (carrick#1789). A literal's name
+     * is imported through a package specifier only when the entry reaches the
+     * same module by it.
+     */
+    resolveFromEntry?: (specifier: string) => string | undefined;
 }): ResolvedAnchor;
 /**
  * Locate the target node: tightest expression covering the byte span when

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

@@ -8,6 +8,8 @@ import ts from 'typescript';
 import * as path from 'node:path';
 import { printTypeForDestination, substituteUndeclaredNames, undeclaredNamesIn, } from './node-builder.js';
 import { typeIsOrContainsMachinery } from './machinery.js';
+import { installedPackageSpecifier } from './installed-package.js';
+import { realPath } from './service-config.js';
 import { unresolvedAtAnchor, unresolvedSpecifiersReachableFrom, } from './unresolved.js';
 /** Repo-root-relative source file -> extensionless specifier from entryDir. */
 export function entryRelativeSpecifier(entryDir, repoRoot, sourceFile) {
@@ -56,10 +58,13 @@ export function resolveAnchor(program, request, args) {
         // sibling symbol anchor imports is resolved by that import.
         // carrick#1774: the text names types as they read where it was printed,
         // so a name its source file means by a repo module's export is imported
-        // from that module (a string-union alias printed bare read `any`).
+        // from that module (a string-union alias printed bare read `any`), and
+        // (carrick#1789) a name it imports from a package is imported from that
+        // package. carrick#1836: a name the source file cannot see is imported
+        // from the module the inference recorded it was printed for.
         const scoped = siblingSpec
             ? undefined
-            : qualifyNamesFromSource(text, program, request.source_file, args);
+            : qualifyNamesFromSource(text, program, request.source_file, request.printed_names, args);
         const scopedText = scoped ?? text;
         // carrick#1377: rewrite what nothing declares to `unknown` in place, so
         // one member typed by a module the checkout does not have stops taking
@@ -390,15 +395,25 @@ function substituteUndeclaredNamesInText(text, program, destination) {
  * member that reads `any`) or a global of the same name (`Notification`).
  * Each reference whose name the source resolves to a type that a module
  * inside the repo exports becomes `import('<module>').<export>`, with its
- * qualifier and type arguments kept. Anything else is left as written: a
- * global, a name only a function body declares, an unexported local, and a
- * type declared outside the repo or under `node_modules`, which the stub does
- * not ship.
+ * qualifier and type arguments kept. A name the source imports from an
+ * installed package becomes `import('<package specifier>').<export>`
+ * (carrick#1789): the stub ships no `node_modules`, but it pins the packages
+ * its surface imports, and the check phase installs them. Anything else is
+ * left as written: a global, a name only a function body declares, an
+ * unexported local, and a type declared outside the repo that no package
+ * import reaches.
+ *
+ * carrick#1836: a name the source file cannot see at all was printed without
+ * its scope (the inferrer's structural printer writes names bare). When the
+ * inference recorded one declaration for it (`printed`), the name is imported
+ * from that declaration's module, under the same repo rule. A name recorded
+ * for two declarations is left as written: the text no longer says which one
+ * a position meant.
  *
  * Returns the rewritten text, or undefined when nothing was rewritten, so a
  * text with no such name stays byte-identical.
  */
-function qualifyNamesFromSource(text, program, sourceFileRel, args) {
+function qualifyNamesFromSource(text, program, sourceFileRel, printed, args) {
     if (!sourceFileRel)
         return undefined;
     const source = program.getSourceFile(path.join(args.repoRoot, sourceFileRel));
@@ -415,6 +430,14 @@ function qualifyNamesFromSource(text, program, sourceFileRel, args) {
         ts.forEachChild(node, collect);
     };
     collect(parsed);
+    const specOf = (file) => {
+        const rel = path.relative(args.repoRoot, file.fileName);
+        if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+            return undefined;
+        if (rel.split(path.sep).includes('node_modules'))
+            return undefined;
+        return entryRelativeSpecifier(args.entryDir, args.repoRoot, rel.split(path.sep).join('/'));
+    };
     const imports = new Map();
     const importFor = (name) => {
         if (imports.has(name))
@@ -423,12 +446,8 @@ function qualifyNamesFromSource(text, program, sourceFileRel, args) {
         const atSource = checker.resolveName(name, source, meaning, false);
         const target = atSource && resolveSymbolAliases(checker, atSource);
         const declaringFile = target?.declarations?.[0]?.getSourceFile();
-        const rel = declaringFile && path.relative(args.repoRoot, declaringFile.fileName);
-        if (target &&
-            declaringFile &&
-            rel &&
-            !rel.startsWith('..') &&
-            !rel.split(path.sep).includes('node_modules')) {
+        const spec = declaringFile && specOf(declaringFile);
+        if (target && declaringFile && spec) {
             const moduleSymbol = checker.getSymbolAtLocation(declaringFile);
             const exported = moduleSymbol
                 ? checker
@@ -436,28 +455,46 @@ function qualifyNamesFromSource(text, program, sourceFileRel, args) {
                     .filter((candidate) => resolveSymbolAliases(checker, candidate) === target)
                 : [];
             const chosen = exported.find((candidate) => candidate.getName() === name) ?? exported[0];
-            if (chosen) {
-                found = {
-                    spec: entryRelativeSpecifier(args.entryDir, args.repoRoot, rel.split(path.sep).join('/')),
-                    exportName: chosen.getName(),
-                };
-            }
+            if (chosen)
+                found = { spec, exportPath: [chosen.getName()] };
         }
+        if (!found && atSource)
+            found = packageImportOf(program, atSource, args.resolveFromEntry);
+        if (!found && !atSource)
+            found = printedImportOf(program, name, printed, specOf);
         imports.set(name, found);
         return found;
     };
     const leftmost = (name) => ts.isIdentifier(name) ? name : leftmost(name.left);
-    const renameLeftmost = (name, to) => ts.isIdentifier(name)
-        ? ts.factory.createIdentifier(to)
-        : ts.factory.createQualifiedName(renameLeftmost(name.left, to), name.right);
+    const entityName = (parts) => parts
+        .slice(1)
+        .reduce((left, part) => ts.factory.createQualifiedName(left, part), ts.factory.createIdentifier(parts[0]));
+    const replaceLeftmost = (name, to) => ts.isIdentifier(name)
+        ? entityName(to)
+        : ts.factory.createQualifiedName(replaceLeftmost(name.left, to), name.right);
+    const dropLeftmost = (name) => ts.isIdentifier(name.left)
+        ? name.right
+        : ts.factory.createQualifiedName(dropLeftmost(name.left), name.right);
+    // What follows `import('<spec>')`: the export path, then the reference's
+    // own qualifier. Through a namespace import the namespace's name goes, and
+    // the next name must be something the package exports.
+    const qualifierFor = (typeName, target) => {
+        if ('exportPath' in target)
+            return replaceLeftmost(typeName, target.exportPath);
+        if (ts.isIdentifier(typeName))
+            return undefined;
+        const qualifier = dropLeftmost(typeName);
+        return target.namespaceExports.has(leftmost(qualifier).text) ? qualifier : undefined;
+    };
     let rewrites = 0;
     const rewrite = (node) => {
         if (ts.isTypeReferenceNode(node)) {
             const name = leftmost(node.typeName).text;
             const target = typeParameters.has(name) ? undefined : importFor(name);
-            if (target) {
+            const qualifier = target && qualifierFor(node.typeName, target);
+            if (target && qualifier) {
                 rewrites += 1;
-                return ts.factory.createImportTypeNode(ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(target.spec)), undefined, renameLeftmost(node.typeName, target.exportName), node.typeArguments?.map((argument) => rewrite(argument)), false);
+                return ts.factory.createImportTypeNode(ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(target.spec)), undefined, qualifier, node.typeArguments?.map((argument) => rewrite(argument)), false);
             }
         }
         return ts.visitEachChild(node, rewrite, /* context */ undefined);
@@ -469,6 +506,96 @@ function qualifyNamesFromSource(text, program, sourceFileRel, args) {
         .createPrinter({ removeComments: true })
         .printNode(ts.EmitHint.Unspecified, rewritten, parsed.getSourceFile());
 }
+/**
+ * carrick#1789: how the surface entry imports `local`, a name the source file
+ * binds with an import from an installed package, or undefined.
+ *
+ * The entry names the module the source's import resolves to by its file
+ * path, as the node builder names a library type it cannot reach by a bare
+ * specifier; the post-emit rewrite turns that path into the package's bare
+ * specifier and pins the installed version (`installedPackageSpecifier`). A
+ * bare specifier in the entry itself would be resolved from the entry: on a
+ * Deno service that goes through the graph's virtual `node_modules`, and the
+ * emitter then reads the package there, cannot name its types from the
+ * service's own modules (TS2742), and skips their declarations.
+ *
+ * Kept only when the module lies inside an installed package and the bare
+ * specifier that package gives resolves from the entry to the same file. So
+ * a tsconfig path alias to the repo's own module, a workspace package linked
+ * from the repo (no installed copy to pin), and an import of another
+ * installed copy than the entry reaches all stay as written.
+ */
+function packageImportOf(program, local, resolveFromEntry) {
+    if (!resolveFromEntry || !(local.flags & ts.SymbolFlags.Alias))
+        return undefined;
+    const declaration = local.declarations?.[0];
+    let statement;
+    let exportName;
+    if (declaration && ts.isImportSpecifier(declaration)) {
+        // `import { "a-b" as name }` has no qualifier an import type can write.
+        const exported = declaration.propertyName ?? declaration.name;
+        if (!ts.isIdentifier(exported))
+            return undefined;
+        statement = declaration.parent.parent.parent;
+        exportName = exported.text;
+    }
+    else if (declaration && ts.isImportClause(declaration)) {
+        statement = declaration.parent;
+        exportName = 'default';
+    }
+    else if (declaration && ts.isNamespaceImport(declaration)) {
+        statement = declaration.parent.parent;
+    }
+    else {
+        return undefined;
+    }
+    if (!ts.isImportDeclaration(statement))
+        return undefined;
+    const checker = program.getTypeChecker();
+    const moduleSymbol = checker.getSymbolAtLocation(statement.moduleSpecifier);
+    const moduleFile = moduleSymbol?.declarations?.find(ts.isSourceFile);
+    if (!moduleSymbol || !moduleFile)
+        return undefined;
+    const installed = installedPackageSpecifier(moduleFile.fileName, exportName);
+    const fromEntry = installed && resolveFromEntry(installed.specifier);
+    if (!fromEntry || realPath(fromEntry) !== realPath(moduleFile.fileName))
+        return undefined;
+    const spec = moduleFile.fileName;
+    const exported = new Set(checker.getExportsOfModule(moduleSymbol).map((symbol) => symbol.getName()));
+    if (exportName === undefined)
+        return { spec, namespaceExports: exported };
+    return exported.has(exportName) ? { spec, exportPath: [exportName] } : undefined;
+}
+/**
+ * carrick#1836: the import for `name` from the one declaration the inference
+ * recorded printing it for, or undefined.
+ *
+ * Undefined when the name was recorded for no declaration or for several,
+ * when the recorded module is not in this program or not inside the repo
+ * (`specOf`), and when its export path does not lead to a type there: a record
+ * that does not check out names nothing, and the text stays as written.
+ */
+function printedImportOf(program, name, printed, specOf) {
+    const recorded = (printed ?? []).filter((entry) => entry.name === name);
+    const identities = new Set(recorded.map((entry) => `${entry.file}\0${entry.export_path.join('.')}`));
+    if (identities.size !== 1)
+        return undefined;
+    const entry = recorded[0];
+    const declaring = program.getSourceFile(entry.file);
+    const spec = declaring && specOf(declaring);
+    if (!declaring || !spec)
+        return undefined;
+    const checker = program.getTypeChecker();
+    let current = checker.getSymbolAtLocation(declaring);
+    for (const part of entry.export_path) {
+        const next = current && checker.getExportsOfModule(current).find((s) => s.getName() === part);
+        current = next && resolveSymbolAliases(checker, next);
+    }
+    if (!current || !(current.flags & (ts.SymbolFlags.Type | ts.SymbolFlags.Namespace))) {
+        return undefined;
+    }
+    return { spec, exportPath: entry.export_path };
+}
 /** The type node of `type __LiteralAnchor = <text>;`, or undefined. */
 function parseLiteralAnchor(text) {
     const parsed = ts.createSourceFile('literal-anchor.ts', `type __LiteralAnchor = ${text};`, ts.ScriptTarget.Latest, true);

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

@@ -71,6 +71,36 @@ export interface LiteralAnchorRequest {
      * record's `source_file` stays `<inline>`: the answer is still the text.
      */
     source_file?: string;
+    /**
+     * carrick#1836: what the text's bare names meant where they were printed,
+     * for the names `source_file` cannot resolve. A name listed once is
+     * imported from the module that declares it; a name listed for two
+     * declarations is left as written.
+     */
+    printed_names?: PrintedName[];
+    /**
+     * carrick#1842: the text is a body the call site reads as raw text. Copied
+     * onto the alias's record, where the check phase reads it.
+     */
+    raw_text_read?: true;
+}
+/**
+ * The declaration a bare name in printed type text meant (carrick#1836).
+ *
+ * The v1 inferrer prints some types with no enclosing declaration, and that
+ * print writes every named type by its bare name, whether or not the file the
+ * request names can see it. The compiler knew the symbol when it printed the
+ * name; this is that symbol, recorded as the module that declares it and the
+ * export path that reaches it there (`['Status']`, or `['Billing', 'Kind']`
+ * for a namespace member printed as `Kind`).
+ */
+export interface PrintedName {
+    /** The name as the text prints it: the leftmost part of a reference. */
+    name: string;
+    /** Absolute path of the module that declares it. */
+    file: string;
+    /** Export names from that module down to the declaration. */
+    export_path: string[];
 }
 /**
  * Addressable handler: `export type A = Awaited<ReturnType<typeof
@@ -152,7 +182,10 @@ export type SelfCheckOutcome = 'ok' | 'allowlisted_external' | 'decayed_internal
  *    contract.
  *  - `machinery_envelope`: the return resolved to transport (a
  *    Response/Request-shaped envelope) and no payload was recoverable inside
- *    it or from the handler's returned arguments.
+ *    it or from the handler's returned arguments. On a consumer call result it
+ *    is a decided abstain: what the call's result carrier holds is transport
+ *    the service's wrapper rules verify and read no payload out of, such as a
+ *    request library's own response object (carrick#1841).
  *  - `coerced_input`: a request schema's INPUT is `any`/`unknown` at this
  *    position while its parsed output is concrete, which is what a coercion
  *    declares (carrick#1101). The published type carries the output there, so
@@ -271,6 +304,14 @@ export interface CaptureAliasRecord {
      * entry's other provenance. Absent when every position resolves.
      */
     unresolved_in_tree?: TypeProvenance[];
+    /**
+     * carrick#1842: the alias is a body its call site reads as raw text, from
+     * the literal anchor that published it. The check phase reads a pair with
+     * this on either side unverifiable: raw text states no structural contract,
+     * whether or not the other side's type assigns to `string`. Absent
+     * otherwise, and absent on every record a release before this one stored.
+     */
+    raw_text_read?: true;
 }
 /** Aggregate fidelity metric, emitted per capture (one service). */
 export interface CaptureFidelity {

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

@@ -13,6 +13,7 @@
  *   IsVoid gate fired (TS2344)            -> unverifiable (no body read)
  *   IsFormBody gate fired (TS2344)        -> unverifiable (form-encoded body)
  *   IsByteBody gate fired (TS2344)        -> unverifiable (bytes, even agreeing)
+ *   raw-text read marked on a side        -> unverifiable (text, even agreeing)
  *   assignment-class error                -> incompatible
  *   no diagnostics                        -> compatible     [lowest precedence]
  *
@@ -23,7 +24,7 @@
  * Seam: node builtins + this bundle only.
  */
 import type { CheckVerdict } from './api.js';
-import { type ProbePlan } from './check-probe.js';
+import { type ProbePlan, type Side } from './check-probe.js';
 import { type ScrubContext } from './check-scrub.js';
 import type { PairDeepFindings } from './check-deep.js';
 import { type PairFieldReport } from './check-fields.js';
@@ -65,6 +66,13 @@ export interface ClassifyInput {
      * run, in which case the tsc text stands alone.
      */
     fieldReport?: PairFieldReport;
+    /**
+     * The side whose capture record says it reads the body as raw text
+     * (carrick#1842), the sent side when both do. Read from the record, not the
+     * type: a text read publishes `string`, which no type gate can tell from a
+     * JSON body that is a string.
+     */
+    rawTextSide?: Side;
 }
 /** Classify one pair into exactly one bucket, honouring the precedence order. */
 export declare function classifyPair(input: ClassifyInput): CheckVerdict;

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

@@ -13,6 +13,7 @@
  *   IsVoid gate fired (TS2344)            -> unverifiable (no body read)
  *   IsFormBody gate fired (TS2344)        -> unverifiable (form-encoded body)
  *   IsByteBody gate fired (TS2344)        -> unverifiable (bytes, even agreeing)
+ *   raw-text read marked on a side        -> unverifiable (text, even agreeing)
  *   assignment-class error                -> incompatible
  *   no diagnostics                        -> compatible     [lowest precedence]
  *
@@ -194,6 +195,20 @@ export function classifyPair(input) {
             ...notAFact(`the ${side} body is bytes`, side),
         };
     }
+    // 4d. A body read as raw text (carrick#1842): a `.text()` read, or a request
+    //     library's text format, takes the body unparsed, so `string` there
+    //     states no structural contract. Like bytes, the pair is not compared,
+    //     whether or not the other side's type assigns to `string`.
+    if (input.rawTextSide && plan.spec.protocol === 'http') {
+        const side = input.rawTextSide;
+        return {
+            ...base,
+            bucket: 'unverifiable',
+            gate: `${side}:text`,
+            diagnostic: `the ${side} reads the body as raw text, which has no JSON shape to compare with the other side.`,
+            ...notAFact(`the ${side} reads the body as raw text`, side),
+        };
+    }
     // 5. Assignment-class error on the DECISIVE assignment line -> incompatible.
     //
     // On an `http` pair that line is the JSON wire assignment, not the declared

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

@@ -158,7 +158,8 @@ export async function runCheck(opts, onProgress) {
         const spec = opts.pairs.find((p) => p.pair_key === v.pair_key);
         v.pair_id = fnvOfSpec(spec);
     }
-    const { preGated, probing } = preGate(plans, readStubAliasRecords(opts.stubs));
+    const aliasRecords = readStubAliasRecords(opts.stubs);
+    const { preGated, probing } = preGate(plans, aliasRecords);
     writeProbes(ws, probing);
     const errors = [];
     const degraded = [];
@@ -269,6 +270,7 @@ export async function runCheck(opts, onProgress) {
             scrubCtx,
             deepFindings: deepByPair.get(plan.pairId),
             fieldReport: fieldsByPair.get(plan.pairId),
+            rawTextSide: rawTextSideOf(plan, aliasRecords),
         })),
         ...preGated,
         ...unresolved,
@@ -355,6 +357,16 @@ function preGate(plans, aliasRecords) {
     }
     return { preGated, probing };
 }
+/**
+ * The side whose capture record marks its body as read raw (carrick#1842):
+ * the sent side when both are, as the bytes gate names it.
+ */
+function rawTextSideOf(plan, aliasRecords) {
+    return [plan.direction.sent, plan.direction.expected].find((side) => {
+        const endpoint = plan.spec[side];
+        return aliasRecords.get(endpoint.service_name)?.get(endpoint.alias)?.raw_text_read === true;
+    });
+}
 /** First side (producer, then consumer) whose capture recorded a deep decay. */
 function deepDecayOf(plan, aliasRecords) {
     for (const side of ['producer', 'consumer']) {

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

@@ -671,11 +671,19 @@ function resolveAnchors(opts, parsed, ctx, deno) {
                 siblingSymbolSpecs.set(anchor.symbol_name, entryRelativeSpecifier(ctx.entryDir, ctx.repoRoot, anchor.source_file));
             }
         }
+        // A module specifier as the entry resolves it, under the program's own
+        // resolution (the Deno graph's, for a Deno service).
+        const entryMode = entrySource?.impliedNodeFormat;
+        const resolveFromEntry = (specifier) => (deno
+            ? deno.resolve(specifier, ctx.entryPath, options)
+            : ts.resolveModuleName(specifier, ctx.entryPath, options, ts.sys, undefined, undefined, entryMode)
+                .resolvedModule)?.resolvedFileName;
         return opts.anchors.map((request) => resolveAnchor(program, request, {
             repoRoot: ctx.repoRoot,
             entryDir: ctx.entryDir,
             placeholder: placeholders.get(request.alias),
             siblingSymbolSpecs,
+            resolveFromEntry,
         }));
     }
     finally {

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

@@ -247,6 +247,13 @@ function buildSurfaceSpanIndex(surfaceSource) {
         return spans.find((span) => position >= span.start && position <= span.end)?.alias;
     };
 }
+/**
+ * carrick#1842: a literal anchor whose text is a body read as raw text passes
+ * that mark to its record, where the check phase reads it.
+ */
+function rawTextMark(request) {
+    return request.kind === 'literal' && request.raw_text_read ? { raw_text_read: true } : {};
+}
 /** An alias that never reached a capture-native tier: the failure reason was
  * recorded at demotion time; the surface line is `unknown` by construction. */
 function demotedRecord(anchor) {
@@ -267,6 +274,7 @@ function demotedRecord(anchor) {
         ...(anchor.request.kind === 'literal' && anchor.namesUnemittedModule
             ? { unresolved_in_tree: [unemittedModuleProvenance()] }
             : {}),
+        ...rawTextMark(anchor.request),
     };
 }
 function checkedRecord(anchor, ctx) {
@@ -448,6 +456,7 @@ function checkedRecord(anchor, ctx) {
                     .map((p) => unresolvedInTreeProvenance(p, [...unfoundNames].sort())),
             }
             : {}),
+        ...rawTextMark(anchor.request),
     };
 }
 /** Resolve a relative specifier from `fromAbs` to a tree file, if present. */

package/sidecar/dist/src/capture/service-config.d.ts

@@ -17,3 +17,5 @@
  */
 /** Absolute path of the config that types the service, or undefined for none. */
 export declare function findServiceTsconfig(serviceRoot: string, scanRoot?: string): string | undefined;
+/** The path with every symlink resolved; the path as given when it does not exist. */
+export declare function realPath(p: string): string;

package/sidecar/dist/src/capture/service-config.js

@@ -47,7 +47,7 @@ export function findServiceTsconfig(serviceRoot, scanRoot) {
     return undefined;
 }
 /** The path with every symlink resolved; the path as given when it does not exist. */
-function realPath(p) {
+export function realPath(p) {
     try {
         return fs.realpathSync(p);
     }

package/sidecar/dist/src/failure-path.d.ts

@@ -20,17 +20,48 @@
  * any other condition lets everything through. A node is on the failure path
  * only when NO status in 200-299 can reach it.
  *
- * That is deliberately stricter than the retype check's reading of a status
- * test (`okWhenTrue` in retype.ts), which reads the false side of
- * `res.status === 200` as the failure path so it can find a success read to
+ * The retype check (retype.ts) reads the same tests through `testsOnPath` and
+ * keeps its own policy on top: it also reads the false side of
+ * `res.status === 200` as the failure path, so it can find a success read to
  * judge. Here a decided failure REMOVES a read, so the reading has to be sound
  * the other way round: after `if (res.status === 204) return null`, 200 still
  * gets through, and the json read that follows is the payload.
  */
 import { Node } from 'ts-morph';
+/** A set of HTTP statuses, as the predicate that admits them. */
+export type Statuses = (status: number) => boolean;
+/** The statuses `ok` is true for. */
+export declare const SUCCEEDED: Statuses;
+/** The statuses from 100 to 599 that `statuses` admits, in order. */
+export declare function statusesIn(statuses: Statuses): number[];
+/** One test of the response on the path to a node, as the side the node is on. */
+export interface SideTaken {
+    /** Every status that can take this side, and maybe more (see `inexact`). */
+    admits: Statuses;
+    /**
+     * The test reads the response's `ok` or `status` in a form this reading
+     * cannot follow (`res.status === OK`, `codes.includes(res.status)`), or
+     * combines it with a condition that is not about the response
+     * (`res.ok && fresh`). `admits` then lets through more statuses than the
+     * side does: still sound for "no success status reaches the node", but no
+     * longer only the statuses the source singled out.
+     */
+    inexact: boolean;
+}
 /**
  * True when the source reaches `node` only after the response named by
  * `isResponse` failed. The walk climbs from `node` to `boundary` (the function
  * the call sits in) and never looks at a test outside it.
  */
 export declare function reachedOnlyOnFailure(node: Node, boundary: Node, isResponse: (node: Node) => boolean): boolean;
+/**
+ * Each test of the response on the path from `node` up to `boundary` (the
+ * whole file when it is `undefined`), as the side `node` is on: a branch of
+ * an `if` or a conditional expression it sits in, or an earlier `if` in an
+ * enclosing block one of whose branches cannot complete, which leaves the
+ * rest of the block to the other side. A test that does not read the
+ * response's `ok` or `status` is not listed.
+ */
+export declare function testsOnPath(node: Node, boundary: Node | undefined, isResponse: (node: Node) => boolean): SideTaken[];
+/** `node` reads the response's `ok` or `status`, itself or anywhere inside it. */
+export declare function readsResponseStatus(node: Node, isResponse: (node: Node) => boolean): boolean;