@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.18

package/dist/src/alias-chain.js

@@ -19,7 +19,6 @@ export function aliasChains(project, held) {
     const ownFiles = project.ownPaths();
     const steps = new Map();
     const chains = new Map();
-    let asked = 0;
     const declarationsOf = (symbol) => {
         const ids = [];
         for (const handle of symbol.declarations) {
@@ -52,7 +51,6 @@ export function aliasChains(project, held) {
             return steps.get(symbol.id);
         }
         const next = project.aliasStepOf(symbol);
-        asked += 1;
         steps.set(symbol.id, next);
         return next;
     };
@@ -145,8 +143,5 @@ export function aliasChains(project, held) {
         declarationsOf,
         chainOf,
         nextDeclared,
-        get steps() {
-            return asked;
-        },
     };
 }

package/dist/src/amd.js

@@ -0,0 +1,81 @@
+/**
+ * AMD's module forms (references-ts.37), read from the syntax because the binder declares
+ * none of them: `define([<ids>], factory)`, `define("<name>", [<ids>], factory)` and
+ * `require([<ids>], callback)` (https://github.com/amdjs/amdjs-api/blob/master/AMD.md).
+ */
+import { isArrayLiteralExpression, isArrowFunction, isFunctionExpression, isCallExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/ast";
+import { hasURLScheme, isAbsolutePath, resolvePath, startsRelativePath } from "./paths.js";
+import { parenthesesRemoved } from "./unwrap.js";
+/** The ids AMD binds to the factory's CommonJS parameters, which load no module. */
+const FREE_VARIABLES = new Set(["require", "exports", "module"]);
+/** The platform function `callee` is written as. */
+export function amdPlatform(callee) {
+    return callee.text === "define" ? "define" : "require";
+}
+/**
+ * The dependency list one call writes, where it is a call of a bare `define` or `require` in
+ * one of AMD's forms. A `define` with no list, of a factory or a value alone, loads nothing;
+ * a `require` whose first argument is no array literal is CommonJS's.
+ */
+export function amdLoadOf(node) {
+    if (!isCallExpression(node)) {
+        return undefined;
+    }
+    const callee = parenthesesRemoved(node.expression);
+    if (!isIdentifier(callee) || (callee.text !== "define" && callee.text !== "require")) {
+        return undefined;
+    }
+    const written = node.arguments.map((one) => parenthesesRemoved(one));
+    const [first] = written;
+    if (first === undefined) {
+        return undefined;
+    }
+    const define = callee.text === "define";
+    const named = define && isLiteralText(first);
+    const list = written[named ? 1 : 0];
+    if (list !== undefined && isArrayLiteralExpression(list)) {
+        const elements = list.elements.map((one) => parenthesesRemoved(one));
+        const factory = written[named ? 2 : 1];
+        const ids = elements.flatMap((one, at) => isLiteralText(one) && !FREE_VARIABLES.has(one.text)
+            ? [{ id: one, received: receives(factory, at) }]
+            : []);
+        return { callee, ids, computed: elements.some((one) => !isLiteralText(one)) };
+    }
+    if (!define) {
+        return undefined;
+    }
+    // A factory after the list's place makes what stands there a list, here a computed one.
+    return { callee, ids: [], computed: written.length > (named ? 2 : 1) };
+}
+function isLiteralText(node) {
+    return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node);
+}
+/** Whether a factory may receive the dependency at place `at` of its list. */
+function receives(factory, at) {
+    if (factory === undefined) {
+        return false;
+    }
+    if (!isFunctionExpression(factory) && !isArrowFunction(factory)) {
+        return true;
+    }
+    const { parameters } = factory;
+    return at < parameters.length || parameters.some((one) => one.dotDotDotToken !== undefined);
+}
+/**
+ * The path a dependency id names against the calling file's directory: a relative module id,
+ * `./` or `../` with no `.js` ending, with `.js` appended. RequireJS reads any other id
+ * through its configuration or as a URL against the page, which the analysis does not know.
+ */
+export function amdPath(dir, id) {
+    return startsRelativePath(id) && !id.endsWith(".js") ? resolvePath(dir, `${id}.js`) : undefined;
+}
+/**
+ * Whether one call may load a file the analysis cannot name: a computed list, or an id that
+ * RequireJS reads as a URL, one ending in `.js`, starting with `/` or carrying a scheme. Any
+ * other id {@link amdPath} reads no path from is a package's.
+ */
+export function amdUnresolved(load) {
+    return (load.computed ||
+        load.ids.some(({ id }) => amdPath("/", id.text) === undefined &&
+            (id.text.endsWith(".js") || isAbsolutePath(id.text) || hasURLScheme(id.text))));
+}

package/dist/src/analysis.js

@@ -12,6 +12,7 @@ import { consumerReferences } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./roots/configured-declarations.js";
 import { decorator } from "./decorator.js";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
+import { carriersOf, NO_CARRIERS } from "./exposure.js";
 import { deprecatedDeclarations } from "./deprecation.js";
 import { moduleIdentity } from "./load/discover.js";
 import { loadRun } from "./load/load.js";
@@ -19,36 +20,40 @@ import { readSources } from "./entries/sources.js";
 import { readWorkflows } from "./entries/workflow-steps.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
+import { bindingsOf, distinctBindings } from "./bindings.js";
 import { generatedFile, generatedFilesOf } from "./generated-file.js";
-import { inOperandNames } from "./in-operands.js";
+import { inOperandNames } from "./findings/in-operands.js";
 import { sourceFilesOf } from "./source-files.js";
-import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, writtenRecords, } from "./exempt.js";
+import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, isUnansweredRecord, writtenRecords, } from "./exempt.js";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { unmatchedRootFindings } from "./findings/self-check.js";
 import { frameworkLifecycle } from "./framework-lifecycle.js";
-import { implementations, mergeImplementations } from "./implementations.js";
+import { implementations, mergeImplementations } from "./findings/implementations.js";
 import { injectionContainer } from "./injection-container.js";
 import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import {} from "./inventory.js";
 import { inventory } from "./inventory/enumerate.js";
 import { readManifest } from "./roots/manifest.js";
-import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
+import { matrixOf, referenceKey } from "./liveness/matrix.js";
 import { ancestors, dirnamePath, extensionOf, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
 import { skippedUnits } from "./type-errors.js";
 import { reflectiveLookup } from "./reflective-lookup.js";
-import { references, testFileRulesOf } from "./references.js";
+import { references } from "./references.js";
 import { rootSet, unmatchedEverywhere, } from "./roots/root-set.js";
 import { decodedMembers, serializationContract } from "./serialization-contract.js";
-import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
+import { outsideTestReferences, testFilesAt } from "./tests/outside.js";
+import { formedForNode } from "./load/synthesize.js";
 import { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.js";
-import { supportReferences, testSupportFiles } from "./test-support.js";
+import { targetTestFile, testFilePaths, testFileRulesOf, withheldBy, } from "./tests/file-class.js";
+import { testSupportFiles } from "./tests/support.js";
 import { accessorsOf, storesOf } from "./stores.js";
 import { isPartKind } from "./suppress.js";
 import { bindRows, readBaseline, readIgnoreFile } from "./suppress-file.js";
 import { inlineDirectives, inlineSuppressions } from "./suppress-inline.js";
+import { sweep } from "./liveness/sweep.js";
 import { readTemplates, templateField } from "./template-field.js";
 import { bytewise } from "./text/compare.js";
 import { holdsManifest, manifestAt } from "./fs/manifest.js";
@@ -109,6 +114,7 @@ function readProjects(engine, host, scope, config, stage) {
                     workflows,
                 });
                 const rooted = rootSet(project, held, targetRoot, { ...options, sources, skips });
+                const generated = generatedFilesOf(own, sources.generated);
                 return {
                     configuration: planned.id,
                     configFile: project.configFile,
@@ -120,8 +126,12 @@ function readProjects(engine, host, scope, config, stage) {
                         .ownSourceFiles()
                         .filter((file) => referenceOnly(file.fileName))
                         .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
-                    generated: generatedFilesOf(own, sources.generated),
+                    generated,
+                    bindings: bindingsOf(own.byPath, generated, new Map(held.symbols
+                        .filter((one) => one.kind === "file")
+                        .map((one) => [one.position.path, one.ref]))),
                     sources,
+                    formedForNode: formedForNode(planned),
                 };
             };
             for (const file of project.ownSourceFiles()) {
@@ -130,14 +140,25 @@ function readProjects(engine, host, scope, config, stage) {
             return stage(project, { configuration: planned.id, read });
         });
         const consumed = new Map();
+        const consumerHeld = new Set();
         for (const { project, consumer } of classified.consumed) {
             const side = { id: consumer.id, root: consumer.path };
-            for (const reference of consumerReferences(project, host, targetRoot, side, config, parse)) {
+            const read = consumerReferences(project, host, targetRoot, side, config, parse);
+            for (const reference of read.references) {
                 consumed.set(referenceKey(reference), reference);
             }
+            for (const id of read.held) {
+                consumerHeld.add(id);
+            }
         }
         const outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path))), parse);
-        return { answers, references: [...consumed.values()], outsideTests, workflows };
+        return {
+            answers,
+            references: [...consumed.values()],
+            consumerHeld: [...consumerHeld],
+            outsideTests,
+            workflows,
+        };
     });
 }
 /**
@@ -202,6 +223,13 @@ export function runRoots(engine, host, scope, config, provenance) {
         unanswered: read.unanswered,
     };
 }
+/** The production mode a configuration sets: a consumer's test reference is classed as `analysis.consumer_tests` says. */
+export function productionMode(config) {
+    return {
+        production: true,
+        consumerTestsProduction: config.analysis.consumer_tests === "production",
+    };
+}
 /** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
 export const DETECTORS = new Map([
     ["interface-satisfaction", interfaceSatisfaction],
@@ -268,11 +296,13 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
     const directories = runDirectories(host, targetRoot, (fileName, text) => engine.parseSourceFile(fileName, text));
     const read = readProjects(engine, host, scope, config, (project, opened) => {
         const projectRead = opened.read();
+        const testFile = targetTestFile(projectRead.sources.testFiles);
         const resolved = references(project, projectRead.held, targetRoot, {
-            testFiles: config.ts.test_files,
-            testFileNames: projectRead.sources.testFiles,
+            testFile,
             directories,
+            formedForNode: projectRead.formedForNode,
         });
+        const testFiles = testFilePaths(project, targetRoot, testFile);
         const evidence = evidenceRecords({
             project,
             held: projectRead.held,
@@ -292,7 +322,9 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         return {
             projectRead,
             references: resolved.references,
-            testFiles: resolved.testFilePaths,
+            held: resolved.held,
+            possiblyLoaded: resolved.possiblyLoaded,
+            testFiles,
             evidence,
             componentFiles: components.map(pathOf),
             imports: new Map(project.ownSourceFiles().flatMap((file) => {
@@ -316,8 +348,8 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 line: lineOf(file.originalText, warning.offset),
                 reason: warning.reason,
             }))),
-            decoded: decodedMembers(project, projectRead.held, productionFiles(project, targetRoot, resolved.testFilePaths), consumers),
-            extra: extra(project, projectRead, resolved.references, resolved.testFilePaths, resolved.unseenLoads.map((position) => ({
+            decoded: decodedMembers(project, projectRead.held, productionFiles(project, targetRoot, testFiles), consumers),
+            extra: extra(project, projectRead, resolved.references, testFiles, resolved.unseenLoads.map((position) => ({
                 configuration: projectRead.configuration,
                 position,
             }))),
@@ -359,7 +391,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             testFiles: new Set([...one.testFiles, ...support]),
         });
         const exempt = detected.records;
-        const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
+        const made = [...one.references, ...(satisfied?.references ?? [])];
         const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
         const supportFiles = [...support].filter((path) => held.has(path)).sort(bytewise);
         const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort(bytewise);
@@ -386,13 +418,13 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             unanswered: [
                 ...projectRead.held.unanswered,
                 ...projectRead.rooted.unanswered,
-                ...made
-                    .filter((reference) => reference.resolution === "by-name")
-                    .map((reference) => reference.to),
+                ...made.filter((reference) => reference.guessed === true).map((reference) => reference.to),
+                ...one.held,
                 ...exempt.filter(isUnansweredRecord).map((record) => record.id),
                 ...one.decoded.unanswered,
             ],
             filledOutside: one.decoded.filled,
+            possiblyLoaded: one.possiblyLoaded,
             typeErrorSkips: projectRead.typeErrorSkips,
             unmappedEntries: projectRead.rooted.unmappedEntries,
             heldScripts: projectRead.rooted.heldScripts,
@@ -418,11 +450,13 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         unansweredHeld: [
             ...new Set([
                 ...answers.flatMap((one) => one.unanswered),
-                ...consumed.filter((one) => one.resolution === "by-name").map((one) => one.to),
+                ...consumed.filter((one) => one.guessed === true).map((one) => one.to),
+                ...read.result.consumerHeld,
             ]),
         ],
         projects,
         consumers: read.plan.discovery.consumers,
+        declaresConsumers: scope.consumers.length > 0,
         notBuilt: read.classified.notBuilt,
         unanswered: read.unanswered,
         componentsUnread: read.plan.workspace?.componentsUnread ?? [],
@@ -436,29 +470,6 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         workflows: read.result.workflows,
     };
 }
-/**
- * The run swept under one set of marks with the records that hold. A record a component
- * file's markup holds counts only while the file is live, and what it holds may be what
- * keeps the file live, so each file's markup joins only once a sweep without it finds the
- * file live, until a sweep finds no further file live.
- */
-function holdingSweep(read, input) {
-    const paths = new Set(read.exempt.flatMap((record) => record.whileLive ?? []));
-    let live = new Set();
-    for (;;) {
-        const swept = {
-            ...input,
-            exempt: holdingWhile(read.exempt, live),
-            unanswered: read.unansweredHeld,
-        };
-        const result = sweepMatrix(read.matrix, swept);
-        const next = new Set(liveFilesAt(read.matrix, result, paths).map((one) => one.position.path));
-        if (next.size === live.size) {
-            return { swept, result };
-        }
-        live = next;
-    }
-}
 /**
  * The test references exemption evidence written in a test file makes: each is a read of
  * the declaration it would retain, made by the test file at the evidence's site.
@@ -491,7 +502,7 @@ function evidenceReferences(symbols, inTestFiles) {
  * makes being a test's.
  */
 function countedWrites(references, support, mode) {
-    return new Set(supportReferences(references, support).flatMap((reference) => reference.use === "write" && !(mode.production && reference.test) ? [reference.to] : []));
+    return new Set(references.flatMap((reference) => reference.use === "write" && !withheldBy(mode, reference, support) ? [reference.to] : []));
 }
 /**
  * The declarations every reference the mode counts stores into, a loaded consumer's
@@ -501,8 +512,9 @@ function writtenOnly(read, mode) {
     const written = new Set();
     const readSome = new Set();
     for (const { configured } of read.projects) {
+        const support = new Set(configured.supportFiles ?? []);
         for (const reference of configured.references) {
-            if (mode.production && reference.test) {
+            if (withheldBy(mode, reference, support)) {
                 continue;
             }
             if (reference.use === "write" && reference.consumer === undefined) {
@@ -515,55 +527,22 @@ function writtenOnly(read, mode) {
     }
     return new Set([...written].filter((id) => !readSome.has(id)));
 }
-/**
- * The sweep of a run read once, under one set of marks. Where a question went unanswered,
- * the run is swept once more without what that question could have kept live and without
- * the references that stood in for its answer, and every declaration that sweep judges
- * dead and this one judges live, or dead by another rule, is held by the gap too, as is
- * every declaration that makes such a reference.
- */
+/** The sweep of a run read once, under one set of marks. */
 function sweptOf(read, input) {
-    const { swept, result } = holdingSweep(read, input);
-    const exempt = swept.exempt ?? [];
-    const held = new Set(read.unansweredHeld);
-    if (held.size > 0) {
-        // What a declaration reads where the checker did not answer is unknown, so a rule
-        // over what it reads, the test of dead code among them, cannot judge it.
-        for (const { configured } of read.projects) {
-            for (const reference of configured.references) {
-                if (reference.resolution === "by-name") {
-                    held.add(reference.from);
-                }
-            }
-        }
-        const dead = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
-        const answered = matrixOf(read.projects.map(({ configured }) => ({
-            ...configured,
-            references: configured.references.filter((one) => one.resolution !== "by-name"),
-        })));
-        const bare = {
-            ...swept,
-            exempt: exempt.filter((record) => !isUnansweredRecord(record)),
-            unanswered: [],
-        };
-        for (const candidate of sweepMatrix(answered, bare).candidates) {
-            const kept = dead.get(candidate.id);
-            if (kept?.testOfDeadCode !== candidate.testOfDeadCode ||
-                kept.relation !== candidate.relation) {
-                held.add(candidate.id);
-            }
-        }
-    }
+    const componentFiles = [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(bytewise);
     return {
         matrix: read.matrix,
-        sweep: result,
-        exempt,
-        retained: retainedIn(read.matrix, swept, writtenOnly(read, input.mode)),
+        sweep: sweep(read.matrix, {
+            ...input,
+            exempt: read.exempt,
+            unanswered: read.unansweredHeld,
+            componentFiles,
+            unseenCallers: !read.declaresConsumers,
+            writeOnly: writtenOnly(read, input.mode),
+        }),
         notBuilt: read.notBuilt,
         unanswered: read.unanswered,
-        heldByUnanswered: [...held],
         skipped: read.projects.flatMap((one) => one.skipped),
-        componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(bytewise),
     };
 }
 /**
@@ -592,12 +571,15 @@ export function readEmitterRun(engine, host, scope, config, mode, detectors) {
         implementations: implementations(project, read.held),
         heldByInclusion: heldByInclusion(project, targetRoot),
         generated: read.generated,
+        bindings: read.bindings,
         inOperands: inOperandNames(project, targetRoot, testFiles),
         rooted: read.rooted,
         directives: inlineDirectives(project, read.held, targetRoot).filter((directive) => !read.referenceOnly.includes(directive.site.path)),
         declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
         parts: projectParts(project, read.held, references, targetRoot),
         unseenLoads,
+        // Only a closed world reports an unnecessary export, which is all the carriers decide.
+        carriers: config.consumers.complete ? carriersOf(project, read.held) : NO_CARRIERS,
     }));
     // Whether a declaration carries the marker decides its code, so one whose answer went
     // unread is reported by nothing.
@@ -659,8 +641,9 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
         deprecated: new Set(projects.flatMap((one) => one.extra.deprecation.deprecated)),
         stores: storesOf(projects.map((one) => ({
             references: one.configured.references,
+            support: new Set(one.configured.supportFiles ?? []),
             accessors: one.extra.accessors,
-        })), swept.exempt, input.mode),
+        })), swept.sweep.exempt, input.mode),
         dependencies: dependenciesOf(host, targetRoot, read.workflows, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id), members.read, members.unbuilt, read.nestedDirs),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         files: {
@@ -678,9 +661,16 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             encapsulated: readManifest(host, targetRoot).declaresExports,
             edges: readEdgeSides(host, targetRoot),
             filledOutside: new Set(projects.flatMap((one) => one.filledOutside)),
+            possiblyLoaded: new Set(projects.flatMap((one) => one.possiblyLoaded)),
+            carriers: {
+                named: new Map([
+                    ...Map.groupBy(projects.flatMap((one) => [...one.extra.carriers.named]), ([id]) => id),
+                ].map(([id, entries]) => [id, [...new Set(entries.flatMap(([, named]) => named))]])),
+                unread: new Set(projects.flatMap((one) => [...one.extra.carriers.unread])),
+            },
         },
         selfCheck,
-        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered])),
+        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.sweep.exempt.map((one) => one.id), ...swept.sweep.held])),
     };
 }
 /**
@@ -725,6 +715,7 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
             heldScripts: read.projects.flatMap((one) => one.heldScripts.map((held) => ({ ...held, configFile: one.configFile }))),
             unseenLoads: read.projects.flatMap((one) => one.extra.unseenLoads),
             generated: new Map(read.projects.flatMap((one) => [...one.extra.generated])),
+            bindings: distinctBindings(read.projects.flatMap((one) => one.extra.bindings)),
         },
         configured: read.projects.map((one) => one.configured),
         symbols,
@@ -792,7 +783,7 @@ export function runAnalysis(engine, host, scope, config, provenance, mode, detec
  * declarations of its own the run holds for them.
  */
 export function unansweredCounts(analysis) {
-    const held = new Set(analysis.swept.heldByUnanswered);
+    const held = new Set(analysis.swept.sweep.held);
     return analysis.run.projects.flatMap((project) => {
         const questions = analysis.run.unanswered.filter((one) => one.configFile === project.configFile).length +
             analysis.run.unread.filter((one) => one.kind === "manifest" && one.configFile === project.configFile).length +

package/dist/src/augmentations.js

@@ -8,7 +8,7 @@
  */
 import { isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
-import { referenceKey } from "./matrix.js";
+import { referenceKey } from "./liveness/matrix.js";
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
 export function isGlobalBlock(symbol, held, files) {
     return (symbol.kind === "namespace" &&
@@ -50,19 +50,15 @@ function holdersOf(held, scripts) {
  * 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) {
+function ambientGlobalInterfaces(held, interfaces, scripts) {
     const holders = holdersOf(held, scripts);
     return holders === undefined
         ? []
         : interfaces.filter((id) => held.ambient.has(id) && holders(id).global);
 }
 /**
- * Each ambient global interface of the project's own files that merges into an interface
- * declared outside them, with every interface, namespace and block between it and the
- * global scope: the outside declaration names it wherever a value is typed by it. Where
- * every outside declaration is a package's, not the compiler's library, and declares no
- * member, each member it declares as well: such an interface is a slot the package reads
- * by type, as `keyof` does, in declarations the analysis does not walk.
+ * Which ambient global interfaces of the project's own files, `files`, merge into an interface
+ * declared outside them, and what each merge keeps.
  */
 export function mergedGlobalInterfaces(project, held, files) {
     const scripts = new Set();
@@ -88,7 +84,7 @@ export function mergedGlobalInterfaces(project, held, files) {
     const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
     const asked = [...names].filter(([id]) => global.has(id));
     if (asked.length === 0) {
-        return [];
+        return { scripts, interfaces: new Set(), kept: [] };
     }
     const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
     const holders = holdersOf(held, scripts);
@@ -99,22 +95,25 @@ export function mergedGlobalInterfaces(project, held, files) {
         const node = project.declarationAt(handle)?.node;
         return node !== undefined && isInterfaceDeclaration(node) && node.members.length === 0;
     };
-    return [
-        ...new Set(asked.flatMap(([id], at) => {
-            const symbol = answers[at];
-            if (typeof symbol !== "object") {
-                return [];
-            }
-            const outside = symbol.declarations.filter((handle) => !files.byName.has(handle.path));
-            if (outside.length === 0) {
-                return [];
-            }
-            const members = outside.every(empty)
-                ? held.symbols.filter((one) => one.parent === id).map((one) => one.id)
-                : [];
-            return [id, ...(holders?.(id).ids ?? []), ...members];
-        })),
-    ];
+    const interfaces = new Set();
+    const kept = new Set();
+    asked.forEach(([id], at) => {
+        const symbol = answers[at];
+        const outside = typeof symbol === "object"
+            ? symbol.declarations.filter((handle) => !files.byName.has(handle.path))
+            : [];
+        if (outside.length === 0) {
+            return;
+        }
+        interfaces.add(id);
+        const members = outside.every(empty)
+            ? held.symbols.filter((one) => one.parent === id).map((one) => one.id)
+            : [];
+        for (const one of [id, ...(holders?.(id).ids ?? []), ...members]) {
+            kept.add(one);
+        }
+    });
+    return { scripts, interfaces, kept: [...kept] };
 }
 /**
  * For each reference to a declaration an augmentation block, or the global scope of a