carrick 0.3.117 → 0.3.119

package/package.json

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

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

@@ -89,6 +89,20 @@ const RUNTIME_TYPE_PACKAGES = new Set([
  * package's, never the runtime module.
  */
 const RUNTIME_MODULE = /^node:/;
+/**
+ * A key for the language's own library (carrick#2445): `lib:<lib file>`
+ * (`lib:lib.dom.d.ts`) names the globals that default-library file declares.
+ * Its installed version is the compiler's, so the store keys it
+ * `lib:lib.dom.d.ts@<typescript version>`. A global has no specifier: the
+ * probe reads it as `globalThis.<name>`, and its home is the default-library
+ * file set (`DEFAULT_LIBRARY_HOME`).
+ */
+const DEFAULT_LIBRARY = /^lib:/;
+/**
+ * The owner a home names for every default-library file. No package name
+ * holds a `:`, so only a `lib:` key's home ever holds it.
+ */
+const DEFAULT_LIBRARY_HOME = 'lib:';
 /** A dependency range that names the service's own source, not a registry release. */
 const LOCAL_RANGE = /^(workspace|file|link|portal):/;
 /** A resolved module lands on TypeScript: a declaration file or source. */
@@ -283,7 +297,7 @@ export class LibraryClaimsVerifier {
         }
         const importLines = importKeys.map((key, i) => {
             const [pkg, name] = JSON.parse(key);
-            return importLine(pkg, name, `__carrick_e${i}`);
+            return probeLine(pkg, name, `__carrick_e${i}`);
         });
         // One statement per receiver a message check's maker or scope claim
         // builds, after the imports: that receiver built with no argument and no
@@ -322,7 +336,8 @@ export class LibraryClaimsVerifier {
             const exportReads = new Map();
             const httpReceivers = new Map();
             const judged = new Map();
-            const declarationOf = (check) => file.statements[importIndex.get(exportKey(check))];
+            /** The probe's import of the check's export, or its read of a global (`probeLine`). */
+            const statementOf = (check) => file.statements[importIndex.get(exportKey(check))];
             /** The probe's no-argument build of `receiver` on the check's export, resolved. */
             const atDefaults = (check, receiver) => {
                 const index = builtIndex.get(builtKey(check, receiver));
@@ -333,7 +348,9 @@ export class LibraryClaimsVerifier {
                 const key = `${runtimeModules}\u0000${check.package}`;
                 let moduleRead = moduleReads.get(key);
                 if (!moduleRead) {
-                    moduleRead = reader.readModule(check.package, declarationOf(check), runtimeModules);
+                    moduleRead = DEFAULT_LIBRARY.test(check.package)
+                        ? reader.readDefaultLibrary(check.package)
+                        : reader.readModule(check.package, statementOf(check), runtimeModules);
                     moduleReads.set(key, moduleRead);
                 }
                 return moduleRead;
@@ -342,7 +359,9 @@ export class LibraryClaimsVerifier {
                 const key = exportKey(check);
                 let exportRead = exportReads.get(key);
                 if (!exportRead) {
-                    exportRead = reader.readExport(declarationOf(check));
+                    exportRead = DEFAULT_LIBRARY.test(check.package)
+                        ? reader.readGlobal(check.package, statementOf(check))
+                        : reader.readExport(statementOf(check));
                     exportReads.set(key, exportRead);
                 }
                 return exportRead;
@@ -534,15 +553,25 @@ export class LibraryClaimsVerifier {
             return { surfaces: [], surface_sha256: fullSurfaceSha256([]) };
         // Each specifier twice: as a namespace, which holds its named exports, and
         // as a default import, which is how a module that exports a value whole
-        // (`export =`) is imported as `default`.
-        const imports = packages.flatMap((pkg, i) => [
-            `import * as __carrick_ns${i} from ${JSON.stringify(pkg)};`,
-            importLine(pkg, 'default', `__carrick_d${i}`),
-        ]);
-        const probeOf = (file, i) => ({
-            namespace: file.statements[2 * i],
-            defaultImport: file.statements[2 * i + 1],
+        // (`export =`) is imported as `default`. A `lib:` key imports nothing: its
+        // globals are read from the file it names.
+        const imports = [];
+        const importAt = packages.map((pkg, i) => {
+            if (DEFAULT_LIBRARY.test(pkg))
+                return undefined;
+            const at = imports.length;
+            imports.push(`import * as __carrick_ns${i} from ${JSON.stringify(pkg)};`, importLine(pkg, 'default', `__carrick_d${i}`));
+            return at;
         });
+        const probeOf = (file, i) => {
+            const at = importAt[i];
+            return at === undefined
+                ? { defaultLibrary: packages[i] }
+                : {
+                    namespace: file.statements[at],
+                    defaultImport: file.statements[at + 1],
+                };
+        };
         const makers = this.readProbe(fromDir, imports, (_checker, reader, file) => packages.map((pkg, i) => reader.makersOf(pkg, probeOf(file, i), only[pkg])));
         const importLines = [];
         const buildLines = [];
@@ -550,7 +579,7 @@ export class LibraryClaimsVerifier {
         packages.forEach((pkg, i) => {
             for (const { export: name, receivers } of makers[i]) {
                 const local = `__carrick_e${importLines.length}`;
-                importLines.push(importLine(pkg, name, local));
+                importLines.push(probeLine(pkg, name, local));
                 for (const receiver of receivers) {
                     const expression = receiverExpression(local, receiver);
                     if (expression === undefined)
@@ -744,6 +773,18 @@ function typeSymbols(type) {
     }
     return symbols;
 }
+/**
+ * The probe's read of one export, bound to `local`: its import, or for a
+ * `lib:` key the global itself, as `globalThis` holds it. A block-scoped
+ * global (`declare const`) is not on `globalThis`; no default-library file
+ * declares one.
+ */
+function probeLine(pkg, name, local) {
+    if (!DEFAULT_LIBRARY.test(pkg))
+        return importLine(pkg, name, local);
+    const access = IDENTIFIER.test(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
+    return `const ${local} = globalThis${access};`;
+}
 /** The probe's import of one export, bound to `local`. */
 function importLine(pkg, name, local) {
     const specifier = JSON.stringify(pkg);
@@ -943,6 +984,54 @@ class DeclarationReader {
             ?.redirectInfo?.redirectTarget;
         return target === file && this.isInstalledFile(file.fileName);
     }
+    /**
+     * A `lib:` key: the default-library file it names, as the program's own
+     * `lib` setting loads it, read by the compiler that built the program. A
+     * file the program does not load is no module reason: each global answers
+     * `export_missing` (`readGlobal`).
+     */
+    readDefaultLibrary(pkg) {
+        const entry = { package: pkg, installed_version: ts.version };
+        const file = this.defaultLibraryFile(pkg);
+        if (file)
+            entry.resolved_file = file.fileName;
+        return { entry };
+    }
+    /** The default-library file a `lib:` key names, when the program loads it. */
+    defaultLibraryFile(pkg) {
+        const name = pkg.slice('lib:'.length);
+        return this.program
+            .getSourceFiles()
+            .find(file => this.program.isSourceFileDefaultLibrary(file) && path.basename(file.fileName) === name);
+    }
+    /**
+     * `T` for a global (`probeLine`'s `globalThis` read): the type the probe's
+     * local gets, and the global it names. The global must be a value the
+     * key's lib file declares; one only another file declares (the runtime's
+     * types, the service) is missing from it.
+     */
+    readGlobal(pkg, statement) {
+        const declaration = statement && ts.isVariableStatement(statement) ? statement.declarationList.declarations[0] : undefined;
+        const access = declaration?.initializer;
+        const name = access && ts.isPropertyAccessExpression(access)
+            ? access.name
+            : access && ts.isElementAccessExpression(access)
+                ? access.argumentExpression
+                : undefined;
+        const target = name ? this.checker.getSymbolAtLocation(name) : undefined;
+        const file = this.defaultLibraryFile(pkg);
+        if (!declaration ||
+            !target ||
+            !file ||
+            !(target.flags & ts.SymbolFlags.Value) ||
+            !(target.declarations ?? []).some(each => each.getSourceFile() === file)) {
+            return { reason: 'export_missing' };
+        }
+        const type = this.checker.getTypeAtLocation(declaration.name);
+        if (this.isOpenTop(type))
+            return { reason: 'export_untyped' };
+        return { value: { type, target } };
+    }
     /** `T`: the type the probe's import gets, and the declaration it names. */
     readExport(declaration) {
         const clause = declaration.importClause;
@@ -1038,6 +1127,9 @@ class DeclarationReader {
      * sub-object's, along a claim's `path`).
      */
     homeOf(pkg, symbols, base) {
+        // A global's home is the default-library file set, and only that.
+        if (DEFAULT_LIBRARY.test(pkg))
+            return base ?? new Set([DEFAULT_LIBRARY_HOME]);
         const named = packageNameOf(pkg);
         const home = new Set(base ?? [named, typesPackageOf(named)]);
         const runtime = RUNTIME_MODULE.test(pkg) || RUNTIME_TYPE_PACKAGES.has(named) || RUNTIME_TYPE_PACKAGES.has(typesPackageOf(named));
@@ -1061,6 +1153,8 @@ class DeclarationReader {
         return installed === undefined ? undefined : installed.packageName ?? installed.directoryName;
     }
     isOwnFile(file, home) {
+        if (this.program.isSourceFileDefaultLibrary(file))
+            return home.has(DEFAULT_LIBRARY_HOME);
         const owner = this.packageOf(file);
         return owner !== undefined && home.has(owner);
     }
@@ -2231,7 +2325,7 @@ class DeclarationReader {
         this.setPackage(pkg);
         // Runtime modules on: a `node:` specifier is listed from the runtime's
         // types package, as the message roles read it.
-        const moduleRead = this.readModule(pkg, probe.namespace, true);
+        const moduleRead = 'defaultLibrary' in probe ? this.readDefaultLibrary(pkg) : this.readModule(pkg, probe.namespace, true);
         const surface = { package: pkg, truncated: 0, exports: [] };
         if (moduleRead.entry.resolved_file)
             surface.resolved_file = moduleRead.entry.resolved_file;
@@ -2294,7 +2388,7 @@ class DeclarationReader {
      */
     makersOf(pkg, probe, only) {
         this.setPackage(pkg);
-        if (this.readModule(pkg, probe.namespace, true).reason)
+        if ('namespace' in probe && this.readModule(pkg, probe.namespace, true).reason)
             return [];
         return (this.listedExports(probe, only) ?? [])
             .filter(({ type }) => !this.isOpenTop(type))
@@ -2314,6 +2408,8 @@ class DeclarationReader {
      * resolves to no module symbol.
      */
     listedExports(probe, only) {
+        if ('defaultLibrary' in probe)
+            return this.listedGlobals(probe.defaultLibrary, only);
         const moduleSymbol = this.checker.getSymbolAtLocation(probe.namespace.moduleSpecifier);
         if (!moduleSymbol)
             return undefined;
@@ -2339,6 +2435,23 @@ class DeclarationReader {
         }
         return listed.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
     }
+    /**
+     * The value globals a `lib:` key's file declares (every one, or only those
+     * `only` names), sorted by name, each with its declared type: none when the
+     * program's `lib` setting does not load the file.
+     */
+    listedGlobals(pkg, only) {
+        const file = this.defaultLibraryFile(pkg);
+        if (!file)
+            return [];
+        return this.checker
+            .getSymbolsInScope(this.probe, ts.SymbolFlags.Value)
+            .filter(symbol => (symbol.flags & ts.SymbolFlags.Prototype) === 0 &&
+            (only === undefined || only.includes(symbol.getName())) &&
+            (symbol.declarations ?? []).some(declaration => declaration.getSourceFile() === file))
+            .map(symbol => ({ name: symbol.getName(), target: symbol, type: this.checker.getTypeOfSymbol(symbol) }))
+            .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    }
     /**
      * The ways an export makes a receiver, in listing order: calling it
      * (`instance:()`), constructing it (`instance:new`), then calling or
@@ -2896,16 +3009,21 @@ class DeclarationReader {
     }
     /**
      * What a factory builds says nothing: the type itself, or any branch of a
-     * conditional return type, does.
+     * conditional return type, does. A conditional whose branches lead back to
+     * itself (a recursive alias) is read once: `seen` holds the conditionals
+     * on the way down, and one met again says nothing new.
      */
-    returnSaysNothing(type) {
+    returnSaysNothing(type, seen = new Set()) {
         if (this.saysNothing(type))
             return true;
         return this.parts(type).some(part => {
             if (!(part.flags & ts.TypeFlags.Conditional))
                 return false;
             const node = part.root.node;
-            return [node.trueType, node.falseType].some(branch => this.returnSaysNothing(this.checker.getTypeFromTypeNode(branch)));
+            if (seen.has(node))
+                return false;
+            seen.add(node);
+            return [node.trueType, node.falseType].some(branch => this.returnSaysNothing(this.checker.getTypeFromTypeNode(branch), seen));
         });
     }
     /** `any` (an unresolved type included) or `unknown`. */

package/sidecar/dist/src/position-rows.d.ts

@@ -2,7 +2,7 @@
  * Per-position compiler rows for a service (carrick#2405, move 2 of the fact
  * layer). Record-only: nothing in a scan reads the file yet.
  *
- * For every source file the scanner sends, one row for each position of four
+ * For every source file the scanner sends, one row for each position of six
  * kinds, each holding what the compiler knows there: the symbol, the
  * declaration it is attributed to (file and line), the package that declares
  * it and the type text.
@@ -13,11 +13,22 @@
  * | `member`  | property or element access                        | the name or the argument  | the access     |
  * | `compare` | `=== !== == != < > <= >= instanceof in`           | the left operand          | the left operand |
  * | `ident`   | an identifier in expression position              | itself                    | itself         |
+ * | `impl`    | a `call` or `member` whose declaration has no body | an implementation of it  | nothing        |
+ * | `jsx`     | a JSX opening or self-closing element's tag        | the tag's name           | the tag        |
  *
- * A row's key is `(start, end, kind)`: TypeScript `getStart()`/`getEnd()` of
- * the node, in UTF-16 code units from the start of the file, which is what
- * the scanner's `sidecar_position` gives for an SWC span. Every path written
- * is relative to the scanned repo's root, with `/` separators.
+ * An `impl` row (version 2, carrick#2430) follows the `call` or `member` row
+ * it belongs to and has its span: one per declaration that go-to-implementation
+ * names for that row's declaration, when that declaration is an interface's
+ * or type literal's method, a function-typed property signature, an abstract
+ * member, or a function-typed class property or parameter with no
+ * initializer. Its `decl_*` name the implementing declaration. Past
+ * {@link IMPL_CAP} the row is one, with {@link FLAG_TOO_MANY} and nothing else.
+ *
+ * A row's key is `(start, end, kind)`, except that several `impl` rows share
+ * one: TypeScript `getStart()`/`getEnd()` of the node, in UTF-16 code units
+ * from the start of the file, which is what the scanner's `sidecar_position`
+ * gives for an SWC span. Every path written is relative to the scanned repo's
+ * root, with `/` separators.
  *
  * Each file is read in the program of the project that owns it
  * (`ProjectLoader.projectKeyFor`, carrick#1604), one owner's program at a
@@ -33,7 +44,7 @@ import { ts } from 'ts-morph';
 import type { ProjectLoader } from './project-loader.js';
 import type { PositionRowsCounts } from './types.js';
 /** The format's version, written in the header. */
-export declare const POSITION_ROWS_VERSION = 1;
+export declare const POSITION_ROWS_VERSION = 2;
 /** The type is `any`, declared or inferred. Never set with the error type. */
 export declare const FLAG_ANY = 1;
 /** The type is the compiler's error type: something did not resolve. */
@@ -42,7 +53,22 @@ export declare const FLAG_ERROR_TYPE = 2;
 export declare const FLAG_CHECKER_THREW = 4;
 /** The declaration is outside the checkout, not the default library and in no installed package. */
 export declare const FLAG_DECLARATION_UNNAMED = 8;
-export type PositionKind = 'call' | 'member' | 'compare' | 'ident';
+/** An `impl` row standing for more implementations than {@link IMPL_CAP}; it names none. */
+export declare const FLAG_TOO_MANY = 16;
+/**
+ * The declaration is published under the row's symbol name: its module
+ * exports it by that name, or it is a global (a script's top-level
+ * declaration, or one in `declare global`). A member of a class, interface,
+ * type literal or object literal never is (carrick#2508).
+ */
+export declare const FLAG_PUBLISHED = 32;
+/** The declaration is what its module exports as `export =` or `default` (carrick#2508). */
+export declare const FLAG_MODULE_DEFAULT = 64;
+/** The most implementations one declaration's `impl` rows list. */
+export declare const IMPL_CAP = 16;
+/** The kinds {@link kindOf} gives a node; `impl` and `jsx` rows are written beside them. */
+export type NodeKind = 'call' | 'member' | 'compare' | 'ident';
+export type PositionKind = NodeKind | 'impl' | 'jsx';
 /** `[kind, start, end, symbol, decl_file, decl_line, decl_package, type_text, flags]` */
 export type PositionRow = [
     PositionKind,
@@ -75,4 +101,4 @@ export interface PositionRowsOptions {
  */
 export declare function writePositionRows(options: PositionRowsOptions): PositionRowsCounts;
 /** The kind of row a node gives, if any (exported for the editor-parity test, carrick#2418). */
-export declare function kindOf(node: ts.Node): PositionKind | undefined;
+export declare function kindOf(node: ts.Node): NodeKind | undefined;

package/sidecar/dist/src/position-rows.js

@@ -2,7 +2,7 @@
  * Per-position compiler rows for a service (carrick#2405, move 2 of the fact
  * layer). Record-only: nothing in a scan reads the file yet.
  *
- * For every source file the scanner sends, one row for each position of four
+ * For every source file the scanner sends, one row for each position of six
  * kinds, each holding what the compiler knows there: the symbol, the
  * declaration it is attributed to (file and line), the package that declares
  * it and the type text.
@@ -13,11 +13,22 @@
  * | `member`  | property or element access                        | the name or the argument  | the access     |
  * | `compare` | `=== !== == != < > <= >= instanceof in`           | the left operand          | the left operand |
  * | `ident`   | an identifier in expression position              | itself                    | itself         |
+ * | `impl`    | a `call` or `member` whose declaration has no body | an implementation of it  | nothing        |
+ * | `jsx`     | a JSX opening or self-closing element's tag        | the tag's name           | the tag        |
  *
- * A row's key is `(start, end, kind)`: TypeScript `getStart()`/`getEnd()` of
- * the node, in UTF-16 code units from the start of the file, which is what
- * the scanner's `sidecar_position` gives for an SWC span. Every path written
- * is relative to the scanned repo's root, with `/` separators.
+ * An `impl` row (version 2, carrick#2430) follows the `call` or `member` row
+ * it belongs to and has its span: one per declaration that go-to-implementation
+ * names for that row's declaration, when that declaration is an interface's
+ * or type literal's method, a function-typed property signature, an abstract
+ * member, or a function-typed class property or parameter with no
+ * initializer. Its `decl_*` name the implementing declaration. Past
+ * {@link IMPL_CAP} the row is one, with {@link FLAG_TOO_MANY} and nothing else.
+ *
+ * A row's key is `(start, end, kind)`, except that several `impl` rows share
+ * one: TypeScript `getStart()`/`getEnd()` of the node, in UTF-16 code units
+ * from the start of the file, which is what the scanner's `sidecar_position`
+ * gives for an SWC span. Every path written is relative to the scanned repo's
+ * root, with `/` separators.
  *
  * Each file is read in the program of the project that owns it
  * (`ProjectLoader.projectKeyFor`, carrick#1604), one owner's program at a
@@ -38,7 +49,7 @@ import { WriteGuard, installedPackageDirectory, isDeclarationFileName, moduleExp
 import { attributedDeclaration, installedPackageOf } from './declaration-attribution.js';
 import { typeToStringAsDeclared } from './print-type.js';
 /** The format's version, written in the header. */
-export const POSITION_ROWS_VERSION = 1;
+export const POSITION_ROWS_VERSION = 2;
 /** The type is `any`, declared or inferred. Never set with the error type. */
 export const FLAG_ANY = 1;
 /** The type is the compiler's error type: something did not resolve. */
@@ -47,6 +58,19 @@ export const FLAG_ERROR_TYPE = 2;
 export const FLAG_CHECKER_THREW = 4;
 /** The declaration is outside the checkout, not the default library and in no installed package. */
 export const FLAG_DECLARATION_UNNAMED = 8;
+/** An `impl` row standing for more implementations than {@link IMPL_CAP}; it names none. */
+export const FLAG_TOO_MANY = 16;
+/**
+ * The declaration is published under the row's symbol name: its module
+ * exports it by that name, or it is a global (a script's top-level
+ * declaration, or one in `declare global`). A member of a class, interface,
+ * type literal or object literal never is (carrick#2508).
+ */
+export const FLAG_PUBLISHED = 32;
+/** The declaration is what its module exports as `export =` or `default` (carrick#2508). */
+export const FLAG_MODULE_DEFAULT = 64;
+/** The most implementations one declaration's `impl` rows list. */
+export const IMPL_CAP = 16;
 const COMPARE_OPERATORS = new Set([
     ts.SyntaxKind.EqualsEqualsEqualsToken,
     ts.SyntaxKind.ExclamationEqualsEqualsToken,
@@ -79,6 +103,8 @@ export function writePositionRows(options) {
         resolved: 0,
         any: 0,
         error_type: 0,
+        impl: 0,
+        jsx: 0,
         bytes: 0,
         load_ms: 0,
         walk_ms: 0,
@@ -127,11 +153,16 @@ export function writePositionRows(options) {
             }
             read.set(index, sourceFile?.getFilePath());
         }
-        // Built once, after every file the group adds.
-        const program = project.getProgram().compilerObject;
+        // Built once, after every file the group adds. The language service's
+        // program is the one walked, so go-to-implementation answers over it
+        // and no second program is built.
+        const service = project.getLanguageService().compilerObject;
+        const program = service.getProgram();
+        if (!program)
+            throw new Error('the language service built no program');
         counts.load_ms += performance.now() - loadStarted;
         const walkStarted = performance.now();
-        const walker = new PositionWalker(program, paths, loader);
+        const walker = new PositionWalker(program, service, paths, loader);
         const missed = [];
         for (const index of indexes) {
             if (!read.has(index))
@@ -151,22 +182,23 @@ export function writePositionRows(options) {
                     counts.any += 1;
                 if (row[8] & FLAG_ERROR_TYPE)
                     counts.error_type += 1;
+                if (row[0] === 'impl')
+                    counts.impl += 1;
+                if (row[0] === 'jsx')
+                    counts.jsx += 1;
             }
             lines[index] = fileLine({ f: paths.relative(files[index]), h: hashes.get(index), r: rows });
             options.onFile?.();
         }
         counts.walk_ms += performance.now() - walkStarted;
-        return missed;
+        return { missed, program };
     };
     const hashes = new Map();
     for (const [key, indexes] of groups) {
         const project = loader.getProjectFor(key);
-        const missed = walkGroup(project, indexes, hashes);
+        const { missed, program } = walkGroup(project, indexes, hashes);
         if (missed.length > 0) {
-            const declarations = project
-                .getProgram()
-                .compilerObject.getRootFileNames()
-                .filter(isDeclarationFileName);
+            const declarations = program.getRootFileNames().filter(isDeclarationFileName);
             untaken.set(key, { indexes: missed, declarations });
         }
         // One owner's program at a time.
@@ -184,7 +216,7 @@ export function writePositionRows(options) {
             }
         }
         counts.load_ms += performance.now() - loadStarted;
-        for (const index of walkGroup(project, indexes, hashes)) {
+        for (const index of walkGroup(project, indexes, hashes).missed) {
             lines[index] = fileLine({ f: paths.relative(files[index]), h: hashes.get(index), skip: 'not_in_program', r: [] });
             options.onFile?.();
         }
@@ -344,11 +376,23 @@ function toSlashes(p) {
 /** The rows of one program's files. */
 class PositionWalker {
     program;
+    service;
     paths;
     loader;
     checker;
-    constructor(program, paths, loader) {
+    /**
+     * Each bodyless declaration's implementations, as `impl` rows with no span
+     * yet (`start` and `end` are 0): go-to-implementation searches the whole
+     * program, so it is asked once per declaration, never per call.
+     */
+    implementations = new Map();
+    /** The same for a member whose symbol has no declaration, keyed by symbol. */
+    undeclaredImplementations = new Map();
+    /** Each module's exports by name, and its `export =` and `default` targets, aliases followed. */
+    moduleExports = new Map();
+    constructor(program, service, paths, loader) {
         this.program = program;
+        this.service = service;
         this.paths = paths;
         this.loader = loader;
         this.checker = program.getTypeChecker();
@@ -357,8 +401,17 @@ class PositionWalker {
         const rows = [];
         const visit = (node) => {
             const kind = kindOf(node);
-            if (kind)
-                rows.push(this.row(kind, node, sourceFile));
+            if (kind) {
+                const row = this.row(kind, node, sourceFile);
+                rows.push(row);
+                if ((kind === 'call' || kind === 'member') && !(row[8] & FLAG_CHECKER_THREW)) {
+                    for (const impl of this.implRows(kind, node))
+                        rows.push(['impl', row[1], row[2], ...tail(impl)]);
+                }
+            }
+            if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+                rows.push(this.row('jsx', node.tagName, sourceFile));
+            }
             ts.forEachChild(node, visit);
         };
         ts.forEachChild(sourceFile, visit);
@@ -370,7 +423,7 @@ class PositionWalker {
         try {
             const symbol = this.symbolOf(kind, node);
             const typed = kind === 'compare' ? node.left : node;
-            const type = this.checker.getTypeAtLocation(typed);
+            const type = (kind === 'jsx' && this.intrinsicProps(node)) || this.checker.getTypeAtLocation(typed);
             let flags = 0;
             if (type.flags & ts.TypeFlags.Any) {
                 flags |= type.intrinsicName === 'error' ? FLAG_ERROR_TYPE : FLAG_ANY;
@@ -382,6 +435,9 @@ class PositionWalker {
                 this.ownerDeclaration(kind, node, symbol);
             if (!declaration)
                 return [kind, start, end, ts.symbolName(symbol), null, null, null, typeText, flags];
+            // A declaration named through its owner's type is a member.
+            if ((symbol.declarations ?? []).includes(declaration))
+                flags |= this.publication(symbol, declaration);
             // A file's own module symbol is named by the compiler as the quoted
             // absolute file name (`"/<checkout>/pkg/index"`). Name it as `decl_file`
             // names the file. A symbol that merely lives in a file (CommonJS
@@ -389,13 +445,9 @@ class PositionWalker {
             const symbolName = ts.symbolName(symbol);
             const isModule = declaration.kind === ts.SyntaxKind.SourceFile && symbolName.startsWith('"');
             const declaringFile = declaration.getSourceFile();
-            const declFile = this.program.isSourceFileDefaultLibrary(declaringFile)
-                ? `lib:${path.basename(declaringFile.fileName)}`
-                : this.paths.declaringFile(declaringFile.fileName);
+            const { declFile, declLine, declPackage } = this.located(declaringFile, declaration.getStart(declaringFile));
             if (declFile === null)
                 flags |= FLAG_DECLARATION_UNNAMED;
-            const declLine = declaringFile.getLineAndCharacterOfPosition(declaration.getStart(declaringFile)).line + 1;
-            const declPackage = this.paths.declaringPackage(declaringFile.fileName, (file) => this.loader.packageOf(file));
             const name = isModule ? declFile : symbolName;
             return [kind, start, end, name, declFile, declLine, declPackage, typeText, flags];
         }
@@ -403,6 +455,121 @@ class PositionWalker {
             return [kind, start, end, null, null, null, null, null, FLAG_CHECKER_THREW];
         }
     }
+    /**
+     * An intrinsic element's type: the attributes `JSX.IntrinsicElements`
+     * gives its tag. The compiler types an intrinsic tag name itself as the
+     * error type, though the name resolves. A tag is intrinsic when it is an
+     * identifier that starts with a lowercase letter or holds a `-`, as the
+     * language reads it.
+     */
+    intrinsicProps(tag) {
+        if (!ts.isIdentifier(tag) || !/^[a-z]|-/.test(tag.text))
+            return undefined;
+        const element = tag.parent;
+        if (!ts.isJsxOpeningElement(element) && !ts.isJsxSelfClosingElement(element))
+            return undefined;
+        return this.checker.getContextualType(element.attributes);
+    }
+    /** How rows name a position in a program file: its file, 1-based line and package. */
+    located(declaringFile, position) {
+        const declFile = this.program.isSourceFileDefaultLibrary(declaringFile)
+            ? `lib:${path.basename(declaringFile.fileName)}`
+            : this.paths.declaringFile(declaringFile.fileName);
+        const declLine = declaringFile.getLineAndCharacterOfPosition(position).line + 1;
+        const declPackage = this.paths.declaringPackage(declaringFile.fileName, (file) => this.loader.packageOf(file));
+        return { declFile, declLine, declPackage };
+    }
+    /**
+     * The `impl` rows of a `call` or `member` row (spans unset): none unless the
+     * row's declaration has no body of its own ({@link isBodyless}). Its own
+     * search, apart from the row's: a throw here writes one `impl` row flagged
+     * {@link FLAG_CHECKER_THREW} and leaves the row as it was.
+     */
+    implRows(kind, node) {
+        let declaration;
+        try {
+            const symbol = this.symbolOf(kind, node);
+            if (symbol && (symbol.declarations ?? []).length === 0)
+                return this.undeclaredImplRows(kind, node, symbol);
+            declaration = symbol ? attributedDeclaration(() => this.program, symbol.declarations ?? []) : undefined;
+            if (!declaration || !isBodyless(declaration, this.checker))
+                return [];
+        }
+        catch {
+            return [];
+        }
+        let rows = this.implementations.get(declaration);
+        if (!rows) {
+            try {
+                rows = this.implementationsOf(declaration);
+            }
+            catch {
+                rows = [['impl', 0, 0, null, null, null, null, null, FLAG_CHECKER_THREW]];
+            }
+            this.implementations.set(declaration, rows);
+        }
+        return rows;
+    }
+    /**
+     * The `impl` rows of a member whose symbol has no declaration (a mapped
+     * type's member): there is no declaration name to ask at, so the answer is
+     * asked at the use site's name, once per symbol. Same shape as
+     * {@link implementationsOf}; nothing of the symbol's own is filtered out.
+     */
+    undeclaredImplRows(kind, node, symbol) {
+        const cached = this.undeclaredImplementations.get(symbol);
+        if (cached)
+            return cached;
+        let rows;
+        try {
+            const named = nameNodeOf(kind, node);
+            rows = named ? this.implementationRows(named, []) : [];
+        }
+        catch {
+            rows = [['impl', 0, 0, null, null, null, null, null, FLAG_CHECKER_THREW]];
+        }
+        this.undeclaredImplementations.set(symbol, rows);
+        return rows;
+    }
+    /**
+     * What go-to-implementation names for `declaration`, asked at its name:
+     * every declaration the language service answers, except the symbol's own
+     * (an overloaded method answers with its other signatures), in file and
+     * position order.
+     */
+    implementationsOf(declaration) {
+        const name = ts.getNameOfDeclaration(declaration) ?? declaration;
+        const own = (this.checker.getSymbolAtLocation(name) ?? declaration.symbol)
+            ?.declarations ?? [declaration];
+        return this.implementationRows(name, own);
+    }
+    /** Go-to-implementation at `name`, minus results inside `own`, as sorted `impl` rows. */
+    implementationRows(name, own) {
+        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;
+            if (own.some((d) => d.getSourceFile() === file && d.pos <= start && start < d.end))
+                continue;
+            found.set(`${location.fileName}\u0000${start}`, { file, start });
+        }
+        if (found.size === 0)
+            return [];
+        if (found.size > IMPL_CAP)
+            return [['impl', 0, 0, null, null, null, null, null, FLAG_TOO_MANY]];
+        const rows = [...found.values()].map(({ file, start }) => {
+            const { declFile, declLine, declPackage } = this.located(file, start);
+            const named = nodeStartingAt(file, start);
+            const symbol = named ? this.checker.getSymbolAtLocation(named) : undefined;
+            const flags = declFile === null ? FLAG_DECLARATION_UNNAMED : 0;
+            return { start, row: ['impl', 0, 0, symbol ? ts.symbolName(symbol) : null, declFile, declLine, declPackage, null, flags] };
+        });
+        rows.sort((a, b) => compareNames(a.row[4], b.row[4]) || a.start - b.start);
+        return rows.map(({ row }) => row);
+    }
     /**
      * The declaration a member with none is attributed to (carrick#2448): the
      * mapped type node, or the alias naming it, of the receiver's type. A
@@ -427,6 +594,68 @@ class PositionWalker {
         const owner = holders[0].getSymbol() ?? holders[0].aliasSymbol;
         return attributedDeclaration(() => this.program, owner?.declarations ?? []);
     }
+    /**
+     * How `declaration`'s module publishes `symbol`: {@link FLAG_PUBLISHED}
+     * when under the symbol's own name (or as a global), and
+     * {@link FLAG_MODULE_DEFAULT} when as the module's `export =` or `default`.
+     * The module is the nearest ambient `declare module "…"` or the file.
+     */
+    publication(symbol, declaration) {
+        let container = declaration.parent;
+        while (container && !ts.isSourceFile(container) && !ts.isModuleBlock(container)) {
+            // Anything but a statement list between the declaration and its module
+            // (a class, interface, type or object literal, a function body) makes
+            // it a member or a local.
+            if (!ts.isVariableDeclarationList(container) && !ts.isVariableStatement(container))
+                return 0;
+            container = container.parent;
+        }
+        if (!container)
+            return 0;
+        const block = ts.isModuleBlock(container) ? container.parent : undefined;
+        if (block && block.flags & ts.NodeFlags.GlobalAugmentation)
+            return FLAG_PUBLISHED;
+        // A namespace's member is published when the module its file is publishes it.
+        if (block && !ts.isStringLiteral(block.name))
+            return this.publishedByExports(symbol, declaration);
+        const moduleSymbol = this.checker.getSymbolAtLocation(block ? block.name : container);
+        if (moduleSymbol)
+            return this.publishedIn(moduleSymbol, symbol);
+        // A script's top-level declaration is a global.
+        return ts.isSourceFile(container) && !ts.isExternalModule(container) ? FLAG_PUBLISHED : 0;
+    }
+    /** A namespace member, found among the exports of the module it sits in. */
+    publishedByExports(symbol, declaration) {
+        for (let node = declaration.parent; node; node = node.parent) {
+            if (ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name)) {
+                const moduleSymbol = this.checker.getSymbolAtLocation(node.name);
+                return moduleSymbol ? this.publishedIn(moduleSymbol, symbol) : 0;
+            }
+            if (ts.isSourceFile(node)) {
+                const moduleSymbol = this.checker.getSymbolAtLocation(node);
+                return moduleSymbol ? this.publishedIn(moduleSymbol, symbol) & FLAG_PUBLISHED : 0;
+            }
+        }
+        return 0;
+    }
+    publishedIn(moduleSymbol, symbol) {
+        let exports = this.moduleExports.get(moduleSymbol);
+        if (!exports) {
+            const resolve = (s) => s.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(s) : s;
+            const byName = new Map();
+            for (const exported of this.checker.getExportsOfModule(moduleSymbol)) {
+                byName.set(exported.getName(), resolve(exported));
+            }
+            const wholes = [ts.InternalSymbolName.ExportEquals, ts.InternalSymbolName.Default]
+                .map((key) => moduleSymbol.exports?.get(key))
+                .filter((own) => own !== undefined)
+                .map(resolve);
+            exports = { byName, wholes };
+            this.moduleExports.set(moduleSymbol, exports);
+        }
+        return ((exports.byName.get(symbol.getName()) === symbol ? FLAG_PUBLISHED : 0) |
+            (exports.wholes.includes(symbol) ? FLAG_MODULE_DEFAULT : 0));
+    }
     /** The row's symbol, following aliases to a target that has a declaration. */
     symbolOf(kind, node) {
         let symbol;
@@ -550,6 +779,54 @@ class PositionWalker {
         return this.host;
     }
 }
+/** A row's fields after its kind and span. */
+function tail(row) {
+    return [row[3], row[4], row[5], row[6], row[7], row[8]];
+}
+/** Order two `decl_file` names, `null` last. */
+function compareNames(a, b) {
+    if (a === b)
+        return 0;
+    if (a === null)
+        return 1;
+    if (b === null)
+        return -1;
+    return a < b ? -1 : 1;
+}
+/**
+ * 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 kind of row a node gives, if any (exported for the editor-parity test, carrick#2418). */
 export function kindOf(node) {
     if (ts.isCallExpression(node) || ts.isNewExpression(node) || ts.isTaggedTemplateExpression(node)) {
@@ -576,6 +853,12 @@ function nameNodeOf(kind, node) {
             return referenceName(node.left);
         case 'ident':
             return node;
+        case 'impl':
+            return undefined;
+        case 'jsx':
+            // The tag: `<Badge>`, `<ui.Button>`, `<this.Panel>`; a namespaced
+            // name (`<svg:path>`) names nothing.
+            return ts.isJsxNamespacedName(node) ? undefined : (referenceName(node) ?? node);
     }
 }
 /**

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

@@ -765,6 +765,10 @@ export interface PositionRowsCounts {
     any: number;
     /** Rows whose type is the compiler's error type (flag 2). */
     error_type: number;
+    /** `impl` rows: implementations of a bodyless declaration, or one past the cap (carrick#2430). */
+    impl: number;
+    /** `jsx` rows: one per JSX opening or self-closing element. */
+    jsx: number;
     /** The rows file's size on disk, compressed. */
     bytes: number;
     /** Time spent building programs and reading files into them. */