carrick 0.3.124 → 0.3.126

package/package.json

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

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

@@ -212,10 +212,14 @@ export type SelfCheckOutcome = 'ok' | 'allowlisted_external' | 'decayed_internal
  *    serialised itself, and at least one return builds that string in a way
  *    the inferrer cannot trace to a typed value, so it publishes no part of
  *    the contract (carrick#2200).
+ *  - `body_built_by_callee`: a request locator names an argument of a call
+ *    into a function that builds the request body from it, and the body that
+ *    function builds cannot be typed, so the argument is not the body and no
+ *    contract is published (carrick#2628).
  *  - `not_recorded`: the position carries a top type and this layer has no
  *    cause for it.
  */
-export type TypeProvenanceReason = 'declared' | 'unresolved_import' | 'budget_exhausted' | 'no_payload_evidence' | 'machinery_envelope' | 'coerced_input' | 'no_success_payload' | 'no_request_body' | 'projected_value_only' | 'serialised_body_unread' | 'not_recorded';
+export type TypeProvenanceReason = 'declared' | 'unresolved_import' | 'budget_exhausted' | 'no_payload_evidence' | 'machinery_envelope' | 'coerced_input' | 'no_success_payload' | 'no_request_body' | 'projected_value_only' | 'serialised_body_unread' | 'body_built_by_callee' | 'not_recorded';
 /**
  * One `any`/`unknown` finding inside a captured or inferred type, with its
  * position and its cause. Sorted by `path` wherever a list is emitted, so the

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/deno-project.d.ts

@@ -39,6 +39,13 @@ export declare class DenoProject {
      * no identity. A file the workspace itself owns belongs to no package and
      * answers nothing, exactly as a workspace-declared type does under Node. */
     packageOf(file: string): string | undefined;
+    /** The npm package directory a resolved file lies in, and the package's
+     * name: its cache directory, which carries no `node_modules` segment, so
+     * only the graph can say where the package starts (carrick#2599). */
+    packageDirectoryOf(file: string): {
+        directory: string;
+        name: string;
+    } | undefined;
     private isNpmFile;
     /** Let TypeScript interpret real package exports/types using Deno's exact
      * dependency graph. Only the resolution host sees virtual node_modules;

package/sidecar/dist/src/capture/deno-project.js

@@ -280,6 +280,13 @@ export class DenoProject {
         const specifier = this.specifiersByPath.get(resolved);
         return specifier ? jsrPackageName(specifier) : undefined;
     }
+    /** The npm package directory a resolved file lies in, and the package's
+     * name: its cache directory, which carries no `node_modules` segment, so
+     * only the graph can say where the package starts (carrick#2599). */
+    packageDirectoryOf(file) {
+        const owner = this.npmOwner(path.resolve(file));
+        return owner?.localPath ? { directory: owner.localPath, name: owner.name } : undefined;
+    }
     isNpmFile(file) {
         return !!this.npmOwner(file) || file.split(path.sep).includes('node_modules');
     }

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/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/declaration-attribution.d.ts

@@ -20,6 +20,17 @@ import type { ts } from 'ts-morph';
  * with one declaration needs none.
  */
 export declare function attributedDeclaration<T extends ts.Node>(programOf: () => ts.Program, declarations: readonly T[]): T | undefined;
+/**
+ * The declaration a member is attributed to when it is read on `holder`: its
+ * own ({@link attributedDeclaration}), or, for a member with none (a mapped
+ * type's), the declaration of the holder's type: its symbol's, else its alias
+ * symbol's (carrick#2448). The per-position rows and a library verdict's
+ * `declarations` (carrick#2654) both name a member this way, so a verdict
+ * joins the row of the call it judges.
+ */
+export declare function memberDeclaration(programOf: () => ts.Program, member: ts.Symbol, holder: ts.Type): ts.Declaration | undefined;
+/** The declaration of a type's symbol, else of its alias symbol: a mapped type node, or the alias naming it. */
+export declare function typeDeclaration(programOf: () => ts.Program, type: ts.Type): ts.Declaration | undefined;
 /**
  * The npm package a declaring file belongs to, by the module graph where
  * there is one and by its path otherwise. `undefined` when neither names one.

package/sidecar/dist/src/declaration-attribution.js

@@ -31,6 +31,22 @@ export function attributedDeclaration(programOf, declarations) {
         return pathA < pathB ? -1 : pathA > pathB ? 1 : a.getStart() - b.getStart();
     })[0];
 }
+/**
+ * The declaration a member is attributed to when it is read on `holder`: its
+ * own ({@link attributedDeclaration}), or, for a member with none (a mapped
+ * type's), the declaration of the holder's type: its symbol's, else its alias
+ * symbol's (carrick#2448). The per-position rows and a library verdict's
+ * `declarations` (carrick#2654) both name a member this way, so a verdict
+ * joins the row of the call it judges.
+ */
+export function memberDeclaration(programOf, member, holder) {
+    return attributedDeclaration(programOf, member.declarations ?? []) ?? typeDeclaration(programOf, holder);
+}
+/** The declaration of a type's symbol, else of its alias symbol: a mapped type node, or the alias naming it. */
+export function typeDeclaration(programOf, type) {
+    const owner = type.getSymbol() ?? type.aliasSymbol;
+    return attributedDeclaration(programOf, owner?.declarations ?? []);
+}
 /**
  * The npm package a declaring file belongs to, by the module graph where
  * there is one and by its path otherwise. `undefined` when neither names one.

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

@@ -0,0 +1,43 @@
+/**
+ * The implementations of a bodyless declaration, asked where discovery stops
+ * at one (carrick#2432 slice B): a call through an interface's method, a
+ * function-typed property or an abstract member, whose receiver the scanner
+ * cannot follow to a value.
+ *
+ * Each question is the span of a `call` (or `member`) position row, in the
+ * rows' numbering (UTF-16 code units from the start of the file, as the
+ * scanner's `sidecar_position` gives). The call's symbol and declaration are
+ * read exactly as the row read them ({@link PositionWalker.symbolOf}), and
+ * go-to-implementation is asked once per declaration, at its name, over the
+ * language service's program of the project that owns the file. That is the
+ * analysis program: nothing here releases it.
+ *
+ * Each answer:
+ * - holds none of the declaration's own signatures: asked at an overloaded
+ *   interface or abstract method, go-to-implementation names only the bodies
+ *   that implement it (TypeScript 6.0, pinned in implementations.test.ts).
+ *   The walk's filter for them (`implementationRows`, removed in #2561) is
+ *   not carried over: no bodyless declaration reaches it;
+ * - names each implementation as a row names a declaration
+ *   ({@link PositionWalker.located}), at the implementation's declaration's
+ *   start, so it joins to a definition as a `call` row at it would;
+ * - is sorted by file, then position;
+ * - holds at most {@link IMPLEMENTATIONS_CAP}; past it, none, and `too_many`.
+ *
+ * The position rows carry no implementations (version 4, carrick#2561): this
+ * action is the only place they are asked.
+ */
+import type { ProjectLoader } from './project-loader.js';
+import type { ImplementationsAnswer, ImplementationsQuery } from './types.js';
+/** The most implementations one answer lists. */
+export declare const IMPLEMENTATIONS_CAP = 16;
+export interface ImplementationsOptions {
+    loader: ProjectLoader;
+    /** Every name in an answer is relative to it, as in the position rows. */
+    scanRoot: string;
+    queries: ImplementationsQuery[];
+    /** Called after each question is answered. */
+    onAnswer?: () => void;
+}
+/** One answer per question, in request order. */
+export declare function findImplementations(options: ImplementationsOptions): ImplementationsAnswer[];

package/sidecar/dist/src/implementations.js

@@ -0,0 +1,224 @@
+/**
+ * The implementations of a bodyless declaration, asked where discovery stops
+ * at one (carrick#2432 slice B): a call through an interface's method, a
+ * function-typed property or an abstract member, whose receiver the scanner
+ * cannot follow to a value.
+ *
+ * Each question is the span of a `call` (or `member`) position row, in the
+ * rows' numbering (UTF-16 code units from the start of the file, as the
+ * scanner's `sidecar_position` gives). The call's symbol and declaration are
+ * read exactly as the row read them ({@link PositionWalker.symbolOf}), and
+ * go-to-implementation is asked once per declaration, at its name, over the
+ * language service's program of the project that owns the file. That is the
+ * analysis program: nothing here releases it.
+ *
+ * Each answer:
+ * - holds none of the declaration's own signatures: asked at an overloaded
+ *   interface or abstract method, go-to-implementation names only the bodies
+ *   that implement it (TypeScript 6.0, pinned in implementations.test.ts).
+ *   The walk's filter for them (`implementationRows`, removed in #2561) is
+ *   not carried over: no bodyless declaration reaches it;
+ * - names each implementation as a row names a declaration
+ *   ({@link PositionWalker.located}), at the implementation's declaration's
+ *   start, so it joins to a definition as a `call` row at it would;
+ * - is sorted by file, then position;
+ * - holds at most {@link IMPLEMENTATIONS_CAP}; past it, none, and `too_many`.
+ *
+ * The position rows carry no implementations (version 4, carrick#2561): this
+ * action is the only place they are asked.
+ */
+import * as path from 'node:path';
+import { ts } from 'ts-morph';
+import { attributedDeclaration } from './declaration-attribution.js';
+import { PathNames, PositionWalker, compareNames, kindOf } from './position-rows.js';
+/** The most implementations one answer lists. */
+export const IMPLEMENTATIONS_CAP = 16;
+/** One answer per question, in request order. */
+export function findImplementations(options) {
+    const { loader, scanRoot, queries } = options;
+    const paths = new PathNames(scanRoot);
+    const answers = new Array(queries.length);
+    const groups = new Map();
+    queries.forEach((query, index) => {
+        const key = loader.projectKeyFor(path.resolve(query.file));
+        groups.set(key, [...(groups.get(key) ?? []), index]);
+    });
+    for (const [key, indexes] of groups) {
+        const service = loader.getProjectFor(key).getLanguageService().compilerObject;
+        const program = service.getProgram();
+        if (!program)
+            throw new Error('the language service built no program');
+        const finder = new ImplementationFinder(program, service, new PositionWalker(program, paths, loader));
+        for (const index of indexes) {
+            answers[index] = finder.answer(queries[index]);
+            options.onAnswer?.();
+        }
+    }
+    return answers;
+}
+/** An answer with nothing found, and why. */
+function none(reason, declaration = null) {
+    return { declaration, implementations: [], too_many: false, reason };
+}
+class ImplementationFinder {
+    program;
+    service;
+    walker;
+    checker;
+    /** Answers by declaration: a declaration is searched once, however many calls reach it. */
+    searched = new Map();
+    constructor(program, service, walker) {
+        this.program = program;
+        this.service = service;
+        this.walker = walker;
+        this.checker = program.getTypeChecker();
+    }
+    answer(query) {
+        const sourceFile = this.program.getSourceFile(path.resolve(query.file));
+        if (!sourceFile)
+            return none('not_in_program');
+        const found = positionAt(sourceFile, query.start, query.end);
+        if (!found)
+            return none('no_call');
+        let declaration;
+        let named = null;
+        try {
+            const symbol = this.walker.symbolOf(found.kind, found.node);
+            if (!symbol)
+                return none('no_symbol');
+            declaration = attributedDeclaration(() => this.program, symbol.declarations ?? []);
+            if (!declaration)
+                return none('no_declaration');
+            named = this.named(declaration, ts.symbolName(symbol));
+            if (!isBodyless(declaration, this.checker))
+                return none('has_body', named);
+        }
+        catch {
+            return none('checker_threw', named);
+        }
+        let searched = this.searched.get(declaration);
+        if (!searched) {
+            try {
+                searched = this.implementationsOf(declaration);
+            }
+            catch {
+                return none('checker_threw', named);
+            }
+            this.searched.set(declaration, searched);
+        }
+        return { declaration: named, ...searched };
+    }
+    /** A declaration as a row names it: its symbol, file and line. */
+    named(declaration, symbol) {
+        const file = declaration.getSourceFile();
+        const { declFile, declLine, declPackage } = this.walker.located(file, declaration.getStart(file));
+        return { symbol, decl_file: declFile, decl_line: declLine, decl_package: declPackage };
+    }
+    /**
+     * What go-to-implementation names for `declaration`, asked at its name,
+     * in file and position order.
+     */
+    implementationsOf(declaration) {
+        const name = ts.getNameOfDeclaration(declaration) ?? declaration;
+        const declaringFile = name.getSourceFile();
+        const found = new Map();
+        for (const location of this.service.getImplementationAtPosition(declaringFile.fileName, name.getStart(declaringFile)) ?? []) {
+            const file = this.program.getSourceFile(location.fileName);
+            if (!file)
+                continue;
+            const start = location.textSpan.start;
+            found.set(`${location.fileName}\u0000${start}`, { file, start });
+        }
+        if (found.size > IMPLEMENTATIONS_CAP)
+            return { implementations: [], too_many: true };
+        const implementations = [...found.values()].map(({ file, start }) => {
+            const at = nodeStartingAt(file, start);
+            const symbol = at ? this.checker.getSymbolAtLocation(at) : undefined;
+            // The declaration the answer points into, so its line is the one a
+            // `call` row at the implementation names: the declaration's start,
+            // decorators and modifiers included, not its name's.
+            const holder = symbol?.declarations?.find((d) => d.getSourceFile() === file && d.getStart(file) <= start && start < d.end) ??
+                (at ? enclosingDeclaration(at) : undefined);
+            const placed = holder ? holder.getStart(file) : start;
+            const { declFile, declLine, declPackage } = this.walker.located(file, placed);
+            return {
+                file: declFile,
+                start: placed,
+                named: { symbol: symbol ? ts.symbolName(symbol) : null, decl_file: declFile, decl_line: declLine, decl_package: declPackage },
+            };
+        });
+        implementations.sort((a, b) => compareNames(a.file, b.file) || a.start - b.start);
+        return { implementations: implementations.map(({ named }) => named), too_many: false };
+    }
+}
+/**
+ * The `call` or `member` position whose span is exactly `start..end`: the
+ * node a row of that kind was written at. A call is preferred where both
+ * kinds share the span.
+ */
+function positionAt(file, start, end) {
+    let member;
+    let call;
+    const visit = (node) => {
+        const nodeStart = node.getStart(file);
+        if (end <= nodeStart || node.getEnd() < start)
+            return;
+        if (nodeStart === start && node.getEnd() === end) {
+            const kind = kindOf(node);
+            if (kind === 'call')
+                call ??= node;
+            if (kind === 'member')
+                member ??= node;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(file, visit);
+    if (call)
+        return { kind: 'call', node: call };
+    if (member)
+        return { kind: 'member', node: member };
+    return undefined;
+}
+/**
+ * Whether a declaration has no body for a call to run: an interface's or type
+ * literal's method, a function-typed property signature, an abstract method or
+ * property, or a function-typed class property or parameter with no
+ * initializer. Its implementations are what go-to-implementation names.
+ */
+function isBodyless(declaration, checker) {
+    const functionTyped = () => checker.getTypeAtLocation(declaration).getNonNullableType().getCallSignatures().length > 0;
+    if (ts.isMethodSignature(declaration))
+        return true;
+    if (ts.isPropertySignature(declaration))
+        return functionTyped();
+    if (ts.isMethodDeclaration(declaration) || ts.isPropertyDeclaration(declaration)) {
+        if (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Abstract)
+            return true;
+        return ts.isPropertyDeclaration(declaration) && !declaration.initializer && functionTyped();
+    }
+    if (ts.isParameter(declaration))
+        return !declaration.initializer && functionTyped();
+    return false;
+}
+/** The innermost node of `file` that starts at `position` (an implementation's name). */
+function nodeStartingAt(file, position) {
+    let found;
+    const visit = (node) => {
+        if (position < node.getStart(file) || position >= node.getEnd())
+            return;
+        if (node.getStart(file) === position)
+            found = node;
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(file, visit);
+    return found;
+}
+/** The nearest declaration holding `node`: what an answer with no symbol points into. */
+function enclosingDeclaration(node) {
+    for (let at = node; at && !ts.isSourceFile(at); at = at.parent) {
+        if (ts.isFunctionLike(at) || ts.isClassLike(at) || ts.isPropertyAssignment(at) || ts.isVariableDeclaration(at)) {
+            return at;
+        }
+    }
+    return undefined;
+}