carrick 0.3.116 → 0.3.118

package/sidecar/dist/src/project-loader.d.ts

@@ -38,6 +38,14 @@ export interface LoadResult {
     error?: string;
     initTimeMs?: number;
 }
+/**
+ * What a build makes (carrick#2413). `listed` is the project as its config
+ * lists it. `scripts` has the same options with JavaScript accepted and lists
+ * no file: it is for the files the listed program does not take (a `.js`,
+ * `.mjs` or `.cjs` file under a config without `allowJs`), which the caller
+ * adds.
+ */
+export type BuildKind = 'listed' | 'scripts';
 /**
  * ProjectLoader - Manages ts-morph Project initialization and access
  *
@@ -58,7 +66,10 @@ export interface LoadResult {
  */
 export declare class ProjectLoader {
     private project;
-    /** Set by `load()`; builds the ts-morph project on first `getProject()`. */
+    /**
+     * Set by `load()`; builds the ts-morph project on first `getProject()`,
+     * and the default project's `scripts` program for `scriptProjectFor`.
+     */
     private buildProject;
     /**
      * The Deno graph this project resolved through, when it did (carrick#1260).
@@ -101,15 +112,18 @@ export declare class ProjectLoader {
      * Nothing at all otherwise, so a project is built as it always was.
      */
     private fileSystemOption;
-    /** A ts-morph project built from one tsconfig and the files it lists. */
+    /**
+     * A ts-morph project built from one tsconfig: with the files it lists, or
+     * as its `scripts` program (`BuildKind`).
+     */
     private projectFromConfig;
     /**
      * Which project types `file` (carrick#1604): the key of its owning
-     * project's program, or `''` for the default one. A tsconfig that
-     * references other projects owns only the files it lists itself; any other
-     * file belongs to the first project it references (depth-first, in
-     * declared order) whose file list includes it, and is typed under that
-     * project's options. A file no project includes, and every request that
+     * project's program, or `''` for the default one. In a tsconfig that
+     * references other projects, a file belongs to the first project in search
+     * order (the named config, then its references depth-first, in declared
+     * order) that lists it while none of its own references does (carrick#2418),
+     * and is typed under that project's options. A file no project includes, and every request that
      * names no file, uses the default project, built from the named tsconfig
      * as before.
      */
@@ -119,6 +133,21 @@ export declare class ProjectLoader {
      * kept: a service whose files all belong to one project builds one.
      */
     getProjectFor(key: string): Project;
+    /**
+     * The `scripts` program (`BuildKind`) of the project behind a key from
+     * `projectKeyFor`: its options with JavaScript accepted, built by the same
+     * factory, and no file listed. Not kept; the caller drops it. For the walk's
+     * files that the owner's program does not take (carrick#2413).
+     */
+    scriptProjectFor(key: string): Project;
+    /**
+     * Drop the program behind a key from `projectKeyFor`, so the memory it
+     * holds can go before the next one is built. The next `getProjectFor` on
+     * the key builds it again. For a walk that reads one owner's program at a
+     * time and never comes back to it (carrick#2405); the actions that keep
+     * their programs for the life of the process never call it.
+     */
+    releaseProjectFor(key: string): void;
     /**
      * Get the ts-morph Project, building it on first call.
      *

package/sidecar/dist/src/project-loader.js

@@ -12,7 +12,7 @@
 import { Project, getCompilerOptionsFromTsConfig } from 'ts-morph';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
-import { DenoProject, findDenoConfig, findServiceTsconfig, serviceConfigPath, sidecarCompilerOptions, untrustedReadBound, } from './capture/index.js';
+import { DenoProject, findDenoConfig, findServiceTsconfig, referenceRedirectOf, serviceConfigPath, sidecarCompilerOptions, untrustedReadBound, } from './capture/index.js';
 import { moduleFormatResolutionHost } from './module-format.js';
 import { ExternalImports, registerExternalImports } from './origin.js';
 /**
@@ -44,6 +44,10 @@ const DEFAULT_COMPILER_OPTIONS = {
     resolveJsonModule: true,
     isolatedModules: true,
 };
+/** `options` as `kind` builds them. */
+function optionsFor(kind, options) {
+    return kind === 'scripts' ? { ...options, allowJs: true } : options;
+}
 /**
  * Map string module values to ts-morph enum values
  */
@@ -108,7 +112,10 @@ const TARGET_MAP = {
  */
 export class ProjectLoader {
     project = null;
-    /** Set by `load()`; builds the ts-morph project on first `getProject()`. */
+    /**
+     * Set by `load()`; builds the ts-morph project on first `getProject()`,
+     * and the default project's `scripts` program for `scriptProjectFor`.
+     */
     buildProject = null;
     /**
      * The Deno graph this project resolved through, when it did (carrick#1260).
@@ -175,13 +182,14 @@ export class ProjectLoader {
             if (this.tsconfigSnapshot) {
                 const snapshot = this.tsconfigSnapshot;
                 this.log('Project will load with tsconfig snapshot');
-                this.buildProject = () => {
+                this.buildProject = (kind) => {
                     const project = new Project({
                         ...this.fileSystemOption(),
-                        compilerOptions: sidecarCompilerOptions(this.snapshotToCompilerOptions(snapshot)),
+                        compilerOptions: sidecarCompilerOptions(optionsFor(kind, this.snapshotToCompilerOptions(snapshot))),
                         skipAddingFilesFromTsConfig: true,
                     });
-                    this.addDefaultSourceFiles(project);
+                    if (kind === 'listed')
+                        this.addDefaultSourceFiles(project);
                     return project;
                 };
             }
@@ -191,7 +199,7 @@ export class ProjectLoader {
                 const denoConfig = findDenoConfig(this.repoRoot, this.tsconfigPath);
                 if (denoConfig) {
                     this.log(`Project will load with Deno config: ${denoConfig.configPath}`);
-                    this.buildProject = () => {
+                    this.buildProject = (kind) => {
                         const deno = new DenoProject(denoConfig, this.repoRoot);
                         this.denoProject = deno;
                         // The graph's external-library verdicts, kept past the program
@@ -199,7 +207,7 @@ export class ProjectLoader {
                         const imports = new ExternalImports();
                         const project = new Project({
                             ...this.fileSystemOption(),
-                            compilerOptions: sidecarCompilerOptions(deno.parsed.options),
+                            compilerOptions: sidecarCompilerOptions(optionsFor(kind, deno.parsed.options)),
                             skipAddingFilesFromTsConfig: true,
                             resolutionHost: imports.recording((host, getOptions) => ({
                                 resolveModuleNames: (names, from) => names.map(name => deno.resolve(name, from, getOptions(), host)),
@@ -207,28 +215,31 @@ export class ProjectLoader {
                             })),
                         });
                         registerExternalImports(project, imports);
-                        for (const file of deno.parsed.fileNames)
-                            project.addSourceFileAtPath(file);
-                        for (const diagnostic of deno.diagnostics)
-                            this.logError(diagnostic);
+                        if (kind === 'listed') {
+                            for (const file of deno.parsed.fileNames)
+                                project.addSourceFileAtPath(file);
+                            for (const diagnostic of deno.diagnostics)
+                                this.logError(diagnostic);
+                        }
                         return project;
                     };
                 }
                 else if (tsconfigPath) {
                     this.log(`Project will load with tsconfig: ${tsconfigPath}`);
                     this.namedTsconfigPath = tsconfigPath;
-                    this.buildProject = () => this.projectFromConfig(tsconfigPath);
+                    this.buildProject = (kind) => this.projectFromConfig(tsconfigPath, kind);
                 }
                 else {
                     this.log('No tsconfig.json found, using default compiler options');
-                    this.buildProject = () => {
+                    this.buildProject = (kind) => {
                         const project = new Project({
                             ...this.fileSystemOption(),
-                            compilerOptions: sidecarCompilerOptions(DEFAULT_COMPILER_OPTIONS),
+                            compilerOptions: sidecarCompilerOptions(optionsFor(kind, DEFAULT_COMPILER_OPTIONS)),
                             skipAddingFilesFromTsConfig: true,
                         });
                         // Add source files from common locations
-                        this.addDefaultSourceFiles(project);
+                        if (kind === 'listed')
+                            this.addDefaultSourceFiles(project);
                         return project;
                     };
                 }
@@ -330,30 +341,34 @@ export class ProjectLoader {
         const bound = untrustedReadBound(this.repoRoot);
         return bound ? { fileSystem: boundedFileSystem(bound) } : {};
     }
-    /** A ts-morph project built from one tsconfig and the files it lists. */
-    projectFromConfig(configPath) {
+    /**
+     * A ts-morph project built from one tsconfig: with the files it lists, or
+     * as its `scripts` program (`BuildKind`).
+     */
+    projectFromConfig(configPath, kind = 'listed') {
         const imports = new ExternalImports();
         const project = new Project({
             ...this.fileSystemOption(),
             tsConfigFilePath: configPath,
             // Over the tsconfig's own options: ts-morph lays these on top.
-            compilerOptions: sidecarCompilerOptions(getCompilerOptionsFromTsConfig(configPath).options),
-            skipAddingFilesFromTsConfig: false,
+            compilerOptions: sidecarCompilerOptions(optionsFor(kind, getCompilerOptionsFromTsConfig(configPath).options)),
+            skipAddingFilesFromTsConfig: kind === 'scripts',
             // Each import resolves in its file's own module format (carrick#1619),
-            // and every external-library answer is kept past the program rebuilds
-            // that drop it (carrick#1731).
-            resolutionHost: imports.recording(moduleFormatResolutionHost),
+            // a referenced project's unbuilt output reads as its source, under its
+            // own options (carrick#2418), and every external-library answer is kept
+            // past the program rebuilds that drop it (carrick#1731).
+            resolutionHost: imports.recording(moduleFormatResolutionHost(referenceRedirectOf(configPath, this.repoRoot))),
         });
         registerExternalImports(project, imports);
         return project;
     }
     /**
      * Which project types `file` (carrick#1604): the key of its owning
-     * project's program, or `''` for the default one. A tsconfig that
-     * references other projects owns only the files it lists itself; any other
-     * file belongs to the first project it references (depth-first, in
-     * declared order) whose file list includes it, and is typed under that
-     * project's options. A file no project includes, and every request that
+     * project's program, or `''` for the default one. In a tsconfig that
+     * references other projects, a file belongs to the first project in search
+     * order (the named config, then its references depth-first, in declared
+     * order) that lists it while none of its own references does (carrick#2418),
+     * and is typed under that project's options. A file no project includes, and every request that
      * names no file, uses the default project, built from the named tsconfig
      * as before.
      */
@@ -381,6 +396,33 @@ export class ProjectLoader {
         }
         return project;
     }
+    /**
+     * The `scripts` program (`BuildKind`) of the project behind a key from
+     * `projectKeyFor`: its options with JavaScript accepted, built by the same
+     * factory, and no file listed. Not kept; the caller drops it. For the walk's
+     * files that the owner's program does not take (carrick#2413).
+     */
+    scriptProjectFor(key) {
+        if (!this.initialized || !this.buildProject) {
+            throw new Error('Project not initialized. Call load() first and ensure it succeeds.');
+        }
+        return key === '' ? this.buildProject('scripts') : this.projectFromConfig(key, 'scripts');
+    }
+    /**
+     * Drop the program behind a key from `projectKeyFor`, so the memory it
+     * holds can go before the next one is built. The next `getProjectFor` on
+     * the key builds it again. For a walk that reads one owner's program at a
+     * time and never comes back to it (carrick#2405); the actions that keep
+     * their programs for the life of the process never call it.
+     */
+    releaseProjectFor(key) {
+        if (key === '') {
+            this.project = null;
+        }
+        else {
+            this.ownerProjects.delete(key);
+        }
+    }
     /**
      * Get the ts-morph Project, building it on first call.
      *
@@ -393,7 +435,7 @@ export class ProjectLoader {
         }
         if (!this.project) {
             const startTime = performance.now();
-            this.project = this.buildProject();
+            this.project = this.buildProject('listed');
             const buildTimeMs = Math.round(performance.now() - startTime);
             this.log(`Project built in ${buildTimeMs}ms ` +
                 `(${this.project.getSourceFiles().length} source files)`);

package/sidecar/dist/src/retype.js

@@ -290,6 +290,13 @@ export class Retyper {
                     remaining.set(k, left - 1);
                     continue;
                 }
+                // The rewrite only removes or replaces source text, so an unused
+                // declaration that is new after it is the rewrite's own doing: the
+                // statement it replaced was the declaration's only use
+                // (carrick#2426). Unused diagnostics the file already raised are
+                // matched out above and never reach here.
+                if (UNUSED_DECLARATION_CODES.has(d.code))
+                    continue;
                 added.push(mapped);
             }
             added.sort((a, b) => a.start - b.start || a.code - b.code);
@@ -828,6 +835,12 @@ function bodyReadEdit(read) {
 function declaresTypeParameters(call) {
     return (resolvedDeclaration(call)?.typeParameters?.length ?? 0) > 0;
 }
+/**
+ * "Declared but never used" and its grouped forms: unused locals and imports
+ * (6133, 6192, 6196, 6198, 6199), unused properties (6138) and unused type
+ * parameters (6205).
+ */
+const UNUSED_DECLARATION_CODES = new Set([6133, 6138, 6192, 6196, 6198, 6199, 6205]);
 function key(d) {
     return `${d.start}:${d.code}`;
 }

package/sidecar/dist/src/type-inferrer.d.ts

@@ -357,9 +357,13 @@ export declare class TypeInferrer {
      * Returns `undefined` when this does not apply, which leaves the caller's
      * own reading of the located expression untouched:
      *  - the row's line is neither a route registration nor a line inside the
-     *    handler the located send sits in;
+     *    handler the located send sits in, unless the located send states an
+     *    error or redirect status and the handler keeps another send (carrick#2463);
      *  - the located expression is neither a send nor the argument of one;
-     *  - that send is not one the handler returns;
+     *  - that send is neither one the handler returns nor a statement of it;
+     *  - it is a success send the handler does not return (a statement send
+     *    joins only when the located send is dropped, and only when it ends
+     *    the handler's path);
      *  - it is a success send and the only one that survives, so the join would
      *    be the located body anyway;
      *  - no joined body is the located one (a text body beside JSON ones).
@@ -370,6 +374,23 @@ export declare class TypeInferrer {
      * or the redirect location back in.
      */
     private inferFromResponseSites;
+    /**
+     * The response sends `func` makes as statements (`res.status(409).json(e);`),
+     * for a handler that sends through a parameter and returns nothing. Only the
+     * outermost call of a statement is a send, only in `func`'s own scope, and
+     * only where `isSend` accepts it, so a logger call or an `await save()`
+     * statement is never one.
+     */
+    private responseSendStatements;
+    /**
+     * True when nothing in `func` runs after `statement`: a bare `return;`
+     * follows it, or it is the last statement of its block and the statement
+     * that block belongs to (an `if` branch, a `try` or `catch` block) is itself
+     * last, up to `func`'s body. A statement inside a loop, a `switch` case or
+     * any other construct does not end the path; a send there is not read as a
+     * success body.
+     */
+    private statementEndsFunctionPath;
     /**
      * True when `candidate` is a response send: a call or `new` whose result is
      * transport machinery (by the extraction config's verified rule or the
@@ -1533,35 +1554,10 @@ export declare class TypeInferrer {
      * The npm package name that declares a type. `undefined` when the type has
      * no declaration to read (a top type, a primitive, an anonymous object
      * literal) or when nothing owns its declaration but the workspace itself.
-     *
-     * The module graph is asked first, where there is one, because it is the
-     * only thing that can answer for a project whose resolution does not go
-     * through `node_modules`. Deno resolves an npm dependency's types straight
-     * out of its own cache
-     * (`$DENO_DIR/npm/<registry-host>/<name>/<version>/…`), a path with no
-     * `node_modules` segment anywhere in it, so the scan below found no package
-     * for ANY dependency-declared type on such a repo and every receiver the
-     * compiler had typed correctly went unclassified (carrick#1260). It runs
-     * first rather than second because a mixed checkout has both, and the graph
-     * is what actually resolved the module.
-     *
-     * The path scan is the Node answer: the LAST `node_modules` segment wins,
-     * which is what a nested or content-addressed store
-     * (`node_modules/.store/pkg@1.0.0/node_modules/pkg`) requires. Scoped names
-     * keep both segments.
+     * The declaration is the attributed one (carrick#2031), and the package is
+     * named by the module graph first, then by the path (`installedPackageOf`).
      */
     private declaringPackageOf;
-    /**
-     * The declaration a symbol is attributed to (carrick#2031). One declaration
-     * is itself. Where several files merge one symbol (a global interface the
-     * compiler's library declares and a typings package augments), their order
-     * is the order the checker merged them in, and on TypeScript 6 that changes
-     * once the program is rebuilt, so the first one is not an answer. The
-     * compiler's default library wins where it declares the symbol; otherwise,
-     * and among the library's own files, the declaring file whose path sorts
-     * first, then the earliest declaration in it.
-     */
-    private attributedDeclaration;
     /**
      * The awaited return type of the member invoked on the receiver. Reported as
      * a fact next to the receiver; a caller that classified on it alone would be

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

@@ -28,6 +28,7 @@ import { externalImportsOf, isExternalOrigin } from './origin.js';
 import { reachedOnlyOnFailure } from './failure-path.js';
 import { readResponseModes } from './response-modes.js';
 import { functionAtLine } from './function-line-index.js';
+import { attributedDeclaration, installedPackageOf } from './declaration-attribution.js';
 import { endLineOf, startLineOf } from './line-index.js';
 import { elapsedMs, inferTiming, phaseClock, timedPhase } from './infer-timing.js';
 import { classifyStatusCodes, constituents, httpStatus, statesNoBody, statesNoShape, statusKeyCode, statusTableOf, successEntries, } from './capture/index.js';
@@ -1566,9 +1567,13 @@ export class TypeInferrer {
      * Returns `undefined` when this does not apply, which leaves the caller's
      * own reading of the located expression untouched:
      *  - the row's line is neither a route registration nor a line inside the
-     *    handler the located send sits in;
+     *    handler the located send sits in, unless the located send states an
+     *    error or redirect status and the handler keeps another send (carrick#2463);
      *  - the located expression is neither a send nor the argument of one;
-     *  - that send is not one the handler returns;
+     *  - that send is neither one the handler returns nor a statement of it;
+     *  - it is a success send the handler does not return (a statement send
+     *    joins only when the located send is dropped, and only when it ends
+     *    the handler's path);
      *  - it is a success send and the only one that survives, so the join would
      *    be the located body anyway;
      *  - no joined body is the located one (a text body beside JSON ones).
@@ -1585,27 +1590,53 @@ export class TypeInferrer {
         // The row's line is a registration, or a line inside the handler the
         // located send sits in (carrick#2005: a file-based route's row names the
         // send's own line, and a send's line is no registration). A row whose
-        // line is outside that function says nothing about it.
-        if (!this.registrationAtLine(sourceFile, request.line_number) &&
-            !(func.getStartLineNumber() <= request.line_number &&
-                request.line_number <= func.getEndLineNumber())) {
-            return undefined;
-        }
-        const branches = this.responseReturnedExpressions(func).flatMap((expression) => this.expandResponseBranches(expression, 0));
-        if (branches.length === 0)
-            return undefined;
-        const serialisers = this.calleesProvenSerialiser(branches);
+        // line is outside that function says nothing about the function, so it
+        // is "untied" (carrick#2463): only a located error or redirect send is
+        // walked then, and only when a send survives the drop.
+        const tied = !!this.registrationAtLine(sourceFile, request.line_number) ||
+            (func.getStartLineNumber() <= request.line_number &&
+                request.line_number <= func.getEndLineNumber());
+        const returnedBranches = this.responseReturnedExpressions(func).flatMap((expression) => this.expandResponseBranches(expression, 0));
+        const serialisers = this.calleesProvenSerialiser(returnedBranches);
         const isSend = (candidate) => this.isResponseSend(candidate, extractionConfig, serialisers);
+        // carrick#2427: a handler that sends through a parameter returns nothing,
+        // its sends are statements, and the located one can be an error send.
+        // Statement sends find and drop that branch. A call whose result is
+        // response machinery is not always a body send, though (a header or
+        // cookie setter returns the response too), so a statement send is a
+        // success body only when the located send is dropped and the statement
+        // ends the handler's path. A located success send joins the returned
+        // sends alone.
+        const statementSends = this.responseSendStatements(func, isSend);
+        const locatingBranches = [...returnedBranches, ...statementSends.map((s) => s.send)];
+        if (locatingBranches.length === 0)
+            return undefined;
         const peeled = this.peelTransparentExpression(located);
         const site = isSend(peeled) ? peeled : this.receivingCallOf(located, isSend);
         if (!site)
             return undefined;
         const contains = (outer, inner) => outer.getStart() <= inner.getStart() && inner.getEnd() <= outer.getEnd();
-        const locatedBranch = branches.find((branch) => contains(branch, site));
+        const locatedBranch = locatingBranches.find((branch) => contains(branch, site));
         if (!locatedBranch)
             return undefined;
         const dropped = (status) => status === 'error' || status === 'redirect';
         const siteStatus = this.responseSiteStatus(site, true);
+        if (!tied && !dropped(siteStatus))
+            return undefined;
+        let branches;
+        if (dropped(siteStatus)) {
+            branches = [
+                ...returnedBranches,
+                ...statementSends
+                    .filter((s) => s.send === locatedBranch || this.statementEndsFunctionPath(s.statement, func))
+                    .map((s) => s.send),
+            ];
+        }
+        else {
+            if (!returnedBranches.includes(locatedBranch))
+                return undefined;
+            branches = returnedBranches;
+        }
         const survivors = [];
         for (const branch of branches) {
             const status = branch === locatedBranch ? siteStatus : this.responseSiteStatus(branch, true);
@@ -1619,6 +1650,10 @@ export class TypeInferrer {
                 continue;
             survivors.push(branch);
         }
+        // carrick#2463 (D2): an untied row claims "no success payload" only when
+        // the function it reads keeps a send after the error sends are dropped.
+        if (!tied && survivors.length === 0)
+            return undefined;
         const locatedDropped = dropped(siteStatus);
         if (!locatedDropped && survivors.length <= 1)
             return undefined;
@@ -1646,6 +1681,73 @@ export class TypeInferrer {
         }
         return undefined;
     }
+    /**
+     * The response sends `func` makes as statements (`res.status(409).json(e);`),
+     * for a handler that sends through a parameter and returns nothing. Only the
+     * outermost call of a statement is a send, only in `func`'s own scope, and
+     * only where `isSend` accepts it, so a logger call or an `await save()`
+     * statement is never one.
+     */
+    responseSendStatements(func, isSend) {
+        const body = func.getBody();
+        if (!body || !Node.isBlock(body))
+            return [];
+        const sends = [];
+        for (const statement of body.getDescendantsOfKind(SyntaxKind.ExpressionStatement)) {
+            if (this.findContainingFunctionForNode(statement) !== func)
+                continue;
+            const expression = this.peelTransparentExpression(statement.getExpression());
+            if (isSend(expression))
+                sends.push({ statement, send: expression });
+        }
+        return sends;
+    }
+    /**
+     * True when nothing in `func` runs after `statement`: a bare `return;`
+     * follows it, or it is the last statement of its block and the statement
+     * that block belongs to (an `if` branch, a `try` or `catch` block) is itself
+     * last, up to `func`'s body. A statement inside a loop, a `switch` case or
+     * any other construct does not end the path; a send there is not read as a
+     * success body.
+     */
+    statementEndsFunctionPath(statement, func) {
+        const body = func.getBody();
+        const next = statement.getNextSibling();
+        if (next && Node.isReturnStatement(next) && !next.getExpression())
+            return true;
+        let current = statement;
+        for (;;) {
+            const parent = current.getParent();
+            if (!parent)
+                return false;
+            if (Node.isIfStatement(parent)) {
+                current = parent;
+                continue;
+            }
+            if (!Node.isBlock(parent))
+                return false;
+            const statements = parent.getStatements();
+            if (statements[statements.length - 1] !== current)
+                return false;
+            if (parent === body)
+                return true;
+            const owner = parent.getParent();
+            if (!owner)
+                return false;
+            if (Node.isIfStatement(owner) || Node.isTryStatement(owner) || Node.isBlock(owner)) {
+                current = Node.isBlock(owner) ? parent : owner;
+                continue;
+            }
+            if (Node.isCatchClause(owner)) {
+                const tryStatement = owner.getParent();
+                if (!tryStatement || !Node.isTryStatement(tryStatement))
+                    return false;
+                current = tryStatement;
+                continue;
+            }
+            return false;
+        }
+    }
     /**
      * True when `candidate` is a response send: a call or `new` whose result is
      * transport machinery (by the extraction config's verified rule or the
@@ -5849,69 +5951,16 @@ export class TypeInferrer {
      * The npm package name that declares a type. `undefined` when the type has
      * no declaration to read (a top type, a primitive, an anonymous object
      * literal) or when nothing owns its declaration but the workspace itself.
-     *
-     * The module graph is asked first, where there is one, because it is the
-     * only thing that can answer for a project whose resolution does not go
-     * through `node_modules`. Deno resolves an npm dependency's types straight
-     * out of its own cache
-     * (`$DENO_DIR/npm/<registry-host>/<name>/<version>/…`), a path with no
-     * `node_modules` segment anywhere in it, so the scan below found no package
-     * for ANY dependency-declared type on such a repo and every receiver the
-     * compiler had typed correctly went unclassified (carrick#1260). It runs
-     * first rather than second because a mixed checkout has both, and the graph
-     * is what actually resolved the module.
-     *
-     * The path scan is the Node answer: the LAST `node_modules` segment wins,
-     * which is what a nested or content-addressed store
-     * (`node_modules/.store/pkg@1.0.0/node_modules/pkg`) requires. Scoped names
-     * keep both segments.
+     * The declaration is the attributed one (carrick#2031), and the package is
+     * named by the module graph first, then by the path (`installedPackageOf`).
      */
     declaringPackageOf(type) {
         const symbol = type.getSymbol() ?? type.getAliasSymbol();
-        const declaration = this.attributedDeclaration(symbol?.getDeclarations() ?? []);
+        const declaration = attributedDeclaration(() => this.project.getProgram().compilerObject, (symbol?.getDeclarations() ?? []).map((node) => node.compilerNode));
         if (!declaration) {
             return undefined;
         }
-        const filePath = declaration.getSourceFile().getFilePath().replace(/\\/g, '/');
-        const named = this.packageOf?.(filePath);
-        if (named) {
-            return named;
-        }
-        const marker = '/node_modules/';
-        const index = filePath.lastIndexOf(marker);
-        if (index < 0) {
-            return undefined;
-        }
-        const rest = filePath.slice(index + marker.length).split('/');
-        if (rest.length === 0 || rest[0].length === 0) {
-            return undefined;
-        }
-        if (rest[0].startsWith('@')) {
-            return rest.length > 1 ? `${rest[0]}/${rest[1]}` : undefined;
-        }
-        return rest[0];
-    }
-    /**
-     * The declaration a symbol is attributed to (carrick#2031). One declaration
-     * is itself. Where several files merge one symbol (a global interface the
-     * compiler's library declares and a typings package augments), their order
-     * is the order the checker merged them in, and on TypeScript 6 that changes
-     * once the program is rebuilt, so the first one is not an answer. The
-     * compiler's default library wins where it declares the symbol; otherwise,
-     * and among the library's own files, the declaring file whose path sorts
-     * first, then the earliest declaration in it.
-     */
-    attributedDeclaration(declarations) {
-        if (declarations.length <= 1)
-            return declarations[0];
-        const program = this.project.getProgram().compilerObject;
-        const fromLibrary = declarations.filter((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile().compilerNode));
-        const candidates = fromLibrary.length > 0 ? fromLibrary : declarations;
-        return [...candidates].sort((a, b) => {
-            const pathA = a.getSourceFile().getFilePath();
-            const pathB = b.getSourceFile().getFilePath();
-            return pathA < pathB ? -1 : pathA > pathB ? 1 : a.getStart() - b.getStart();
-        })[0];
+        return installedPackageOf(declaration.getSourceFile().fileName, this.packageOf);
     }
     /**
      * The awaited return type of the member invoked on the receiver. Reported as