carrick 0.3.106 → 0.3.108

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

@@ -23,8 +23,10 @@ import { validateInferRequestItem } from './validators.js';
 import { notePrintedType, PrintedTypes } from './printed-names.js';
 import { externalImportsOf, isExternalOrigin } from './origin.js';
 import { reachedOnlyOnFailure } from './failure-path.js';
+import { functionAtLine } from './function-line-index.js';
+import { elapsedMs, inferTiming, phaseClock, timedPhase } from './infer-timing.js';
 import { addedDiagnostics, applyInsertions, fileDiagnostics, literalInsertions, mapBack, mapForward, normalise, pathOf, } from './unwidened.js';
-import { expandTypeStructural, } from './type-structural-expander.js';
+import { expandTypeStructural, jsonWireType, } from './type-structural-expander.js';
 /**
  * TS/lib globals and primitives that must never be emitted as a deterministic
  * type anchor (`primary_type_symbol`). A payload whose resolved symbol is one of
@@ -239,7 +241,9 @@ const RAW_TEXT_FORMAT = 'text';
  */
 const TYPE_TEXT_FLAGS = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.InTypeAlias;
 function typeText(type, enclosingNode) {
-    const text = type.getText(enclosingNode, TYPE_TEXT_FLAGS);
+    // Timed as the print (carrick#1985): the type is already computed when it
+    // gets here, so this is what its length costs.
+    const text = timedPhase('print', () => type.getText(enclosingNode, TYPE_TEXT_FLAGS));
     notePrintedType(type, enclosingNode, text);
     return text;
 }
@@ -255,13 +259,17 @@ function isBareStringText(text) {
 /**
  * How long the unwidened reading of one batch may take by default. The
  * reading adds a field and never an answer, so running out costs only the
- * readings not yet made; the rewrite is always undone.
+ * readings not yet made; the rewrite is always undone. It reports no
+ * progress, so this is also the longest a batch goes silent after its last
+ * request: well inside the 900s the scanner allows between two signs of life.
  */
 const UNWIDENED_BUDGET_MS = 120_000;
 /**
- * No reading starts or continues past this long after the batch began: the
- * scanner's read deadline for one request is 900s, and the inferences the
- * batch already made must reach it.
+ * No reading starts or continues past this long after the batch began. The
+ * number dates from when the scanner allowed a whole request 900s; it now
+ * allows that long between progress reports (carrick#1914), so a batch can
+ * run past this and still be read. A batch that does publishes no unwidened
+ * reading, as before.
  */
 const UNWIDENED_LATEST_MS = 600_000;
 /**
@@ -282,6 +290,12 @@ export class TypeInferrer {
      */
     readNodes = new WeakMap();
     unwidenedBudgetMs;
+    /**
+     * The files a request has named to this inferrer, as the requests named
+     * them (carrick#1985). It lives as long as the project does, so the first
+     * request of a file is the first of the process, not of a batch.
+     */
+    filesAsked = new Set();
     constructor(options) {
         this.project = options.project;
         this.packageOf = options.packageOf;
@@ -306,24 +320,32 @@ export class TypeInferrer {
      *
      * @param requests - Array of inference requests
      * @param extractionConfig - Agent-generated extraction config for payload unwrapping
+     * @param onRequestDone - Called once per request, as the batch is done with it
      * @returns InferResult with inferred types or errors
      */
-    infer(requests, extractionConfig) {
+    infer(requests, extractionConfig, onRequestDone) {
         const started = performance.now();
         const inferredTypes = [];
         const errors = [];
         /** Response inferences the unwidened reading re-reads (carrick#1516). */
         const responses = [];
+        /** How long each request took, in the order they were done (carrick#1985). */
+        const timings = [];
         for (const request of requests) {
-            // Plain JavaScript has no type annotations to extract, and `checkJs` is
-            // off, so inferring against a `.js` file yields nothing useful — it only
-            // crashes deep in the compiler API on undefined symbols (`escapedName`,
-            // `flags`) and floods the log with the resulting error strings. Skip it.
-            // `allowJs` stays on so `.ts` files can still resolve `.js` imports.
-            if (/\.(js|jsx|mjs|cjs)$/i.test(request.file_path)) {
-                continue;
-            }
+            const slotStarted = performance.now();
+            const phasesStarted = phaseClock();
+            const firstInFile = !this.filesAsked.has(request.file_path);
+            this.filesAsked.add(request.file_path);
+            let printedLength = 0;
             try {
+                // Plain JavaScript has no type annotations to extract, and `checkJs` is
+                // off, so inferring against a `.js` file yields nothing useful — it only
+                // crashes deep in the compiler API on undefined symbols (`escapedName`,
+                // `flags`) and floods the log with the resulting error strings. Skip it.
+                // `allowJs` stays on so `.ts` files can still resolve `.js` imports.
+                if (/\.(js|jsx|mjs|cjs)$/i.test(request.file_path)) {
+                    continue;
+                }
                 const loc = this.formatRequestLocation(request);
                 const itemError = validateInferRequestItem(request);
                 if (itemError) {
@@ -337,6 +359,7 @@ export class TypeInferrer {
                 const prints = new PrintedTypes();
                 const result = prints.during(() => this.inferSingle(request, extractionConfig));
                 if (result) {
+                    printedLength = result.type_string.length;
                     this.recordPrintedNames(result, request, prints);
                     inferredTypes.push(result);
                     if (request.infer_kind === 'response_body' || request.infer_kind === 'function_return') {
@@ -352,6 +375,23 @@ export class TypeInferrer {
                 const loc = this.formatRequestLocation(request);
                 errors.push(`Error inferring type at ${request.file_path}:${loc}: ${error}`);
             }
+            finally {
+                // Before the caller is told: what it does with the news (a progress
+                // frame) is not this request's time.
+                const phases = phaseClock();
+                timings.push({
+                    ...(request.alias === undefined ? {} : { alias: request.alias }),
+                    file_path: request.file_path,
+                    line_number: request.line_number,
+                    infer_kind: request.infer_kind,
+                    ms: elapsedMs(slotStarted, performance.now()),
+                    type_ms: elapsedMs(phasesStarted.type, phases.type),
+                    print_ms: elapsedMs(phasesStarted.print, phases.print),
+                    printed_length: printedLength,
+                    first_in_file: firstInFile,
+                });
+                onRequestDone?.();
+            }
         }
         try {
             const deadline = Math.min(performance.now() + this.unwidenedBudgetMs, started + UNWIDENED_LATEST_MS);
@@ -364,6 +404,7 @@ export class TypeInferrer {
         return {
             success: errors.length === 0 || inferredTypes.length > 0,
             inferred_types: inferredTypes.length > 0 ? inferredTypes : undefined,
+            timing: inferTiming(timings),
             errors: errors.length > 0 ? errors : undefined,
         };
     }
@@ -771,7 +812,7 @@ export class TypeInferrer {
             return null;
         }
         const anchor = this.unwrapArrayLevels(awaitedType);
-        const inferred = this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(func), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, this.primaryTypeSymbol(anchor.element), anchor.depth);
+        const inferred = this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(func), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, this.primaryTypeSymbol(anchor.element), anchor.depth, this.primaryTypeSymbolSource(anchor.element));
         if (provenance && provenance.length > 0) {
             inferred.any_provenance = provenance;
         }
@@ -790,7 +831,10 @@ export class TypeInferrer {
             return null;
         }
         const isExplicit = func.getReturnTypeNode() !== undefined;
-        const typeString = typeText(func.getReturnType(), func);
+        // The compiler call is timed apart from the print of what it returns
+        // (carrick#1985).
+        const returnType = timedPhase('type', () => func.getReturnType());
+        const typeString = typeText(returnType, func);
         return this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(func));
     }
     /**
@@ -817,7 +861,7 @@ export class TypeInferrer {
             return null;
         }
         const isExplicit = target.param.getTypeNode() !== undefined;
-        const paramType = target.node.getType();
+        const paramType = timedPhase('type', () => target.node.getType());
         const typeString = typeText(paramType, target.node);
         // Deterministic anchor for the pub/sub two-anchor arbitration
         // (carrick#413): report the payload type's root symbol, its declaration
@@ -892,11 +936,50 @@ export class TypeInferrer {
                 this.log(`Line ${request.line_number} is a route registration; following handler return`);
                 return this.buildFunctionReturnInferredType(request, atLine.handler, extractionConfig, true);
             }
+            // carrick#807: the request named an expression and the file holds none
+            // that matches. Where its line declares the handler, that handler is
+            // still the row's, and what it returns is still the question. Without
+            // this the unmatched text also fails the function lookup below, and a
+            // row a line-only request answers is lost to a locator that added
+            // nothing.
+            const declaredHandler = request.expression_text
+                ? this.handlerDeclaredAtLine(sourceFile, request.line_number)
+                : undefined;
+            if (declaredHandler) {
+                this.log(`No node matches the located expression at ${request.file_path}:${request.line_number}; ` +
+                    'reading what the handler this line declares returns');
+                return this.buildFunctionReturnInferredType(request, declaredHandler, extractionConfig, true);
+            }
             // No locator, or locator didn't resolve — likely a payload-less handler
             // (redirect, 204, streaming). Infer the containing function's return type.
             this.log(`No payload node found for request at ${request.file_path}:${request.line_number}; falling back to function return`);
             return this.inferFunctionReturn(sourceFile, request, extractionConfig);
         }
+        // carrick#807: the row's line declares the handler itself, as it does for
+        // a route its module's place in the project states, and the located
+        // expression sits inside that handler. What the handler returns is the
+        // answer a line-only request gets, and a locator must not change it.
+        // The ancestor test comes first because it is free: only a node inside a
+        // function that opens on the row's line can be inside the one the line
+        // declares, and most rows are not.
+        const insideFunctionOnLine = node
+            .getAncestors()
+            .some((ancestor) => (Node.isFunctionDeclaration(ancestor) ||
+            Node.isArrowFunction(ancestor) ||
+            Node.isFunctionExpression(ancestor) ||
+            Node.isMethodDeclaration(ancestor)) &&
+            ancestor.getStartLineNumber() === request.line_number);
+        const declaredHandler = insideFunctionOnLine
+            ? this.handlerDeclaredAtLine(sourceFile, request.line_number)
+            : undefined;
+        if (declaredHandler &&
+            declaredHandler.getStart() <= node.getStart() &&
+            node.getEnd() <= declaredHandler.getEnd()) {
+            const returned = this.responseOfDeclaredHandler(request, declaredHandler, node, extractionConfig);
+            if (returned !== undefined) {
+                return returned;
+            }
+        }
         // Route-registry object literal: the locator lands on the registry entry
         // `{ method, path, handler: healthCheckHandler }`, whose response contract
         // is the handler's RETURN type — one indirection away, NOT the object's own
@@ -1013,7 +1096,141 @@ export class TypeInferrer {
             typeString = this.expandResolvedTypeStructural(resolved, typeString, this.wireFormatFor(request));
         }
         const anchor = this.unwrapArrayLevels(this.unwrapPromiseType(payloadType));
-        return this.createInferredType(request, typeString, false, this.getNodeLocation(payloadNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, this.primaryTypeSymbol(anchor.element), anchor.depth);
+        return this.createInferredType(request, typeString, false, this.getNodeLocation(payloadNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, this.primaryTypeSymbol(anchor.element), anchor.depth, this.primaryTypeSymbolSource(anchor.element));
+    }
+    /**
+     * The handler a module exports on `line`: a function that opens on exactly
+     * that line, exported at the top of its module, where no call on the line
+     * registers a route (carrick#807).
+     *
+     * That is the anchor of a route its module's place in the project states:
+     * the row's line is the handler's own export, and the module's exports are
+     * how the framework finds it. Each condition keeps another kind of row out:
+     *
+     *  - the line has to be the function's first, with no tolerance. A model
+     *    row that names no site of its own can sit on any line of a handler,
+     *    and the nearest function to such a line is whatever is declared
+     *    beside it;
+     *  - a method of a class is a controller's handler, whose rows are
+     *    anchored on what a model located before the method's own return;
+     *  - a line that registers a route has a registration to read.
+     */
+    handlerDeclaredAtLine(sourceFile, line) {
+        const declared = this.exportedFunctionOpeningOn(sourceFile, line);
+        return declared && !this.registrationAtLine(sourceFile, line) ? declared : undefined;
+    }
+    /**
+     * `handlerDeclaredAtLine` without its registration test, for a caller that
+     * has already looked for a registration on the line.
+     */
+    exportedFunctionOpeningOn(sourceFile, line) {
+        const declared = this.findFunctionByLine(sourceFile, line);
+        if (!declared || declared.getStartLineNumber() !== line)
+            return undefined;
+        if (Node.isFunctionDeclaration(declared)) {
+            return Node.isSourceFile(declared.getParent()) && declared.isExported()
+                ? declared
+                : undefined;
+        }
+        if (!Node.isArrowFunction(declared) && !Node.isFunctionExpression(declared)) {
+            return undefined;
+        }
+        const binding = declared.getParent();
+        if (!Node.isVariableDeclaration(binding) || binding.getInitializer() !== declared) {
+            return undefined;
+        }
+        const statement = binding.getVariableStatement();
+        return statement && Node.isSourceFile(statement.getParent()) && statement.isExported()
+            ? declared
+            : undefined;
+    }
+    /**
+     * The response of a handler the request's line declares, for a request
+     * that also located an expression inside it (carrick#807).
+     *
+     * The handler's own return is read first, exactly as a `function_return`
+     * request at the line reads it, and that reading stands: a body it
+     * recovered, and a decision it made not to publish one. The located
+     * expression is consulted in one case only. Where the handler returns a
+     * call nothing resolves (its library is not installed), the return walk
+     * reads no argument the source does not annotate, because it cannot tell a
+     * response sender from a query. A located payload that is an ARGUMENT of
+     * such a returned call says which it is, so the same walk runs again with
+     * that callee taken as a sender: every success body the handler returns
+     * through it, error branches dropped as before. The located expression's
+     * own type is never what is published here.
+     *
+     * Returns `undefined` when the located expression is something the return
+     * walk never looked at, so it is left to the readings below:
+     *  - the handler returns nothing (`void`): it sends through a parameter;
+     *  - the handler returns transport the walk read no body out of, and the
+     *    located expression is not part of what it returns. A body built before
+     *    the response is returned (`const res = send(body); ...; return res`)
+     *    is one. Named on a send that states an error or redirect status, it is
+     *    no success body and the row abstains.
+     */
+    responseOfDeclaredHandler(request, handler, located, extractionConfig) {
+        const walked = this.buildFunctionReturnInferredType(request, handler, extractionConfig);
+        const returned = this.responseReturnedExpressions(handler);
+        if (walked === null) {
+            // The walk read everything the handler returns and published nothing.
+            // A located expression inside one of those returns was part of that.
+            if (this.returnedSendHolding(returned, located)) {
+                this.log(`Response locator at ${request.file_path}:${request.line_number} names a send ` +
+                    'its handler returns, which carries no body a contract can describe; abstaining');
+                return null;
+            }
+            // Outside the return, it is either a send itself or what one was handed.
+            const sends = [
+                this.peelTransparentExpression(located),
+                this.receivingCallOf(located, () => true),
+            ];
+            const statesNoBody = sends.some((send) => {
+                const status = send ? this.responseSiteStatus(send) : 'undecided';
+                return status === 'error' || status === 'redirect';
+            });
+            if (statesNoBody) {
+                this.log(`Response locator at ${request.file_path}:${request.line_number} names an error ` +
+                    'or redirect send and its handler returns no success body; abstaining');
+                return null;
+            }
+            return undefined;
+        }
+        const text = walked.type_string.trim();
+        if (text === 'void' || text === 'undefined' || text === 'never' || text === '') {
+            return undefined;
+        }
+        const unresolvedCallee = (walked.any_provenance ?? []).some((entry) => entry.reason === 'no_payload_evidence');
+        if (!unresolvedCallee) {
+            return walked;
+        }
+        const sender = this.returnedSendHolding(returned, located);
+        const identity = sender ? this.calleeIdentity(sender) : undefined;
+        if (identity) {
+            const recovered = this.recoverPayloadFromResponseExpressions(returned, true, this.wireFormatFor(request), new Set([identity]));
+            if (recovered) {
+                this.log(`Return type at ${request.file_path}:${request.line_number} resolves to nothing; ` +
+                    'the located payload is an argument of a call the handler returns, so that ' +
+                    "call is a response sender and its success bodies are the route's");
+                return this.inferredFromRecoveredPayload(request, recovered);
+            }
+        }
+        return walked;
+    }
+    /**
+     * The call inside one of `returned` that the located expression is, or is
+     * an argument of: the send a located payload was handed to. `undefined`
+     * when the located expression is not part of what the handler returns.
+     */
+    returnedSendHolding(returned, located) {
+        const branches = returned.flatMap((expression) => this.expandResponseBranches(expression, 0));
+        const isReturned = (candidate) => branches.some((branch) => branch.getStart() <= candidate.getStart() && candidate.getEnd() <= branch.getEnd());
+        const peeled = this.peelTransparentExpression(located);
+        if ((Node.isCallExpression(peeled) || Node.isNewExpression(peeled)) &&
+            branches.includes(peeled)) {
+            return peeled;
+        }
+        return this.receivingCallOf(located, isReturned);
     }
     /**
      * True when a located call's own result is the route's payload, so the
@@ -1038,7 +1255,10 @@ export class TypeInferrer {
         if (this.symbolIsLibOrExternalOrigin(element.getSymbol() ?? element.getAliasSymbol())) {
             return false;
         }
-        return this.nodeCarriesPayloadContract(call, false);
+        // Asked of the result as DECLARED. A value of the repo's own that
+        // serialises to a string is still what the route sends, and drilling into
+        // the call that built it would publish what it was built from.
+        return this.nodeCarriesPayloadContract(call, false, false);
     }
     /**
      * The wire representation a request's printed type takes. A route response
@@ -1069,7 +1289,12 @@ export class TypeInferrer {
         // resolved symbol is the better answer and keeps its precedence.
         const stated = recovered.statedTypeNode;
         const writtenAnchor = resolvedSymbol === undefined && stated ? this.writtenAnchorOf(stated) : undefined;
-        return this.createInferredType(request, recovered.typeString, recovered.isExplicit, this.getNodeLocation(recovered.node), undefined, resolvedSymbol ?? writtenAnchor?.symbol, writtenAnchor ? writtenAnchor.depth : recoveredAnchor?.depth, writtenAnchor?.source);
+        // carrick#1819: a symbol the resolved type carries has a declaration file
+        // as much as one read off the annotation does.
+        const resolvedSource = resolvedSymbol !== undefined && recoveredAnchor
+            ? this.primaryTypeSymbolSource(recoveredAnchor.element)
+            : undefined;
+        return this.createInferredType(request, recovered.typeString, recovered.isExplicit, this.getNodeLocation(recovered.node), undefined, resolvedSymbol ?? writtenAnchor?.symbol, writtenAnchor ? writtenAnchor.depth : recoveredAnchor?.depth, writtenAnchor ? writtenAnchor.source : resolvedSource);
     }
     /**
      * carrick#1161: type a route response from every send in the handler the
@@ -1234,6 +1459,38 @@ export class TypeInferrer {
             typeString = explicitType;
             isExplicit = true;
         }
+        // carrick#1843: a rule can now match a thenable or a carrier by its alias,
+        // so on a result that is a carrier (`Task<Outcome<Reply<T>, E>>`) the
+        // rules reach what the carrier holds before the carrier read below does.
+        // That changes who finds the payload, never what is published: where the
+        // rules read through the carrier, their answer is given the way the
+        // carrier read gives its own. A result that is no carrier keeps the
+        // answer it had.
+        const where = `${request.file_path}:${request.line_number}`;
+        const resultIsCarrier = !explicitType && this.resultCarrierArguments(returnType, terminalNode) !== undefined;
+        // carrick#1877: the terminal holds a thenable the names do not peel, a
+        // subclass of `Promise` or a class with a `then` of its own. What a
+        // caller receives is what `await` yields for it, as it is for the
+        // `Promise<T>` the text unwrap at the end of this function peels: the
+        // class is transport. A rule that matched the type as written, a type the
+        // source states and a carrier behind the thenable have each answered
+        // already and keep their answers.
+        if (!unwrapResult.wasUnwrapped && !explicitType && !resultIsCarrier) {
+            const yielded = this.awaitedBeyondPromise(returnType);
+            if (yielded) {
+                typeString = typeText(yielded, terminalNode);
+            }
+        }
+        // The rules verified what the carrier holds as transport and read no
+        // payload out of it (`Reply<unknown>`). That is the decision carrick#1841
+        // makes below, and it is decided here for the same reason: left
+        // undecided, the capture's own locator re-reads the raw call and
+        // publishes the library's objects.
+        if (unwrapResult.verifiedMachinery && resultIsCarrier) {
+            this.log(`Call result at ${where} is a carrier of transport the service's wrapper rules ` +
+                'verify and read no payload out of; this site states no response contract');
+            return this.transportAbstain(request, callExpr);
+        }
         // carrick#1376: the call answers a RESULT CARRIER — a generic union whose
         // branches say whether the call worked and carry, on the success side, the
         // value it produced. The carrier is the transport's own bookkeeping; the
@@ -1241,12 +1498,30 @@ export class TypeInferrer {
         // the carrier instead reports an envelope as a wire contract, which is the
         // same class of answer the machinery guard refuses on the producer side.
         //
-        // A wrapper rule that already unwrapped, and a type the source itself
-        // states, both outrank this: they are what the service's own config and
-        // its own author said.
-        const carrierCandidate = unwrapResult.wasUnwrapped || explicitType
+        // A type the source itself states outranks this: it is what the author
+        // said. A wrapper rule that unwrapped is read first, and on a carrier it
+        // no longer ends the matter (carrick#1843):
+        //
+        //  - a service with a rule for `Task` and none for `Outcome` leaves
+        //    `Outcome<Reply<T>, E>`, which is as much a carrier as it was before
+        //    the rule could match. The carrier read takes what the rule left.
+        //  - a service with a rule for `Outcome` too reads the payload out of the
+        //    carrier itself. That payload is what the carrier holds, and is
+        //    published as the carrier read publishes it, so a site answers the
+        //    same whichever of the two found its payload.
+        //
+        // A rule that left no single payload (a union join) leaves nothing to
+        // read.
+        const afterRules = unwrapResult.wasUnwrapped ? unwrapResult.payloadType : returnType;
+        const readThroughCarrier = unwrapResult.wasUnwrapped &&
+            resultIsCarrier &&
+            !!afterRules &&
+            this.resultCarrierArguments(afterRules, terminalNode) === undefined;
+        const carrierCandidate = explicitType || !afterRules
             ? undefined
-            : this.resultCarrierPayload(returnType, terminalNode, use.projections, `${request.file_path}:${request.line_number}`);
+            : readThroughCarrier
+                ? afterRules
+                : this.resultCarrierPayload(afterRules, terminalNode, use.projections, where);
         // carrick#1841: what the carrier holds goes through the service's wrapper
         // rules before it is published, as the call's own result did. The carrier
         // is found by its shape, so what it holds can still be a library's
@@ -1269,21 +1544,9 @@ export class TypeInferrer {
             carrierUnwrap?.wasUnwrapped &&
             carrierUnwrap.typeString.trim() === 'unknown') {
             const carried = typeText(carrierCandidate, terminalNode);
-            this.log(`Call result at ${request.file_path}:${request.line_number} carries ${carried}, which ` +
-                "the service's wrapper rules verify as transport and read no payload out of; this " +
-                'site states no response contract');
-            const abstain = this.createInferredType(request, 'unknown', false, this.getNodeLocation(callExpr));
-            abstain.any_provenance = [
-                {
-                    path: '',
-                    kind: 'unknown',
-                    reason: 'machinery_envelope',
-                    detail: "what this call's result carries is transport that the service's wrapper rules " +
-                        'verify and read no payload out of (a library response object around the body), ' +
-                        'so this site states no response contract',
-                },
-            ];
-            return abstain;
+            this.log(`Call result at ${where} carries ${carried}, which the service's wrapper rules ` +
+                'verify as transport and read no payload out of; this site states no response contract');
+            return this.transportAbstain(request, callExpr);
         }
         const carried = carrierUnwrap?.wasUnwrapped && carrierUnwrap.payloadType
             ? carrierUnwrap.payloadType
@@ -1358,19 +1621,40 @@ export class TypeInferrer {
         // to no single payload (union join, verified machinery) carries no
         // payloadType and anchors nothing; the wrapper's own symbol must never
         // anchor via that path.
-        const callPayloadType = this.unwrapPromiseType(callExpr.getType());
-        const callUnwrap = this.unwrapTypeWithConfig(callPayloadType, callExpr, extractionConfig);
+        //
+        // carrick#1877: the call's payload is what `await` yields for the call's
+        // type. Where no rule matched that type as the names peel it, the same
+        // protocol reading the text takes is read here, so a subclass of
+        // `Promise` anchors the row on what it resolves to and never on itself.
+        let callPayloadType = this.unwrapPromiseType(callExpr.getType());
+        let callUnwrap = this.unwrapTypeWithConfig(callPayloadType, callExpr, extractionConfig);
+        let readByProtocol = false;
+        if (!callUnwrap.wasUnwrapped) {
+            const yielded = this.awaitedBeyondPromise(callPayloadType);
+            if (yielded) {
+                callPayloadType = yielded;
+                callUnwrap = this.unwrapTypeWithConfig(yielded, callExpr, extractionConfig);
+                readByProtocol = true;
+            }
+        }
         // carrick#1376: the carrier's own symbol must never anchor either. The
         // surface pre-claims the alias from the anchor, so anchoring on the
         // carrier makes the capture emit the transport's bookkeeping as the
         // operation's declaration — and where the carrier is a local interface the
         // service does not export, nothing is emitted at all and the row reads
         // null. The payload the carrier was found to hold is the anchor.
-        const anchorSource = carrierPayload
-            ? carrierPayload
-            : callUnwrap.wasUnwrapped
-                ? callUnwrap.payloadType
-                : callPayloadType;
+        //
+        // carrick#1843: that holds for a carrier a rule left of the call's own
+        // result too. A rule for `Task` alone turns `Task<Outcome<T, E>>` into
+        // `Outcome<T, E>` here, and where the terminal's read took no payload out
+        // of it (an open payload, or a terminal further down a chain) the
+        // carrier's alias would otherwise be the anchor. The same holds for a
+        // carrier the protocol reading left (carrick#1877).
+        const callAfterRules = callUnwrap.wasUnwrapped ? callUnwrap.payloadType : callPayloadType;
+        const leftCarrier = (callUnwrap.wasUnwrapped || readByProtocol) &&
+            !!callAfterRules &&
+            this.resultCarrierArguments(callAfterRules, callExpr) !== undefined;
+        const anchorSource = carrierPayload ?? (leftCarrier ? undefined : callAfterRules);
         let anchor = anchorSource
             ? this.unwrapArrayLevels(this.unwrapPromiseType(anchorSource))
             : undefined;
@@ -1415,7 +1699,7 @@ export class TypeInferrer {
                 }
             }
         }
-        const inferred = this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(terminalNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, anchor ? this.primaryTypeSymbol(anchor.element) : undefined, anchor?.depth);
+        const inferred = this.createInferredType(request, typeString, isExplicit, this.getNodeLocation(terminalNode), unwrapResult.wasUnwrapped ? unwrapResult.typeString : undefined, anchor ? this.primaryTypeSymbol(anchor.element) : undefined, anchor?.depth, anchor ? this.primaryTypeSymbolSource(anchor.element) : undefined);
         // carrick#1749: say when the text is the source's own statement of the
         // body, and what that statement is rooted at, so the scanner can tell a
         // model symbol that names the body from one that names a part of it.
@@ -1528,6 +1812,17 @@ export class TypeInferrer {
      * else, and is not reported.
      */
     statedBodyAtRead(terminal) {
+        const typeNode = this.typeNodeStatedAtRead(terminal);
+        return typeNode ? this.statedRoot(typeNode) : undefined;
+    }
+    /**
+     * The type node `statedBodyAtRead` reads, for a caller that wants the
+     * annotation itself: a consumer's response read reports its root, and a
+     * handler's request read prints it (carrick#807). One reading of "stated at
+     * the read" for both, so the two cannot disagree about which annotation
+     * belongs to a read.
+     */
+    typeNodeStatedAtRead(terminal) {
         const typeNode = this.explicitTypeNodeFromAncestor(terminal);
         const owner = typeNode?.getParent();
         if (!typeNode || !owner || this.leavesAPositionOpen(typeNode))
@@ -1554,7 +1849,7 @@ export class TypeInferrer {
             }
             current = parent;
         }
-        return this.statedRoot(typeNode);
+        return typeNode;
     }
     /**
      * A stated type with `any` or `unknown` written anywhere in it (`unknown`,
@@ -1694,12 +1989,31 @@ export class TypeInferrer {
             // expression in the body (`c.req.json<T>()`, `req.body as T`).
             const atLine = this.registrationAtLine(sourceFile, request.line_number);
             if (atLine) {
-                const requestType = this.requestContractFromRegistration(atLine.registration, atLine.handler);
-                if (requestType) {
-                    return this.declaredRequestInferredType(request, requestType, this.getNodeLocation(atLine.handler));
+                const declared = this.declaredRequestContract(atLine.registration, atLine.handler);
+                if (declared) {
+                    return this.declaredRequestInferredType(request, declared, this.getNodeLocation(atLine.handler));
                 }
             }
-            return null;
+            // With no call registering a route on this line, the line is the
+            // handler's own export: all that anchors a route its module's place in
+            // the project states (carrick#807). Either way the body is what the
+            // handler reads off the platform request it was handed, where the
+            // source says what it read.
+            const handler = atLine?.handler ?? this.exportedFunctionOpeningOn(sourceFile, request.line_number);
+            if (!handler) {
+                return null;
+            }
+            const read = this.platformBodyReadIn(handler);
+            const stated = read ? this.requestStatedAtBodyRead(request, read) : null;
+            if (stated) {
+                return stated;
+            }
+            // The first typed read anywhere in the handler is a looser reading, and
+            // is kept only where a registration already had it.
+            const typedRead = atLine ? this.inferRequestReadFromHandler(atLine.handler) : null;
+            return typedRead
+                ? this.declaredRequestInferredType(request, { text: typedRead }, this.getNodeLocation(handler))
+                : null;
         }
         // Inline-handler registration (`app.post('/x', async (c) => { … })`) or a
         // route-registry object literal: the locator lands on the registration, not
@@ -1973,6 +2287,21 @@ export class TypeInferrer {
                 return { terminal: returnExpr, projectionOnly: false, projections: [] };
             }
         }
+        // carrick#1851: the source reads the body in place on the call's own
+        // value, `const body = await (await fetch(url)).text()`. No binding holds
+        // the response, so the walk below has nothing to follow, and the call
+        // itself would stand as the terminal and publish the transport object.
+        // The read is the terminal, as it is when the walk finds it on a binding,
+        // and a call that takes the read and states what it returns says more
+        // than the read does (carrick#1382).
+        const inPlaceRead = this.bodyReadOnCallValue(callExpr);
+        if (inPlaceRead) {
+            return {
+                terminal: this.statedPayloadAroundBodyRead(inPlaceRead) ?? inPlaceRead,
+                projectionOnly: false,
+                projections: [],
+            };
+        }
         const binding = this.extractBindingFromCall(callExpr);
         if (binding && func) {
             let currentNames = binding.names;
@@ -2134,36 +2463,11 @@ export class TypeInferrer {
      * reader can see is an envelope.
      */
     resultCarrierPayload(type, at, projections, where) {
-        const carrier = this.unwrapThenableType(this.unwrapPromiseType(type));
-        if (!carrier.isUnion()) {
-            return undefined;
-        }
-        const branches = carrier.getUnionTypes();
-        if (branches.length < 2 || !branches.every((branch) => this.isObjectShape(branch))) {
-            return undefined;
-        }
-        const args = [
-            ...carrier.getAliasTypeArguments(),
-            ...carrier.getTypeArguments(),
-        ];
-        if (args.length < 2) {
-            return undefined;
-        }
-        // A type argument only names a payload when a branch actually holds it:
-        // a generic that parameterises a status code or a key carries nothing.
-        const carried = args.filter((arg) => branches.some((branch) => branch
-            .getProperties()
-            .some((property) => {
-            try {
-                return property.getTypeAtLocation(at).getText() === arg.getText();
-            }
-            catch {
-                return false;
-            }
-        })));
-        if (carried.length === 0) {
+        const shape = this.resultCarrierArguments(type, at);
+        if (!shape) {
             return undefined;
         }
+        const { carrier, carried } = shape;
         const argTexts = new Map(carried.map((arg) => [arg.getText(), arg]));
         const read = new Set();
         for (const projection of projections) {
@@ -2198,12 +2502,102 @@ export class TypeInferrer {
         return undefined;
     }
     /**
-     * `Future<T>` -> `T` for a promise-like of the source's own making, read off
-     * the await protocol rather than a name: a `then` whose first parameter is a
-     * callback, whose own first parameter is the value awaiting it yields.
-     * `Promise` and `PromiseLike` are peeled by `unwrapPromiseType` before this.
+     * The shape test of `resultCarrierPayload`: the carrier `type` is, once a
+     * promise-like around it is peeled, and the type arguments a branch of it
+     * holds as a member. `undefined` when `type` is not a carrier.
+     */
+    resultCarrierArguments(type, at) {
+        const carrier = this.unwrapThenableType(this.unwrapPromiseType(type));
+        if (!carrier.isUnion()) {
+            return undefined;
+        }
+        const branches = carrier.getUnionTypes();
+        if (branches.length < 2 || !branches.every((branch) => this.isObjectShape(branch))) {
+            return undefined;
+        }
+        const args = [
+            ...carrier.getAliasTypeArguments(),
+            ...carrier.getTypeArguments(),
+        ];
+        if (args.length < 2) {
+            return undefined;
+        }
+        // A type argument only names a payload when a branch actually holds it:
+        // a generic that parameterises a status code or a key carries nothing.
+        const carried = args.filter((arg) => branches.some((branch) => branch
+            .getProperties()
+            .some((property) => {
+            try {
+                return property.getTypeAtLocation(at).getText() === arg.getText();
+            }
+            catch {
+                return false;
+            }
+        })));
+        return carried.length === 0 ? undefined : { carrier, carried };
+    }
+    /**
+     * The decided abstain of a call whose result carries transport the
+     * service's wrapper rules verify and read no payload out of (carrick#1841,
+     * carrick#1843): `unknown` with `machinery_envelope` at the root and no
+     * anchor. The root reason is what keeps the capture's own locator from
+     * re-reading the raw call (`inference_decided_no_contract`,
+     * engine/type_compat_v2.rs).
+     */
+    transportAbstain(request, callExpr) {
+        const abstain = this.createInferredType(request, 'unknown', false, this.getNodeLocation(callExpr));
+        abstain.any_provenance = [
+            {
+                path: '',
+                kind: 'unknown',
+                reason: 'machinery_envelope',
+                detail: "what this call's result carries is transport that the service's wrapper rules " +
+                    'verify and read no payload out of (a library response object around the body), ' +
+                    'so this site states no response contract',
+            },
+        ];
+        return abstain;
+    }
+    /**
+     * `Future<T>` -> `T` for a thenable, read off the await protocol rather
+     * than a name: a `then` whose first parameter is a callback, whose own
+     * first parameter is the value awaiting it yields. `Promise` and
+     * `PromiseLike` are peeled by `unwrapPromiseType` before this.
+     *
+     * The callback is read through `null` and `undefined` (carrick#1877). A
+     * `then` of the source's own making declares `(value: T) => void`; the
+     * platform's declares `onfulfilled?: ((value: T) => ...) | null`, and that
+     * is the `then` a subclass of `Promise` inherits. Read as written, an
+     * optional, nullable callback has no call signature, and the subclass was
+     * not seen as a thenable at all.
+     *
+     * A `then` that cannot be called, or whose first parameter is no callback,
+     * is no protocol, and the type is returned as it is.
+     *
+     * The compiler's own awaited type arbitrates. This walk reads the first
+     * signature of `then`; the language reads all of them. Where awaiting the
+     * type and awaiting what this walk found are not the same thing to the
+     * compiler (an overloaded `then` whose first signature is not the one
+     * `await` takes), the walk did not read the protocol, and the type is
+     * returned as it is rather than published as a guess.
      */
     unwrapThenableType(type) {
+        const yielded = this.firstThenValue(type);
+        if (yielded === type)
+            return type;
+        try {
+            const checker = this.project.getTypeChecker().compilerObject;
+            const awaited = checker.getAwaitedType(type.compilerType);
+            return awaited !== undefined && awaited === checker.getAwaitedType(yielded.compilerType)
+                ? yielded
+                : type;
+        }
+        catch {
+            return type;
+        }
+    }
+    /** The value `then`'s first signature hands its callback, read until it stops changing. */
+    firstThenValue(type) {
         let current = type;
         for (let depth = 0; depth < 8; depth++) {
             const then = current.getProperty('then');
@@ -2216,7 +2610,8 @@ export class TypeInferrer {
                     .getTypeAtLocation(declaration)
                     .getCallSignatures()[0]
                     ?.getParameters()[0]
-                    ?.getTypeAtLocation(declaration);
+                    ?.getTypeAtLocation(declaration)
+                    .getNonNullableType();
             }
             catch {
                 return current;
@@ -2231,6 +2626,18 @@ export class TypeInferrer {
         }
         return current;
     }
+    /**
+     * What `await` yields for `type` where the names do not say: `type` is,
+     * once `Promise` and `PromiseLike` are peeled, a thenable by the protocol
+     * (a subclass of `Promise`, a class with a `then` of its own). `undefined`
+     * where the names say it all or `type` is no thenable, so a caller keeps
+     * the reading it had (carrick#1877).
+     */
+    awaitedBeyondPromise(type) {
+        const named = this.unwrapPromiseType(type);
+        const yielded = this.unwrapThenableType(named);
+        return yielded === named ? undefined : yielded;
+    }
     /**
      * The platform's error shape, in full: `name` and `message` strings AND a
      * `stack`, which is what the `Error` interface declares and every subclass
@@ -2513,16 +2920,40 @@ export class TypeInferrer {
         });
     }
     /**
-     * The zero-argument whole-body read that takes `identifier` as its receiver,
+     * The zero-argument whole-body read taken in place on the value `callExpr`
+     * yields, or `undefined` (carrick#1851): `(await fetch(url)).text()`. The
+     * receiver is the call itself, through the wrappers that leave a value as
+     * it is (parentheses, `await`, `!`), so it is the same read
+     * `bodyReadOnReceiver` finds on a binding of that value. A call that is not
+     * awaited first is read the same way: a request that is a promise and reads
+     * its own body (`send(url).json()`) yields the body from that read too.
+     */
+    bodyReadOnCallValue(callExpr) {
+        let value = callExpr;
+        for (;;) {
+            const parent = value.getParent();
+            if (!parent ||
+                !(Node.isParenthesizedExpression(parent) ||
+                    Node.isAwaitExpression(parent) ||
+                    Node.isNonNullExpression(parent)) ||
+                parent.getExpression() !== value) {
+                break;
+            }
+            value = parent;
+        }
+        return this.bodyReadOnReceiver(value);
+    }
+    /**
+     * The zero-argument whole-body read that takes `receiver` as its receiver,
      * `res.json()` or `res.text()`, or `undefined`. A text read is a body read
      * like a json one (carrick#1842): without it, `return res.text()` left the
      * walk on the response binding and published the transport object.
      */
-    bodyReadOnReceiver(identifier) {
-        const access = identifier.getParent();
+    bodyReadOnReceiver(receiver) {
+        const access = receiver.getParent();
         if (!access ||
             !Node.isPropertyAccessExpression(access) ||
-            access.getExpression() !== identifier ||
+            access.getExpression() !== receiver ||
             !WHOLE_BODY_READS.has(access.getName())) {
             return undefined;
         }
@@ -2787,26 +3218,31 @@ export class TypeInferrer {
         if (depth >= maxDepth) {
             return { kind: 'no-match' };
         }
-        const symbol = type.getSymbol() || type.getAliasSymbol();
-        const symbolName = symbol?.getName();
-        // 1. Check exact wrapperSymbols match. When the rule also carries
-        // originModuleGlobs, the symbol's declaration must come from a matching
-        // module — names like `Response` are shared by the DOM, frameworks, and
-        // HTTP clients, so a bare name match would unwrap unrelated types.
-        if (rule.wrapperSymbols && symbolName && rule.wrapperSymbols.includes(symbolName)) {
-            const originGated = !!(rule.originModuleGlobs && rule.originModuleGlobs.length > 0);
-            if (!originGated || this.symbolOriginatesFromModules(symbol, rule.originModuleGlobs)) {
-                const extracted = this.extractPayloadFromWrapper(type, node, rule, config, depth);
-                if (extracted) {
-                    return { kind: 'extracted', result: extracted };
-                }
-                // A name-only match is not proof of machinery: a local type that
-                // happens to share the name must keep its real structural type when
-                // nothing was extracted. Only origin-verified matches may collapse
-                // to `unknown`.
-                return originGated ? { kind: 'verified-no-payload' } : { kind: 'no-match' };
+        const readings = this.wrapperReadings(type);
+        // 1. Check exact wrapperSymbols match, against either name the type goes
+        // by (carrick#1843). When the rule also carries originModuleGlobs, the
+        // declaration of the name that matched must come from a matching module
+        // — names like `Response` are shared by the DOM, frameworks, and HTTP
+        // clients, so a bare name match would unwrap unrelated types. A name
+        // that fails that gate is no match, and the rule's test of members and
+        // origin below still has its turn: a service's alias that shares the
+        // rule's name can stand around the very type the rule verifies.
+        const named = readings.filter((reading) => rule.wrapperSymbols?.includes(reading.symbol.getName()));
+        const globs = rule.originModuleGlobs ?? [];
+        const originGated = globs.length > 0;
+        const matched = originGated
+            ? named.find((reading) => this.symbolOriginatesFromModules(reading.symbol, globs))
+            : named[0];
+        if (matched) {
+            const extracted = this.extractPayloadFromWrapper(type, matched, node, rule, config, depth);
+            if (extracted) {
+                return { kind: 'extracted', result: extracted };
             }
-            return { kind: 'no-match' };
+            // A name-only match is not proof of machinery: a local type that
+            // happens to share the name must keep its real structural type when
+            // nothing was extracted. Only origin-verified matches may collapse
+            // to `unknown`.
+            return originGated ? { kind: 'verified-no-payload' } : { kind: 'no-match' };
         }
         // 2. Check machineryIndicators + originModuleGlobs. Indicators alone are
         // too many false positives, so the origin gate is mandatory here — which
@@ -2818,10 +3254,18 @@ export class TypeInferrer {
             if (!this.typeHasMachineryIndicators(type, rule.machineryIndicators)) {
                 return { kind: 'no-match' };
             }
-            if (!this.symbolOriginatesFromModules(symbol, rule.originModuleGlobs)) {
+            // The rule named neither of the type's names, so this branch reads
+            // what it always read: the first symbol the type has, and the type's
+            // own arguments. An alias the rule did not name says nothing about
+            // where a payload is, whoever declares it (carrick#1843):
+            // `Omit<Response, 'json'>` is written through a library alias whose
+            // first argument is the transport itself, and a service's own alias
+            // around a library's object orders its parameters as it likes.
+            const symbol = type.getSymbol() || type.getAliasSymbol();
+            if (!symbol || !this.symbolOriginatesFromModules(symbol, rule.originModuleGlobs)) {
                 return { kind: 'no-match' };
             }
-            const extracted = this.extractPayloadFromWrapper(type, node, rule, config, depth);
+            const extracted = this.extractPayloadFromWrapper(type, { symbol, typeArguments: type.getTypeArguments(), viaAlias: false }, node, rule, config, depth);
             if (extracted) {
                 return { kind: 'extracted', result: extracted };
             }
@@ -2829,14 +3273,44 @@ export class TypeInferrer {
         }
         return { kind: 'no-match' };
     }
+    /**
+     * The names `type` goes by, own symbol first (carrick#1843).
+     *
+     * `type Task<A> = __Task<A>` has the class's symbol and arguments, and the
+     * alias's beside them. `type Reply<T> = { ... }` has the anonymous `__type`
+     * with no arguments of its own. `type Outcome<A, E> = Done<A, E> |
+     * Failed<A, E>` has no symbol of its own at all. In each, the alias and its
+     * arguments are what a rule naming `Task`, `Reply` or `Outcome` describes.
+     */
+    wrapperReadings(type) {
+        const readings = [];
+        const own = type.getSymbol();
+        if (own) {
+            readings.push({ symbol: own, typeArguments: type.getTypeArguments(), viaAlias: false });
+        }
+        const alias = type.getAliasSymbol();
+        if (alias && alias !== own) {
+            readings.push({
+                symbol: alias,
+                typeArguments: type.getAliasTypeArguments(),
+                viaAlias: true,
+            });
+        }
+        return readings;
+    }
     /**
      * Extract the payload type from a matched wrapper. Returns null when the
      * rule matched the wrapper but no payload is recoverable from generics or
      * property paths — the caller decides what a payload-less match means
      * (verified machinery collapses to `unknown` after every rule has run;
      * a name-only match leaves the type untouched).
+     *
+     * `payloadGenericIndex` counts the arguments of `reading`, the name the
+     * rule matched (carrick#1843): an alias is free to order its parameters
+     * differently from the type it stands for, so the same index into the
+     * other list is a different argument.
      */
-    extractPayloadFromWrapper(type, node, rule, config, depth) {
+    extractPayloadFromWrapper(type, reading, node, rule, config, depth) {
         // The outer extraction already succeeded on the paths below; a recursive
         // inner pass that finds nothing more must not demote the result back to
         // "not unwrapped" (which would discard the recovered payload). Only when
@@ -2855,7 +3329,7 @@ export class TypeInferrer {
         };
         // 1. Try generic type argument at payloadGenericIndex
         const genericIndex = rule.payloadGenericIndex ?? 0;
-        const typeArgs = type.getTypeArguments();
+        const typeArgs = reading.typeArguments;
         if (typeArgs.length > genericIndex) {
             const payloadArg = typeArgs[genericIndex];
             // Check if it's a useful type (not any/unknown/never)
@@ -2872,8 +3346,11 @@ export class TypeInferrer {
                     payloadType: payloadArg,
                 };
             }
-            // Try "first useful generic" heuristic
-            for (let i = 0; i < typeArgs.length; i++) {
+            // Try "first useful generic" heuristic. It is a guess about a type's
+            // own arguments and is not extended to an alias's (carrick#1843): the
+            // alias this reaches most often is a result carrier, `Outcome<A, E>`,
+            // whose next argument after an open payload is the error side.
+            for (let i = 0; !reading.viaAlias && i < typeArgs.length; i++) {
                 const argType = typeArgs[i];
                 const text = typeText(argType, node);
                 if (!this.isUselessType(text)) {
@@ -3390,10 +3867,15 @@ export class TypeInferrer {
      * stated status, and what survives is joined as a union exactly as several
      * return statements are.
      */
-    recoverPayloadFromResponseExpressions(expressions, statedOnly, wire) {
+    recoverPayloadFromResponseExpressions(expressions, statedOnly, wire, alsoSerialisers) {
         const candidates = [];
         const returned = expressions.flatMap((expression) => this.expandResponseBranches(expression, 0));
+        // `alsoSerialisers` are callees a caller has its own evidence for
+        // (`calleeIdentity` keys), beside the ones these expressions prove.
         const serialisers = this.calleesProvenSerialiser(returned);
+        for (const identity of alsoSerialisers ?? []) {
+            serialisers.add(identity);
+        }
         for (const expression of returned) {
             const payloadNode = this.responseHelperPayloadNode(expression, 0, statedOnly, serialisers);
             if (!payloadNode)
@@ -3646,8 +4128,11 @@ export class TypeInferrer {
      *
      * Under `statedOnly` the annotation is the ONLY thing that counts, so an
      * unresolvable callee's arguments never become a contract by accident.
+     *
+     * `asSent` judges the object in the form it is sent in, which is what an
+     * ARGUMENT handed to a sender is asked; see `typeIsObjectShaped`.
      */
-    nodeCarriesPayloadContract(node, statedOnly) {
+    nodeCarriesPayloadContract(node, statedOnly, asSent = true) {
         if (this.statedTypeNodeOf(node))
             return true;
         if (statedOnly)
@@ -3665,24 +4150,37 @@ export class TypeInferrer {
             return false;
         if (this.typeIsOrContainsResponseMachinery(type))
             return false;
-        return this.typeIsObjectShaped(type, 0);
+        return this.typeIsObjectShaped(type, 0, asSent);
     }
-    /** Object, array-of-object, or a union/intersection containing one. */
-    typeIsObjectShaped(type, depth) {
+    /**
+     * Object, array-of-object, or a union/intersection containing one.
+     *
+     * With `asSent` the object is judged in the form it is SENT in
+     * (carrick#1163): a value that declares `toJSON()` travels as what that
+     * returns. A `URL` or a `Date` is therefore the string it serialises to,
+     * the bare primitive this rule already refuses, and `redirect(new URL(path,
+     * base))` hands over a location exactly as `redirect("/next")` does
+     * (carrick#807). A value whose JSON form is itself an object is a body like
+     * any other.
+     */
+    typeIsObjectShaped(type, depth, asSent) {
         if (depth > 2)
             return false;
         if (type.isUnion()) {
-            return type.getUnionTypes().some((m) => this.typeIsObjectShaped(m, depth + 1));
+            return type.getUnionTypes().some((m) => this.typeIsObjectShaped(m, depth + 1, asSent));
         }
         if (type.isIntersection()) {
             return type
                 .getIntersectionTypes()
-                .some((m) => this.typeIsObjectShaped(m, depth + 1));
+                .some((m) => this.typeIsObjectShaped(m, depth + 1, asSent));
         }
         if (type.isArray()) {
             const element = type.getArrayElementType();
-            return element ? this.typeIsObjectShaped(element, depth + 1) : false;
+            return element ? this.typeIsObjectShaped(element, depth + 1, asSent) : false;
         }
+        const sent = asSent ? jsonWireType(type) : undefined;
+        if (sent)
+            return this.typeIsObjectShaped(sent, depth + 1, asSent);
         return type.isObject() && !type.isTuple();
     }
     /**
@@ -3927,11 +4425,19 @@ export class TypeInferrer {
     /**
      * Declaration file (absolute path) of the anchor symbol
      * `primaryTypeSymbol` reports for this type, or `undefined` when the type
-     * has no user-facing anchor or no source declaration. The scanner's
-     * pub/sub two-anchor arbitration (carrick#413) uses this to re-aim a
-     * demoted explicit bundle request: the bundler resolves a `SymbolRequest`
-     * only against declarations IN its `source_file`, so the request must
-     * point at the file that actually declares the tsc-witnessed payload type.
+     * has no user-facing anchor or no source declaration. Every path that
+     * reports the symbol reports this beside it (carrick#1819): it is where a
+     * reader finds the type an anchor names. The scanner's pub/sub two-anchor
+     * arbitration (carrick#413) also uses it to re-aim a demoted explicit
+     * bundle request: the bundler resolves a `SymbolRequest` only against
+     * declarations IN its `source_file`, so the request must point at the file
+     * that actually declares the tsc-witnessed payload type.
+     *
+     * The declarations read are those of the type's own symbol, so a name
+     * imported through a barrel reports the file that declares it, and a name
+     * two files declare reports the one this type resolves to. A declaration in
+     * an installed package or a TypeScript lib is reported as it is found, as
+     * an absolute path; what a reader is shown for it is the scanner's call.
      *
      * Only declaration kinds the bundler's `validateSymbols` can resolve
      * (interface, type alias, class, enum, function, variable) count. A
@@ -4251,44 +4757,7 @@ export class TypeInferrer {
      * which is the honest answer and the one a consumer check can act on.
      */
     findFunctionByLine(sourceFile, line) {
-        const LINE_TOLERANCE = 2;
-        const functions = [];
-        /** Statements opening inside the forward window, in source order. */
-        const windowStatements = [];
-        for (const node of sourceFile.getDescendants()) {
-            if (Node.isFunctionDeclaration(node) ||
-                Node.isArrowFunction(node) ||
-                Node.isFunctionExpression(node) ||
-                Node.isMethodDeclaration(node)) {
-                functions.push(node);
-            }
-            if (Node.isStatement(node)) {
-                const start = node.getStartLineNumber();
-                if (start >= line && start <= line + LINE_TOLERANCE) {
-                    windowStatements.push(node);
-                }
-            }
-        }
-        const separatedFromAnchor = (fn) => windowStatements.some((statement) => statement.getStartLineNumber() < fn.getStartLineNumber() &&
-            !(statement.getStart() <= fn.getStart() && statement.getEnd() >= fn.getEnd()));
-        let best;
-        let bestDelta = Infinity;
-        for (const fn of functions) {
-            const delta = Math.abs(fn.getStartLineNumber() - line);
-            if (delta > LINE_TOLERANCE)
-                continue;
-            if (fn.getStartLineNumber() > line && separatedFromAnchor(fn))
-                continue;
-            const isCloser = delta < bestDelta;
-            const isInnermostTie = delta === bestDelta &&
-                best !== undefined &&
-                fn.getEnd() - fn.getStart() < best.getEnd() - best.getStart();
-            if (isCloser || isInnermostTie) {
-                best = fn;
-                bestDelta = delta;
-            }
-        }
-        return best;
+        return functionAtLine(sourceFile, line);
     }
     /**
      * Walk up from a node to find its innermost containing function.
@@ -4561,6 +5030,98 @@ export class TypeInferrer {
         });
         return found;
     }
+    /**
+     * The call in a handler that reads the request's body off the platform
+     * request the handler was handed, or `undefined` (carrick#807).
+     *
+     * Read by shape, with no method name consulted:
+     *
+     *  - a call that takes nothing, on a member of a value whose type is request
+     *    machinery (`typeIsFrameworkMachinery`: declared by the platform or an
+     *    installed library, and carrying its body readers);
+     *  - that value is rooted at one of the handler's OWN parameters, named or
+     *    destructured. A response read off an outbound call inside the handler
+     *    (`(await upstream.json()) as Rate`) has the same shape one variable
+     *    away, and is the opposite side of a different exchange;
+     *  - and the call's result, awaited, is `any` or `unknown`: the platform's
+     *    untyped parse. A read that states its own type (`formData()`, a typed
+     *    `json<T>()`) is not this shape and is left to the readers that
+     *    already handle it.
+     *
+     * The first such call in source order: a body is read once.
+     */
+    platformBodyReadIn(handler) {
+        const parameters = new Set(handler.getParameters());
+        const rootedAtParameter = (expression) => {
+            let root = expression;
+            while (Node.isPropertyAccessExpression(root) ||
+                Node.isNonNullExpression(root) ||
+                Node.isParenthesizedExpression(root)) {
+                root = root.getExpression();
+            }
+            if (!Node.isIdentifier(root))
+                return false;
+            return (root.getSymbol()?.getDeclarations() ?? []).some((declaration) => {
+                const parameter = Node.isParameterDeclaration(declaration)
+                    ? declaration
+                    : Node.isBindingElement(declaration)
+                        ? declaration.getFirstAncestorByKind(SyntaxKind.Parameter)
+                        : undefined;
+                return parameter !== undefined && parameters.has(parameter);
+            });
+        };
+        for (const call of handler.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+            if (call.getArguments().length > 0)
+                continue;
+            const callee = call.getExpression();
+            if (!Node.isPropertyAccessExpression(callee))
+                continue;
+            const receiver = callee.getExpression();
+            if (!rootedAtParameter(receiver))
+                continue;
+            const yielded = this.unwrapPromiseType(call.getType());
+            if (!yielded.isAny() && !yielded.isUnknown())
+                continue;
+            if (!this.typeIsFrameworkMachinery(receiver.getType()))
+                continue;
+            return call;
+        }
+        return undefined;
+    }
+    /**
+     * The request contract the source states AT a body read, or null when it
+     * states none there (carrick#807).
+     *
+     * Three statements count, each of them on the read itself:
+     *
+     *  - a cast on it: `(await request.json()) as NewWidget`;
+     *  - the annotation of the binding it initialises:
+     *    `const input: NewWidget = await request.json()`;
+     *  - a schema the read, or the binding that holds it, is handed to
+     *    (`schemaConsumingRead`): the schema's input is what a caller may send.
+     *
+     * The first two are `typeNodeStatedAtRead`, the reading a consumer's
+     * response read already gets. An annotation further out is not one of them:
+     * `const saved: Saved = await save(await request.json())` types what `save`
+     * returned, and reading it as the body would publish the wrong side of the
+     * handler. Nor is a placeholder (`as unknown`, `Record<string, unknown>`).
+     */
+    requestStatedAtBodyRead(request, read) {
+        const statedNode = this.typeNodeStatedAtRead(read);
+        const statedText = statedNode ? this.structuralTextFromTypeNode(statedNode) : null;
+        if (statedText) {
+            this.log(`Request at ${request.file_path}:${request.line_number} is the body its handler ` +
+                'reads off the platform request, as the source types that read');
+            return this.createInferredType(request, statedText, true, this.getNodeLocation(read));
+        }
+        const validated = this.schemaConsumingRead(read);
+        if (validated) {
+            this.log(`Request at ${request.file_path}:${request.line_number} is the body its handler ` +
+                "reads off the platform request and validates with a schema; publishing the schema's input");
+            return this.declaredRequestInferredType(request, validated, this.getNodeLocation(read));
+        }
+        return null;
+    }
     /**
      * Resolve a type-annotation/type-argument node to fully-structural text,
      * dropping any `Promise<…>` wrapper (`c.req.json<T>()` returns `Promise<T>`,
@@ -5013,6 +5574,14 @@ export class TypeInferrer {
      * request type resolves `body` to `unknown`/`any`, which the useless-type
      * guard rejects. So a handler that declares nothing yields null and the next
      * anchor runs.
+     *
+     * The member has to be one the route's own annotation can have filled
+     * (carrick#807). The platform `Request` declares `body` too, as the byte
+     * stream every request carries, and so does each library type that extends
+     * it. That is concrete, so it passed the useless-type guard and a handler
+     * taking the platform request published a stream as its request contract,
+     * ahead of the body read inside it. A `body` a library declares with one
+     * fixed type says nothing about this route and is skipped.
      */
     requestBodyFromHandlerParams(func) {
         for (const param of func.getParameters()) {
@@ -5024,7 +5593,7 @@ export class TypeInferrer {
                 continue;
             }
             const bodySymbol = paramType.getProperty('body');
-            if (!bodySymbol) {
+            if (!bodySymbol || this.memberIsFixedByItsLibrary(bodySymbol)) {
                 continue;
             }
             let bodyType;
@@ -5041,6 +5610,41 @@ export class TypeInferrer {
         }
         return null;
     }
+    /**
+     * True when a member is declared by a library, or by the platform, with a
+     * type that names none of its declaring type's parameters: the same type on
+     * every value, whichever route the value belongs to.
+     *
+     * `body: ReqBody` on a request type generic in its body is a slot, and the
+     * handler's annotation fills it. `readonly body: ReadableStream<Uint8Array>
+     * | null` on the platform request is not. A member the repo declares itself
+     * is never fixed in this sense: writing `body: NewWidget` on the handler's
+     * own request type is the annotation, and one declaration of the repo's
+     * among several (an intersection with the platform type) decides it. A
+     * declaration that states no type at all is left to the guards that read
+     * the type.
+     */
+    memberIsFixedByItsLibrary(member) {
+        const declarations = member.getDeclarations();
+        if (declarations.length === 0)
+            return false;
+        const program = this.project.getProgram().compilerObject;
+        const imports = externalImportsOf(this.project);
+        return declarations.every((declaration) => {
+            const declaredByLibrary = isExternalOrigin(program, declaration.getSourceFile().compilerNode, this.repoRoot, imports);
+            if (!declaredByLibrary)
+                return false;
+            const typeNode = Node.isPropertySignature(declaration) || Node.isPropertyDeclaration(declaration)
+                ? declaration.getTypeNode()
+                : Node.isGetAccessorDeclaration(declaration)
+                    ? declaration.getReturnTypeNode()
+                    : undefined;
+            if (!typeNode)
+                return false;
+            const names = [typeNode, ...typeNode.getDescendants()].filter(Node.isIdentifier);
+            return !names.some((name) => (name.getSymbol()?.getDeclarations() ?? []).some(Node.isTypeParameterDeclaration));
+        });
+    }
     /**
      * Anchor (b2): the contract declared by a VALIDATOR MIDDLEWARE on the
      * registration (carrick#964).