@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

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

@@ -9,43 +9,45 @@ import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import { lineOf, readComponent } from "./component-files.js";
 import { kindOf } from "./config.js";
 import { consumerReferences } from "./consumers.js";
-import { configuredDeclarations, configuredRef, declarationsNamed, } from "./configured-declarations.js";
+import { configuredDeclarations, configuredRef, declarationsNamed, } from "./roots/configured-declarations.js";
 import { decorator } from "./decorator.js";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
 import { moduleIdentity } from "./load/discover.js";
 import { loadRun } from "./load/load.js";
-import { generatedFiles } from "./conventions.js";
+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 { 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 "./manifest.js";
+import { readManifest } from "./roots/manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
 import { ancestors, dirnamePath, extensionOf, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
-import { skippedRoots, skippedUnits } from "./type-errors.js";
+import { skippedUnits } from "./type-errors.js";
 import { reflectiveLookup } from "./reflective-lookup.js";
-import { references, testFileRulesOf } from "./references.js";
-import { roots, unmatchedEverywhere, } from "./roots.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 { mergedGlobalInterfaces } from "./augmentations.js";
-import { unseenLoadsOf } from "./unseen-loads.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";
@@ -53,6 +55,7 @@ import { inlineDirectives, inlineSuppressions } from "./suppress-inline.js";
 import { readTemplates, templateField } from "./template-field.js";
 import { bytewise } from "./text/compare.js";
 import { holdsManifest, manifestAt } from "./fs/manifest.js";
+import { runDirectories } from "./entries/run-directories.js";
 import { globExpression } from "./text/glob.js";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
@@ -82,14 +85,13 @@ function readProjects(engine, host, scope, config, stage) {
     const parse = (fileName, text) => engine.parseSourceFile(fileName, text);
     return loadRun(engine, host, scope, config, ({ plan, classified, runFiles }) => {
         const { packages, conventions } = plan;
+        const workflows = readWorkflows(host, targetRoot);
         const options = {
             host,
             manifest: packages.manifest,
             otherPackages: packages.entries,
             patterns: config.roots.patterns,
             entryFiles: config.ts.entry_files,
-            conventions,
-            testFiles: config.ts.test_files,
             parse,
             publishedAPI: config.target.kind !== undefined && kindOf(config.target.kind) === "library",
             publishedMembers: packages.published,
@@ -99,18 +101,18 @@ function readProjects(engine, host, scope, config, stage) {
         const answers = classified.analyzed.map(({ plan: planned, project, skips, referenceOnly }) => {
             const read = () => {
                 const held = inventory(project, host, targetRoot);
-                const found = roots(project, held, targetRoot, options);
-                const kept = skippedRoots(project, held, skips);
-                const rooted = kept.length === 0
-                    ? found
-                    : {
-                        ...found,
-                        liveUnderReachability: [
-                            ...found.liveUnderReachability,
-                            ...kept.map((id) => ({ id, kind: "type-error", source: "" })),
-                        ],
-                    };
                 const own = sourceFilesOf(project, targetRoot);
+                const sources = readSources({
+                    host,
+                    targetRoot,
+                    files: own,
+                    parse,
+                    testFiles: config.ts.test_files,
+                    conventions,
+                    workflows,
+                });
+                const rooted = rootSet(project, held, targetRoot, { ...options, sources, skips });
+                const generated = generatedFilesOf(own, sources.generated);
                 return {
                     configuration: planned.id,
                     configFile: project.configFile,
@@ -122,8 +124,12 @@ function readProjects(engine, host, scope, config, stage) {
                         .ownSourceFiles()
                         .filter((file) => referenceOnly(file.fileName))
                         .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
-                    generated: generatedFilesOf(own, generatedFiles(conventions, own)),
-                    testFileNames: conventions.testFiles,
+                    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()) {
@@ -132,14 +138,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)) {
+            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 };
+        return {
+            answers,
+            references: [...consumed.values()],
+            consumerHeld: [...consumerHeld],
+            outsideTests,
+            workflows,
+        };
     });
 }
 /**
@@ -204,6 +221,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],
@@ -267,12 +291,16 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         ? { delimiters: config.analysis.template_delimiters, files: [] }
         : readTemplates(host, targetRoot, config.analysis);
     const consumers = scope.consumers.map((consumer) => consumer.path);
+    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.testFileNames,
+            testFile,
+            directories,
+            formedForNode: projectRead.formedForNode,
         });
+        const testFiles = testFilePaths(project, targetRoot, testFile);
         const evidence = evidenceRecords({
             project,
             held: projectRead.held,
@@ -292,10 +320,11 @@ 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),
-            augmented: mergedGlobalInterfaces(project, projectRead.held, sourceFilesOf(project, targetRoot)).map((id) => ({ id, kind: "global-augmentation", source: "" })),
             imports: new Map(project.ownSourceFiles().flatMap((file) => {
                 const path = relativePath(targetRoot, file.fileName);
                 if (path === undefined) {
@@ -317,8 +346,11 @@ 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),
+            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,
+            }))),
         };
     });
     const outsidePaths = read.result.outsideTests.map((one) => one.path);
@@ -332,7 +364,9 @@ 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, 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 { support, testUsed } = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), 
+    // An outside declaration naming a global augmentation calls nothing of its file.
+    withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability.filter((root) => root.kind !== "global-augmentation")), withOutside.flatMap((one) => one.testFiles), testEvidence(host, targetRoot, withOutside));
     // A member a decode fills or a copy carries is written: a value decoded and sent again carries it on.
     const written = new Set([
         ...countedWrites([...withOutside.flatMap((one) => one.references), ...read.result.references], support, mode),
@@ -355,7 +389,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);
@@ -363,9 +397,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
             references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
-            // The augmentations are rooted after test support is read: an outside declaration
-            // naming one calls nothing of its file.
-            roots: [...projectRead.rooted.liveUnderReachability, ...one.augmented],
+            roots: projectRead.rooted.liveUnderReachability,
             testFiles: [...one.testFiles, ...supportFiles],
             ...(supportFiles.length === 0 ? {} : { supportFiles }),
             ...(testUsedFiles.length === 0 ? {} : { testUsedFiles }),
@@ -384,13 +416,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,
@@ -416,7 +448,8 @@ 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,
@@ -431,6 +464,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         conventionUses: read.plan.conventions.uses,
         memberDirs: read.plan.packages.members,
         nestedDirs: read.plan.packages.nested,
+        workflows: read.result.workflows,
     };
 }
 /**
@@ -488,7 +522,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
@@ -498,8 +532,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) {
@@ -528,7 +563,7 @@ function sweptOf(read, input) {
         // 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") {
+                if (reference.guessed === true) {
                     held.add(reference.from);
                 }
             }
@@ -536,7 +571,7 @@ function sweptOf(read, input) {
         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"),
+            references: configured.references.filter((one) => one.guessed !== true),
         })));
         const bare = {
             ...swept,
@@ -582,19 +617,20 @@ function productionFiles(project, targetRoot, testFiles) {
 /** Reads a run's projects with every per-project fact an emitter reads. */
 export function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const targetRoot = scope.target.path;
-    const run = readRun(engine, host, scope, config, mode, detectors, (project, read, references, testFiles) => ({
+    const run = readRun(engine, host, scope, config, mode, detectors, (project, read, references, testFiles, unseenLoads) => ({
         deprecation: deprecatedDeclarations(project, read.held),
         accessors: accessorsOf(project, read.held),
-        needs: projectNeeds(project, read.held, host, targetRoot, (fileName, text) => engine.parseSourceFile(fileName, text)),
+        needs: projectNeeds(project, read.held, host, targetRoot, (fileName, text) => engine.parseSourceFile(fileName, text), read.sources.configuration, read.sources.workflows),
         implementations: implementations(project, read.held),
         heldByInclusion: heldByInclusion(project, targetRoot),
-        generated: [...read.generated.keys()],
+        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: unseenLoadsOf(project, read.configuration, targetRoot, testFiles),
+        unseenLoads,
     }));
     // Whether a declaration carries the marker decides its code, so one whose answer went
     // unread is reported by nothing.
@@ -656,14 +692,15 @@ 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),
-        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id), members.read, members.unbuilt, read.nestedDirs),
+        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: {
             tree: sourceTree(host, targetRoot),
             heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
-            generated: new Set(projects.flatMap((one) => one.extra.generated)),
+            generated: new Set(projects.flatMap((one) => [...one.extra.generated.keys()])),
             inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
             unseenLoads: projects.flatMap((one) => one.extra.unseenLoads),
         },
@@ -675,6 +712,7 @@ 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)),
         },
         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])),
@@ -721,6 +759,8 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
             unmappedEntries: unmappedEverywhere(read.projects),
             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,

package/dist/src/augmentations.js

@@ -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