carrick 0.3.129 → 0.3.130

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.129",
+  "version": "0.3.130",
   "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.130",
+    "@carrick-tools/cli-darwin-x64": "0.3.130",
+    "@carrick-tools/cli-linux-arm64": "0.3.130",
+    "@carrick-tools/cli-linux-x64": "0.3.130",
+    "@carrick-tools/cli-win32-x64": "0.3.130"
   },
   "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.130",
   "author": {
     "name": "Carrick",
     "email": "hello@carrick.tools"

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.

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.
@@ -9567,6 +9743,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.