carrick 0.3.129 → 0.3.131

package/package.json

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

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

@@ -10,7 +10,9 @@
  *   surface import error (probe lines 1-2)-> unverifiable
  *   IsAny gate fired (TS2344)             -> gate_caught_baked_any
  *   IsUnknown/IsNever gate fired (TS2344) -> unverifiable
- *   IsVoid gate fired (TS2344)            -> unverifiable (no body read)
+ *   IsVoid gate fired (TS2344)            -> compatible with a note when the
+ *                                            consumer reads no response body;
+ *                                            else 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)
@@ -94,3 +96,5 @@ export declare function classifyPair(input: ClassifyInput): CheckVerdict;
  * (carrick#2011).
  */
 export declare const CONSUMER_WIDER_NOTE: string;
+/** The note on a pair whose consumer reads no response body (carrick#1162). */
+export declare const CONSUMER_READS_NO_BODY_NOTE = "the consumer reads no response body (its expected response is void), so the producer response is not compared with a read";

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

@@ -10,7 +10,9 @@
  *   surface import error (probe lines 1-2)-> unverifiable
  *   IsAny gate fired (TS2344)             -> gate_caught_baked_any
  *   IsUnknown/IsNever gate fired (TS2344) -> unverifiable
- *   IsVoid gate fired (TS2344)            -> unverifiable (no body read)
+ *   IsVoid gate fired (TS2344)            -> compatible with a note when the
+ *                                            consumer reads no response body;
+ *                                            else 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)
@@ -167,6 +169,21 @@ export function classifyPair(input) {
         .find((name) => name.endsWith(':void') || name.endsWith(':form'));
     if (shapeGate) {
         const { side, kind } = sideForGate(shapeGate, plan);
+        // A call site that reads no response body is compatible with whatever the
+        // producer answers: nothing it does depends on the body. Only the
+        // response direction (http, graphql), where the consumer is the expected
+        // side; a void producer, or a consumer that sends void (a request, a
+        // socket or pub/sub payload), still states no contract. The producer's
+        // own top-type gates fired above, and `factness` still reads the producer
+        // side, so a producer with an `any` inside stays not a fact.
+        if (kind === 'void' && side === 'consumer' && plan.direction.expected === 'consumer') {
+            return {
+                ...base,
+                bucket: 'compatible',
+                notes: [...base.notes, CONSUMER_READS_NO_BODY_NOTE],
+                ...factness(input),
+            };
+        }
         if (kind === 'void') {
             return {
                 ...base,
@@ -357,6 +374,8 @@ export function classifyPair(input) {
  */
 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';
+/** The note on a pair whose consumer reads no response body (carrick#1162). */
+export const CONSUMER_READS_NO_BODY_NOTE = 'the consumer reads no response body (its expected response is void), so the producer response is not compared with a read';
 function onUnwidenedLines(plan, diagnostic) {
     return plan.unwidenedFromLine !== undefined && diagnostic.line >= plan.unwidenedFromLine;
 }

package/sidecar/dist/src/retype.js

@@ -195,6 +195,12 @@ export class Retyper {
             };
         }
         if (declaresTypeParameters(call)) {
+            const inferred = inferredTypeParameterOf(call);
+            if (inferred) {
+                return (`the callee declares several type parameters and '${inferred}' is ` +
+                    `inferred from the arguments, so writing one type argument would turn ` +
+                    `its inference off`);
+            }
             const open = call.getFirstChildByKind(SyntaxKind.OpenParenToken);
             if (!open)
                 return 'the consumer call has no argument list to retype';
@@ -948,6 +954,42 @@ function bodyReadEdit(read) {
         { start: end, end, text: ` as Promise<${stated}>)`, statedAt: ' as Promise<'.length },
     ];
 }
+/**
+ * The name of a type parameter after the first that the call's arguments
+ * infer and whose default would change the call if inference were off, or
+ * `undefined`.
+ *
+ * Writing one type argument makes every other parameter take its default
+ * instead of its inferred type. A parameter the argument list mentions
+ * (`TVariables` in `options: Options<TData, TError, TVariables>`) and whose
+ * default is not `any` or `unknown` then types the argument against the
+ * default (`void`), and the call reports a diagnostic about the written
+ * argument, not about anything the consumer reads. A parameter nothing in the
+ * argument list mentions, or one defaulting to `any`, is unaffected.
+ */
+function inferredTypeParameterOf(call) {
+    const declaration = resolvedDeclaration(call);
+    const typeParameters = declaration?.typeParameters;
+    if (!declaration || !typeParameters || typeParameters.length < 2)
+        return undefined;
+    for (const parameter of typeParameters.slice(1)) {
+        const fallback = parameter.default;
+        if (fallback &&
+            (fallback.kind === ts.SyntaxKind.AnyKeyword || fallback.kind === ts.SyntaxKind.UnknownKeyword)) {
+            continue;
+        }
+        const name = parameter.name.text;
+        if (declaration.parameters.some((p) => p.type && mentionsTypeName(p.type, name)))
+            return name;
+    }
+    return undefined;
+}
+function mentionsTypeName(node, name) {
+    if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.text === name) {
+        return true;
+    }
+    return ts.forEachChild(node, (child) => (mentionsTypeName(child, name) ? true : undefined)) ?? false;
+}
 function declaresTypeParameters(call) {
     return (resolvedDeclaration(call)?.typeParameters?.length ?? 0) > 0;
 }

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

@@ -495,6 +495,15 @@ export declare class TypeInferrer {
     private inferExpression;
     private inferRequestBody;
     private resolveCallResultTerminalNode;
+    /**
+     * carrick#2756: what a `catch` clause does with the response describes a
+     * body that failed to read (`catch (e) { log(await res.text()); throw e }`),
+     * not the payload, yet it comes after the success read and would win as the
+     * last whole read. Where the source uses the tracked value anywhere outside
+     * a `catch` clause that does not hold the call, the clause's uses are left
+     * out of the walk. Where every use is in such a clause the walk is as it was.
+     */
+    private catchReadsDeferred;
     /**
      * Where the walk ends on the call's own destructuring binding (`const {
      * tasks } = await api.list()`), the declaration has no type of its own: the
@@ -1234,6 +1243,17 @@ export declare class TypeInferrer {
      * contract, and neither the envelope nor its `string` body is any of it.
      */
     private inferSerialisedBodyEnvelope;
+    /**
+     * carrick#2674: the locator names a request call's options object literal
+     * and the member that carries the call's body. The call sends no request
+     * body when the literal can write no such member: no spread, no computed
+     * key, and no member of that name in any form (assignment, shorthand,
+     * method, accessor, quoted key), nor any other body-named member
+     * (`BODY_MEMBER_NAMES`, `REQUEST_BODY_PARTS`). Anything else is not decided here, so the
+     * answer is null. `configArgumentBody` stays the reader of the member
+     * itself; the checks above it are this kind's own.
+     */
+    private inferRequestConfig;
     /** An `unknown` answer the inferrer decided, carrying its reason at the root. */
     private decidedAbstain;
     /**
@@ -2134,6 +2154,21 @@ export declare class TypeInferrer {
      * literal's own member, or a variable's member read off its type.
      */
     private configArgumentBody;
+    /** A property whose name is computed, so the literal's written keys do not name it. */
+    private isComputedMember;
+    /**
+     * A config literal that spreads another object, or writes a computed key,
+     * names no `body` itself, so the literal's own type is read: the call sends
+     * no body only when every branch of that type declares no `body` member, or
+     * one typed `undefined` or `never`. The literal and each spread are first
+     * read for a type that rules nothing out: one not known (a spread of an
+     * untyped object), a generic one (a type parameter, or an intersection with
+     * one), or one with a string index signature (which the compiler drops
+     * from a spread's result). Any of those abstains.
+     */
+    private spreadLiteralBody;
+    /** Why a spread-side type rules out no member, or undefined when it can be read. */
+    private spreadTypeUnread;
     /**
      * Per parameter position of the call's resolved declaration: a body slot, a
      * config slot (with the member that carries the body), an opaque generic
@@ -2150,6 +2185,12 @@ export declare class TypeInferrer {
     private configSlot;
     /** The value an object literal gives `name`: an assignment's initializer or a shorthand's identifier. */
     private objectLiteralMemberValue;
+    /**
+     * The last member an object literal writes under `name`, in any form
+     * (assignment, shorthand, method, accessor), with a quoted or numeric key
+     * read by its text. Spreads and computed keys name nothing here.
+     */
+    private literalMemberNamed;
     /**
      * An explicit request `InferredType` for a contract the route declares,
      * carrying the provenance the reading recorded.
@@ -2489,6 +2530,13 @@ export declare class TypeInferrer {
      * then substring match (preferring containing matches).
      */
     private matchByText;
+    /**
+     * The text a locator opens with before an elision, or `undefined` when the
+     * locator has none. An elision is `...` followed only by closing brackets
+     * (`{ a: x, ... }`); `...rest` is a spread and source text. An opening too
+     * short to tell nodes apart is judged by the caller.
+     */
+    private elidedLocatorOpening;
     /**
      * What a locator's text names, read off its own parse (carrick#2056):
      *

package/sidecar/dist/src/type-inferrer.js

@@ -890,6 +890,8 @@ export class TypeInferrer {
                 return this.inferFunctionParam(sourceFile, request);
             case 'receiver_type':
                 return this.inferReceiverType(sourceFile, request);
+            case 'request_config':
+                return this.inferRequestConfig(sourceFile, request);
             default:
                 this.logError(`Unknown infer kind: ${request.infer_kind}`);
                 return null;
@@ -2970,7 +2972,7 @@ export class TypeInferrer {
             // `response.json()` is one in place.
             const callValueIsTransport = this.typeIsOrContainsResponseMachinery(callValue);
             const startPos = callExpr.getStart();
-            const candidates = this.collectDefUseNodes(func);
+            const candidates = this.catchReadsDeferred(this.collectDefUseNodes(func), func, startPos, currentNames);
             for (const expr of candidates) {
                 if (expr.getStart() <= startPos)
                     continue;
@@ -3080,6 +3082,26 @@ export class TypeInferrer {
         }
         return { terminal: callExpr, projectionOnly: false, projections: [] };
     }
+    /**
+     * carrick#2756: what a `catch` clause does with the response describes a
+     * body that failed to read (`catch (e) { log(await res.text()); throw e }`),
+     * not the payload, yet it comes after the success read and would win as the
+     * last whole read. Where the source uses the tracked value anywhere outside
+     * a `catch` clause that does not hold the call, the clause's uses are left
+     * out of the walk. Where every use is in such a clause the walk is as it was.
+     */
+    catchReadsDeferred(candidates, func, startPos, names) {
+        const inLaterCatch = (node) => node
+            .getAncestors()
+            .some((a) => Node.isCatchClause(a) &&
+            a.getStart() > startPos &&
+            a.getAncestors().includes(func));
+        const usesOutside = candidates.some((c) => c.getStart() > startPos &&
+            Node.isIdentifier(c) &&
+            this.isIdentifierUsage(c, names) &&
+            !inLaterCatch(c));
+        return usesOutside ? candidates.filter((c) => !inLaterCatch(c)) : candidates;
+    }
     /**
      * Where the walk ends on the call's own destructuring binding (`const {
      * tasks } = await api.list()`), the declaration has no type of its own: the
@@ -5383,6 +5405,59 @@ export class TypeInferrer {
         }
         return this.inferredFromRecoveredPayload(request, recovered);
     }
+    /**
+     * carrick#2674: the locator names a request call's options object literal
+     * and the member that carries the call's body. The call sends no request
+     * body when the literal can write no such member: no spread, no computed
+     * key, and no member of that name in any form (assignment, shorthand,
+     * method, accessor, quoted key), nor any other body-named member
+     * (`BODY_MEMBER_NAMES`, `REQUEST_BODY_PARTS`). Anything else is not decided here, so the
+     * answer is null. `configArgumentBody` stays the reader of the member
+     * itself; the checks above it are this kind's own.
+     */
+    inferRequestConfig(sourceFile, request) {
+        const member = request.member;
+        if (!member)
+            return null;
+        const located = this.resolveTargetNode(sourceFile, request);
+        if (!located)
+            return null;
+        const literal = this.unwrapExpressionNode(located);
+        if (!Node.isObjectLiteralExpression(literal))
+            return null;
+        for (const property of literal.getProperties()) {
+            // A spread has no name node, so it falls out here with anything else
+            // unnamed: the literal may write the member through it.
+            const nameNode = Node.isShorthandPropertyAssignment(property)
+                ? property.getNameNode()
+                : property.getNameNode?.();
+            if (!nameNode)
+                return null;
+            if (Node.isComputedPropertyName(nameNode))
+                return null;
+            const name = Node.isStringLiteral(nameNode) || Node.isNoSubstitutionTemplateLiteral(nameNode)
+                ? nameNode.getLiteralText()
+                : nameNode.getText();
+            // A client may take its body through a member other than the one the
+            // locator names (`json`, `form`, `data`), so any body-named key refuses,
+            // the same rule `requestObjectBody` keeps.
+            if (name === member || BODY_MEMBER_NAMES.has(name) || REQUEST_BODY_PARTS.has(name)) {
+                return null;
+            }
+        }
+        const read = this.configArgumentBody(literal, member, "the call's request config");
+        if (read.kind !== 'no_body')
+            return null;
+        this.log(`Request config at ${request.file_path}:${request.line_number} writes no '${member}' member; ` +
+            'the call sends no request body');
+        return this.decidedAbstain(request, this.getNodeLocation(literal), {
+            path: '',
+            kind: 'unknown',
+            reason: 'no_request_body',
+            detail: `the call's request config sets no '${read.member}' member, which is where the call ` +
+                'takes its body, so the call sends no request body',
+        });
+    }
     /** An `unknown` answer the inferrer decided, carrying its reason at the root. */
     decidedAbstain(request, location, reason) {
         const abstain = this.createInferredType(request, 'unknown', false, location);
@@ -7849,6 +7924,17 @@ export class TypeInferrer {
             const value = this.objectLiteralMemberValue(unwrapped, member);
             if (value)
                 return { kind: 'body', node: value, from };
+            if (this.literalMemberNamed(unwrapped, member)) {
+                return {
+                    kind: 'abstain',
+                    why: `the request config writes its '${member}' member as a method or accessor, so its value is unread`,
+                };
+            }
+            if (unwrapped
+                .getProperties()
+                .some((p) => Node.isSpreadAssignment(p) || this.isComputedMember(p))) {
+                return this.spreadLiteralBody(unwrapped, member);
+            }
             return { kind: 'no_body', member };
         }
         const property = unwrapped.getType().getProperty(member);
@@ -7865,6 +7951,73 @@ export class TypeInferrer {
             why: `the located request config's type does not resolve its '${member}' member`,
         };
     }
+    /** A property whose name is computed, so the literal's written keys do not name it. */
+    isComputedMember(property) {
+        return ((Node.isPropertyAssignment(property) ||
+            Node.isShorthandPropertyAssignment(property) ||
+            Node.isMethodDeclaration(property)) &&
+            Node.isComputedPropertyName(property.getNameNode()));
+    }
+    /**
+     * A config literal that spreads another object, or writes a computed key,
+     * names no `body` itself, so the literal's own type is read: the call sends
+     * no body only when every branch of that type declares no `body` member, or
+     * one typed `undefined` or `never`. The literal and each spread are first
+     * read for a type that rules nothing out: one not known (a spread of an
+     * untyped object), a generic one (a type parameter, or an intersection with
+     * one), or one with a string index signature (which the compiler drops
+     * from a spread's result). Any of those abstains.
+     */
+    spreadLiteralBody(literal, member) {
+        const literalType = literal.getType();
+        const read = [
+            literalType,
+            ...literal
+                .getProperties()
+                .filter(Node.isSpreadAssignment)
+                .map((spread) => spread.getExpression().getType()),
+        ];
+        for (const type of read) {
+            const unread = this.spreadTypeUnread(type);
+            if (unread) {
+                return {
+                    kind: 'abstain',
+                    why: `the request config spreads an object whose type ${unread}, so its '${member}' member is unread`,
+                };
+            }
+        }
+        const branches = literalType.isUnion() ? literalType.getUnionTypes() : [literalType];
+        for (const branch of branches) {
+            const property = branch.getProperty(member);
+            if (!property)
+                continue;
+            const type = property.getTypeAtLocation(literal);
+            const bare = type.isAny() || type.isUnknown() ? type : type.getNonNullableType();
+            if (bare.isNever() || bare.isUndefined() || bare.isVoid())
+                continue;
+            return {
+                kind: 'abstain',
+                why: `the request config spreads an object whose '${member}' member may carry a body`,
+            };
+        }
+        return { kind: 'no_body', member };
+    }
+    /** Why a spread-side type rules out no member, or undefined when it can be read. */
+    spreadTypeUnread(type) {
+        const branches = type.isUnion() ? type.getUnionTypes() : [type];
+        for (const branch of branches) {
+            const parts = branch.isIntersection() ? branch.getIntersectionTypes() : [branch];
+            for (const part of parts) {
+                if (part.isAny() || part.isUnknown())
+                    return 'is not known';
+                if ((part.compilerType.flags & ts.TypeFlags.Instantiable) !== 0)
+                    return 'is generic';
+            }
+            if (branch.getStringIndexType())
+                return 'has an index signature';
+        }
+        return undefined;
+    }
     /**
      * Per parameter position of the call's resolved declaration: a body slot, a
      * config slot (with the member that carries the body), an opaque generic
@@ -7948,7 +8101,7 @@ export class TypeInferrer {
     }
     /** The value an object literal gives `name`: an assignment's initializer or a shorthand's identifier. */
     objectLiteralMemberValue(literal, name) {
-        const property = literal.getProperty(name);
+        const property = this.literalMemberNamed(literal, name);
         if (!property)
             return undefined;
         if (Node.isPropertyAssignment(property))
@@ -7957,6 +8110,29 @@ export class TypeInferrer {
             return property.getNameNode();
         return undefined;
     }
+    /**
+     * The last member an object literal writes under `name`, in any form
+     * (assignment, shorthand, method, accessor), with a quoted or numeric key
+     * read by its text. Spreads and computed keys name nothing here.
+     */
+    literalMemberNamed(literal, name) {
+        let found;
+        for (const property of literal.getProperties()) {
+            if (Node.isSpreadAssignment(property))
+                continue;
+            const nameNode = property.getNameNode();
+            if (Node.isComputedPropertyName(nameNode))
+                continue;
+            const text = Node.isStringLiteral(nameNode) ||
+                Node.isNoSubstitutionTemplateLiteral(nameNode) ||
+                Node.isNumericLiteral(nameNode)
+                ? nameNode.getLiteralText()
+                : nameNode.getText();
+            if (text === name)
+                found = property;
+        }
+        return found;
+    }
     /**
      * An explicit request `InferredType` for a contract the route declares,
      * carrying the provenance the reading recorded.
@@ -9133,6 +9309,26 @@ export class TypeInferrer {
         if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(normalizedTarget)) {
             return undefined;
         }
+        // A locator that elides members (`body: { a: x, ... }`) stands for the
+        // whole node it opens: the text before the elision is where the source
+        // opens. Never a node the text merely contains, which is one member of the
+        // payload it names.
+        // An opening shorter than this (`{`) names no node in particular.
+        const MIN_ELIDED_OPENING_LEN = 8;
+        const elidedOpening = this.elidedLocatorOpening(normalizedTarget);
+        if (elidedOpening !== undefined) {
+            if (elidedOpening.length < MIN_ELIDED_OPENING_LEN)
+                return undefined;
+            const opened = candidates.filter((c) => c.text.startsWith(elidedOpening));
+            if (opened.length === 0)
+                return undefined;
+            if (lineNumber !== undefined) {
+                const distance = (c) => Math.abs(startLineOf(c.node) - lineNumber);
+                const nearest = Math.min(...opened.map(distance));
+                return this.pickBestMatch(opened.filter((c) => distance(c) === nearest).map((c) => c.node), lineNumber);
+            }
+            return this.pickBestMatch(opened.map((c) => c.node), lineNumber);
+        }
         // Fall back to substring match
         // For the reverse direction (target contains node text), require a minimum node text
         // length to avoid matching tiny identifiers like "res" or "body" too broadly.
@@ -9199,6 +9395,18 @@ export class TypeInferrer {
         }
         return bound.size > 0 ? this.pickBestMatch([...bound], lineNumber) : undefined;
     }
+    /**
+     * The text a locator opens with before an elision, or `undefined` when the
+     * locator has none. An elision is `...` followed only by closing brackets
+     * (`{ a: x, ... }`); `...rest` is a spread and source text. An opening too
+     * short to tell nodes apart is judged by the caller.
+     */
+    elidedLocatorOpening(normalizedTarget) {
+        const match = /^(.*?)[\s,]*\.\.\.[\s,)}\]]*$/s.exec(normalizedTarget);
+        if (!match)
+            return undefined;
+        return match[1];
+    }
     /**
      * What a locator's text names, read off its own parse (carrick#2056):
      *
@@ -9567,6 +9775,8 @@ export class TypeInferrer {
                 return 'SigReturn';
             case 'function_param':
                 return 'Param';
+            case 'request_config':
+                return 'RequestConfig';
             default:
                 return 'Type';
         }

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

@@ -6,7 +6,7 @@ import type { ResponseModes } from './response-modes.js';
 /**
  * The kind of type inference to perform
  */
-export type InferKind = 'function_return' | 'expression' | 'call_result' | 'variable' | 'response_body' | 'request_body' | 'signature_return' | 'function_param' | 'receiver_type';
+export type InferKind = 'function_return' | 'expression' | 'call_result' | 'variable' | 'response_body' | 'request_body' | 'signature_return' | 'function_param' | 'receiver_type' | 'request_config';
 /**
  * A rule for unwrapping machinery/wrapper types to extract payload types.
  *
@@ -711,6 +711,8 @@ export interface InferRequestItem {
     alias?: string;
     /** Target parameter name for `function_param` inference. */
     param_name?: string;
+    /** The member of a request options literal that carries the body (`request_config`). */
+    member?: string;
 }
 /**
  * Response status

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

@@ -4,7 +4,7 @@
  */
 import { z } from 'zod';
 import type { SidecarRequest, InferRequestItem, LibraryCheck } from './types.js';
-export declare const InferKindSchema: z.ZodEnum<["function_return", "expression", "call_result", "variable", "response_body", "request_body", "signature_return", "function_param", "receiver_type"]>;
+export declare const InferKindSchema: z.ZodEnum<["function_return", "expression", "call_result", "variable", "response_body", "request_body", "signature_return", "function_param", "receiver_type", "request_config"]>;
 export declare const SymbolRequestSchema: z.ZodObject<{
     symbol_name: z.ZodString;
     source_file: z.ZodString;
@@ -31,13 +31,15 @@ export declare const InferRequestItemSchema: z.ZodObject<{
     span_end: z.ZodOptional<z.ZodNumber>;
     expression_text: z.ZodOptional<z.ZodString>;
     expression_line: z.ZodOptional<z.ZodNumber>;
-    infer_kind: z.ZodEnum<["function_return", "expression", "call_result", "variable", "response_body", "request_body", "signature_return", "function_param", "receiver_type"]>;
+    infer_kind: z.ZodEnum<["function_return", "expression", "call_result", "variable", "response_body", "request_body", "signature_return", "function_param", "receiver_type", "request_config"]>;
     alias: z.ZodOptional<z.ZodString>;
     param_name: z.ZodOptional<z.ZodString>;
+    member: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     file_path: string;
     line_number: number;
-    infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+    infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+    member?: string | undefined;
     param_name?: string | undefined;
     alias?: string | undefined;
     span_start?: number | undefined;
@@ -47,7 +49,8 @@ export declare const InferRequestItemSchema: z.ZodObject<{
 }, {
     file_path: string;
     line_number: number;
-    infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+    infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+    member?: string | undefined;
     param_name?: string | undefined;
     alias?: string | undefined;
     span_start?: number | undefined;
@@ -633,13 +636,15 @@ export declare const InferRequestSchema: z.ZodObject<{
         span_end: z.ZodOptional<z.ZodNumber>;
         expression_text: z.ZodOptional<z.ZodString>;
         expression_line: z.ZodOptional<z.ZodNumber>;
-        infer_kind: z.ZodEnum<["function_return", "expression", "call_result", "variable", "response_body", "request_body", "signature_return", "function_param", "receiver_type"]>;
+        infer_kind: z.ZodEnum<["function_return", "expression", "call_result", "variable", "response_body", "request_body", "signature_return", "function_param", "receiver_type", "request_config"]>;
         alias: z.ZodOptional<z.ZodString>;
         param_name: z.ZodOptional<z.ZodString>;
+        member: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         file_path: string;
         line_number: number;
-        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+        member?: string | undefined;
         param_name?: string | undefined;
         alias?: string | undefined;
         span_start?: number | undefined;
@@ -649,7 +654,8 @@ export declare const InferRequestSchema: z.ZodObject<{
     }, {
         file_path: string;
         line_number: number;
-        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+        member?: string | undefined;
         param_name?: string | undefined;
         alias?: string | undefined;
         span_start?: number | undefined;
@@ -739,7 +745,8 @@ export declare const InferRequestSchema: z.ZodObject<{
     requests: {
         file_path: string;
         line_number: number;
-        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+        member?: string | undefined;
         param_name?: string | undefined;
         alias?: string | undefined;
         span_start?: number | undefined;
@@ -775,7 +782,8 @@ export declare const InferRequestSchema: z.ZodObject<{
     requests: {
         file_path: string;
         line_number: number;
-        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+        member?: string | undefined;
         param_name?: string | undefined;
         alias?: string | undefined;
         span_start?: number | undefined;
@@ -2984,13 +2992,15 @@ export declare const SidecarRequestSchema: z.ZodDiscriminatedUnion<"action", [z.
         span_end: z.ZodOptional<z.ZodNumber>;
         expression_text: z.ZodOptional<z.ZodString>;
         expression_line: z.ZodOptional<z.ZodNumber>;
-        infer_kind: z.ZodEnum<["function_return", "expression", "call_result", "variable", "response_body", "request_body", "signature_return", "function_param", "receiver_type"]>;
+        infer_kind: z.ZodEnum<["function_return", "expression", "call_result", "variable", "response_body", "request_body", "signature_return", "function_param", "receiver_type", "request_config"]>;
         alias: z.ZodOptional<z.ZodString>;
         param_name: z.ZodOptional<z.ZodString>;
+        member: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         file_path: string;
         line_number: number;
-        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+        member?: string | undefined;
         param_name?: string | undefined;
         alias?: string | undefined;
         span_start?: number | undefined;
@@ -3000,7 +3010,8 @@ export declare const SidecarRequestSchema: z.ZodDiscriminatedUnion<"action", [z.
     }, {
         file_path: string;
         line_number: number;
-        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+        member?: string | undefined;
         param_name?: string | undefined;
         alias?: string | undefined;
         span_start?: number | undefined;
@@ -3090,7 +3101,8 @@ export declare const SidecarRequestSchema: z.ZodDiscriminatedUnion<"action", [z.
     requests: {
         file_path: string;
         line_number: number;
-        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+        member?: string | undefined;
         param_name?: string | undefined;
         alias?: string | undefined;
         span_start?: number | undefined;
@@ -3126,7 +3138,8 @@ export declare const SidecarRequestSchema: z.ZodDiscriminatedUnion<"action", [z.
     requests: {
         file_path: string;
         line_number: number;
-        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type";
+        infer_kind: "function_return" | "expression" | "call_result" | "variable" | "response_body" | "request_body" | "signature_return" | "function_param" | "receiver_type" | "request_config";
+        member?: string | undefined;
         param_name?: string | undefined;
         alias?: string | undefined;
         span_start?: number | undefined;

package/sidecar/dist/src/validators.js

@@ -16,6 +16,7 @@ export const InferKindSchema = z.enum([
     'signature_return',
     'function_param',
     'receiver_type',
+    'request_config',
 ]);
 // ============================================================================
 // Extraction Config Schemas (New)
@@ -92,6 +93,8 @@ export const InferRequestItemSchema = z.object({
     infer_kind: InferKindSchema,
     alias: z.string().optional(),
     param_name: z.string().optional(),
+    // The body-carrying member a `request_config` item asks about.
+    member: z.string().optional(),
 });
 /**
  * Per-item locator validation for infer requests.