carrick 0.3.123 → 0.3.125

package/package.json

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

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

@@ -29,6 +29,7 @@
  */
 import { decisiveAssignmentLine, unwidenedAliasOf, } from './check-probe.js';
 import { scrubDiagnostic, scrubPaths } from './check-scrub.js';
+import { onlyDeclaredOpenAny } from './deep-walk.js';
 import { describeFieldReport, fieldReportNotes, } from './check-fields.js';
 const PRIMARY_RE = /^(?<file>(?:[a-zA-Z]:)?[^(]*?)\((?<line>\d+),(?<col>\d+)\): error TS(?<code>\d+): (?<msg>.*)$/;
 /** Parse `tsc --pretty false` output into structured diagnostics. */
@@ -350,9 +351,10 @@ function onUnwidenedLines(plan, diagnostic) {
  * - its own declarations typecheck (the alias is not poisoned);
  * - the member-level walk ran over it and found no `any`/`unknown`, which
  *   would assign to whatever the other side declares;
- * - the same walk found none on the two published sides either. A mismatch
- *   that is not a fact stays the mismatch it was: the reading would be
- *   clearing it against a member that accepts anything.
+ * - the same walk found none on the two published sides either, an open
+ *   member included (carrick#2591). A mismatch that is not a fact stays the
+ *   mismatch it was: the reading would be clearing it against a member that
+ *   accepts anything.
  */
 function unwidenedReadingFits(input) {
     const { plan, probeDiags, poisonReason } = input;
@@ -364,7 +366,7 @@ function unwidenedReadingFits(input) {
     if (poisonReason(sent.service_name, unwidenedAliasOf(sent.alias)))
         return false;
     const walked = input.deepFindings?.sentUnwidened;
-    return walked !== undefined && walked.length === 0 && factness(input).resolved;
+    return walked !== undefined && walked.length === 0 && factness(input, true).resolved;
 }
 /**
  * The field-level sentence appended to a mismatch diagnostic
@@ -410,7 +412,7 @@ function namedFields(input, scrubCtx) {
  * empty. A walk that could not run leaves the verdict not-a-fact: absence of
  * findings is not evidence.
  */
-function factness(input) {
+function factness(input, strict = false) {
     const findings = input.deepFindings;
     if (!findings) {
         return {
@@ -419,6 +421,10 @@ function factness(input) {
         };
     }
     for (const side of ['sent', 'expected']) {
+        // Open members only (carrick#2591): the closed members were judged and an
+        // open one is never a mismatch, so the verdict is a fact about the type.
+        if (!strict && onlyDeclaredOpenAny(findings[side]))
+            continue;
         const first = findings[side][0];
         if (!first)
             continue;

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

@@ -25,6 +25,7 @@ import { scrubPaths } from './check-scrub.js';
 import { assembleWorkspace, writeProbes, } from './check-workspace.js';
 import { buildPoisonIndexes } from './check-poison.js';
 import { openProbeProgram, probeDeepFindings } from './check-deep.js';
+import { onlyDeclaredOpenAny } from './deep-walk.js';
 import { pairFieldReports } from './check-fields.js';
 import { pairDispatchUnions } from './check-union.js';
 function runProcess(command, args, cwd, env) {
@@ -465,7 +466,13 @@ function deepDecayOf(plan, aliasRecords) {
         const record = aliasRecords.get(endpoint.service_name)?.get(endpoint.alias);
         // The capture emits every deep finding it made; the FIRST is the one the
         // pre-gate reads, exactly as when the walk stopped at the first hit.
-        const finding = record?.any_provenance?.[0];
+        const findings = record?.any_provenance ?? [];
+        // An `any` the source declares under a named member is an open member
+        // (carrick#2591): the pair is probed, and the compiler judges the closed
+        // members. Anything else on the record keeps the pair out of the probe.
+        if (onlyDeclaredOpenAny(findings))
+            continue;
+        const finding = findings[0];
         if (finding) {
             return { side, kind: finding.kind, path: finding.path };
         }

package/sidecar/dist/src/capture/deep-walk.d.ts

@@ -20,6 +20,14 @@ import type { TypeProvenance } from './api.js';
  * within its depth/node budget, treated as unverifiable (fail closed) rather
  * than silently clean. */
 export type DeepTopType = Pick<TypeProvenance, 'kind' | 'path'>;
+/** Cap on findings reported per alias. The FIRST one is what the check phase
+ * pre-gates on, so verdicts never depend on this number; the rest are there to
+ * tell a reader which fields are `any` (carrick#376), and a type with more
+ * than this many is already better described by "this type is not typed".
+ * The scanner mirrors it (`CAPTURE_FINDINGS_CAP` in
+ * `src/engine/type_compat_v2.rs`): a record this long may have stopped
+ * listing, so it cannot vouch for every position (carrick#1752). */
+export declare const MAX_DEEP_FINDINGS = 32;
 /**
  * Depth-bounded structural walk for a disqualifying top type at ANY depth:
  * a member, array element, index signature, type argument, or callable RETURN
@@ -76,6 +84,29 @@ export declare function findUncarriedPositions(root: ts.Type, program: ts.Progra
 /** TypeScript's unresolved-reference placeholder: `TypeFlags.Any` with the
  * internal `intrinsicName === 'error'` (stable since TS 1.x; see `anchors.ts`). */
 export declare function isErrorPlaceholder(t: ts.Type): boolean;
+/**
+ * True when a deep-walk path passes through a named member (the same rule as
+ * `path_names_a_member` in `src/engine/type_compat_v2.rs`). The walk writes a
+ * member as its name, an element or type argument as `<n>`, an index signature
+ * as `[index]` and a callable return as `()`; a path made of the last three
+ * alone sits at the root of the type or inside a container, never in a field.
+ */
+export declare function pathNamesAMember(path: string): boolean;
+/**
+ * True when every finding is an `any` the SOURCE declares under a named
+ * member (carrick#2591): an OPEN member. The policy: an open member is never
+ * a mismatch, and the closed members are judged as for a fully typed pair.
+ * `any` accepts and supplies every shape in the assignment the probe makes, so
+ * the compiler already judges only the closed members.
+ *
+ * Nothing else qualifies. A callable's return (`getData()`) is no data
+ * member. An `unknown` member rejects a narrower counterparty
+ * under assignment, so it would read as a mismatch the policy forbids; a
+ * `budget_exhausted` sentinel, a root top type and an `any` an unresolved
+ * import left say nothing about the author's intent. A list as long as the
+ * walk's cap may have stopped listing, so it cannot vouch for every position.
+ */
+export declare function onlyDeclaredOpenAny(findings: readonly TypeProvenance[]): boolean;
 /** What an anchor's SOURCE program could not resolve (carrick#1164). */
 export interface UnresolvedAtAnchor {
     /** Member paths holding the unresolved-reference placeholder. */

package/sidecar/dist/src/capture/deep-walk.js

@@ -22,7 +22,7 @@ import { memberPath } from './member-name.js';
  * The scanner mirrors it (`CAPTURE_FINDINGS_CAP` in
  * `src/engine/type_compat_v2.rs`): a record this long may have stopped
  * listing, so it cannot vouch for every position (carrick#1752). */
-const MAX_DEEP_FINDINGS = 32;
+export const MAX_DEEP_FINDINGS = 32;
 /**
  * Depth-bounded structural walk for a disqualifying top type at ANY depth:
  * a member, array element, index signature, type argument, or callable RETURN
@@ -269,6 +269,48 @@ function walkTopTypes(root, program, checker, location, flagOf) {
     rest.sort((a, b) => a.path.localeCompare(b.path));
     return [head, ...rest];
 }
+/**
+ * True when a deep-walk path passes through a named member (the same rule as
+ * `path_names_a_member` in `src/engine/type_compat_v2.rs`). The walk writes a
+ * member as its name, an element or type argument as `<n>`, an index signature
+ * as `[index]` and a callable return as `()`; a path made of the last three
+ * alone sits at the root of the type or inside a container, never in a field.
+ */
+export function pathNamesAMember(path) {
+    const rest = path.replaceAll('[index]', '').replaceAll('()', '');
+    let inArgument = false;
+    for (const c of rest) {
+        if (c === '<')
+            inArgument = true;
+        else if (c === '>')
+            inArgument = false;
+        else if (c !== '.' && !inArgument)
+            return true;
+    }
+    return false;
+}
+/**
+ * True when every finding is an `any` the SOURCE declares under a named
+ * member (carrick#2591): an OPEN member. The policy: an open member is never
+ * a mismatch, and the closed members are judged as for a fully typed pair.
+ * `any` accepts and supplies every shape in the assignment the probe makes, so
+ * the compiler already judges only the closed members.
+ *
+ * Nothing else qualifies. A callable's return (`getData()`) is no data
+ * member. An `unknown` member rejects a narrower counterparty
+ * under assignment, so it would read as a mismatch the policy forbids; a
+ * `budget_exhausted` sentinel, a root top type and an `any` an unresolved
+ * import left say nothing about the author's intent. A list as long as the
+ * walk's cap may have stopped listing, so it cannot vouch for every position.
+ */
+export function onlyDeclaredOpenAny(findings) {
+    return (findings.length > 0 &&
+        findings.length < MAX_DEEP_FINDINGS &&
+        findings.every((f) => f.kind === 'any' &&
+            f.reason === 'declared' &&
+            pathNamesAMember(f.path) &&
+            !f.path.includes('()')));
+}
 /** The disqualifier the self-check and the check phase gate on (see
  * `findDisqualifyingTopTypes`). */
 function disqualifyingFlag(t) {

package/sidecar/dist/src/capture/index.d.ts

@@ -34,7 +34,7 @@ export { sidecarCompilerOptions } from './compiler-options.js';
 export { isInsideCheckout, untrustedReadBound, UNTRUSTED_TREE_ENV, type ReadBound } from './checkout.js';
 export { serviceConfigPath } from './project-references.js';
 export { referenceRedirectOf } from './reference-redirect.js';
-export { findServiceTsconfig } from './service-config.js';
+export { findServiceTsconfig, fileConfigPath } from './service-config.js';
 export { WriteGuard } from './guarded-fs.js';
 export { installedPackageDirectory } from './installed-package-directory.js';
 export { isDeclarationFileName, packageNameOf } from './specifiers.js';

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

@@ -52,7 +52,7 @@ export { sidecarCompilerOptions } from './compiler-options.js';
 export { isInsideCheckout, untrustedReadBound, UNTRUSTED_TREE_ENV } from './checkout.js';
 export { serviceConfigPath } from './project-references.js';
 export { referenceRedirectOf } from './reference-redirect.js';
-export { findServiceTsconfig } from './service-config.js';
+export { findServiceTsconfig, fileConfigPath } from './service-config.js';
 // carrick#2405: the per-position rows write through the guard, and name an
 // installed declaring file the way the capture's resolution walk does.
 export { WriteGuard } from './guarded-fs.js';

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

@@ -39,6 +39,12 @@ export const MACHINERY_MEMBER_INDICATORS = new Set([
     'clone',
     'json',
     'statusText',
+    // FROZEN (old path, 2026-10-21): the reply-object half below only (the
+    // fetch half above and the threshold stay). Deletions and safety fixes
+    // only. Fixes for wrong or missing types go in labelled reply objects
+    // (carrick#2472 C4) and the language library rows (carrick#2445). Delete
+    // when a delete-and-replay on the four repos moves no row wrongly, after
+    // carrick-cloud#2379 and carrick#2445 (carrick#2472, C6).
     // Node http ServerResponse / reply-object surface
     'statusCode',
     'statusMessage',

package/sidecar/dist/src/capture/service-config.d.ts

@@ -19,3 +19,14 @@
 export declare function findServiceTsconfig(serviceRoot: string, scanRoot?: string): string | undefined;
 /** The path with every symlink resolved; the path as given when it does not exist. */
 export declare function realPath(p: string): string;
+/**
+ * The config an editor types `file` under, for a service with none at its
+ * root (carrick#1604): the nearest `tsconfig.json`, then `jsconfig.json`, in
+ * each directory from the file's up to the service root, inclusive. The
+ * climb stops after a directory named `node_modules`, as tsserver's does. A file
+ * outside the service root, or with no config on its way up, has none.
+ *
+ * `known` caches the answer per directory; pass one map for one service so
+ * its files share the climb.
+ */
+export declare function fileConfigPath(file: string, serviceRoot: string, known?: Map<string, string | undefined>): string | undefined;

package/sidecar/dist/src/capture/service-config.js

@@ -55,3 +55,43 @@ export function realPath(p) {
         return path.resolve(p);
     }
 }
+/** The names an editor looks for in a file's directory, in order. */
+const FILE_CONFIG_NAMES = ['tsconfig.json', 'jsconfig.json'];
+/**
+ * The config an editor types `file` under, for a service with none at its
+ * root (carrick#1604): the nearest `tsconfig.json`, then `jsconfig.json`, in
+ * each directory from the file's up to the service root, inclusive. The
+ * climb stops after a directory named `node_modules`, as tsserver's does. A file
+ * outside the service root, or with no config on its way up, has none.
+ *
+ * `known` caches the answer per directory; pass one map for one service so
+ * its files share the climb.
+ */
+export function fileConfigPath(file, serviceRoot, known = new Map()) {
+    const root = path.resolve(serviceRoot);
+    const climbed = [];
+    let found;
+    let dir = path.dirname(path.resolve(file));
+    for (;;) {
+        const from = path.relative(root, dir);
+        if (from.startsWith('..') || path.isAbsolute(from))
+            break;
+        if (known.has(dir)) {
+            found = known.get(dir);
+            break;
+        }
+        climbed.push(dir);
+        const name = FILE_CONFIG_NAMES.find((n) => fs.existsSync(path.join(dir, n)));
+        if (name !== undefined) {
+            found = path.join(dir, name);
+            break;
+        }
+        // tsserver looks in a `node_modules` directory itself, then stops.
+        if (dir === root || path.basename(dir) === 'node_modules')
+            break;
+        dir = path.dirname(dir);
+    }
+    for (const d of climbed)
+        known.set(d, found);
+    return found;
+}

package/sidecar/dist/src/index.js

@@ -442,7 +442,7 @@ function handleVerifyLibraryClaims(request) {
         writeProgress(request.request_id, 'verify_library_claims', 'program ready');
         const fromDir = path.resolve(projectLoader.getRepoRoot(), request.from_dir);
         log(`Verifying ${request.checks.length} library claim(s) from ${fromDir}`);
-        const { semantics, modules } = claimsVerifier.run(fromDir, request.checks, request.budget_ms ?? SEMANTICS_BUDGET_MS);
+        const { semantics, modules } = claimsVerifier.run(fromDir, request.checks, request.budget_ms ?? SEMANTICS_BUDGET_MS, request.scan_root);
         return {
             request_id: request.request_id,
             status: 'success',

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

@@ -63,7 +63,7 @@ export declare class LibraryClaimsVerifier {
      * A check on an instance or a scope reads the maker or scope claims of the
      * same request first, whatever their place in it.
      */
-    run(fromDir: string, checks: LibraryCheck[], budgetMs: number): VerifyResult;
+    run(fromDir: string, checks: LibraryCheck[], budgetMs: number, scanRoot?: string): VerifyResult;
     /**
      * Each specifier's declared surface, read with the verifier's predicates
      * (carrick#1660): every value export (or only those `only` names for the

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

@@ -39,6 +39,7 @@ import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { ts } from 'ts-morph';
+import { PathNames, declaringFileName } from './position-rows.js';
 /** The methods a `verb` claim may name, and a method key may accept. */
 const HTTP_METHODS = new Set([
     'GET',
@@ -130,8 +131,9 @@ const HTTP_V2_RULES = { http: false, message: true, ops: new Set(['request']), m
 const SERVER_RULES = { http: false, message: true, ops: new Set(['receive']), methods: ROUTE_METHODS };
 /**
  * The role table: the role alone picks the checks. A role this build does
- * not read yet (GraphQL executors, server mounts) answers `role_unsupported`,
- * and `none` has nothing on the wire to check.
+ * not read yet (GraphQL executors) answers `role_unsupported`, and `none`
+ * has nothing on the wire to check. A server's mounts are scope claims
+ * (`mounts`, #2474 R0).
  */
 const ROLE_TABLE = {
     http_client: HTTP_RULES,
@@ -238,6 +240,13 @@ export function httpCheck(check) {
         }
     }
 }
+/** Declarations in a fixed order, each once. */
+function sortedDeclarations(declarations) {
+    const seen = new Map();
+    for (const each of declarations)
+        seen.set(`${each.decl_file}:${each.decl_line}`, each);
+    return [...seen.values()].sort((a, b) => (a.decl_file < b.decl_file ? -1 : a.decl_file > b.decl_file ? 1 : a.decl_line - b.decl_line));
+}
 let probeSequence = 0;
 export class LibraryClaimsVerifier {
     project;
@@ -250,10 +259,15 @@ export class LibraryClaimsVerifier {
      * A check on an instance or a scope reads the maker or scope claims of the
      * same request first, whatever their place in it.
      */
-    run(fromDir, checks, budgetMs) {
+    run(fromDir, checks, budgetMs, scanRoot) {
         const deadline = performance.now() + budgetMs;
         const stamp = (check, outcome) => outcome.verdict === 'verified'
-            ? { claim_id: check.claim_id, receiver: check.receiver, verdict: 'verified' }
+            ? {
+                claim_id: check.claim_id,
+                receiver: check.receiver,
+                verdict: 'verified',
+                ...(outcome.declarations?.length ? { declarations: outcome.declarations } : {}),
+            }
             : {
                 claim_id: check.claim_id,
                 receiver: check.receiver,
@@ -330,7 +344,7 @@ export class LibraryClaimsVerifier {
             const file = program.getSourceFile(probe.getFilePath());
             if (!file)
                 throw new Error(`probe file ${probePath} is not in the program`);
-            const reader = new DeclarationReader(program, file, this.project.getModuleResolutionHost(), fromDir);
+            const reader = new DeclarationReader(program, file, this.project.getModuleResolutionHost(), fromDir, scanRoot);
             const localRanges = readLocalRanges(fromDir);
             const moduleReads = new Map();
             const exportReads = new Map();
@@ -501,13 +515,15 @@ export class LibraryClaimsVerifier {
                 const built = builtReceiver(check);
                 const builtAtDefaults = built === undefined ? undefined : atDefaults(check, built);
                 const holding = [];
+                const declarations = [];
                 for (const receiver of receivers.value) {
                     const result = reader.judgeMessage(receiver, check.claim, rules, builtAtDefaults);
                     if (result.outcome.verdict !== 'verified')
                         return result;
                     holding.push(...(result.holding ?? []));
+                    declarations.push(...(result.outcome.declarations ?? []));
                 }
-                return { outcome: VERIFIED, holding };
+                return { outcome: declarations.length > 0 ? { verdict: 'verified', declarations: sortedDeclarations(declarations) } : VERIFIED, holding };
             };
             const semantics = [];
             for (let index = 0; index < checks.length; index++) {
@@ -695,6 +711,19 @@ function placementInvalid(claim) {
     const of = parseReceiver(claim.of);
     return of === undefined || (of.maker === undefined && of.scope === undefined);
 }
+/**
+ * Where a handler's request holds its path and method (#2474 R0) is read on
+ * a receive op with a handler, and names `path` or `url`; every member path
+ * it gives is non-empty.
+ */
+function requestAtValid(claim) {
+    const request = claim.request;
+    if (claim.op !== 'receive' || claim.handler === undefined)
+        return false;
+    if (request.path === undefined && request.url === undefined)
+        return false;
+    return [request.path, request.url, request.method].every(members => members === undefined || members.length > 0);
+}
 /**
  * A message check names a receiver its claim can be read on (contract
  * amendment 2, B3). A maker is read on the export itself. An element with
@@ -841,6 +870,8 @@ class DeclarationReader {
     probe;
     host;
     checker;
+    /** Names declaring files as position rows do: from the scan root, else the service root. */
+    pathNames;
     /** The service root, as a realpath. */
     root;
     packageDirectories = new Map();
@@ -853,11 +884,12 @@ class DeclarationReader {
     declared = new Map();
     /** The service root as given and as a realpath, longest first: what a listing prints as `<root>`. */
     printedRoots;
-    constructor(program, probe, host, serviceRoot) {
+    constructor(program, probe, host, serviceRoot, scanRoot) {
         this.program = program;
         this.probe = probe;
         this.host = host;
         this.checker = program.getTypeChecker();
+        this.pathNames = new PathNames(scanRoot ?? serviceRoot);
         this.root = this.realpath(serviceRoot);
         this.printedRoots = [...new Set([this.root, serviceRoot])]
             .filter(root => root.length > 1)
@@ -1472,9 +1504,26 @@ class DeclarationReader {
      * `member` (after `path`) is a home-declared callable member whose name
      * slot accepts a string, under the name-slot rules, and returns a type that
      * says something, read at its type-parameter defaults (`returnOf`).
+     *
+     * Route fields (#2474 R0, contract amendment of 2026-10-22 on carrick#2434):
+     * - `runs` with `yields`: the member runs the function at `runs` (a
+     *   function with a declared signature) and hands it, at `yields.param`,
+     *   an instance of the package's export `yields.export` (`yieldsOutcome`);
+     * - `mounts`: the receiver the claim is read on fits the parameter there
+     *   (`mountsOutcome`).
+     * Either one binds its instance through a parameter or an argument, not
+     * the member's return, so the return is not read and the claim holds no
+     * overloads: a `>scope:` receiver read through it is not resolved.
+     * `runs` without `yields` (or the reverse), or `mounts` beside either, is
+     * `claim_invalid`.
      */
     judgeScope(receiver, claim, built) {
-        const layout = this.layout({ name: claim.name });
+        if ((claim.runs === undefined) !== (claim.yields === undefined))
+            return { outcome: unchecked('claim_invalid') };
+        if (claim.mounts !== undefined && claim.runs !== undefined)
+            return { outcome: unchecked('claim_invalid') };
+        const binds = claim.runs !== undefined || claim.mounts !== undefined;
+        const layout = this.layout({ name: claim.name, runs: claim.runs, mounts: claim.mounts });
         if ('failure' in layout)
             return { outcome: layout.failure };
         const callee = this.ownCallee(receiver, claim.path ?? [], claim.member, 'call');
@@ -1485,7 +1534,17 @@ class DeclarationReader {
         let best;
         for (const signature of callee.signatures) {
             let result = this.messageSignatureOutcome(signature, layout.value, labels);
-            if (result.rank === Infinity && this.returnSaysNothing(this.returnOf(signature, built))) {
+            if (result.rank === Infinity && claim.yields !== undefined) {
+                const given = this.yieldsOutcome(signature, claim.runs, claim.yields, receiver);
+                if (given)
+                    result = { rank: 5, outcome: given };
+            }
+            if (result.rank === Infinity && claim.mounts !== undefined) {
+                const mounted = this.mountsOutcome(signature, claim.mounts, receiver);
+                if (mounted)
+                    result = { rank: 5, outcome: mounted };
+            }
+            if (result.rank === Infinity && !binds && this.returnSaysNothing(this.returnOf(signature, built))) {
                 result = { rank: 6, outcome: unchecked('scope_unresolved') };
             }
             if (result.rank === Infinity)
@@ -1494,9 +1553,38 @@ class DeclarationReader {
                 best = furthest(best, result.rank, result.outcome);
         }
         if (holding.length > 0)
-            return { outcome: VERIFIED, holding };
+            return binds ? { outcome: VERIFIED } : { outcome: VERIFIED, holding };
         return { outcome: best.outcome };
     }
+    /**
+     * `mounts: { arg, key? }` on a scope (#2474 R0): the receiver the claim is
+     * read on is assignable to the parameter there, so an instance like it can
+     * be served under the scope's name. A parameter typed `any`, `unknown`,
+     * `{}` or by an unconstrained type parameter says nothing
+     * (`mounts_untyped`). There is no separate "not a function" rule: a router
+     * type that is itself a handler is a common shape, and a parameter only a
+     * function fits fails here because the instance does not fit it.
+     * Undefined when it holds.
+     */
+    mountsOutcome(signature, mounts, receiver) {
+        let declared = this.keyParameterAt(signature, mounts.arg);
+        if (declared !== undefined && mounts.key !== undefined) {
+            const property = this.declaredProperty(declared, mounts.key);
+            declared = property ? this.checker.getTypeOfSymbol(property) : undefined;
+        }
+        if (declared === undefined)
+            return failed('param_missing');
+        const slot = this.throughConstraint(declared);
+        if (slot === VARIADIC)
+            return unchecked('mounts_untyped');
+        const parts = this.parts(slot);
+        if (parts.length === 0)
+            return failed('mounts_not_instance');
+        if (parts.some(part => this.isOpenTop(part) || this.isUnconstrained(part) || this.isEmptyObject(part))) {
+            return unchecked('mounts_untyped');
+        }
+        return this.checker.isTypeAssignableTo(receiver.type, slot) ? undefined : failed('mounts_not_instance');
+    }
     /**
      * A send, receive or request op: the home-declared callable member (after
      * `path`; or the receiver itself, when null) with some overload that takes
@@ -1513,6 +1601,9 @@ class DeclarationReader {
         if (claim.yields !== undefined && (claim.op !== 'receive' || claim.handler === undefined)) {
             return unchecked('claim_invalid');
         }
+        // So is where the handler's request holds its path and method (#2474 R0).
+        if (claim.request !== undefined && !requestAtValid(claim))
+            return unchecked('claim_invalid');
         const name = claim.name;
         // A send carries a payload: a name alone on `send(data)` is the data. An
         // op that runs a function or client it is handed takes its name from
@@ -1562,6 +1653,11 @@ class DeclarationReader {
                 if (given)
                     result = { rank: 5, outcome: given };
             }
+            if (result.rank === Infinity && claim.request !== undefined) {
+                const read = this.requestOutcome(signature, claim.handler, claim.request);
+                if (read)
+                    result = { rank: 5, outcome: read };
+            }
             if (result.rank === Infinity) {
                 held = true;
                 break;
@@ -1572,7 +1668,28 @@ class DeclarationReader {
             return best.outcome;
         if (boundRuns)
             return this.boundRunsOutcome(receiver.makerHolding, boundRuns);
-        return VERIFIED;
+        const declarations = this.declarationsOf(callee.signatures);
+        return declarations.length > 0 ? { verdict: 'verified', declarations } : VERIFIED;
+    }
+    /**
+     * Where the signatures a verified op resolved to are declared, as position
+     * rows spell it (`decl_file`, `decl_line`): the member on this receiver, so
+     * two members of one name on two types give two answers. A declaration no
+     * row could name is left out.
+     */
+    declarationsOf(signatures) {
+        const found = [];
+        for (const signature of signatures) {
+            const declaration = signature.getDeclaration();
+            if (!declaration)
+                continue;
+            const file = declaration.getSourceFile();
+            const decl_file = declaringFileName(this.program, this.pathNames, file);
+            if (decl_file === null)
+                continue;
+            found.push({ decl_file, decl_line: file.getLineAndCharacterOfPosition(declaration.getStart(file)).line + 1 });
+        }
+        return sortedDeclarations(found);
     }
     /**
      * The method fields of an op (label structure v2, carrick#2434), under the
@@ -1680,6 +1797,48 @@ class DeclarationReader {
         }
         return failed('yields_not_export');
     }
+    /**
+     * `request: { param, path?, url?, method? }` on a receive op (#2474 R0):
+     * some signature of the handler this overload takes declares a parameter
+     * at `param` on which every member path the claim gives resolves, step by
+     * step, through properties the library declares (`declaredProperty`).
+     * Undefined when it holds.
+     */
+    requestOutcome(signature, handler, request) {
+        let declared = this.keyParameterAt(signature, handler.arg);
+        if (declared !== undefined && handler.key !== undefined) {
+            const property = this.declaredProperty(declared, handler.key);
+            declared = property ? this.checker.getTypeOfSymbol(property) : undefined;
+        }
+        if (declared === undefined)
+            return failed('param_missing');
+        const slot = this.throughConditional(this.throughConstraint(declared));
+        if (slot === VARIADIC)
+            return unchecked('handler_untyped');
+        const paths = [request.path, request.url, request.method].filter((p) => p !== undefined);
+        let best = failed('param_missing');
+        for (const part of this.parts(slot)) {
+            for (const handed of part.getCallSignatures()) {
+                const given = this.parameterAt(handed, request.param);
+                if (given === undefined || given === VARIADIC)
+                    continue;
+                const resolves = paths.every(members => {
+                    let at = given;
+                    for (const member of members) {
+                        const property = this.declaredProperty(at, member);
+                        if (!property)
+                            return false;
+                        at = this.checker.getTypeOfSymbol(property);
+                    }
+                    return true;
+                });
+                if (resolves)
+                    return undefined;
+                best = failed('request_member_missing');
+            }
+        }
+        return best;
+    }
     /**
      * The declarations spell `name` in one of `member`'s parameters: an
      * overload whose parameter there is that literal, or a key of the map a