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

package/dist/src/analysis.js

@@ -5,6 +5,7 @@
  * makes: a view carries a project's identity in its type so a handle cannot cross to
  * another project's checker, which holds only for views the session hands out.
  */
+import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import { lineOf, readComponent } from "./component-files.js";
 import { kindOf } from "./config.js";
 import { consumerLoads, consumerReferences, moduleIdentity, } from "./consumers.js";
@@ -12,7 +13,7 @@ import { configuredDeclarations, configuredRef, declarationsNamed, } from "./con
 import { decorator } from "./decorator.js";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
-import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
+import { discoverProjects, DiscoveryError, isGuess, MISSING_GLOBAL_TYPE, projectErrors, renderDiagnostic, targetRelative, withBaseUrlPaths, } from "./discover.js";
 import { conventionFailuresFor, generatedFiles, readConventions, } from "./conventions.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
@@ -162,6 +163,7 @@ function readProjects(engine, host, scope, config, stage) {
             parse,
             publishedAPI: config.targetKind !== "" && kindOf(config.targetKind, LANGUAGE) === "library",
             publishedMembers: new Set((workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir)),
+            runFiles: new Set(opened.flatMap((one) => one.fileNames().map((name) => resolvePath(host.workingDirectory(), name)))),
         };
     };
     const notBuilt = [...discovered.notBuilt];
@@ -193,6 +195,7 @@ function readProjects(engine, host, scope, config, stage) {
     const joins = discovered.derived
         ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
         : new Map();
+    const programs = withBaseUrlPaths(engine, host, [...discovered.configFiles, ...consumerOf.keys()], workspace?.programs ?? new Map());
     const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (opened) => {
         const consumer = consumerOf.get(opened.configFile);
         const setup = consumer === undefined ? workspace?.unbuildable(opened.configFile) : undefined;
@@ -259,11 +262,26 @@ function readProjects(engine, host, scope, config, stage) {
             configFile: project.configFile,
             error: renderDiagnostic(one, (path) => relativePath(absoluteRoot, path) ?? path),
         })));
+        const missingGlobal = raw.unfound.find(({ diagnostic }) => diagnostic.code === MISSING_GLOBAL_TYPE);
+        const skips = missingGlobal === undefined
+            ? reading.skips
+            : [
+                ...reading.skips,
+                ...project.ownSourceFiles().map((file) => ({
+                    record: {
+                        path: relativePath(absoluteRoot, file.fileName) ?? file.fileName,
+                        line: 1,
+                        message: missingGlobal.diagnostic.text,
+                    },
+                    file,
+                    unit: file,
+                })),
+            ];
         const configuration = ids.get(project.configFile) ?? project.configFile;
         const read = () => {
             const held = inventory(project, host, targetRoot);
             const found = roots(project, held, targetRoot, options);
-            const kept = skippedRoots(project, held, reading.skips);
+            const kept = skippedRoots(project, held, skips);
             const rooted = kept.length === 0
                 ? found
                 : {
@@ -279,8 +297,8 @@ function readProjects(engine, host, scope, config, stage) {
                 configFile: project.configFile,
                 held,
                 rooted,
-                typeErrorSkips: reading.skips.map((one) => one.record),
-                skipped: skippedUnits(reading.skips, absoluteRoot),
+                typeErrorSkips: skips.map((one) => one.record),
+                skipped: skippedUnits(skips, absoluteRoot),
                 referenceOnly: project
                     .ownSourceFiles()
                     .filter((file) => referenceOnly(file.fileName))
@@ -293,9 +311,7 @@ function readProjects(engine, host, scope, config, stage) {
             heldFiles.add(relativePath(absoluteRoot, file.fileName) ?? file.fileName);
         }
         return stage(project, { configuration, read });
-    }, discovered.derived ? "record" : "refuse", joins.size === 0
-        ? workspace?.programs
-        : withJoinedTests(engine, host, workspace?.programs ?? new Map(), joins), () => {
+    }, discovered.derived ? "record" : "refuse", joins.size === 0 ? programs : withJoinedTests(engine, host, programs, joins), () => {
         outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path))), parse);
     }, readManifests);
     for (const configFile of session.unopened) {
@@ -403,6 +419,55 @@ export const DETECTORS = new Map([
     ["framework-lifecycle", frameworkLifecycle],
     ["serialization-contract", serializationContract],
 ]);
+/** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
+const DEV_SECTION = "devDependencies";
+const OTHER_SECTIONS = ["dependencies", "peerDependencies", "optionalDependencies"];
+/**
+ * The imports of a run's own files and the manifests below the target root that test
+ * evidence reads: a package is a devDependency of a file where the nearest manifest at or
+ * above it that declares the package declares it under `devDependencies` alone.
+ */
+function testEvidence(host, targetRoot, projects) {
+    const imports = new Map();
+    for (const one of projects) {
+        for (const [path, specifiers] of one.imports) {
+            imports.set(path, specifiers);
+        }
+    }
+    const manifests = new Map();
+    const manifestAt = (dir) => {
+        if (!manifests.has(dir)) {
+            let value;
+            try {
+                value = JSON.parse(host.readFile(joinPath(dir, "package.json")));
+            }
+            catch {
+                value = undefined;
+            }
+            manifests.set(dir, typeof value === "object" && value !== null && !Array.isArray(value)
+                ? value
+                : undefined);
+        }
+        return manifests.get(dir);
+    };
+    const declares = (section, name) => typeof section === "object" && section !== null && Object.hasOwn(section, name);
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return {
+        imports,
+        devDependency: (path, name) => {
+            for (let dir = dirnamePath(joinPath(root, path));; dir = dirnamePath(dir)) {
+                const manifest = manifestAt(dir);
+                const other = OTHER_SECTIONS.some((one) => declares(manifest?.[one], name));
+                if (declares(manifest?.[DEV_SECTION], name) || other) {
+                    return !other;
+                }
+                if (normalizePath(dir) === normalizePath(root) || dirnamePath(dir) === dir) {
+                    return false;
+                }
+            }
+        },
+    };
+}
 /**
  * Reads every project of the run, its references and exemptions, and `extra`'s answer,
  * while the project's view is open, and merges the projects into one matrix in the run's
@@ -441,6 +506,12 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             testFiles: resolved.testFilePaths,
             evidence,
             componentFiles: components.map(pathOf),
+            imports: new Map(project.ownSourceFiles().flatMap((file) => {
+                const path = relativePath(targetRoot, file.fileName);
+                return path === undefined
+                    ? []
+                    : [[path, file.imports.filter(isStringLiteralLikeNode).map((one) => one.text)]];
+            })),
             componentWarnings: components.flatMap((file) => readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
                 path: pathOf(file),
                 line: lineOf(file.originalText, warning.offset),
@@ -460,7 +531,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
     }));
     // Test-support code is code only test code imports in any configuration of the run: a
     // configuration that holds no test file says nothing about what the tests import.
-    const support = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles));
+    const { support, testUsed } = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles), testEvidence(host, targetRoot, withOutside));
     const settled = settledSatisfaction(withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })), [...withOutside.flatMap((one) => one.references), ...read.consumers.references]);
     const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
@@ -473,13 +544,16 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
         const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
         const supportFiles = [...support].filter((path) => held.has(path)).sort();
+        const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort();
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
             references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
             roots: projectRead.rooted.liveUnderReachability,
-            testFiles: one.testFiles,
+            testFiles: [...one.testFiles, ...supportFiles],
             ...(supportFiles.length === 0 ? {} : { supportFiles }),
+            ...(testUsedFiles.length === 0 ? {} : { testUsedFiles }),
+            ...(projectRead.held.ambient.size === 0 ? {} : { ambient: projectRead.held.ambient }),
             ...(projectRead.referenceOnly.length === 0
                 ? {}
                 : { referenceOnly: projectRead.referenceOnly }),
@@ -500,6 +574,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 ...exempt.filter(isUnansweredRecord).map((record) => record.id),
             ],
             typeErrorSkips: projectRead.typeErrorSkips,
+            unmappedEntries: projectRead.rooted.unmappedEntries,
             skipped: projectRead.skipped,
             componentFiles: one.componentFiles,
             componentWarnings: one.componentWarnings,
@@ -698,7 +773,8 @@ export function readEmitterRun(engine, host, scope, config, mode, detectors) {
  * The workspace members whose dependencies the run judges: `read` holds those a built
  * project holds a file below, `unbuilt` the others whose own directory, the nearest
  * manifest's above the configuration, holds a configuration the run could not build. A
- * member no configuration holds a file of is in neither.
+ * member no configuration holds a file of is in neither. A nested package no built project
+ * holds a file below joins `unbuilt` the same way.
  */
 function judgedMembers(host, targetRoot, read) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
@@ -717,6 +793,14 @@ function judgedMembers(host, targetRoot, read) {
             judged.unbuilt.push(dir);
         }
     }
+    for (const dir of read.nestedDirs) {
+        const below = relativePath(root, dir);
+        if (below !== undefined &&
+            owners.has(dir) &&
+            ![...held].some((path) => path.startsWith(`${below}/`))) {
+            judged.unbuilt.push(dir);
+        }
+    }
     return judged;
 }
 /** The directory of the nearest `package.json` at or above a file, inside `root`, else `root`. */
@@ -801,6 +885,7 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
             componentsUnread: read.componentsUnread,
             librariesUnfound: read.librariesUnfound,
             conventionsApplied: read.conventionsApplied,
+            unmappedEntries: unmappedEverywhere(read.projects),
         },
         configured: read.projects.map((one) => one.configured),
         symbols,
@@ -837,6 +922,19 @@ function inputsOver(host, scope, config, provenance, mode, read, documents) {
         suppressions,
     };
 }
+/** The manifest entries every project of the run reads back to no file, in the first project's order. */
+function unmappedEverywhere(projects) {
+    const key = (entry) => `${entry.dir}\u0000${entry.member}`;
+    const [first, ...rest] = projects;
+    const others = rest.map((one) => new Set(one.unmappedEntries.map(key)));
+    const found = new Map();
+    for (const entry of first?.unmappedEntries ?? []) {
+        if (others.every((one) => one.has(key(entry)))) {
+            found.set(key(entry), entry);
+        }
+    }
+    return [...found.values()];
+}
 /**
  * The analysis of the run the scope and the configuration describe: the run read with its
  * suppressions bound, every family's findings with the suppressions applied and the

package/dist/src/augmentations.js

@@ -6,6 +6,7 @@
  * name, which the language or a library types values by where the target never names it,
  * as `import.meta` or `process.env`, so a use of its member is a use of it.
  */
+import { referenceKey } from "./matrix.js";
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
 function isGlobalBlock(symbol, held, files) {
     return (symbol.kind === "namespace" &&
@@ -14,39 +15,82 @@ function isGlobalBlock(symbol, held, files) {
         !held.modules.has(symbol.id));
 }
 /**
- * For each reference to a declaration an augmentation block, or the global scope of a
- * file in `scripts`, holds, a read at the same place of every interface and namespace
- * between it and the block or the file, and of the block itself. `scripts` holds the
- * files that are no module, by identifier.
+ * Per declaration, the interfaces and namespaces between it and the augmentation block or
+ * the file in `scripts` that holds it, with the block itself, or none where no such block
+ * or file holds it; and whether that holder is the global scope rather than a module
+ * declaration. `scripts` holds the files that are no module, by identifier.
  */
-export function augmentationReferences(held, found, scripts = new Set()) {
+function holdersOf(held, scripts) {
     const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
     const globals = new Set(held.symbols.filter((one) => isGlobalBlock(one, held, files)).map((one) => one.id));
     if (globals.size === 0 && held.modules.size === 0 && scripts.size === 0) {
-        return [];
+        return undefined;
     }
     const byId = new Map(held.symbols.map((one) => [one.id, one]));
-    const holders = (id) => {
+    return (id) => {
         const ids = [];
         for (let at = byId.get(byId.get(id)?.parent ?? ""); at !== undefined; at = byId.get(at.parent)) {
             if (globals.has(at.id) || held.modules.has(at.id)) {
-                return [...ids, at.id];
+                return { ids: [...ids, at.id], global: globals.has(at.id) };
             }
             if (scripts.has(at.id)) {
-                return ids;
+                return { ids, global: true };
             }
             if (at.kind === "interface" || at.kind === "namespace") {
                 ids.push(at.id);
             }
         }
-        return [];
+        return { ids: [], global: false };
     };
-    return found.flatMap((reference) => holders(reference.to).map((to) => ({
-        from: reference.from,
-        to,
-        position: reference.position,
-        use: "read",
-        resolution: reference.resolution,
-        test: reference.test,
-    })));
+}
+/**
+ * The ambient interfaces of the global scope among `interfaces`: each one a declaration
+ * file or a `declare` holds that a `declare global` block, or the top level of a file in
+ * `scripts`, declares, directly or inside a namespace there.
+ */
+export function ambientGlobalInterfaces(held, interfaces, scripts) {
+    const holders = holdersOf(held, scripts);
+    return holders === undefined
+        ? []
+        : interfaces.filter((id) => held.ambient.has(id) && holders(id).global);
+}
+/**
+ * For each reference to a declaration an augmentation block, or the global scope of a
+ * file in `scripts` (the files that are no module), holds, a read at the same place of
+ * every interface and namespace between it and the block or the file, and of the block
+ * itself. A read through an interface of `merged`, an ambient global interface merging
+ * into a language or library one, is a production read whoever writes it: it types a
+ * value the runtime provides, so a test reading a member needs it as code does.
+ */
+export function augmentationReferences(held, found, scripts = new Set(), merged = new Set()) {
+    const holders = holdersOf(held, scripts);
+    if (holders === undefined) {
+        return [];
+    }
+    const fileOf = new Map(held.symbols.filter((one) => one.kind === "file").map((one) => [one.position.path, one.id]));
+    // Two uses at one place of declarations one block holds read the block once there.
+    const made = new Set(found.map(referenceKey));
+    const reads = new Map();
+    for (const reference of found) {
+        const { ids } = holders(reference.to);
+        // A test's read through such an interface is held by the test file, which the test
+        // runner loads whichever of its declarations runs.
+        const typed = reference.test && ids.some((id) => merged.has(id));
+        const from = typed ? (fileOf.get(reference.position.path) ?? reference.from) : reference.from;
+        for (const to of ids) {
+            const read = {
+                from,
+                to,
+                position: reference.position,
+                use: "read",
+                resolution: reference.resolution,
+                test: reference.test && !typed,
+            };
+            const key = referenceKey(read);
+            if (!made.has(key) && !reads.has(key)) {
+                reads.set(key, read);
+            }
+        }
+    }
+    return [...reads.values()];
 }

package/dist/src/automatic-types.js

@@ -0,0 +1,189 @@
+/**
+ * The global names and ambient modules of the `@types` packages a compiler before version 6
+ * includes automatically: every package of each type root when the configuration lists no
+ * `types`. Version 6 and later include none, so the analysis program holds none of their
+ * declarations, and a use of one resolves to nothing; each such use is a use of the package.
+ */
+import { isClassDeclaration, isEnumDeclaration, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, isStringLiteral, isTypeAliasDeclaration, isVariableStatement, SyntaxKind, } from "@typescript/native/ast";
+import { dirnamePath, joinPath, resolvePath } from "./paths.js";
+const TYPE_ROOT = "node_modules/@types";
+const NONE = { globals: new Map(), modules: new Map() };
+/**
+ * The packages each host has read, so a run's configurations share one reading of a type
+ * root; a host reads one unchanging tree for its whole life.
+ */
+const READ = new WeakMap();
+/** Whether one file is a module: it imports, exports or assigns an export at its top level. */
+function isModuleFile(file) {
+    return file.statements.some((statement) => isImportDeclaration(statement) ||
+        isImportEqualsDeclaration(statement) ||
+        isExportDeclaration(statement) ||
+        isExportAssignment(statement) ||
+        (statement.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
+}
+/** The names one statement of a global scope declares, and the ambient modules it declares. */
+function declared(statement, globals, modules) {
+    if (isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+            if (isIdentifier(declaration.name)) {
+                globals.push(declaration.name.text);
+            }
+        }
+    }
+    else if (isFunctionDeclaration(statement) ||
+        isClassDeclaration(statement) ||
+        isInterfaceDeclaration(statement) ||
+        isTypeAliasDeclaration(statement) ||
+        isEnumDeclaration(statement)) {
+        if (statement.name !== undefined) {
+            globals.push(statement.name.text);
+        }
+    }
+    else if (isModuleDeclaration(statement)) {
+        if (isStringLiteral(statement.name)) {
+            modules.push(statement.name.text);
+        }
+        else {
+            globals.push(statement.name.text);
+        }
+    }
+}
+/**
+ * What one declaration file declares in the global scope: its top level where it is no
+ * module, and the body of each `declare global` block where it is one.
+ */
+function fileDeclarations(file, globals, modules) {
+    if (!isModuleFile(file)) {
+        file.statements.forEach((statement) => {
+            declared(statement, globals, modules);
+        });
+        return;
+    }
+    for (const statement of file.statements) {
+        if (isModuleDeclaration(statement) &&
+            isIdentifier(statement.name) &&
+            statement.name.text === "global" &&
+            statement.body !== undefined &&
+            isModuleBlock(statement.body)) {
+            statement.body.statements.forEach((inner) => {
+                declared(inner, globals, modules);
+            });
+        }
+    }
+}
+/** The entry declaration file of one installed type package's directory. */
+function entryOf(host, dir) {
+    try {
+        const manifest = JSON.parse(host.readFile(joinPath(dir, "package.json")));
+        const named = typeof manifest === "object" && manifest !== null
+            ? (manifest["types"] ??
+                manifest["typings"])
+            : undefined;
+        if (typeof named === "string" && named !== "") {
+            const path = resolvePath(dir, named);
+            return path.endsWith(".ts") ? path : `${path}.d.ts`;
+        }
+    }
+    catch {
+        // A package with no readable manifest is read from its index, as the compiler reads it.
+    }
+    return joinPath(dir, "index.d.ts");
+}
+/**
+ * Every global name and ambient module one installed type package declares: in its entry
+ * file and each file a `/// <reference path>` of a file read reaches, inside the package.
+ */
+function packageDeclarations(host, dir, parse) {
+    const known = READ.get(host) ?? new Map();
+    READ.set(host, known);
+    const held = known.get(dir);
+    if (held !== undefined) {
+        return held;
+    }
+    const globals = [];
+    const modules = [];
+    const seen = new Set();
+    const pending = [entryOf(host, dir)];
+    for (let path = pending.pop(); path !== undefined; path = pending.pop()) {
+        if (seen.has(path) || !path.startsWith(`${dir}/`)) {
+            continue;
+        }
+        seen.add(path);
+        let text;
+        try {
+            text = host.readFile(path);
+        }
+        catch {
+            continue;
+        }
+        const file = parse(path, text);
+        fileDeclarations(file, globals, modules);
+        for (const reference of file.referencedFiles) {
+            pending.push(resolvePath(dirnamePath(path), reference.fileName));
+        }
+    }
+    const found = { globals, modules };
+    known.set(dir, found);
+    return found;
+}
+/**
+ * What the `@types` packages a compiler before version 6 would include for one
+ * configuration declare: none where its options list `types`, else every package of each
+ * `node_modules/@types` directory at or above the configuration's directory, the nearest
+ * holding a name winning.
+ */
+export function automaticTypes(host, configFile, options, parse) {
+    if (options["types"] !== undefined) {
+        return NONE;
+    }
+    const globals = new Map();
+    const modules = new Map();
+    const add = (into, name, named) => {
+        const held = into.get(name) ?? [];
+        if (!held.includes(named)) {
+            into.set(name, [...held, named]);
+        }
+    };
+    const read = new Set();
+    for (const root of typeRoots(configFile, options)) {
+        let entries;
+        try {
+            entries = host.readDirectory(root);
+        }
+        catch {
+            entries = [];
+        }
+        for (const entry of entries) {
+            if (read.has(entry.name) || host.kindOf(joinPath(root, entry.name)) !== "directory") {
+                continue;
+            }
+            read.add(entry.name);
+            const named = `@types/${entry.name}`;
+            const found = packageDeclarations(host, joinPath(root, entry.name), parse);
+            found.globals.forEach((name) => {
+                add(globals, name, named);
+            });
+            found.modules.forEach((name) => {
+                add(modules, name, named);
+            });
+        }
+    }
+    return { globals, modules };
+}
+/**
+ * The type roots of one configuration that a package manager installs into: those its
+ * `typeRoots` lists, else each `node_modules/@types` directory at or above its directory.
+ */
+function typeRoots(configFile, options) {
+    const listed = options["typeRoots"];
+    if (Array.isArray(listed)) {
+        return listed.filter((root) => typeof root === "string" && root.endsWith(`/${TYPE_ROOT}`));
+    }
+    const roots = [];
+    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
+        roots.push(joinPath(dir, TYPE_ROOT));
+        if (dirnamePath(dir) === dir) {
+            return roots;
+        }
+    }
+}

package/dist/src/base-url.js

@@ -0,0 +1,18 @@
+import { resolvePath } from "./paths.js";
+/**
+ * The `paths` one configuration's resolved options map under the compilers before version
+ * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
+ * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
+ * options' own `paths` stand. Version 7 reads no `baseUrl`:
+ * https://github.com/microsoft/TypeScript/issues/62207
+ */
+export function baseUrlPaths(options) {
+    const baseUrl = Reflect.get(options, "baseUrl");
+    if (typeof baseUrl !== "string") {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
+        key,
+        targets.map((target) => resolvePath(baseUrl, target)),
+    ]));
+}

package/dist/src/components.js

@@ -129,12 +129,12 @@ function linesSpanned(symbols) {
     return total;
 }
 /**
- * The dead declarations by subgraph place (`at`, and `position` per graph declaration),
- * a test file's only where it tests dead code or nothing the tests reach. `adjacent` holds
- * each reference one makes to another, except an unreferenced test-file declaration's to
- * production code, which decides nothing of its target; an edge each way between a dead
- * member and its dead container; and one back from each production target of an admitted
- * test, which puts the test in its subject's component. `references` holds the first alone.
+ * The dead declarations by subgraph place (`at`, and `position` per graph declaration), a
+ * test file's only where it tests dead code or nothing the tests reach. `adjacent` holds each
+ * reference one makes to another, but an unreferenced test-file declaration's to production
+ * code, which decides nothing; an edge each way between a dead member and its dead container;
+ * and one back from each non-ambient production target of an admitted test, which puts the
+ * test in its subject's component. `references` holds the first alone.
  */
 function deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest) {
     const at = [];
@@ -158,6 +158,7 @@ function deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest) {
             references[from]?.push(to);
             if (testOfDeadCode[index] === true &&
                 graph.test[edge.to] !== true &&
+                graph.ambient[edge.to] !== true &&
                 graph.subject[edge.to] === true) {
                 adjacent[to]?.push(from);
             }

package/dist/src/config.js

@@ -66,6 +66,7 @@ export function defaultConfig() {
             injectionRegistrations: [],
             lifecycleContracts: [],
             serializers: [],
+            rootsComplete: false,
         },
     };
 }

package/dist/src/configuration-files.js

@@ -6,7 +6,7 @@
  * every string either holds as it likes, so each one that spells a declared dependency
  * uses it and each relative one that names a source file of the program roots the file.
  */
-import { isExportDeclaration, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/ast";
+import { isCallExpression, isExportDeclaration, isIdentifier, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 const MANIFEST = "package.json";
 /** A configuration module's name, each form with the spelling a root reports it by. */
@@ -346,18 +346,56 @@ export function configurationFiles(host, targetRoot, files, parse) {
             : outsideModules(host, root, [...dirs], files, holdsManifest, parse, named),
     };
 }
-/** The relative specifiers one file's imports and re-exports name. */
-function relativeSpecifiers(file) {
-    return file.statements.flatMap((statement) => {
-        const specifier = isImportDeclaration(statement) || isExportDeclaration(statement)
+/** The literal module specifier one `require(...)` or `import(...)` call names, if any. */
+function calledSpecifier(node) {
+    if (!isCallExpression(node) || node.arguments.length !== 1) {
+        return undefined;
+    }
+    const callee = node.expression;
+    const loads = callee.kind === SyntaxKind.ImportKeyword || (isIdentifier(callee) && callee.text === "require");
+    return loads ? node.arguments[0] : undefined;
+}
+/**
+ * The relative specifiers one file's imports and re-exports name, and those its
+ * `require(...)` and `import(...)` calls name by a literal.
+ */
+export function relativeSpecifiers(file) {
+    const known = specifiersOf.get(file);
+    if (known !== undefined) {
+        return known;
+    }
+    const found = [];
+    const named = (specifier) => {
+        if (specifier !== undefined &&
+            (isStringLiteral(specifier) || isNoSubstitutionTemplateLiteral(specifier)) &&
+            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))) {
+            found.push(specifier.text);
+        }
+    };
+    const visit = (node) => {
+        named(calledSpecifier(node));
+        node.forEachChild(visit);
+    };
+    for (const statement of file.statements) {
+        named(isImportDeclaration(statement) || isExportDeclaration(statement)
             ? statement.moduleSpecifier
-            : undefined;
-        return specifier !== undefined &&
-            isStringLiteral(specifier) &&
-            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
-            ? [specifier.text]
-            : [];
-    });
+            : undefined);
+        visit(statement);
+    }
+    specifiersOf.set(file, found);
+    return found;
+}
+/** What {@link relativeSpecifiers} found in each file, which every project of a run reads alike. */
+const specifiersOf = new WeakMap();
+/**
+ * The files no program holds that a chain from `seeds` reads: each seed, and each file
+ * below the target root one imports, re-exports or loads by a relative specifier that no
+ * program holds either, until no further file joins, each read against the manifest
+ * directory its seed names. A file that cannot be read is skipped.
+ */
+export function outsideChain(host, targetRoot, files, parse, seeds) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return outsideModules(host, root, [], files, () => false, parse, seeds);
 }
 /**
  * The paths one relative specifier from a configuration file may reach, in the order they