@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.2

package/dist/src/ref.js

@@ -45,9 +45,11 @@ export const REF_EXPRESSIONS = [
     `^${SCOPE}#$`,
     `^${SCOPE}#${TS_HEAD}$`,
     `^${SCOPE}#(?:${TS_QUOTED}\\.)?${TS_HEAD}:alias$`,
+    `^${SCOPE}#${TS_HEAD}:import$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
+    `^${SCOPE}#(?:${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?)?\\(${TS_IDENT}\\)$`,
     `^${MANIFEST_SCOPE}#${TS_PACKAGE}:(?:dependency|dev-dependency|peer-dependency)$`,
 ];
 const REF_FORMS = REF_EXPRESSIONS.map((expression) => new RegExp(expression, "u"));
@@ -86,6 +88,14 @@ function quoted(name) {
 export function computedComponent(text) {
     return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
+/** The reference of an import binding, read against the reference of the module that holds it. */
+export function importRef(moduleRef, name) {
+    return `${moduleRef}${nameComponent(name)}:import`;
+}
+/** The reference of a parameter, read against the reference of the declaration that holds it. */
+export function parameterRef(holderRef, name) {
+    return `${holderRef}(${name})`;
+}
 /** The fragment of an export alias, inside the `declare module` block named, if one is. */
 export function aliasFragment(name, block) {
     const head = block === undefined ? "" : `${quoted(block)}.`;

package/dist/src/references.js

@@ -1,4 +1,4 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isMetaProperty, isModuleBlock, isModuleDeclaration, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
 import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
@@ -6,7 +6,7 @@ import { specifierCandidates } from "./configuration-files.js";
 import { namespaceUses } from "./namespace-objects.js";
 import { globExpression } from "./glob.js";
 import { declarationsByName, isParameterProperty, nodeKey, } from "./inventory.js";
-import { augmentationReferences } from "./augmentations.js";
+import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.js";
 import { elementAccessReferences } from "./element-access.js";
 import { indexedAccessReferences } from "./indexed-access.js";
 import { keyofComparisonReferences } from "./keyof-comparisons.js";
@@ -16,8 +16,9 @@ import { overrideReferences } from "./overrides.js";
 import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition, isComponentFile, renderPosition } from "./position.js";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED } from "./query.js";
+import { typeParameterReads } from "./type-parameter-reads.js";
 import { typeQueryAliases } from "./type-query-alias.js";
-import { computedKeyNames, keyNameOf, keyedUses } from "./symbol-keys.js";
+import { computedKeyNames, iterationReferences, keyNameOf, keyedUses, } from "./symbol-keys.js";
 import { handedOn, valuesOf } from "./value-flow.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
@@ -1134,6 +1135,37 @@ export function references(project, held, targetRoot, options) {
             }
         }
     }
+    /** The ambient global interfaces of the walked files that merge into a declaration outside the project's own files. */
+    const libraryMerged = (scripts) => {
+        const names = new Map();
+        const visit = (node) => {
+            if (isInterfaceDeclaration(node)) {
+                const id = declaredAt(node);
+                if (id !== undefined) {
+                    names.set(id, node.name);
+                }
+            }
+            else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+                node.forEachChild(visit);
+            }
+        };
+        for (const { file } of walked) {
+            file.forEachChild(visit);
+        }
+        const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
+        const asked = [...names].filter(([id]) => global.has(id));
+        if (asked.length === 0) {
+            return new Set();
+        }
+        const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+        return new Set(asked.flatMap(([id], at) => {
+            const symbol = answers[at];
+            return typeof symbol === "object" &&
+                symbol.declarations.some((handle) => !ownPaths.has(handle.path))
+                ? [id]
+                : [];
+        }));
+    };
     const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
     for (const [file, writes] of valued) {
         const uses = usesOf.get(file) ?? [];
@@ -1151,12 +1183,14 @@ export function references(project, held, targetRoot, options) {
         found.push(...indexedAccessReferences(project, held, chains, root, new Set(tests)));
         found.push(...elementAccessReferences(project, held, chains, root, new Set(tests)));
         found.push(...keyofComparisonReferences(project, held, chains, root, new Set(tests)));
+        found.push(...iterationReferences(project, held, chains, root, new Set(tests)));
+        found.push(...typeParameterReads(project, held, chains, root, new Set(tests)));
         found.push(...unimplementedCalleeReads(project, held, chains, root, new Set(tests)));
         found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
         typedLookups = (options.requestCount?.() ?? 0) - before;
     }
     const scripts = new Set(walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId));
-    found.push(...augmentationReferences(held, found, scripts));
+    found.push(...augmentationReferences(held, found, scripts, libraryMerged(scripts)));
     found.sort((a, b) => byPosition(a.position, b.position) ||
         compare(a.to, b.to) ||
         compare(a.from, b.from) ||

package/dist/src/report.js

@@ -4,7 +4,7 @@
  * renders this document, so no two renderings disagree about which findings exist.
  */
 /** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "8.2.0";
+const SCHEMA_VERSION = "9.0.0";
 /** Every report schema version this analyzer reads: the one the Contract it implements admits. */
 export const SCHEMA_VERSIONS_ACCEPTED = [SCHEMA_VERSION];
 /** The name this analyzer writes every document under and mints every identifier with. */
@@ -247,7 +247,9 @@ export function buildReport(input) {
         ]
             .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
             .map(([, skip]) => skip),
-        notes: [],
+        notes: [...new Map((input.notes ?? []).map((one) => [JSON.stringify(one), one])).entries()]
+            .sort(([a, x], [b, y]) => compare(x.kind, y.kind) || compare(x.path, y.path) || compare(a, b))
+            .map(([, note]) => note),
         unanswered_questions: [...input.unanswered]
             .sort((a, b) => compare(a.configuration, b.configuration) ||
             compare(JSON.stringify(a), JSON.stringify(b)))

package/dist/src/resolve.js

@@ -567,6 +567,7 @@ function readDoc(value, label) {
         injectionRegistrations: readDeclarations(ts, "injection_registrations", "ts.injection_registrations", label),
         lifecycleContracts: readLifecycleContracts(ts, label),
         serializers: readDeclarations(ts, "serializers", "ts.serializers", label),
+        rootsComplete: readBoolean(ts, "roots_complete", "ts.roots_complete", label),
     };
 }
 /** Parses one document's text and walks it against the closed key list. */
@@ -776,6 +777,7 @@ function settleAll(inputs) {
             injectionRegistrations: at("ts.injection_registrations", defaults.ts.injectionRegistrations, (doc) => doc.injectionRegistrations),
             lifecycleContracts: at("ts.lifecycle_contracts", defaults.ts.lifecycleContracts, (doc) => doc.lifecycleContracts),
             serializers: at("ts.serializers", defaults.ts.serializers, (doc) => doc.serializers),
+            rootsComplete: at("ts.roots_complete", defaults.ts.rootsComplete, (doc) => doc.rootsComplete),
         },
     };
     return { config, provenance };

package/dist/src/roots.js

@@ -9,11 +9,12 @@
  */
 import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isPropertyDeclaration, isVariableDeclaration, isVariableStatement, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
+import { filesNamedBy, outsideChain, relativeSpecifiers, } from "./configuration-files.js";
 import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
-import { relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
@@ -43,11 +44,22 @@ const READ_BACK_RULES = new Set([
 const OUTPUT_EXTENSION = /\.(?:d\.ts|d\.mts|d\.cts|js|mjs|cjs|jsx)$/u;
 /** The extension a source file's name drops. */
 const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
+/** Whether no `package.json` sits between one file and the manifest's directory, which holds it. */
+function ofPackage(host, dir, file) {
+    for (let at = dirnamePath(file); at !== dir; at = dirnamePath(at)) {
+        if (relativePath(dir, at) === undefined ||
+            host.kindOf(joinPath(at, "package.json")) === "file") {
+            return false;
+        }
+    }
+    return true;
+}
 /**
  * The rooted files one manifest target reads back to by name: its path below the
  * manifest's directory, past its first directory where it names one, without its output
- * extension, is the name, and a rooted file is one whose path below the same directory,
- * without its source extension, ends with that name at a directory boundary.
+ * extension, is the name, and a rooted file of the manifest's own package is one whose
+ * path below the same directory, without its source extension, ends with that name at a
+ * directory boundary.
  */
 function readBackByName(host, entry, rooted) {
     const dir = resolvePath(host.workingDirectory(), entry.dir);
@@ -63,12 +75,41 @@ function readBackByName(host, entry, rooted) {
     const found = new Map();
     for (const file of rooted) {
         const path = relativePath(dir, file.fileName)?.replace(SOURCE_EXTENSION, "");
-        if (path !== undefined && (path === name || path.endsWith(`/${name}`))) {
+        if (path !== undefined &&
+            (path === name || path.endsWith(`/${name}`)) &&
+            ofPackage(host, dir, file.fileName)) {
             found.set(file.fileName, file);
         }
     }
     return [...found.values()];
 }
+/**
+ * The program files a manifest target no program holds reaches: the target is a file
+ * read as a configuration file outside the program is, and each file of the chain it
+ * starts loads the program files its relative specifiers name, read through the emit
+ * mapping, as a command's shim loads the compiled entry it runs.
+ */
+function throughOutside(options, targetRoot, files, entry) {
+    const cwd = options.host.workingDirectory();
+    const path = resolvePath(cwd, entry.path);
+    if (options.parse === undefined ||
+        options.runFiles?.has(path) === true ||
+        options.host.kindOf(path) !== "file") {
+        return [];
+    }
+    const chain = outsideChain(options.host, targetRoot, files, options.parse, [
+        { path, manifestDir: resolvePath(cwd, entry.dir) },
+    ]);
+    const found = new Map();
+    for (const { file } of chain) {
+        for (const specifier of relativeSpecifiers(file)) {
+            for (const named of filesNamedBy(files, dirnamePath(file.fileName), specifier)) {
+                found.set(named.fileName, named);
+            }
+        }
+    }
+    return [...found.values()];
+}
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
     return text.includes("*") || text.includes("?");
@@ -168,8 +209,8 @@ export function roots(project, held, targetRoot, options) {
         found.set([id, kind, source].join("\u0000"), { id, kind, source });
     };
     const entered = [];
-    const enter = (file, kind, source, exports) => {
-        entered.push({ file, kind, source, exports });
+    const enter = (file, kind, source, exports, names) => {
+        entered.push({ file, kind, source, exports, ...(names === undefined ? {} : { names }) });
     };
     const points = entryPoints(project, files, options.testFiles, options.host, targetRoot, options.parse, options.conventions?.selected);
     const published = [];
@@ -191,11 +232,28 @@ export function roots(project, held, targetRoot, options) {
         ...scripted,
         ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
     ];
+    const entryFilesOf = new Map();
     const entryFiles = (entry) => {
+        const known = entryFilesOf.get(entry);
+        if (known !== undefined) {
+            return known;
+        }
+        const found = readEntryFiles(entry);
+        entryFilesOf.set(entry, found);
+        return found;
+    };
+    const readEntryFiles = (entry) => {
         const named = files.named(entry.path);
-        return named.length > 0 || entry.role === "script"
-            ? named
-            : readBackByName(options.host, entry, readBackTo);
+        if (named.length > 0 || entry.role === "script") {
+            return named;
+        }
+        const cwd = options.host.workingDirectory();
+        const shipped = files.namedAsOutput(resolvePath(cwd, entry.dir), resolvePath(cwd, entry.path));
+        if (shipped.length > 0) {
+            return shipped;
+        }
+        const byName = readBackByName(options.host, entry, readBackTo);
+        return byName.length > 0 ? byName : throughOutside(options, targetRoot, files, entry);
     };
     for (const { entry, publishes } of entries) {
         if (publishes) {
@@ -203,27 +261,39 @@ export function roots(project, held, targetRoot, options) {
         }
     }
     const publishedNames = new Set(published.map((file) => file.fileName));
-    for (const { entry } of entries) {
-        for (const file of entryFiles(entry)) {
-            const kind = ENTRY_KINDS[entry.role];
-            enter(file, kind, entry.member, !publishedNames.has(file.fileName));
-        }
-    }
+    const patterned = [];
     for (const pattern of options.entryFiles) {
         const expression = globExpression(pattern);
         for (const [path, file] of files.byPath) {
             if (expression.test(path)) {
-                enter(file, "entry-file", pattern, true);
+                patterned.push({ file, pattern });
             }
         }
     }
+    const unmapped = [];
+    const mapped = patterned.map(({ file }) => file);
+    for (const { entry } of entries) {
+        const named = entryFiles(entry);
+        if (named.length === 0 && entry.role !== "script") {
+            unmapped.push(entry);
+        }
+        mapped.push(...named);
+        for (const file of named) {
+            const kind = ENTRY_KINDS[entry.role];
+            enter(file, kind, entry.member, !publishedNames.has(file.fileName));
+        }
+    }
+    const unmappedEntries = unmapped.filter((entry) => readBackByName(options.host, entry, mapped).length === 0);
+    for (const { file, pattern } of patterned) {
+        enter(file, "entry-file", pattern, true);
+    }
     for (const { file, row } of options.conventions === undefined
         ? []
         : conventionEntries(options.conventions, files)) {
         enter(file, "convention", row, true);
     }
     for (const point of points) {
-        enter(point.file, point.rule, point.source, point.exports);
+        enter(point.file, point.rule, point.source, point.exports, point.names);
     }
     for (const file of files.byPath.values()) {
         for (const alias of typeQueryAliases(file)) {
@@ -236,7 +306,7 @@ export function roots(project, held, targetRoot, options) {
             }
         }
     }
-    const { tables: exportsOf, answered } = exportTables(project, held, [
+    const { tables: exportsOf, named, answered, } = exportTables(project, held, [
         ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
         ...published,
     ]);
@@ -247,8 +317,12 @@ export function roots(project, held, targetRoot, options) {
         }
         add(id, entry.kind, entry.source);
         if (entry.exports) {
-            for (const exported of exportsOf.get(entry.file.fileName) ?? []) {
-                add(exported, entry.kind, entry.source);
+            const byName = named.get(entry.file.fileName);
+            const exported = entry.names === undefined || byName === undefined
+                ? (exportsOf.get(entry.file.fileName) ?? [])
+                : entry.names.flatMap((name) => byName.get(name) ?? []);
+            for (const one of exported) {
+                add(one, entry.kind, entry.source);
             }
         }
     }
@@ -271,6 +345,7 @@ export function roots(project, held, targetRoot, options) {
         liveUnderReachability: ordered,
         unmatched,
         unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
+        unmappedEntries,
     };
 }
 /**
@@ -284,9 +359,10 @@ export function roots(project, held, targetRoot, options) {
 function exportTables(project, held, wanted) {
     const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
     const tables = new Map();
+    const named = new Map();
     let answered = true;
     if (unique.length === 0) {
-        return { tables, answered };
+        return { tables, named, answered };
     }
     const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
     const chains = aliasChains(project, held);
@@ -307,15 +383,18 @@ function exportTables(project, held, wanted) {
             return;
         }
         const ids = new Set();
+        const byName = new Map();
         for (const exported of table) {
             for (const target of chains.chainOf(exported)) {
                 answered &&= !target.guessed;
                 ids.add(target.id);
+                byName.set(exported.name, [...(byName.get(exported.name) ?? []), target.id]);
             }
         }
         tables.set(file.fileName, [...ids]);
+        named.set(file.fileName, byName);
     });
-    return { tables, answered };
+    return { tables, named, answered };
 }
 /** A release tag of a documentation comment: `@` and its name, between white space or the ends. */
 const RELEASE_TAG = /(?:^|\s)@(?:public|beta|alpha)(?=\s|$)/u;
@@ -370,11 +449,13 @@ function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
     const nodes = declarationNodes(held, byPath);
     const chains = aliasChains(project, held);
     const reached = new Set();
+    const entered = new Set();
     const guessed = new Set();
     const pending = [];
     const reach = (id) => {
-        if (!reached.has(id) && byId.get(id)?.kind !== "file") {
-            reached.add(id);
+        const file = byId.get(id)?.kind === "file";
+        if (!(file ? entered : reached).has(id)) {
+            (file ? entered : reached).add(id);
             pending.push(id);
         }
     };
@@ -383,12 +464,7 @@ function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
     }
     for (const file of published) {
         for (const id of exportsOf.get(file.fileName) ?? []) {
-            if (byId.get(id)?.kind === "file") {
-                pending.push(id);
-            }
-            else {
-                reach(id);
-            }
+            reach(id);
         }
     }
     while (pending.length > 0) {
@@ -411,8 +487,7 @@ function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
         });
         for (const symbol of inferredTypeSymbols(project, round.flatMap((id) => {
             const symbol = byId.get(id);
-            const node = symbol === undefined ? undefined : nodes.nodeOf(symbol);
-            return node === undefined ? [] : [node];
+            return symbol === undefined ? [] : nodes.nodesOf(symbol);
         }))) {
             for (const target of chains.chainOf(symbol)) {
                 reach(target.id);
@@ -449,9 +524,7 @@ function declarationNodes(held, byPath) {
                 const id = held.declarations.get(nodeKey(file, node));
                 if (id !== undefined) {
                     found.nodes.add(node);
-                    if (!found.byId.has(id)) {
-                        found.byId.set(id, node);
-                    }
+                    found.byId.set(id, [...(found.byId.get(id) ?? []), node]);
                 }
                 node.forEachChild(visit);
             };
@@ -463,10 +536,9 @@ function declarationNodes(held, byPath) {
     return {
         typeNamesOf: (symbol) => {
             const { byId, nodes } = nodesIn(symbol.position.path);
-            const declaration = byId.get(symbol.id);
-            return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
+            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
         },
-        nodeOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id),
+        nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
     };
 }
 /** How deep the type arguments and constituents of an inferred type are followed. */

package/dist/src/schema.js

@@ -82,6 +82,7 @@ export const SCHEMA_ROOT = {
                     members: { components: declarations, bases: declarations, members: leaf },
                 },
                 serializers: declarations,
+                roots_complete: leaf,
             },
         },
         provenance: { kind: "map" },

package/dist/src/serialization-contract.js

@@ -1,10 +1,10 @@
 /**
  * The serialization-contract class: the data members and `toJSON` of every type a value's
  * static type reaches, where the value reaches `JSON.stringify` or a call `ts.serializers`
- * names, and `toString` too where it reaches an `unknown` or `any` parameter of a function
- * outside the analysis or an erased property of a type the program does not declare. A
- * function of the project handing such a parameter to a destination is one, to a fixpoint,
- * and a function invoked through `call`, `apply` or `bind` is the callee.
+ * names, and `toString` too where it reaches an erased parameter of a function outside the
+ * analysis, or an erased property of a type the program does not declare. A function of
+ * the project handing such a parameter to a destination is one, to a fixpoint, and a
+ * function invoked through `call`, `apply` or `bind` is the callee.
  */
 import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyDeclaration, isSatisfiesExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
@@ -25,6 +25,8 @@ const CONVERSIONS = new Set(["toJSON", "toString"]);
 const SERIALIZED_CONVERSION = "toJSON";
 /** The parameter types that keep nothing of the value they are given. */
 const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+/** How deep a callee's result is searched for a type parameter: `Promise<Box<T>>` is two levels. */
+const MENTION_DEPTH = 3;
 /** The wider of two reaches, where either may be absent. */
 function wider(a, b) {
     return a === "conversions" || b === "conversions" ? "conversions" : (a ?? b);
@@ -381,6 +383,28 @@ function destinations(input, chains, walked) {
         });
         return containing.length === 0 ? target.declarations : containing;
     };
+    /** Whether a type names a type parameter, through constituents, type arguments and call signatures. */
+    const mentions = (type, parameter, depth) => {
+        // A conditional type an alias names, `Awaited<T>` among them, carries its arguments
+        // only on the alias the client's type object reports.
+        const aliased = type
+            .aliasTypeArguments;
+        if (type.id === parameter.id || aliased?.includes(parameter.id) === true) {
+            return true;
+        }
+        if (depth >= MENTION_DEPTH) {
+            return false;
+        }
+        const inner = [
+            ...(type.isUnionType() || type.isIntersectionType() ? must(queries.constituents(type)) : []),
+            ...must(queries.typeArguments(type)),
+            ...must(queries.signaturesOf(type, SignatureKind.Call)).flatMap((signature) => [
+                ...signature.parameters.map((_parameter, at) => must(queries.typeAtPosition(signature, at))),
+                ...[must(queries.returnTypeOf(signature))].filter((one) => one !== undefined),
+            ]),
+        ];
+        return inner.some((one) => mentions(one, parameter, depth + 1));
+    };
     const erasedArguments = new Map();
     const erasedAt = (call, argument) => {
         let indexes = erasedArguments.get(call);
@@ -394,10 +418,32 @@ function destinations(input, chains, walked) {
                     ? []
                     : must(queries.signaturesOf(type, SignatureKind.Call))
                 : [resolvedOf(call)].filter((one) => one !== undefined);
-            indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
-                const parameter = must(queries.parameterType(signature, index));
-                return parameter !== undefined && (parameter.flags & ERASED) !== 0;
-            })
+            // A type parameter of the callee that nothing constrains and its result does not name
+            // keeps nothing of the value either: the instantiated signature names the value's own
+            // type there instead, and a result that names it hands the value back.
+            const generic = invoked.indirect ? undefined : resolvedOf(call);
+            const declared = generic === undefined ? undefined : must(queries.genericOf(generic));
+            const unconstrained = (index) => {
+                const parameter = declared === undefined ? undefined : must(queries.parameterType(declared, index));
+                const parts = parameter === undefined
+                    ? []
+                    : parameter.isUnionType()
+                        ? must(queries.constituents(parameter))
+                        : [parameter];
+                const result = declared === undefined ? undefined : must(queries.returnTypeOf(declared));
+                return parts.some((part) => {
+                    if (!part.isTypeParameter() || (result !== undefined && mentions(result, part, 0))) {
+                        return false;
+                    }
+                    const constraint = must(queries.constraintOf(part));
+                    return constraint === undefined || (constraint.flags & ERASED) !== 0;
+                });
+            };
+            indexes = new Set(invoked.arguments.flatMap((_unused, index) => unconstrained(index) ||
+                signatures.some((signature) => {
+                    const parameter = must(queries.parameterType(signature, index));
+                    return parameter !== undefined && (parameter.flags & ERASED) !== 0;
+                })
                 ? [index]
                 : []));
             erasedArguments.set(call, indexes);

package/dist/src/session.js

@@ -31,6 +31,7 @@ export function openEngine(options) {
         ...(mapper === undefined ? {} : { runExternalCode: true }),
     });
     let closed = false;
+    const parsed = new Map();
     return {
         parseConfigFile: (file) => api.parseConfigFile(file),
         parseConfigJson: (json, configFile) => api.parseJsonConfigFileContent(json, { configFileName: configFile }),
@@ -54,8 +55,14 @@ export function openEngine(options) {
             moduleResolutions: { fallback: "resolve", entries: [...entries] },
         }),
         parseSourceFile: (fileName, text) => {
+            // Every project of a run reads the same files outside its program, so one parse serves all.
+            const known = parsed.get(fileName);
+            if (known?.text === text) {
+                return known.file;
+            }
             const retained = api.createSourceFile(fileName, text);
             try {
+                parsed.set(fileName, { text, file: retained.sourceFile });
                 return retained.sourceFile;
             }
             finally {

package/dist/src/source-files.js

@@ -4,9 +4,13 @@
  * compiler emits from it.
  */
 import { commonDirectory, emittedFrom } from "./emit-map.js";
-import { dirnamePath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
+/** The extension a source file's name drops when the project writes it out. */
+const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/u;
+/** The extensions the project may write a source file's output under. */
+const OUTPUT_EXTENSIONS = [".js", ".mjs", ".cjs", ".jsx", ".d.ts", ".d.mts", ".d.cts"];
 /**
  * Whether one path is what a subpath pattern stands for: the text before the
  * wildcard, any run of characters including the solidus, then the text after it.
@@ -17,6 +21,27 @@ function matchesSubpath(pattern, path) {
     const after = pattern.slice(at + SUBPATH_WILDCARD.length);
     return (path.length >= before.length + after.length && path.startsWith(before) && path.endsWith(after));
 }
+/** The first own file of the paths given that the project holds, or none. */
+function heldAt(byName, paths) {
+    for (const candidate of paths) {
+        const file = byName.get(candidate);
+        if (file !== undefined) {
+            return [file];
+        }
+    }
+    return [];
+}
+/** Where one project writes its output, and the directory it writes it from, absolute. */
+function layoutOf(project, fileNames) {
+    const options = project.program.getCompilerOptions();
+    const configDir = dirnamePath(project.configFile);
+    const at = (option) => option === undefined ? undefined : resolvePath(configDir, option);
+    return {
+        outDir: at(options.outDir),
+        declarationDir: at(options.declarationDir),
+        sourceDir: at(options.rootDir) ?? commonDirectory(fileNames),
+    };
+}
 /**
  * The lookups over one project's own files.
  *
@@ -36,12 +61,7 @@ export function sourceFilesOf(project, targetRoot) {
             byPath.set(path, file);
         }
     }
-    const options = project.program.getCompilerOptions();
-    const configDir = dirnamePath(project.configFile);
-    const at = (option) => option === undefined ? undefined : resolvePath(configDir, option);
-    const outDir = at(options.outDir);
-    const declarationDir = at(options.declarationDir);
-    const sourceDir = at(options.rootDir) ?? commonDirectory([...byName.keys()]);
+    const { outDir, declarationDir, sourceDir } = layoutOf(project, [...byName.keys()]);
     const layout = { outDir, declarationDir, sourceDirs: [sourceDir] };
     /** The source paths one written path may stand for, the path itself first. */
     const candidates = (path) => [path, ...emittedFrom(path, layout)];
@@ -49,15 +69,20 @@ export function sourceFilesOf(project, targetRoot) {
         byPath,
         byName,
         outputDirs: [...new Set([outDir, declarationDir])].filter((dir) => dir !== undefined),
+        writtenAs: (file) => {
+            const below = relativePath(sourceDir, file.fileName);
+            if (below === undefined) {
+                return [];
+            }
+            const written = [outDir, declarationDir].flatMap((dir) => dir === undefined
+                ? []
+                : OUTPUT_EXTENSIONS.map((extension) => joinPath(dir, below.replace(SOURCE_EXTENSION, extension))));
+            return [...new Set(written)].filter((path) => heldAt(byName, candidates(path))[0] === file);
+        },
+        namedAsOutput: (outputDir, path) => heldAt(byName, emittedFrom(path, { outDir: outputDir, sourceDirs: [sourceDir] })),
         named: (path) => {
             if (!path.includes(SUBPATH_WILDCARD)) {
-                for (const candidate of candidates(path)) {
-                    const held = byName.get(candidate);
-                    if (held !== undefined) {
-                        return [held];
-                    }
-                }
-                return [];
+                return heldAt(byName, candidates(path));
             }
             const patterns = candidates(path).filter((candidate) => candidate.includes(SUBPATH_WILDCARD));
             return [...byName.values()].filter((file) => patterns.some((pattern) => matchesSubpath(pattern, file.fileName)));