carrick 0.3.124 → 0.3.126

package/sidecar/dist/src/index.js

@@ -30,6 +30,7 @@ import { PROGRESS_INTERVAL_MS, atMostEvery } from './progress.js';
 import { mergeInferTimings } from './infer-timing.js';
 import { addProgramFiles, listProgramFiles } from './program-files.js';
 import { writePositionRows } from './position-rows.js';
+import { findImplementations } from './implementations.js';
 // ===========================================================================
 // Module-level state
 // ===========================================================================
@@ -90,7 +91,10 @@ function projectComponents(key = '') {
             // (`npm/carrick/package.json`) resolves `typescript ^5.8.0` unpinned,
             // so an install can pair ts-morph's copy with a newer 5.x.
             retyper: new Retyper(project, typeInferrer, jsonWireDeclarations, findDisqualifyingTopTypes),
-            claimsVerifier: new LibraryClaimsVerifier(project),
+            claimsVerifier: new LibraryClaimsVerifier(project, {
+                packageDirectoryOf: (file) => loader.packageDirectoryOf(file),
+                resolveModule: (name, from, options) => loader.resolveThroughGraph(name, from, options),
+            }),
         };
         components.set(key, built);
     }
@@ -556,6 +560,34 @@ function handleAddProgramFiles(request) {
         return { request_id: request.request_id, status: 'error', errors: [error] };
     }
 }
+/**
+ * Handle the 'implementations' action - the implementations of the bodyless
+ * declaration each call goes through (carrick#2432). Asked of the analysis
+ * process: it reads the programs the service's other actions read, and
+ * releases none of them.
+ */
+function handleImplementations(request) {
+    try {
+        const loader = initializedLoader();
+        let done = 0;
+        const report = atMostEvery(PROGRESS_INTERVAL_MS, () => writeProgress(request.request_id, 'implementations', `${done} of ${request.queries.length}`));
+        const answers = findImplementations({
+            loader,
+            scanRoot: request.scan_root,
+            queries: request.queries,
+            onAnswer: () => {
+                done += 1;
+                report();
+            },
+        });
+        return { request_id: request.request_id, status: 'success', result: { answers } };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        logError(`Implementations failed: ${error}`);
+        return { request_id: request.request_id, status: 'error', errors: [error] };
+    }
+}
 /**
  * Handle the 'position_rows' action - write the compiler's rows for each
  * call, member access, comparison and identifier of the given files
@@ -648,6 +680,8 @@ function handleRequest(request) {
             return handleAddProgramFiles(request);
         case 'position_rows':
             return handlePositionRows(request);
+        case 'implementations':
+            return handleImplementations(request);
         case 'health':
             return handleHealth(request);
         case 'shutdown':

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

@@ -35,7 +35,8 @@
  * package's: a `paths` alias or a `declare module` block the service writes
  * for itself is not evidence about the library.
  */
-import { type Project } from 'ts-morph';
+import { ts, type Project } from 'ts-morph';
+import { type PackageDirectoryOf } from './position-rows.js';
 import type { LibraryCheck, LibrarySurface, SemanticsCheck, SemanticsModule, SemanticsResult } from './types.js';
 export interface VerifyResult {
     semantics: SemanticsResult[];
@@ -54,9 +55,23 @@ export interface VerifyResult {
  *   options at argument 1; `request_body` adds the body key there.
  */
 export declare function httpCheck(check: SemanticsCheck): LibraryCheck;
+/**
+ * What a project's module graph says, where it resolved through one rather
+ * than through `node_modules` (carrick#2599). Such a resolver serves a package
+ * from a cache whose path has no `node_modules` segment, so neither the path
+ * nor a Node resolution of the package name finds the files the program
+ * loaded.
+ */
+export interface ModuleGraph {
+    /** The installed package directory a file lies in, and its name. */
+    packageDirectoryOf: PackageDirectoryOf;
+    /** How the program resolves `name` from `from`; `undefined` where there is no graph, and Node resolution answers. */
+    resolveModule(name: string, from: string, options: ts.CompilerOptions): ts.ResolvedModuleFull | undefined;
+}
 export declare class LibraryClaimsVerifier {
     private readonly project;
-    constructor(project: Project);
+    private readonly graph;
+    constructor(project: Project, graph?: ModuleGraph);
     /**
      * Judge every check, in request order, spending at most `budgetMs`. Checks
      * the budget does not reach come back `unchecked` with reason `budget`.

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

@@ -40,6 +40,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { ts } from 'ts-morph';
 import { PathNames, declaringFileName } from './position-rows.js';
+import { memberDeclaration } from './declaration-attribution.js';
 /** The methods a `verb` claim may name, and a method key may accept. */
 const HTTP_METHODS = new Set([
     'GET',
@@ -248,10 +249,13 @@ function sortedDeclarations(declarations) {
     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;
+const NO_MODULE_GRAPH = { packageDirectoryOf: () => undefined, resolveModule: () => undefined };
 export class LibraryClaimsVerifier {
     project;
-    constructor(project) {
+    graph;
+    constructor(project, graph = NO_MODULE_GRAPH) {
         this.project = project;
+        this.graph = graph;
     }
     /**
      * Judge every check, in request order, spending at most `budgetMs`. Checks
@@ -335,7 +339,19 @@ export class LibraryClaimsVerifier {
             builtIndex.set(key, importLines.length + builtLines.length);
             builtLines.push(`${expression};`);
         }
-        const probeText = [...importLines, ...builtLines].join('\n');
+        // A `node:` key may name a file of the runtime's types, whose exports are
+        // globals (`runtimeGlobalFile`): the probe reads each as `globalThis` holds
+        // it, beside its import, and the reader takes the one the key resolves to.
+        const globalIndex = new Map();
+        const globalLines = [];
+        importKeys.forEach((key, i) => {
+            const [pkg, name] = JSON.parse(key);
+            if (!RUNTIME_MODULE.test(pkg))
+                return;
+            globalIndex.set(key, importLines.length + builtLines.length + globalLines.length);
+            globalLines.push(globalRead(name, `__carrick_g${i}`));
+        });
+        const probeText = [...importLines, ...builtLines, ...globalLines].join('\n');
         const probePath = path.join(fromDir, `__carrick_claims_probe_${process.pid}_${probeSequence++}.ts`);
         const probe = this.project.createSourceFile(probePath, `${probeText}\n`, { overwrite: true });
         try {
@@ -344,7 +360,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, scanRoot);
+            const reader = new DeclarationReader(program, file, this.project.getModuleResolutionHost(), fromDir, scanRoot, this.graph);
             const localRanges = readLocalRanges(fromDir);
             const moduleReads = new Map();
             const exportReads = new Map();
@@ -352,6 +368,7 @@ export class LibraryClaimsVerifier {
             const judged = new Map();
             /** 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))];
+            const globalStatementOf = (check) => file.statements[globalIndex.get(exportKey(check)) ?? -1];
             /** 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));
@@ -373,9 +390,12 @@ export class LibraryClaimsVerifier {
                 const key = exportKey(check);
                 let exportRead = exportReads.get(key);
                 if (!exportRead) {
+                    const globalFile = RUNTIME_MODULE.test(check.package) ? readModule(check, rulesFor(check)?.message ?? false).globalFile : undefined;
                     exportRead = DEFAULT_LIBRARY.test(check.package)
-                        ? reader.readGlobal(check.package, statementOf(check))
-                        : reader.readExport(statementOf(check));
+                        ? reader.readGlobal(reader.defaultLibraryFile(check.package), statementOf(check))
+                        : globalFile
+                            ? reader.readGlobal(globalFile, globalStatementOf(check))
+                            : reader.readExport(statementOf(check));
                     exportReads.set(key, exportRead);
                 }
                 return exportRead;
@@ -621,7 +641,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, undefined, this.graph);
             return read(program.getTypeChecker(), reader, file);
         }
         finally {
@@ -809,8 +829,10 @@ function typeSymbols(type) {
  * declares one.
  */
 function probeLine(pkg, name, local) {
-    if (!DEFAULT_LIBRARY.test(pkg))
-        return importLine(pkg, name, local);
+    return DEFAULT_LIBRARY.test(pkg) ? globalRead(name, local) : importLine(pkg, name, local);
+}
+/** The probe's read of the global `name`, bound to `local`. */
+function globalRead(name, local) {
     const access = IDENTIFIER.test(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
     return `const ${local} = globalThis${access};`;
 }
@@ -869,6 +891,7 @@ class DeclarationReader {
     program;
     probe;
     host;
+    graph;
     checker;
     /** Names declaring files as position rows do: from the scan root, else the service root. */
     pathNames;
@@ -884,12 +907,13 @@ 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, scanRoot) {
+    constructor(program, probe, host, serviceRoot, scanRoot, graph) {
         this.program = program;
         this.probe = probe;
         this.host = host;
+        this.graph = graph;
         this.checker = program.getTypeChecker();
-        this.pathNames = new PathNames(scanRoot ?? serviceRoot);
+        this.pathNames = new PathNames(scanRoot ?? serviceRoot, graph.packageDirectoryOf);
         this.root = this.realpath(serviceRoot);
         this.printedRoots = [...new Set([this.root, serviceRoot])]
             .filter(root => root.length > 1)
@@ -931,11 +955,20 @@ class DeclarationReader {
      */
     readModule(pkg, declaration, runtimeModules = false) {
         const specifier = declaration.moduleSpecifier;
-        const resolved = ts.resolveModuleName(pkg, this.probe.fileName, this.program.getCompilerOptions(), this.host, undefined, undefined, this.program.getModeForUsageLocation(this.probe, specifier)).resolvedModule;
+        const resolved = this.graph.resolveModule(pkg, this.probe.fileName, this.program.getCompilerOptions()) ??
+            ts.resolveModuleName(pkg, this.probe.fileName, this.program.getCompilerOptions(), this.host, undefined, undefined, this.program.getModeForUsageLocation(this.probe, specifier)).resolvedModule;
         const entry = { package: pkg };
         const done = (reason) => reason ? { entry: { ...entry, reason }, reason } : { entry };
         const moduleSymbol = this.checker.getSymbolAtLocation(specifier);
         const declarations = moduleSymbol?.declarations ?? [];
+        const globalFile = declarations.length === 0 ? this.runtimeGlobalFile(pkg) : undefined;
+        if (globalFile) {
+            entry.resolved_file = globalFile.fileName;
+            const version = this.installedPackage(globalFile.fileName)?.version;
+            if (version)
+                entry.installed_version = version;
+            return { entry, globalFile };
+        }
         if (runtimeModules && RUNTIME_MODULE.test(pkg))
             return this.readRuntimeModule(declarations, entry, done);
         // The module itself, not a service-side augmentation of it.
@@ -1029,6 +1062,27 @@ class DeclarationReader {
             entry.resolved_file = file.fileName;
         return { entry };
     }
+    /**
+     * The runtime types' file a `node:<path>` key names, when no module has
+     * that name (carrick#2445): `node:web-globals/fetch` is the file
+     * `web-globals/fetch.d.ts` (or `.../index.d.ts`) of the installed runtime
+     * types package, which declares globals. Undefined when the program loads
+     * no such file; the key is then a module name, read as one.
+     */
+    runtimeGlobalFile(pkg) {
+        if (!RUNTIME_MODULE.test(pkg))
+            return undefined;
+        const relative = pkg.slice('node:'.length);
+        return this.program.getSourceFiles().find(file => {
+            const owner = this.packageOf(file);
+            if (owner === undefined || !RUNTIME_TYPE_PACKAGES.has(owner))
+                return false;
+            const name = this.realpath(file.fileName).split(path.sep).join('/');
+            const marker = `/node_modules/${owner}/`;
+            const inside = name.slice(name.lastIndexOf(marker) + marker.length);
+            return inside === `${relative}.d.ts` || inside === `${relative}/index.d.ts`;
+        });
+    }
     /** The default-library file a `lib:` key names, when the program loads it. */
     defaultLibraryFile(pkg) {
         const name = pkg.slice('lib:'.length);
@@ -1042,7 +1096,7 @@ class DeclarationReader {
      * key's lib file declares; one only another file declares (the runtime's
      * types, the service) is missing from it.
      */
-    readGlobal(pkg, statement) {
+    readGlobal(file, statement) {
         const declaration = statement && ts.isVariableStatement(statement) ? statement.declarationList.declarations[0] : undefined;
         const access = declaration?.initializer;
         const name = access && ts.isPropertyAccessExpression(access)
@@ -1051,7 +1105,6 @@ class DeclarationReader {
                 ? access.argumentExpression
                 : undefined;
         const target = name ? this.checker.getSymbolAtLocation(name) : undefined;
-        const file = this.defaultLibraryFile(pkg);
         if (!declaration ||
             !target ||
             !file ||
@@ -1552,8 +1605,12 @@ class DeclarationReader {
             else
                 best = furthest(best, result.rank, result.outcome);
         }
-        if (holding.length > 0)
-            return binds ? { outcome: VERIFIED } : { outcome: VERIFIED, holding };
+        if (holding.length > 0) {
+            // The member's own declarations, as a verified op carries them (#2636).
+            const declarations = this.declarationsOf({ signatures: holding, named: callee.named });
+            const outcome = declarations.length > 0 ? { verdict: 'verified', declarations } : VERIFIED;
+            return binds ? { outcome } : { outcome, holding };
+        }
         return { outcome: best.outcome };
     }
     /**
@@ -1583,8 +1640,107 @@ class DeclarationReader {
         if (parts.some(part => this.isOpenTop(part) || this.isUnconstrained(part) || this.isEmptyObject(part))) {
             return unchecked('mounts_untyped');
         }
+        const erased = this.fitsErased(receiver.type, slot, signature.typeParameters ?? []);
+        if (erased !== undefined)
+            return erased ? undefined : failed('mounts_not_instance');
         return this.checker.isTypeAssignableTo(receiver.type, slot) ? undefined : failed('mounts_not_instance');
     }
+    /**
+     * `receiver` fits `slot` with the signature's own type parameters
+     * (`own`) erased to their constraints (carrick#2652), or undefined when
+     * that reading does not apply. The receiver is built at its defaults, so a
+     * parameter typed `Tree<SubEnv, SubBase>` has free arguments that no default
+     * instance is assignable to. It applies when `slot` and `receiver` are
+     * references to the same generic type and no argument mixes an own type
+     * parameter into a larger type: an argument that is an own type parameter
+     * takes any receiver argument its constraint takes (none: any), every other
+     * argument must be the receiver's.
+     */
+    fitsErased(receiver, slot, own) {
+        if (own.length === 0)
+            return undefined;
+        const from = this.referenceOf(receiver);
+        const to = this.referenceOf(slot);
+        if (from === undefined || to === undefined)
+            return undefined;
+        const count = (to.target.typeParameters ?? []).length;
+        const given = this.argumentsAs(from.target, this.checker.getTypeArguments(from), to.target);
+        const wanted = this.checker.getTypeArguments(to);
+        if (count === 0 || given === undefined || given.length < count || wanted.length < count)
+            return undefined;
+        for (let i = 0; i < count; i++) {
+            if (own.includes(wanted[i])) {
+                const constraint = this.checker.getBaseConstraintOfType(wanted[i]);
+                if (constraint === undefined || this.isOpenTop(constraint))
+                    continue;
+                if (own.some(parameter => this.mentions(constraint, parameter)))
+                    return undefined;
+                if (!this.checker.isTypeAssignableTo(given[i], constraint))
+                    return false;
+            }
+            else if (own.some(parameter => this.mentions(wanted[i], parameter))) {
+                return undefined;
+            }
+            else if (given[i] !== wanted[i] &&
+                !(this.checker.isTypeAssignableTo(given[i], wanted[i]) && this.checker.isTypeAssignableTo(wanted[i], given[i]))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * The type arguments the instance `current<args>` has as an instance of
+     * `target`: its own when it is one, else through the base types its class
+     * extends, where each base argument is a type parameter of the class
+     * (replaced by the matching argument) or names none. Undefined when
+     * `target` is not reached that way.
+     */
+    argumentsAs(current, args, target, depth = 0) {
+        if (current === target)
+            return args;
+        if (depth > 6)
+            return undefined;
+        const parameters = current.typeParameters ?? [];
+        for (const base of this.checker.getBaseTypes(current)) {
+            const reference = this.referenceOf(base);
+            if (reference === undefined)
+                continue;
+            const mapped = [];
+            let usable = true;
+            for (const argument of this.checker.getTypeArguments(reference)) {
+                const index = parameters.indexOf(argument);
+                if (index >= 0)
+                    mapped.push(args[index]);
+                else if (parameters.some(parameter => this.mentions(argument, parameter)))
+                    usable = false;
+                else
+                    mapped.push(argument);
+            }
+            const found = usable ? this.argumentsAs(reference.target, mapped, target, depth + 1) : undefined;
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    }
+    referenceOf(type) {
+        if (!(type.flags & ts.TypeFlags.Object))
+            return undefined;
+        return type.objectFlags & ts.ObjectFlags.Reference ? type : undefined;
+    }
+    /** `type` names `parameter` anywhere in its arguments or members of a union or intersection. */
+    mentions(type, parameter, depth = 0) {
+        if (type === parameter)
+            return true;
+        if (depth > 6)
+            return true;
+        if (type.isUnionOrIntersection())
+            return type.types.some(part => this.mentions(part, parameter, depth + 1));
+        const reference = this.referenceOf(type);
+        if (reference !== undefined) {
+            return this.checker.getTypeArguments(reference).some(argument => this.mentions(argument, parameter, depth + 1));
+        }
+        return false;
+    }
     /**
      * A send, receive or request op: the home-declared callable member (after
      * `path`; or the receiver itself, when null) with some overload that takes
@@ -1668,19 +1824,25 @@ class DeclarationReader {
             return best.outcome;
         if (boundRuns)
             return this.boundRunsOutcome(receiver.makerHolding, boundRuns);
-        const declarations = this.declarationsOf(callee.signatures);
+        const declarations = this.declarationsOf(callee);
         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.
+     * Where a verified op or scope's member is declared, as position rows spell
+     * it (`decl_file`, `decl_line`): the declaration the call row names for the
+     * member symbol on this receiver ({@link memberDeclaration}), so two members
+     * of one name on two types give two answers, and a property typed by an
+     * interface with call signatures names the property, not the signatures
+     * (carrick#2654). A callee that is the receiver itself has no member symbol
+     * and names its signatures' declarations. A declaration no row could name is
+     * left out.
      */
-    declarationsOf(signatures) {
+    declarationsOf(callee) {
         const found = [];
-        for (const signature of signatures) {
-            const declaration = signature.getDeclaration();
+        const named = callee.named
+            ? [memberDeclaration(() => this.program, callee.named.property, callee.named.holder)]
+            : callee.signatures.map(signature => signature.getDeclaration());
+        for (const declaration of named) {
             if (!declaration)
                 continue;
             const file = declaration.getSourceFile();
@@ -2394,6 +2556,9 @@ class DeclarationReader {
      */
     ownCallee(receiver, hops, member, form) {
         let holder = receiver;
+        // The last member the path reaches, with the type it is read on: the
+        // symbol the call row names (carrick#2654).
+        let named;
         for (const hop of hops) {
             const step = this.ownMember(holder, hop);
             if ('failure' in step)
@@ -2401,6 +2566,7 @@ class DeclarationReader {
             const type = step.type;
             if (this.saysNothing(type))
                 return { failure: unchecked('member_untyped') };
+            named = { property: step.property, holder: holder.type };
             holder = { type, home: this.homeOf(receiver.pkg, typeSymbols(type), holder.home) };
         }
         let type = holder.type;
@@ -2412,6 +2578,7 @@ class DeclarationReader {
                 return step;
             type = step.type;
             boundBase = step.bound;
+            named = { property: step.property, holder: holder.type };
         }
         const all = form === 'new'
             ? this.checker.getNonNullableType(type).getConstructSignatures()
@@ -2425,7 +2592,7 @@ class DeclarationReader {
             ? library
             : library.filter(signature => this.isOwnFile(this.signatureFile(signature, type, form), home));
         if (own.length > 0)
-            return { signatures: own, holder: holder.type };
+            return { signatures: own, holder: holder.type, named };
         if (library.length > 0)
             return { failure: failed('member_inherited') };
         return { failure: this.slotFailure(type, form === 'new' ? 'member_not_constructible' : 'member_not_callable') };
@@ -2442,9 +2609,9 @@ class DeclarationReader {
             return { failure: failed('member_missing') };
         const type = this.checker.getTypeOfSymbol(property);
         if (this.isOwnMember(property, apparent, holder.home))
-            return { type, bound: false };
+            return { type, bound: false, property };
         if (this.isBoundByOwnType(property, holder))
-            return { type, bound: true };
+            return { type, bound: true, property };
         return { failure: failed('member_inherited') };
     }
     /**
@@ -2539,7 +2706,7 @@ class DeclarationReader {
             surface.installed_version = moduleRead.entry.installed_version;
         if (moduleRead.reason)
             return { ...surface, reason: moduleRead.reason };
-        const exported = this.listedExports(probe, only);
+        const exported = this.listedExports(probe, only, moduleRead.globalFile);
         if (!exported)
             return { ...surface, reason: 'module_unresolved' };
         let budget = maxEntries;
@@ -2555,6 +2722,9 @@ class DeclarationReader {
         // Three passes: every export and receiver, then every member name, then signatures.
         const names = [];
         const fills = [];
+        // What the package's default export names: a maker also exported by name
+        // under this declaration is imported the same way, so it is read the same.
+        const defaultTarget = exported.find(each => each.name === 'default')?.target;
         for (const { name, target, type } of exported) {
             if (!take())
                 continue;
@@ -2570,7 +2740,7 @@ class DeclarationReader {
             };
             receiverOf('export', type);
             for (const maker of this.makers(pkg, target, type)) {
-                const made = this.madeBy(maker.signatures, built(name, maker.receiver));
+                const made = this.madeBy(maker.signatures, built(name, maker.receiver), target === defaultTarget);
                 if (!made)
                     continue;
                 // One level below the export, what the member builds must declare a callable member.
@@ -2594,9 +2764,10 @@ class DeclarationReader {
      */
     makersOf(pkg, probe, only) {
         this.setPackage(pkg);
-        if ('namespace' in probe && this.readModule(pkg, probe.namespace, true).reason)
+        const moduleRead = 'namespace' in probe ? this.readModule(pkg, probe.namespace, true) : undefined;
+        if (moduleRead?.reason)
             return [];
-        return (this.listedExports(probe, only) ?? [])
+        return (this.listedExports(probe, only, moduleRead?.globalFile) ?? [])
             .filter(({ type }) => !this.isOpenTop(type))
             .map(({ name, target, type }) => ({
             export: name,
@@ -2613,9 +2784,11 @@ class DeclarationReader {
      * `prototype`, which no service imports. Undefined when the specifier
      * resolves to no module symbol.
      */
-    listedExports(probe, only) {
+    listedExports(probe, only, globalFile) {
         if ('defaultLibrary' in probe)
-            return this.listedGlobals(probe.defaultLibrary, only);
+            return this.listedGlobals(this.defaultLibraryFile(probe.defaultLibrary), only);
+        if (globalFile)
+            return this.listedGlobals(globalFile, only);
         const moduleSymbol = this.checker.getSymbolAtLocation(probe.namespace.moduleSpecifier);
         if (!moduleSymbol)
             return undefined;
@@ -2646,8 +2819,7 @@ class DeclarationReader {
      * `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);
+    listedGlobals(file, only) {
         if (!file)
             return [];
         return this.checker
@@ -2694,13 +2866,25 @@ class DeclarationReader {
      * type-parameter defaults where `built` (the probe's no-argument build of
      * the receiver) instantiates it (`returnOf`), less the returns that say
      * nothing, which no maker claim holds on. Listed when what is left is one
-     * object type.
-     */
-    madeBy(signatures, built) {
+     * object type. A `default` export, which a service imports under any local
+     * name (usually the one maker a framework has), or the same declaration
+     * exported by name (carrick#2640), that is overloaded and so
+     * returns several types is listed for the return of the overload the
+     * probe's no-argument build resolves (`built`), when that is an object type
+     * with members of its own.
+     */
+    madeBy(signatures, built, isDefault) {
         const returns = [
             ...new Set(signatures.map(sig => this.returnOf(sig, built)).filter(type => !this.returnSaysNothing(type))),
         ];
-        return returns.length === 1 && this.isObjectType(returns[0]) ? returns[0] : undefined;
+        if (returns.length === 1)
+            return this.isObjectType(returns[0]) ? returns[0] : undefined;
+        if (!isDefault || returns.length === 0 || built === undefined)
+            return undefined;
+        const resolved = this.checker.getReturnTypeOfSignature(built);
+        return !this.returnSaysNothing(resolved) && this.isObjectType(resolved) && this.namedProperties(resolved).length > 0
+            ? resolved
+            : undefined;
     }
     /** The call (or construct) signatures of `type` an installed package or the default library declares. */
     librarySignatures(type, form) {
@@ -3108,23 +3292,34 @@ class DeclarationReader {
      * source file in a directory that happens to be named `node_modules`, or a
      * repository checked out under a `node_modules` ancestor, is not installed.
      * An install hoisted above the service root (`../../node_modules/pkg`) and
-     * a pnpm store (`node_modules/.pnpm/pkg@1/node_modules/pkg`) are.
+     * a pnpm store (`node_modules/.pnpm/pkg@1/node_modules/pkg`) are. A path
+     * with no `node_modules` segment is placed by the module graph, where there
+     * is one (carrick#2599).
      * Mirrored by `installedPackageDirectory` in capture/, which the capture
      * seam keeps from being shared.
      */
     installedPackage(fileName) {
-        const segments = path.relative(this.root, this.realpath(fileName)).split(path.sep);
+        const real = this.realpath(fileName);
+        const segments = path.relative(this.root, real).split(path.sep);
         const last = segments.lastIndexOf('node_modules');
-        if (last < 0)
+        let placed;
+        if (last >= 0) {
+            const width = segments[last + 1]?.startsWith('@') ? 2 : 1;
+            placed = {
+                directory: path.resolve(this.root, ...segments.slice(0, last + 1 + width)),
+                name: segments.slice(last + 1, last + 1 + width).join('/'),
+            };
+        }
+        else {
+            placed = this.graph.packageDirectoryOf(real);
+        }
+        if (placed === undefined)
             return undefined;
-        const width = segments[last + 1]?.startsWith('@') ? 2 : 1;
-        const nameSegments = segments.slice(last + 1, last + 1 + width);
         // No package.json there (a file directly under node_modules included) means no package.
-        const directory = path.resolve(this.root, ...segments.slice(0, last + 1 + width));
-        let known = this.packageDirectories.get(directory);
+        let known = this.packageDirectories.get(placed.directory);
         if (known === undefined) {
-            known = readInstalledPackage(this.host, directory, nameSegments.join('/'));
-            this.packageDirectories.set(directory, known);
+            known = readInstalledPackage(this.host, placed.directory, placed.name);
+            this.packageDirectories.set(placed.directory, known);
         }
         return known ?? undefined;
     }