carrick 0.3.127 → 0.3.129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.127",
+  "version": "0.3.129",
   "carrickCache": {
     "cache_version": 22,
     "intent_cache_version": 2
@@ -113,11 +113,11 @@
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.127",
-    "@carrick-tools/cli-darwin-x64": "0.3.127",
-    "@carrick-tools/cli-linux-arm64": "0.3.127",
-    "@carrick-tools/cli-linux-x64": "0.3.127",
-    "@carrick-tools/cli-win32-x64": "0.3.127"
+    "@carrick-tools/cli-darwin-arm64": "0.3.129",
+    "@carrick-tools/cli-darwin-x64": "0.3.129",
+    "@carrick-tools/cli-linux-arm64": "0.3.129",
+    "@carrick-tools/cli-linux-x64": "0.3.129",
+    "@carrick-tools/cli-win32-x64": "0.3.129"
   },
   "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.127",
+  "version": "0.3.129",
   "author": {
     "name": "Carrick",
     "email": "hello@carrick.tools"

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

@@ -1093,9 +1093,13 @@ function paramLocatorHints(request) {
  * node unchanged. The mirror of the v1 inferrer's `unwrapJsonStringifyArg`:
  * the global serialiser is identified by the standard `JSON` object, the one
  * name every runtime shares.
+ *
+ * carrick#2010: a property whose value is the serialiser call (`body:
+ * JSON.stringify(...)`, the node the line fallback prefers on that line) is
+ * read through to the call, and so to its argument.
  */
 function serialisedArgument(node) {
-    let current = node;
+    let current = ts.isPropertyAssignment(node) ? node.initializer : node;
     while (ts.isParenthesizedExpression(current))
         current = current.expression;
     if (ts.isCallExpression(current) &&

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

@@ -17,7 +17,9 @@
  *   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)
+ *   reading does not repeat               -> producer_wider (carrick#1538),
+ *                                            or compatible with a note when
+ *                                            the consumer sends (carrick#2011)
  *   assignment-class error                -> incompatible
  *   no diagnostics                        -> compatible     [lowest precedence]
  *
@@ -87,3 +89,8 @@ export interface ClassifyInput {
 }
 /** Classify one pair into exactly one bucket, honouring the precedence order. */
 export declare function classifyPair(input: ClassifyInput): CheckVerdict;
+/**
+ * The note on a request the consumer's unwidened reading cleared
+ * (carrick#2011).
+ */
+export declare const CONSUMER_WIDER_NOTE: string;

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

@@ -17,7 +17,9 @@
  *   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)
+ *   reading does not repeat               -> producer_wider (carrick#1538),
+ *                                            or compatible with a note when
+ *                                            the consumer sends (carrick#2011)
  *   assignment-class error                -> incompatible
  *   no diagnostics                        -> compatible     [lowest precedence]
  *
@@ -277,7 +279,19 @@ export function classifyPair(input) {
     //     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.
+    //     carrick#2011: the same for a request body, where the consumer sends
+    //     and its body was read with the literals the call writes kept. A
+    //     consumer has no class of its own on the wire, so the pair is the
+    //     compatible it is, and a note says the published type is wider.
     if (assignDiag && unwidenedReadingFits(input)) {
+        if (plan.direction.sent === 'consumer') {
+            return {
+                ...base,
+                bucket: 'compatible',
+                notes: [...base.notes, CONSUMER_WIDER_NOTE],
+                ...factness(input),
+            };
+        }
         return { ...base, bucket: 'producer_wider', ...factness(input) };
     }
     if (assignDiag) {
@@ -337,6 +351,12 @@ export function classifyPair(input) {
     // 6. No diagnostics -> compatible.
     return { ...base, bucket: 'compatible', ...factness(input) };
 }
+/**
+ * The note on a request the consumer's unwidened reading cleared
+ * (carrick#2011).
+ */
+export const CONSUMER_WIDER_NOTE = "the consumer's published request type is wider than what the call sends: " +
+    'it widened a literal the call writes, and the values sent fit the producer';
 function onUnwidenedLines(plan, diagnostic) {
     return plan.unwidenedFromLine !== undefined && diagnostic.line >= plan.unwidenedFromLine;
 }

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

@@ -136,11 +136,11 @@ export declare function decisiveAssignmentLine(plan: ProbePlan): number;
  * 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.
+ * `unwidenedAliasFor` answers, for the sending side, the surface export that
+ * carries its unwidened reading, when its stub ships one: a producer's
+ * response (carrick#1538) or a consumer's request body (carrick#2011). The
+ * probe of an `http` pair 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.
  */
-export declare function buildProbe(spec: CheckPairSpec, packageOf: (serviceName: string) => string, unwidenedAliasFor?: (sentProducer: CheckPairEndpoint) => string | undefined): ProbePlan;
+export declare function buildProbe(spec: CheckPairSpec, packageOf: (serviceName: string) => string, unwidenedAliasFor?: (sent: CheckPairEndpoint) => string | undefined): ProbePlan;

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

@@ -126,12 +126,12 @@ export function decisiveAssignmentLine(plan) {
  * 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.
+ * `unwidenedAliasFor` answers, for the sending side, the surface export that
+ * carries its unwidened reading, when its stub ships one: a producer's
+ * response (carrick#1538) or a consumer's request body (carrick#2011). The
+ * probe of an `http` pair 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.
  */
 export function buildProbe(spec, packageOf, unwidenedAliasFor) {
     const id = pairId(spec);
@@ -319,15 +319,14 @@ export function buildProbe(spec, packageOf, unwidenedAliasFor) {
     // 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).
+    // Only an `http` pair gets one: a response the producer sends, or a request
+    // body the consumer sends (carrick#2011), each judged on a decisive
+    // assignment the second reading mirrors, here in the wire form. A GraphQL
+    // pair compares an unwrapped comparand (above), which a plain assignment of
+    // the reading would not mirror. Socket and pub/sub payloads are not read
+    // again.
     let unwidenedFromLine;
-    const sentUnwidenedAlias = direction.sent === 'producer' && spec.protocol === 'http'
-        ? unwidenedAliasFor?.(sentEndpoint)
-        : undefined;
+    const sentUnwidenedAlias = spec.protocol === 'http' ? unwidenedAliasFor?.(sentEndpoint) : undefined;
     if (sentUnwidenedAlias !== undefined) {
         const local = UNWIDENED_LOCAL_NAME;
         unwidenedFromLine = push(`import type { ${sentUnwidenedAlias} as ${local} } from '${sentPkg}';`);

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

@@ -388,17 +388,17 @@ 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
+ * The unwidened reading a sending side's stub ships beside one of its aliases
+ * (carrick#1538, carrick#2011), 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) => {
+    return (sent) => {
         const record = aliasRecords
-            .get(sentProducer.service_name)
-            ?.get(unwidenedAliasOf(sentProducer.alias));
+            .get(sent.service_name)
+            ?.get(unwidenedAliasOf(sent.alias));
         if (!record || record.any_provenance?.length)
             return undefined;
         return record.alias;

package/sidecar/dist/src/index.js

@@ -26,6 +26,7 @@ import { DefinitionResolver } from './definition-resolver.js';
 import { captureStub, findDisqualifyingTopTypes, jsonWireDeclarations, runCheck, } from './capture/index.js';
 import { Retyper } from './retype.js';
 import { LibraryClaimsVerifier, httpCheck } from './library-claims.js';
+import { readServerLabels } from './server-labels.js';
 import { PROGRESS_INTERVAL_MS, atMostEvery } from './progress.js';
 import { mergeInferTimings } from './infer-timing.js';
 import { addProgramFiles, listProgramFiles } from './program-files.js';
@@ -108,6 +109,7 @@ function projectComponents(key = '') {
                 packageDirectoryOf: (file) => loader.packageDirectoryOf(file),
                 resolveModule: (name, from, options) => loader.resolveThroughGraph(name, from, options),
             }),
+            labelledMembers: new Map(),
         };
         components.set(key, built);
     }
@@ -337,10 +339,13 @@ function handleInfer(request) {
         // One count for the request, whichever programs its items span.
         let done = 0;
         const report = atMostEvery(PROGRESS_INTERVAL_MS, () => writeProgress(request.request_id, 'infer', `${done} of ${request.requests.length}`));
-        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 results = [...byProject(request.requests, (item) => item.file_path)].map(([key, items]) => {
+            const built = projectComponents(key);
+            return built.typeInferrer.infer(items, request.extraction_config, () => {
+                done += 1;
+                report();
+            }, request.model_symbols, labelledMembersFor(built, key, items, request.server_claims));
+        });
         const result = results.length === 1
             ? results[0]
             : (() => {
@@ -372,6 +377,40 @@ function handleInfer(request) {
         };
     }
 }
+/**
+ * How long reading one program's server-framework labels may take: as
+ * long as a verify_library_claims request, since the reading builds a
+ * program of its own. Labels it does not reach are not read.
+ */
+const SERVER_CLAIMS_BUDGET_MS = 600_000;
+/** The infer kinds a route row asks: only these read a handler's parameters (carrick#2674). */
+const ROUTE_ROW_KINDS = new Set(['response_body', 'request_body']);
+/**
+ * carrick#2674: the members an `infer` request's server-framework claims
+ * name, verified again in a program of their own beside the inferrer's for
+ * `key` (`readServerLabels`). Undefined when the request carries none, or
+ * the group asks no route row, so the inferrer reads nothing new. Read once
+ * per program and claims.
+ */
+function labelledMembersFor(built, key, items, claims) {
+    if (!claims || claims.checks.length === 0)
+        return undefined;
+    if (!items.some((item) => ROUTE_ROW_KINDS.has(item.infer_kind)))
+        return undefined;
+    const cacheKey = JSON.stringify(claims);
+    let labels = built.labelledMembers.get(cacheKey);
+    if (!labels) {
+        const loader = initializedLoader();
+        labels = readServerLabels({
+            getRepoRoot: () => loader.getRepoRoot(),
+            scriptProjectFor: (owner) => loader.scriptProjectFor(owner),
+            packageDirectoryOf: (file) => loader.packageDirectoryOf(file),
+            resolveModule: (name, from, options) => loader.resolveThroughGraph(name, from, options),
+        }, key, claims, SERVER_CLAIMS_BUDGET_MS, log);
+        built.labelledMembers.set(cacheKey, labels);
+    }
+    return labels;
+}
 /**
  * How long one retype_check request may spend before the items it has not
  * reached abstain: well inside the scanner's 900s read deadline.

package/sidecar/dist/src/library-claims.d.ts

@@ -37,7 +37,25 @@
  */
 import { ts, type Project } from 'ts-morph';
 import { type PackageDirectoryOf } from './position-rows.js';
-import type { LibraryCheck, LibrarySurface, SemanticsCheck, SemanticsModule, SemanticsResult } from './types.js';
+import type { ClaimSlot, LibraryCheck, LibrarySurface, SemanticsCheck, SemanticsModule, SemanticsDeclaration, SemanticsResult } from './types.js';
+/** How one check came out, before it is stamped with its claim and receiver. */
+type Outcome = {
+    verdict: 'verified';
+    declarations?: DeclaredAt[];
+    /**
+     * In-process only, never stamped onto a verdict: the declarations of
+     * the member a verified op calls, and, for a receive op whose
+     * `request` names a `body`, of the member that path ends on
+     * (carrick#2674). Read by `labelledMembers`.
+     */
+    members?: readonly ts.Declaration[];
+    bodyMembers?: readonly ts.Declaration[];
+} | {
+    verdict: 'failed' | 'unchecked';
+    reason: string;
+};
+/** Where a member is declared, spelled as a position row's `decl_file` and `decl_line`. */
+type DeclaredAt = SemanticsDeclaration;
 export interface VerifyResult {
     semantics: SemanticsResult[];
     modules: SemanticsModule[];
@@ -78,7 +96,15 @@ export declare class LibraryClaimsVerifier {
      * A check on an instance or a scope reads the maker or scope claims of the
      * same request first, whatever their place in it.
      */
-    run(fromDir: string, checks: LibraryCheck[], budgetMs: number, scanRoot?: string): VerifyResult;
+    run(fromDir: string, checks: LibraryCheck[], budgetMs: number, scanRoot?: string, options?: RunOptions): VerifyResult;
+    /**
+     * The members a service's server-framework labels name, read with the
+     * verifier itself so only a label that verifies in the service's own
+     * program counts (carrick#2674): each verified `send` op that carries a
+     * `payload` slot, and each verified `receive` op whose `request` names a
+     * `body` path. Other checks are not judged.
+     */
+    labelledMembers(fromDir: string, checks: LibraryCheck[], budgetMs: number, scanRoot?: string, typePackages?: Readonly<Record<string, readonly string[]>>): LabelledMembers;
     /**
      * Each specifier's declared surface, read with the verifier's predicates
      * (carrick#1660): every value export (or only those `only` names for the
@@ -114,7 +140,41 @@ export interface ListedSurface {
  * array of `[package, exports]` for every surface that listed at least one
  * export, sorted by `package` (code unit order). A specifier that lists
  * nothing (unresolved, local, no value exports) is left out, so asking for a
- * subpath a version does not have changes nothing. Type text already names
+ * subpath a version does not have changes nothing. Handler members are not
+ * hashed. Type text already names
  * the request's directory as `<root>`.
  */
 export declare function fullSurfaceSha256(surfaces: readonly LibrarySurface[]): string;
+/** What `run` reads beyond the checks; none of it is part of a verdict. */
+interface RunOptions {
+    /** Called with each check's outcome, in request order. */
+    observe?: (check: LibraryCheck, outcome: Outcome) => void;
+    /** Read server `send` ops as replies (`SERVER_REPLY_RULES`). */
+    readReplies?: boolean;
+    /**
+     * Per package specifier, the type-only packages the store says its surface
+     * re-exports (carrick#2674): a member one of them declares is the
+     * package's own, as the store reads it.
+     */
+    typePackages?: Readonly<Record<string, readonly string[]>>;
+}
+/**
+ * A declaration's key within one process: its file as the compiler names it
+ * and its start. Two programs of one project name a declaration alike, so a
+ * label read in the verifier's probe program joins a member read in the
+ * inferrer's (carrick#2674).
+ */
+export declare function declarationKey(declaration: ts.Node): string;
+/**
+ * The members a service's verified server-framework labels name, by
+ * {@link declarationKey} (carrick#2674): each `send` op member with the slot
+ * its payload sits in, and each member a receive op's `request.body` path
+ * ends on.
+ */
+export interface LabelledMembers {
+    sends: ReadonlyMap<string, ClaimSlot>;
+    bodies: ReadonlySet<string>;
+    /** How each label read came out (`verified`, or the reason it was not), for the log. */
+    outcomes?: Readonly<Record<string, number>>;
+}
+export {};