carrick 0.3.126 → 0.3.127

package/package.json

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

package/sidecar/dist/src/index.js

@@ -56,6 +56,18 @@ function initializedLoader() {
     }
     return projectLoader;
 }
+/**
+ * carrick#2100: the unwidened reading's budget in milliseconds, when
+ * `CARRICK_UNWIDENED_BUDGET_MS` sets one. A switch for tests that drive the
+ * scanner's binary: it forces the budget to run out on any machine. Unset or
+ * not a whole number of milliseconds, the inferrer's default stands.
+ */
+function unwidenedBudgetFromEnv() {
+    const value = process.env.CARRICK_UNWIDENED_BUDGET_MS;
+    if (value === undefined || !/^\d+$/.test(value.trim()))
+        return undefined;
+    return Number(value.trim());
+}
 /**
  * Get the project-backed components, building the project if this is the
  * first request that needs it.
@@ -78,6 +90,7 @@ function projectComponents(key = '') {
             project,
             repoRoot,
             packageOf: (filePath) => loader.packageOf(filePath),
+            unwidenedBudgetMs: unwidenedBudgetFromEnv(),
         });
         built = {
             typeBundler: new TypeBundler({ project, repoRoot }),

package/sidecar/dist/src/library-claims.js

@@ -456,6 +456,7 @@ export class LibraryClaimsVerifier {
                         makerBindsName,
                         scoped: receiverPath.scope !== undefined,
                         makerHolding,
+                        madeBy: receiverPath.maker?.member === null && receiverPath.scope === undefined ? check.export : undefined,
                     })),
                 };
             };
@@ -1735,6 +1736,15 @@ class DeclarationReader {
             return true;
         if (type.isUnionOrIntersection())
             return type.types.some(part => this.mentions(part, parameter, depth + 1));
+        // A deferred conditional (`Server extends X ? A : B`) or an alias
+        // instance names its parameter in its check type or its alias arguments
+        // (carrick#2663).
+        if (type.aliasTypeArguments?.some(argument => this.mentions(argument, parameter, depth + 1)))
+            return true;
+        if (type.flags & ts.TypeFlags.Conditional) {
+            const conditional = type;
+            return [conditional.checkType, conditional.extendsType].some(part => this.mentions(part, parameter, depth + 1));
+        }
         const reference = this.referenceOf(type);
         if (reference !== undefined) {
             return this.checker.getTypeArguments(reference).some(argument => this.mentions(argument, parameter, depth + 1));
@@ -1927,11 +1937,17 @@ class DeclarationReader {
         return failure.verdict === 'failed' ? failed(reason) : unchecked(reason);
     }
     /**
-     * `yields: { param, export, side }` on a receive op: some signature of the
-     * handler this overload takes declares a parameter at `param` whose type
-     * is the package's own export named `export` (a class, or the interface
-     * an instance has), declared in the receiver's home packages. `side` is
-     * `client` or `server` (`yields_side_invalid`). Undefined when it holds.
+     * `yields: { param, export, side }` on a receive op or a scope: some
+     * signature of the function this overload takes declares a parameter at
+     * `param` whose type is either
+     * - the package's own export named `export` (a class, or the interface an
+     *   instance has), declared in the receiver's home packages; or
+     * - when `export` is the maker whose own call made the instance the claim
+     *   is read on (`madeBy`, carrick#2663): that instance, compared by
+     *   declaration (`handsInstance`), since a factory's result has no export
+     *   name of its own.
+     * `side` is `client` or `server` (`yields_side_invalid`). Undefined when it
+     * holds.
      */
     yieldsOutcome(signature, handler, yields, receiver) {
         if (yields.side !== 'client' && yields.side !== 'server')
@@ -1955,10 +1971,44 @@ class DeclarationReader {
                     (symbol.declarations ?? []).some(declaration => this.isOwnFile(declaration.getSourceFile(), receiver.home)));
                 if (named)
                     return undefined;
+                if (yields.export === receiver.madeBy && this.handsInstance(given, receiver, signature.typeParameters ?? [])) {
+                    return undefined;
+                }
             }
         }
         return failed('yields_not_export');
     }
+    /**
+     * `given` (each part, nullish dropped) is the instance `receiver` holds:
+     * some part of its intersection is a class or interface the receiver's
+     * home packages declare, and the same declaration (the same symbol, never
+     * the same name) as a part of the instance's own intersection. A generic
+     * instance is built at its defaults while `given` threads the overload's
+     * own type parameters (`own`) through its arguments, so the arguments are
+     * read as `fitsErased` reads a mounted instance (carrick#2652): a
+     * definite mismatch refuses, an argument it cannot read leaves the
+     * declaration to decide.
+     */
+    handsInstance(given, receiver, own) {
+        const declared = (type) => {
+            const symbol = type.getSymbol();
+            if (!symbol || !(symbol.flags & (ts.SymbolFlags.Class | ts.SymbolFlags.Interface)))
+                return undefined;
+            const home = (symbol.declarations ?? []).some(declaration => this.isOwnFile(declaration.getSourceFile(), receiver.home));
+            return home ? symbol : undefined;
+        };
+        const intersected = (type) => (type.isIntersection() ? type.types : [type]);
+        const instances = this.parts(receiver.type)
+            .flatMap(intersected)
+            .filter(part => declared(part) !== undefined);
+        const parts = this.parts(given);
+        return (parts.length > 0 &&
+            parts.every(part => intersected(part).some(handed => {
+                const symbol = declared(handed);
+                return (symbol !== undefined &&
+                    instances.some(instance => declared(instance) === symbol && this.fitsErased(instance, handed, own) !== false));
+            })));
+    }
     /**
      * `request: { param, path?, url?, method? }` on a receive op (#2474 R0):
      * some signature of the handler this overload takes declares a parameter

package/sidecar/dist/src/retype.js

@@ -548,14 +548,8 @@ function bodyReadsOf(call) {
     const chained = bodyReadOn(top);
     if (chained)
         return checkedBodyReads([chained]);
-    const declaration = top.getParent();
-    if (!declaration ||
-        !Node.isVariableDeclaration(declaration) ||
-        declaration.getInitializer() !== top) {
-        return [];
-    }
-    const name = declaration.getNameNode();
-    if (!Node.isIdentifier(name))
+    const name = responseBinding(top);
+    if (!name)
         return [];
     const reads = [];
     let handedOn = false;
@@ -583,6 +577,92 @@ function bodyReadsOf(call) {
     }
     return checkedBodyReads(reads);
 }
+/**
+ * The name the located call's response is bound to, when the source binds it
+ * in one of three ways: `const res = await call`, the first parameter of a
+ * `.then` callback (`call.then((res) => res.json())`), or an element of an
+ * array destructured off `Promise.all` (`const [a, b] = await Promise.all([call, ...])`).
+ */
+function responseBinding(top) {
+    const declaration = top.getParent();
+    if (declaration && Node.isVariableDeclaration(declaration) && declaration.getInitializer() === top) {
+        const name = declaration.getNameNode();
+        return Node.isIdentifier(name) ? name : undefined;
+    }
+    return thenParameter(top) ?? promiseAllElement(top);
+}
+/** `top.then((res) => ...)`: the callback's first parameter. */
+function thenParameter(top) {
+    const access = top.getParent();
+    if (!access || !Node.isPropertyAccessExpression(access) || access.getExpression() !== top) {
+        return undefined;
+    }
+    if (access.getName() !== 'then')
+        return undefined;
+    const then = access.getParent();
+    if (!then || !Node.isCallExpression(then) || then.getExpression() !== access)
+        return undefined;
+    const callback = then.getArguments()[0];
+    if (!callback || !(Node.isArrowFunction(callback) || Node.isFunctionExpression(callback))) {
+        return undefined;
+    }
+    const name = callback.getParameters()[0]?.getNameNode();
+    return name && Node.isIdentifier(name) ? name : undefined;
+}
+/**
+ * The name `top` is destructured to, when `top` is one element of the array
+ * literal handed to the language library's `Promise.all` and the call's
+ * awaited result is destructured to names:
+ * `const [a, b] = await Promise.all([call, other])`. An element after a
+ * spread has no position the destructuring can be read against.
+ */
+function promiseAllElement(top) {
+    const array = top.getParent();
+    if (!array || !Node.isArrayLiteralExpression(array))
+        return undefined;
+    const elements = array.getElements();
+    const index = elements.indexOf(top);
+    if (index < 0 || elements.slice(0, index + 1).some((e) => Node.isSpreadElement(e))) {
+        return undefined;
+    }
+    const all = array.getParent();
+    if (!all ||
+        !Node.isCallExpression(all) ||
+        all.getArguments()[0] !== array ||
+        !isLibraryPromiseAll(all)) {
+        return undefined;
+    }
+    let result = all;
+    while (Node.isAwaitExpression(result.getParentOrThrow()) ||
+        Node.isParenthesizedExpression(result.getParentOrThrow())) {
+        result = result.getParentOrThrow();
+    }
+    const declaration = result.getParent();
+    if (!declaration || !Node.isVariableDeclaration(declaration) || declaration.getInitializer() !== result) {
+        return undefined;
+    }
+    const pattern = declaration.getNameNode();
+    if (!Node.isArrayBindingPattern(pattern))
+        return undefined;
+    const element = pattern.getElements()[index];
+    if (!element || !Node.isBindingElement(element) || element.getDotDotDotToken())
+        return undefined;
+    const name = element.getNameNode();
+    return Node.isIdentifier(name) ? name : undefined;
+}
+/** `Promise.all` as the language library declares it, not a lookalike. */
+function isLibraryPromiseAll(call) {
+    const callee = call.getExpression();
+    if (!Node.isPropertyAccessExpression(callee) || callee.getName() !== 'all')
+        return false;
+    const declaration = resolvedDeclaration(call);
+    if (!declaration)
+        return false;
+    return call
+        .getProject()
+        .getProgram()
+        .compilerObject.isSourceFileDefaultLibrary(declaration.getSourceFile());
+}
 /**
  * Why these body reads cannot be retyped, or the reads to retype.
  *

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

@@ -167,7 +167,10 @@ export declare class TypeInferrer {
      * read is the project the scan loaded.
      *
      * Nothing is read past `deadline`: a batch that runs out keeps the readings
-     * it made and publishes none for the rest.
+     * it made and publishes none for the rest, and marks each of the rest
+     * `unwidened_out_of_budget` (carrick#2100). A request that never needed a
+     * reading (a declared return, nothing to mark) or lost it for a reason of
+     * its own (a marking that added a diagnostic) is never marked.
      */
     private addUnwidenedReadings;
     /**
@@ -295,6 +298,17 @@ export declare class TypeInferrer {
      * when the located expression is not part of what the handler returns.
      */
     private returnedSendHolding;
+    /**
+     * True when `node` is a bare reference to a parameter of the handler the
+     * route registration on the request's line hands in (found as
+     * `registrationAtLine` finds it, wrappers included): the request, the reply
+     * or the context the framework passes, never a body the route sends
+     * (carrick-cloud#2576). Where the parameter's type is declared is not read:
+     * a parameter of any other function is data, whether the repo or an
+     * installed package types it (`.then((account) => reply.send(account))`, a
+     * helper's `account: Account`).
+     */
+    private isRouteHandlerParameter;
     /**
      * True when a located call's own result is the route's payload, so the
      * transitional drill into its first argument must not run (carrick#1732).
@@ -1703,11 +1717,14 @@ export declare class TypeInferrer {
      */
     private registrationHandlerAt;
     /**
-     * The handler function referenced by a route-registration call: the first
+     * The handler function referenced by a route-registration call: the LAST
      * argument that is an inline function, or an identifier bound to a function
-     * (typically the 2nd+ arg — the path literal is not function-valued, so it is
-     * skipped naturally). No callee-name check: a call whose argument resolves to
-     * a function is structurally a registration regardless of the framework.
+     * (carrick#2472 P3-2b). The functions before it are middleware
+     * (`route(path).post(auth, audit, handler)`), which runs first and hands on;
+     * reading the first function read a middleware as the route. The path
+     * literal is not function-valued, so it is skipped naturally. No callee-name
+     * check: a call whose argument resolves to a function is structurally a
+     * registration regardless of the framework.
      */
     private handlerFromRegistrationCall;
     /**
@@ -1722,16 +1739,32 @@ export declare class TypeInferrer {
      * declaration (via the compiler's definition nodes) and returned when that
      * declaration is — or initializes to — a function. Anything else (a path
      * literal, an object, a non-function binding) yields undefined.
+     * `followWrapperCalls` false reads a binding to a wrapper call as no
+     * function, so a name the wrapper walk meets is never walked again.
      */
     private asHandlerFunction;
     /**
      * Extract a `FunctionLike` from a declaration node the compiler resolved an
      * identifier to: a function declaration is itself the function; a variable
      * declaration / binding whose initializer is an inline function yields that
-     * function (`const h = async () => { … }`). Import/re-export shims are walked
-     * by ts-morph's `getDefinitionNodes`, so no manual import chasing is needed.
+     * function (`const h = async () => { … }`), and one whose initializer is a
+     * wrapper call yields the function the call wraps
+     * (`const h = wrap<Contract>(async (req, res) => { … })`, carrick#2472
+     * P3-2b; `functionWrappedBy`). Import/re-export shims are walked by
+     * ts-morph's `getDefinitionNodes`, so no manual import chasing is needed.
      */
     private functionFromDeclaration;
+    /**
+     * The function a call wraps, for a name bound to that call and used as a
+     * handler (carrick#2472 P3-2b): the call's one argument that is a function
+     * literal, a name bound to one, or another such call, a few calls deep.
+     *
+     * Two conditions keep this to wrappers. The call's own value has to be
+     * callable, because the name is used as a function: `rows.map((row) => …)`
+     * is handed a function and yields a list. And exactly one argument may be a
+     * function: with two there is no saying which of them is wrapped.
+     */
+    private functionWrappedBy;
     /**
      * True when `handler` reads nothing from the incoming message (carrick#827):
      * every use of one of its parameters, named or destructured, is the receiver
@@ -1952,6 +1985,12 @@ export declare class TypeInferrer {
      * below reads it.
      */
     private bodyBuiltByCallee;
+    /**
+     * `bodyBuiltByCallee`, telling apart a callee that sends the argument
+     * unchanged (`passes`) from one that states nothing about it (`none`).
+     * `depth` counts the forwarded locals followed (carrick#2671).
+     */
+    private calleeBodyRead;
     /**
      * The request body value `use` is part of, inside `scope`: the value of a
      * body-named object member, or the argument at a body slot of a call,
@@ -1959,6 +1998,15 @@ export declare class TypeInferrer {
      * around it. `use` itself when it is that value whole.
      */
     private bodyValueAround;
+    /**
+     * carrick#2671: the `const` local whose initializer holds `use`, inside
+     * `scope`, when `scope` sends that local unchanged as the body: whole in a
+     * body slot, or as an argument into a function that passes it on as its
+     * body. The local's name, so its declared type is read. Undefined when the
+     * local is never sent, when a further body is built from it, or when a
+     * function lies between `use` and the declaration.
+     */
+    private forwardedLocalHolding;
     /** `value` is `use` behind what `sentValue` sees through. */
     private isSameValue;
     /**

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

@@ -176,6 +176,12 @@ const RESPONSE_INIT_MEMBER_NAMES = new Set([
  * two; the bound is a backstop against a pathologically nested return.
  */
 const RESPONSE_HELPER_MAX_DEPTH = 4;
+/**
+ * How many wrapper calls a handler bound to one is followed through
+ * (carrick#2472 P3-2b): `wrap(trace(async (req, res) => …))` needs two. A
+ * backstop against a pathologically nested initializer.
+ */
+const WRAPPER_CALL_MAX_DEPTH = 3;
 /**
  * Members an options object uses to state an HTTP status. A >= 400 status marks
  * the branch an error path, whose shape is not the endpoint's contract.
@@ -620,13 +626,19 @@ export class TypeInferrer {
      * read is the project the scan loaded.
      *
      * Nothing is read past `deadline`: a batch that runs out keeps the readings
-     * it made and publishes none for the rest.
+     * it made and publishes none for the rest, and marks each of the rest
+     * `unwidened_out_of_budget` (carrick#2100). A request that never needed a
+     * reading (a declared return, nothing to mark) or lost it for a reason of
+     * its own (a marking that added a diagnostic) is never marked.
      */
     addUnwidenedReadings(responses, extractionConfig, deadline) {
-        const outOfTime = (stage) => {
+        const outOfTime = (stage, unread) => {
             if (performance.now() <= deadline)
                 return false;
-            this.log(`Unwidened reading stopped ${stage}: it ran out of its budget`);
+            this.log(`Unwidened reading stopped ${stage}: it ran out of its budget, ` +
+                `${unread.length} reading(s) not made`);
+            for (const plan of unread)
+                plan.result.unwidened_out_of_budget = true;
             return true;
         };
         const plans = [];
@@ -685,7 +697,7 @@ export class TypeInferrer {
             insertions.set(file, normalise(list));
         const before = new Map();
         for (const file of checkedFiles) {
-            if (outOfTime('before the rewrite'))
+            if (outOfTime('before the rewrite', plans))
                 return;
             before.set(file, fileDiagnostics(file));
         }
@@ -701,7 +713,7 @@ export class TypeInferrer {
             // holds it loses its reading.
             const tainted = new Set();
             for (const file of checkedFiles) {
-                if (outOfTime('while checking the rewrite'))
+                if (outOfTime('while checking the rewrite', plans))
                     return;
                 const list = insertions.get(file) ?? [];
                 for (const at of addedDiagnostics(before.get(file), fileDiagnostics(file), list)) {
@@ -713,9 +725,10 @@ export class TypeInferrer {
                     }
                 }
             }
-            for (const plan of plans) {
-                if (outOfTime('while re-reading'))
+            for (const [at, plan] of plans.entries()) {
+                if (outOfTime('while re-reading', plans.slice(at).filter((rest) => !tainted.has(rest)))) {
                     return;
+                }
                 if (tainted.has(plan)) {
                     this.log(`Unwidened reading for ${plan.request.file_path}:${plan.request.line_number} ` +
                         'dropped: marking its literals added a diagnostic on its path');
@@ -901,6 +914,16 @@ export class TypeInferrer {
         if (this.serialisedBodyEnvelopeEngages(awaitedType, func)) {
             return this.inferSerialisedBodyEnvelope(request, func);
         }
+        // A route handler that returns the reply it was handed (`return reply`)
+        // states no body by that return; the reply's type is built from the
+        // route's request type argument (carrick-cloud#2576).
+        const returned = this.returnedExpressions(func);
+        if (returned.length > 0 &&
+            returned.every((expression) => this.isRouteHandlerParameter(this.unwrapExpressionNode(expression), request))) {
+            this.log(`Return at ${request.file_path}:${request.line_number} is an object the ` +
+                'framework handed the handler; it states no body');
+            return null;
+        }
         const unwrapResult = this.unwrapTypeWithConfig(awaitedType, func, extractionConfig);
         if (unwrapResult.wasUnwrapped && !unwrapResult.verifiedMachinery) {
             typeString = unwrapResult.typeString;
@@ -1278,6 +1301,16 @@ export class TypeInferrer {
                 payloadNode = args[0];
             }
         }
+        // A parameter the route registration hands its handler is never the
+        // route's body: not the reply a handler returns (`return reply`), and not
+        // the request the drill reaches in a call that forwards it
+        // (`return finish(request, reply)`), whose type the framework built from
+        // the route's request type argument (carrick-cloud#2576).
+        if (this.isRouteHandlerParameter(payloadNode, request)) {
+            this.log(`Response payload at ${request.file_path}:${request.line_number} is an object ` +
+                'the framework handed the handler; it states no body');
+            return null;
+        }
         const payloadType = payloadNode.getType();
         let typeString = typeText(payloadType, payloadNode);
         const unwrapResult = this.unwrapTypeWithConfig(payloadType, payloadNode, extractionConfig);
@@ -1447,6 +1480,30 @@ export class TypeInferrer {
         }
         return this.receivingCallOf(located, isReturned);
     }
+    /**
+     * True when `node` is a bare reference to a parameter of the handler the
+     * route registration on the request's line hands in (found as
+     * `registrationAtLine` finds it, wrappers included): the request, the reply
+     * or the context the framework passes, never a body the route sends
+     * (carrick-cloud#2576). Where the parameter's type is declared is not read:
+     * a parameter of any other function is data, whether the repo or an
+     * installed package types it (`.then((account) => reply.send(account))`, a
+     * helper's `account: Account`).
+     */
+    isRouteHandlerParameter(node, request) {
+        if (!Node.isIdentifier(node))
+            return false;
+        const owners = (node.getSymbol()?.getDeclarations() ?? [])
+            .filter((decl) => Node.isParameterDeclaration(decl))
+            .map((decl) => decl.getParent().compilerNode);
+        if (owners.length === 0)
+            return false;
+        const sourceFile = this.project.getSourceFile(request.file_path);
+        if (!sourceFile)
+            return false;
+        const handler = this.registrationAtLine(sourceFile, request.line_number)?.handler;
+        return handler !== undefined && owners.includes(handler.compilerNode);
+    }
     /**
      * True when a located call's own result is the route's payload, so the
      * transitional drill into its first argument must not run (carrick#1732).
@@ -6305,14 +6362,17 @@ export class TypeInferrer {
         return undefined;
     }
     /**
-     * The handler function referenced by a route-registration call: the first
+     * The handler function referenced by a route-registration call: the LAST
      * argument that is an inline function, or an identifier bound to a function
-     * (typically the 2nd+ arg — the path literal is not function-valued, so it is
-     * skipped naturally). No callee-name check: a call whose argument resolves to
-     * a function is structurally a registration regardless of the framework.
+     * (carrick#2472 P3-2b). The functions before it are middleware
+     * (`route(path).post(auth, audit, handler)`), which runs first and hands on;
+     * reading the first function read a middleware as the route. The path
+     * literal is not function-valued, so it is skipped naturally. No callee-name
+     * check: a call whose argument resolves to a function is structurally a
+     * registration regardless of the framework.
      */
     handlerFromRegistrationCall(call) {
-        for (const arg of call.getArguments()) {
+        for (const arg of [...call.getArguments()].reverse()) {
             const handler = this.asHandlerFunction(arg);
             if (handler) {
                 return handler;
@@ -6351,15 +6411,17 @@ export class TypeInferrer {
      * declaration (via the compiler's definition nodes) and returned when that
      * declaration is — or initializes to — a function. Anything else (a path
      * literal, an object, a non-function binding) yields undefined.
+     * `followWrapperCalls` false reads a binding to a wrapper call as no
+     * function, so a name the wrapper walk meets is never walked again.
      */
-    asHandlerFunction(node) {
+    asHandlerFunction(node, followWrapperCalls = true) {
         const expr = this.unwrapExpressionNode(node);
         if (Node.isArrowFunction(expr) || Node.isFunctionExpression(expr)) {
             return expr;
         }
         if (Node.isIdentifier(expr)) {
             for (const def of expr.getDefinitionNodes()) {
-                const func = this.functionFromDeclaration(def);
+                const func = this.functionFromDeclaration(def, followWrapperCalls);
                 if (func) {
                     return func;
                 }
@@ -6371,10 +6433,13 @@ export class TypeInferrer {
      * Extract a `FunctionLike` from a declaration node the compiler resolved an
      * identifier to: a function declaration is itself the function; a variable
      * declaration / binding whose initializer is an inline function yields that
-     * function (`const h = async () => { … }`). Import/re-export shims are walked
-     * by ts-morph's `getDefinitionNodes`, so no manual import chasing is needed.
+     * function (`const h = async () => { … }`), and one whose initializer is a
+     * wrapper call yields the function the call wraps
+     * (`const h = wrap<Contract>(async (req, res) => { … })`, carrick#2472
+     * P3-2b; `functionWrappedBy`). Import/re-export shims are walked by
+     * ts-morph's `getDefinitionNodes`, so no manual import chasing is needed.
      */
-    functionFromDeclaration(decl) {
+    functionFromDeclaration(decl, followWrapperCalls = true) {
         if (Node.isFunctionDeclaration(decl)) {
             return decl;
         }
@@ -6399,10 +6464,43 @@ export class TypeInferrer {
                 if (Node.isArrowFunction(inner) || Node.isFunctionExpression(inner)) {
                     return inner;
                 }
+                if (followWrapperCalls && Node.isCallExpression(inner)) {
+                    return this.functionWrappedBy(inner, 0);
+                }
             }
         }
         return undefined;
     }
+    /**
+     * The function a call wraps, for a name bound to that call and used as a
+     * handler (carrick#2472 P3-2b): the call's one argument that is a function
+     * literal, a name bound to one, or another such call, a few calls deep.
+     *
+     * Two conditions keep this to wrappers. The call's own value has to be
+     * callable, because the name is used as a function: `rows.map((row) => …)`
+     * is handed a function and yields a list. And exactly one argument may be a
+     * function: with two there is no saying which of them is wrapped.
+     */
+    functionWrappedBy(call, depth) {
+        if (depth >= WRAPPER_CALL_MAX_DEPTH)
+            return undefined;
+        if (!this.isCallableType(call.getType()))
+            return undefined;
+        const wrapped = [];
+        for (const arg of call.getArguments()) {
+            const value = this.unwrapExpressionNode(arg);
+            const func = Node.isArrowFunction(value) || Node.isFunctionExpression(value)
+                ? value
+                : Node.isCallExpression(value)
+                    ? this.functionWrappedBy(value, depth + 1)
+                    : Node.isIdentifier(value)
+                        ? this.asHandlerFunction(value, false)
+                        : undefined;
+            if (func)
+                wrapped.push(func);
+        }
+        return wrapped.length === 1 ? wrapped[0] : undefined;
+    }
     /**
      * True when `handler` reads nothing from the incoming message (carrick#827):
      * every use of one of its parameters, named or destructured, is the receiver
@@ -7045,6 +7143,15 @@ export class TypeInferrer {
      * below reads it.
      */
     bodyBuiltByCallee(node) {
+        const read = this.calleeBodyRead(node, 0);
+        return read.kind === 'passes' ? { kind: 'none' } : read;
+    }
+    /**
+     * `bodyBuiltByCallee`, telling apart a callee that sends the argument
+     * unchanged (`passes`) from one that states nothing about it (`none`).
+     * `depth` counts the forwarded locals followed (carrick#2671).
+     */
+    calleeBodyRead(node, depth) {
         const own = node.getType();
         if (own.isAny() || own.isUnknown())
             return { kind: 'none' };
@@ -7107,6 +7214,15 @@ export class TypeInferrer {
                 built.push(value);
                 continue;
             }
+            // carrick#2671: the use builds a local (`const payload = { ...input,
+            // code: norm(input.code) }`) the function then sends unchanged, itself
+            // or through a helper that passes it on as the body. The body is that
+            // local.
+            const forwarded = this.forwardedLocalHolding(use, body, depth);
+            if (forwarded) {
+                built.push(forwarded);
+                continue;
+            }
             const ancestors = use.getAncestors();
             const insideLiteral = ancestors
                 .slice(0, ancestors.indexOf(body))
@@ -7119,7 +7235,7 @@ export class TypeInferrer {
             }
         }
         if (built.length === 0)
-            return { kind: 'none' };
+            return passedThrough ? { kind: 'passes' } : { kind: 'none' };
         if (passedThrough) {
             return { kind: 'abstain', why: `the called function both sends the argument and builds a body from it (${from})` };
         }
@@ -7170,6 +7286,78 @@ export class TypeInferrer {
         }
         return undefined;
     }
+    /**
+     * carrick#2671: the `const` local whose initializer holds `use`, inside
+     * `scope`, when `scope` sends that local unchanged as the body: whole in a
+     * body slot, or as an argument into a function that passes it on as its
+     * body. The local's name, so its declared type is read. Undefined when the
+     * local is never sent, when a further body is built from it, or when a
+     * function lies between `use` and the declaration.
+     */
+    forwardedLocalHolding(use, scope, depth) {
+        if (depth >= 2)
+            return undefined;
+        let current = use;
+        let declaration;
+        while (current !== scope) {
+            const parent = current.getParent();
+            if (!parent)
+                return undefined;
+            if (Node.isArrowFunction(parent) ||
+                Node.isFunctionExpression(parent) ||
+                Node.isFunctionDeclaration(parent) ||
+                Node.isMethodDeclaration(parent)) {
+                return undefined;
+            }
+            if (Node.isVariableDeclaration(parent) && parent.getInitializer() === current) {
+                declaration = parent;
+                break;
+            }
+            current = parent;
+        }
+        if (!declaration)
+            return undefined;
+        if (declaration.getVariableStatement()?.getDeclarationKind() !== VariableDeclarationKind.Const) {
+            return undefined;
+        }
+        const name = declaration.getNameNode();
+        if (!Node.isIdentifier(name))
+            return undefined;
+        const symbol = name.getSymbol()?.compilerSymbol;
+        if (!symbol)
+            return undefined;
+        const checker = this.project.getTypeChecker().compilerObject;
+        let sent = false;
+        for (const ref of scope.getDescendantsOfKind(SyntaxKind.Identifier)) {
+            if (ref === name)
+                continue;
+            const parent = ref.getParent();
+            const refSymbol = parent && Node.isShorthandPropertyAssignment(parent)
+                ? checker.getShorthandAssignmentValueSymbol(parent.compilerNode)
+                : ref.getSymbol()?.compilerSymbol;
+            if (refSymbol !== symbol)
+                continue;
+            if (this.inSendNothingTest(ref, scope))
+                continue;
+            const value = this.bodyValueAround(ref, scope);
+            if (value === ref) {
+                sent = true;
+                continue;
+            }
+            if (value)
+                return undefined;
+            if (parent && Node.isCallExpression(parent) && parent.getArguments().includes(ref)) {
+                const onward = this.calleeBodyRead(ref, depth + 1);
+                if (onward.kind === 'passes') {
+                    sent = true;
+                    continue;
+                }
+                if (onward.kind !== 'none')
+                    return undefined;
+            }
+        }
+        return sent ? name : undefined;
+    }
     /** `value` is `use` behind what `sentValue` sees through. */
     isSameValue(value, use) {
         return this.sentValue(value) === use;

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

@@ -1113,6 +1113,14 @@ export interface InferredType {
      * was dropped as unsound.
      */
     unwidened_type_string?: string;
+    /**
+     * carrick#2100, response inferences only: `true` when this inference was
+     * owed an unwidened reading (its handler's path has literals to mark) and
+     * the batch's time budget ran out before it was read. The reading's absence
+     * then says nothing about the handler, so the check must not judge the
+     * widened `type_string` as what the handler sends. Absent otherwise.
+     */
+    unwidened_out_of_budget?: true;
     /**
      * carrick#1749, `call_result` only: present when the source itself states
      * the type of the body it reads, AT the read: a cast of the read