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

package/dist/src/serialization-contract.js

@@ -12,7 +12,7 @@ import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync"
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
 import { classMembers, memberComponent, typesAt } from "./class-members.js";
-import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./roots/configured-declarations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must, Unanswerable } from "./query.js";

package/dist/src/source-files.js

@@ -5,12 +5,11 @@
  */
 import { commonDirectory, emittedFrom } from "./load/emit-map.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { OUTPUT_EXTENSIONS } from "./extensions.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
 /** The extension a source file's name drops when the project writes it out. */
 const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/u;
-/** The extensions the project may write a source file's output under. */
-const OUTPUT_EXTENSIONS = [".js", ".mjs", ".cjs", ".jsx", ".d.ts", ".d.mts", ".d.cts"];
 /**
  * Whether one path is what a subpath pattern stands for: the text before the
  * wildcard, any run of characters including the solidus, then the text after it.
@@ -43,13 +42,10 @@ function layoutOf(project, fileNames) {
     };
 }
 /**
- * The lookups over one project's own files.
- *
- * A path that names an emitted file is read back to the source the project would
- * emit it from through the project's own emit mapping and nothing else: the
- * extension is one the compiler emits from a source extension, and a path below the
- * output directory is read below the directory the compiler emits from, which the
- * configuration declares or which is the directory every input file shares.
+ * The lookups over one project's own files. A path naming an emitted file is read back to its
+ * source through the project's own emit mapping alone: the extension is one the compiler emits
+ * from a source extension, and a path below the output directory is read below the directory
+ * the compiler emits from, which the configuration declares or every input file shares.
  */
 export function sourceFilesOf(project, targetRoot) {
     const byName = new Map();

package/dist/src/suppress.js

@@ -4,9 +4,9 @@
  * ignore entry or a baseline row. A bound record marks its declaration live before the
  * sweep, unless its code reports a part or a dependency row, and is in effect when it
  * withholds a finding its code would have produced there, dormant when the configuration
- * withholds every such finding anyway, and stale otherwise.
+ * or a hold withholds every such finding anyway, and stale otherwise.
  */
-import { KIND_ROWS, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
+import { KIND_ROWS, REMEDIES, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
 import { UsageError } from "./usage.js";
 import { positionKey } from "./position.js";
 import { isRef } from "./ref.js";
@@ -66,6 +66,8 @@ export function isSymbolRef(value) {
 export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
+/** No hold. */
+const NO_HOLDS = { withholds: () => false, holdsRecord: () => false };
 /** The subject of the kind each live code names. */
 const SUBJECT_OF_CODE = new Map(KIND_ROWS.map((row) => [row.code, row.subject]));
 /** The subject a finding about one symbol kind is about. */
@@ -78,32 +80,25 @@ function subjectOf(kind) {
 function rowOf(subject) {
     return subject === "file" || subject === "dependency" || subject === "record";
 }
-/**
- * Whether a finding's subject is a row of a document rather than a declaration. Apart
- * from a dependency row, nothing withholds a finding about one.
- */
+/** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind) {
     return rowOf(subjectOf(kind));
 }
-/** Whether a code reports a row of a document. */
-export function isRowCode(code) {
-    return rowOf(SUBJECT_OF_CODE.get(code));
+/** The subject a code reports, which kinds.json's remedies table answers for. */
+export function subjectOfCode(code) {
+    return SUBJECT_OF_CODE.get(code);
 }
 /**
- * Whether a finding's subject is a dependency row. An ignore entry or a baseline row
- * naming the row's reference and file withholds its finding and marks nothing, and an
- * inline directive never binds one.
+ * Whether a record of `mechanism` can name a finding about `subject`, as kinds.json's
+ * remedies table lists the suppressions of each subject. A subject the table does not
+ * know is a declaration's.
  */
-export function isDependencySubject(kind) {
-    return subjectOf(kind) === "dependency";
-}
-/** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
-export function isDependencyCode(code) {
-    return SUBJECT_OF_CODE.get(code) === "dependency";
+export function names(subject, mechanism) {
+    return REMEDIES[subject ?? "declaration"].suppressions.includes(mechanism);
 }
-/** Whether a code reports a row of a document that no record of any mechanism can name. */
-export function isUnsuppressibleCode(code) {
-    return isRowCode(code) && !isDependencyCode(code);
+/** Whether a finding about a symbol of `kind` is one a record of `mechanism` can name. */
+export function namesKind(kind, mechanism) {
+    return names(subjectOf(kind), mechanism);
 }
 /**
  * Whether a finding's subject is a part of the declaration its reference names: a part
@@ -136,14 +131,13 @@ export function pairs(record, finding) {
     if (record.code !== finding.code) {
         return false;
     }
-    if (isDependencySubject(finding.symbol.kind)) {
-        return (record.mechanism !== "inline" &&
-            record.symbol === finding.symbol.ref &&
-            record.path === finding.position.path);
-    }
-    if (isRowSubject(finding.symbol.kind)) {
+    const subject = subjectOf(finding.symbol.kind);
+    if (!names(subject, record.mechanism)) {
         return false;
     }
+    if (subject === "dependency") {
+        return record.symbol === finding.symbol.ref && record.path === finding.position.path;
+    }
     if (record.bound !== "" && record.bound === positionKey(finding.position)) {
         return true;
     }
@@ -155,10 +149,10 @@ export function pairs(record, finding) {
  * there: swept with no mark for a liveness kind, and as swept otherwise. The first record
  * in reading order claims a finding, so a second naming it is stale; a part-kind record
  * claims every finding of its code about a part of its declaration. A record is dormant
- * when the dials withhold every finding it claims, read from those findings alone, or when
- * it claims none and its code's severity is `allow`.
+ * when the dials or `holds` withhold every finding it claims, or when it claims none and
+ * its code is at `allow` or a hold keeps its declaration live.
  */
-export function ledgerOf(records, would, dials) {
+export function ledgerOf(records, would, dials, holds = NO_HOLDS) {
     const taken = new Set();
     const verdicts = [];
     for (const record of records) {
@@ -166,13 +160,17 @@ export function ledgerOf(records, would, dials) {
         const first = would.find(open);
         const claimed = first === undefined ? [] : isPartKind(record.code) ? would.filter(open) : [first];
         if (claimed.length === 0) {
-            verdicts.push(record.bound !== "" && dials.allows(record.code) ? "dormant" : "stale");
+            verdicts.push(record.bound !== "" && (dials.allows(record.code) || holds.holdsRecord(record))
+                ? "dormant"
+                : "stale");
             continue;
         }
         for (const finding of claimed) {
             taken.add(claimKey(finding));
         }
-        verdicts.push(claimed.every((finding) => dials.withholds(finding)) ? "dormant" : "in-effect");
+        verdicts.push(claimed.every((finding) => dials.withholds(finding) || holds.withholds(finding))
+            ? "dormant"
+            : "in-effect");
     }
     return {
         verdicts,

package/dist/src/test-support.js

@@ -5,7 +5,7 @@
  * another such file, so it is judged with the tests: what it references is referenced by
  * test code.
  */
-import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.js";
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./entries/convention-rows.js";
 import { packageOfSpecifier } from "./dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
@@ -14,7 +14,9 @@ const SKIP_ROOT = "type-error";
  * convention row reads test files for, and the convention table's test libraries.
  */
 const TEST_PACKAGES = new Set([
-    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
+    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined ||
+        row.testDirectories !== undefined ||
+        row.testRunner !== undefined).map((row) => row.package),
     ...TEST_LIBRARIES,
 ]);
 /**

package/dist/src/verbs/analyze.js

@@ -3,6 +3,7 @@ import { runAnalysis, runBaselineWrite, unansweredCounts, } from "../analysis.js
 import { kindOf } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { analyzerProvenance, verdictOf } from "../findings-pass.js";
+import { factsDocument } from "../facts.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
 import { moduleIdentity } from "../load/discover.js";
 import { partialNotes } from "../partial.js";
@@ -21,7 +22,7 @@ import { diagnose, message } from "../product.js";
 import { ownVersion } from "./version.js";
 /** The options `analyze` takes beside the ones every verb takes. */
 export const ANALYZE_OPTIONS = {
-    plain: ["report", "baseline-write", "exit-code", "template"],
+    plain: ["report", "facts", "baseline-write", "exit-code", "template"],
     repeatable: ["format"],
 };
 /** The two values `--exit-code` takes; on, the default, puts the run's verdict in the exit code. */
@@ -211,8 +212,13 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     const { config, provenance } = resolve(inputs());
     const invoked = host.workingDirectory();
     const baseline = option("baseline-write");
+    const facts = option("facts");
+    if (facts === "") {
+        throw new UsageError("--facts names the path the facts document is written to, and named none");
+    }
     const documents = {
         report: resolvePath(invoked, reportPath),
+        facts: facts === undefined ? undefined : resolvePath(invoked, facts),
         formats: formatsOf(repeated("format"), config.reporters.formats),
         baseline: baseline === undefined ? undefined : resolvePath(invoked, baseline),
     };
@@ -281,6 +287,12 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         throw productFault(`built a report that breaks the report schema at ${refused.pointer || "the document"}: ${refused.keyword}: ${refused.reason}`);
     }
     writeDocument(host, documents.report, "name a path the run can write", () => json(report));
+    const factsPath = documents.facts;
+    if (factsPath !== undefined) {
+        writeDocument(host, factsPath, "name a path the run can write", () => [
+            factsDocument(version, run.generated),
+        ]);
+    }
     const options = {
         readSource: (path) => host.readFile(joinPath(targetRoot, path)),
         template,

package/dist/src/verbs/describe.js

@@ -1,12 +1,13 @@
-import { CONTRACT_VERSION, EXIT_CLEAN, EXIT_USAGE, SCHEMA_VERSIONS, } from "../contract/contract.generated.js";
+import { CONTRACT_VERSION, EXIT_CLEAN, EXIT_USAGE, FACTS_VERSION, SCHEMA_VERSIONS, } from "../contract/contract.generated.js";
 import { CONFORMANCE } from "../conformance.js";
 import {} from "./verb.js";
 import { diagnose, LANGUAGE, PRODUCT } from "../product.js";
 import { ownVersion } from "./version.js";
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
- * report schema versions it reads, the languages it claims, and its recorded result over
- * the conformance corpus, a member the document omits where no run is recorded.
+ * report schema versions it reads, the languages it claims, the facts version it writes,
+ * and its recorded result over the conformance corpus, a member the document omits where
+ * no run is recorded.
  */
 export function describeDocument(version, recorded) {
     const document = {
@@ -15,6 +16,7 @@ export function describeDocument(version, recorded) {
         contract_version: CONTRACT_VERSION,
         schema_versions_accepted: SCHEMA_VERSIONS,
         languages: [LANGUAGE],
+        facts_version_written: FACTS_VERSION,
         ...(recorded === undefined
             ? {}
             : {

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.15",
+  "version": "8.0.0-dev.16",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.15",
+  "version": "8.0.0-dev.16",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -32,7 +32,7 @@
     "lint:fix": "eslint . --fix && prettier --write ."
   },
   "dependencies": {
-    "@typescript/native": "npm:typescript@7.1.0-dev.20261029.1"
+    "@typescript/native": "npm:typescript@7.1.0-dev.20261103.1"
   },
   "overrides": {
     "qs": "^6.15.2"

package/src/analysis.ts

@@ -14,17 +14,19 @@ import {
   configuredDeclarations,
   configuredRef,
   declarationsNamed,
-} from "./configured-declarations.ts";
+} from "./roots/configured-declarations.ts";
 import { decorator } from "./decorator.ts";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.ts";
 import { deprecatedDeclarations, type Deprecation } from "./deprecation.ts";
 import { moduleIdentity, type LoadedConsumer, type NotBuilt } from "./load/discover.ts";
 import type { LibraryUnfound } from "./load/classify.ts";
 import { loadRun, type LoadedRun } from "./load/load.ts";
-import { generatedFiles, type AppliedConvention } from "./conventions.ts";
+import type { AppliedConvention } from "./entries/conventions.ts";
+import { readSources, type SourceFacts } from "./entries/sources.ts";
+import { readWorkflows, type Workflows } from "./entries/workflow-steps.ts";
 import { readEdgeSides } from "./edges.ts";
 import { enumGroup } from "./enum-group.ts";
-import { generatedFile, generatedFilesOf } from "./generated-file.ts";
+import { generatedFile, generatedFilesOf, type GeneratedFact } from "./generated-file.ts";
 import { inOperandNames } from "./in-operands.ts";
 import { sourceFilesOf } from "./source-files.ts";
 import {
@@ -53,7 +55,7 @@ import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfac
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
 import { type Inventory, type InventorySymbol } from "./inventory.ts";
 import { inventory } from "./inventory/enumerate.ts";
-import { readManifest, type ManifestEntry } from "./manifest.ts";
+import { readManifest, type ManifestEntry } from "./roots/manifest.ts";
 import {
   liveFilesAt,
   matrixOf,
@@ -74,22 +76,20 @@ import {
 import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
 import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
-import { skippedRoots, skippedUnits, type SkippedUnit } from "./type-errors.ts";
+import { skippedUnits, type SkippedUnit } from "./type-errors.ts";
 import { reflectiveLookup } from "./reflective-lookup.ts";
 import { references, testFileRulesOf, type Reference, type TestFileRule } from "./references.ts";
 import {
-  roots,
+  rootSet,
   unmatchedEverywhere,
-  type Root,
   type RootKind,
   type Roots,
   type HeldScripts,
-} from "./roots.ts";
+} from "./roots/root-set.ts";
 import type { Scope } from "./scope.ts";
 import { decodedMembers, serializationContract, type Decoded } from "./serialization-contract.ts";
 import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
-import { mergedGlobalInterfaces } from "./augmentations.ts";
-import { unseenLoadsOf, type UnseenLoad } from "./unseen-loads.ts";
+import type { UnseenLoad } from "./roots/unseen-loads.ts";
 import type { UnresolvedSpecifier } from "./load/specifiers.ts";
 import type { UnreadInput } from "./load/plan.ts";
 import { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.ts";
@@ -103,6 +103,7 @@ import type { Exemption, Mode, SweepInput } from "./sweep.ts";
 import { readTemplates, templateField } from "./template-field.ts";
 import { bytewise } from "./text/compare.ts";
 import { holdsManifest, manifestAt } from "./fs/manifest.ts";
+import { runDirectories } from "./entries/run-directories.ts";
 import { globExpression } from "./text/glob.ts";
 
 /** The setting whose source decides where a finding about a configured root sits. */
@@ -176,10 +177,10 @@ interface ProjectRead {
   readonly typeErrorSkips: readonly TypeErrorSkip[];
   /** The lines each of those skips withholds every finding on. */
   readonly skipped: readonly SkippedUnit[];
-  /** The project's generated files, by path below the target root, each with the detail its retentions name. */
-  readonly generated: ReadonlyMap<string, string>;
-  /** The files, absolute, an applied convention row names as test files. */
-  readonly testFileNames: ReadonlySet<string>;
+  /** The project's generated files, by path below the target root, each with what decided it. */
+  readonly generated: ReadonlyMap<string, GeneratedFact>;
+  /** What the project's entry sources enter and name, read once. */
+  readonly sources: SourceFacts;
 }
 
 /** One target project the run analyzes, as its stage is handed it. */
@@ -196,6 +197,8 @@ interface ProjectsRead<Answer> {
   readonly references: readonly Reference[];
   /** The test files below the target root no project the run reads holds, parsed. */
   readonly outsideTests: readonly OutsideTest[];
+  /** The target root's workflow steps, git hooks and makefile, read once for every project. */
+  readonly workflows: Workflows;
 }
 
 /**
@@ -216,14 +219,13 @@ function readProjects<Answer>(
   const parse = (fileName: string, text: string) => 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,
@@ -233,19 +235,17 @@ function readProjects<Answer>(
     const answers = classified.analyzed.map(({ plan: planned, project, skips, referenceOnly }) => {
       const read = (): ProjectRead => {
         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" as const, 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 });
         return {
           configuration: planned.id,
           configFile: project.configFile,
@@ -257,8 +257,8 @@ function readProjects<Answer>(
             .ownSourceFiles()
             .filter((file) => referenceOnly(file.fileName))
             .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
-          generated: generatedFilesOf(own, generatedFiles(conventions, own)),
-          testFileNames: conventions.testFiles,
+          generated: generatedFilesOf(own, sources.generated),
+          sources,
         };
       };
       for (const file of project.ownSourceFiles()) {
@@ -269,7 +269,7 @@ function readProjects<Answer>(
     const consumed = new Map<string, Reference>();
     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)) {
+      for (const reference of consumerReferences(project, host, targetRoot, side, config, parse)) {
         consumed.set(referenceKey(reference), reference);
       }
     }
@@ -281,7 +281,7 @@ function readProjects<Answer>(
       ),
       parse,
     );
-    return { answers, references: [...consumed.values()], outsideTests };
+    return { answers, references: [...consumed.values()], outsideTests, workflows };
   });
 }
 
@@ -463,8 +463,6 @@ interface ReadProject<Extra> {
   readonly componentWarnings: readonly ComponentWarning[];
   /** Per own file below the target root, the module specifiers its imports write. */
   readonly imports: ReadonlyMap<string, readonly string[]>;
-  /** The global augmentations a declaration outside the project names. */
-  readonly augmented: readonly Root[];
   /** The data members its production code decodes into. */
   readonly decoded: Decoded;
   readonly extra: Extra;
@@ -499,6 +497,8 @@ interface ReadRun<Extra> {
   readonly memberDirs: readonly string[];
   /** The directory of every nested package, absolute. */
   readonly nestedDirs: readonly string[];
+  /** The target root's workflow steps, git hooks and makefile, read once. */
+  readonly workflows: Workflows;
 }
 
 /** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
@@ -564,6 +564,7 @@ function readRun<Extra>(
     read: ProjectRead,
     references: readonly Reference[],
     testFiles: readonly string[],
+    unseenLoads: readonly UnseenLoad[],
   ) => Extra,
 ): ReadRun<Extra> {
   const targetRoot = scope.target.path;
@@ -572,11 +573,15 @@ function readRun<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<ReadProject<Extra>>(engine, host, scope, config, (project, opened) => {
     const projectRead = opened.read();
     const resolved = references(project, projectRead.held, targetRoot, {
       testFiles: config.ts.test_files,
-      testFileNames: projectRead.testFileNames,
+      testFileNames: projectRead.sources.testFiles,
+      directories,
     });
     const evidence = evidenceRecords(
       {
@@ -605,11 +610,6 @@ function readRun<Extra>(
       testFiles: resolved.testFilePaths,
       evidence,
       componentFiles: components.map(pathOf),
-      augmented: mergedGlobalInterfaces(
-        project,
-        projectRead.held,
-        sourceFilesOf(project, targetRoot),
-      ).map((id): Root => ({ id, kind: "global-augmentation", source: "" })),
       imports: new Map(
         project.ownSourceFiles().flatMap((file) => {
           const path = relativePath(targetRoot, file.fileName);
@@ -641,7 +641,16 @@ function readRun<Extra>(
         productionFiles(project, targetRoot, resolved.testFilePaths),
         consumers,
       ),
-      extra: extra(project, projectRead, resolved.references, resolved.testFilePaths),
+      extra: extra(
+        project,
+        projectRead,
+        resolved.references,
+        resolved.testFilePaths,
+        resolved.unseenLoads.map((position) => ({
+          configuration: projectRead.configuration,
+          position,
+        })),
+      ),
     };
   });
   const outsidePaths = read.result.outsideTests.map((one) => one.path);
@@ -658,7 +667,12 @@ function readRun<Extra>(
   const { support, testUsed } = testSupportFiles(
     withOutside.flatMap((one) => one.projectRead.held.symbols),
     withOutside.flatMap((one) => one.references),
-    withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability),
+    // 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),
   );
@@ -699,9 +713,7 @@ function readRun<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 }),
@@ -769,6 +781,7 @@ function readRun<Extra>(
     conventionUses: read.plan.conventions.uses,
     memberDirs: read.plan.packages.members,
     nestedDirs: read.plan.packages.nested,
+    workflows: read.result.workflows,
   };
 }
 
@@ -958,7 +971,7 @@ interface EmitterExtra {
   readonly needs: ReturnType<typeof projectNeeds>;
   readonly implementations: ReturnType<typeof implementations>;
   readonly heldByInclusion: readonly string[];
-  readonly generated: readonly string[];
+  readonly generated: ReadonlyMap<string, GeneratedFact>;
   readonly inOperands: readonly string[];
   readonly rooted: Roots;
   readonly directives: readonly InlineDirective[];
@@ -996,15 +1009,21 @@ export function readEmitterRun(
     config,
     mode,
     detectors,
-    (project, read, references, testFiles) => ({
+    (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,
       inOperands: inOperandNames(project, targetRoot, testFiles),
       rooted: read.rooted,
       directives: inlineDirectives(project, read.held, targetRoot).filter(
@@ -1012,7 +1031,7 @@ export function readEmitterRun(
       ),
       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
@@ -1101,6 +1120,7 @@ export function emitterInputOver(
     dependencies: dependenciesOf(
       host,
       targetRoot,
+      read.workflows,
       [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)],
       swept.sweep.candidates.map((candidate) => candidate.id),
       members.read,
@@ -1111,7 +1131,7 @@ export function emitterInputOver(
     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),
     },
@@ -1211,6 +1231,7 @@ function readAnalysis(
         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])),
     },
     configured: read.projects.map((one) => one.configured),
     symbols,
@@ -1317,6 +1338,8 @@ interface RunFacts {
   readonly heldScripts: readonly (HeldScripts & { readonly configFile: string })[];
   /** The loads of production files whose target the run cannot resolve, per configuration. */
   readonly unseenLoads: readonly UnseenLoad[];
+  /** Every generated file of the run, by its path below the target root, each once. */
+  readonly generated: ReadonlyMap<string, GeneratedFact>;
 }
 
 /** One configuration whose component files a run cannot read. */

package/src/automatic-types.ts

@@ -25,7 +25,7 @@ import {
   type SourceFile,
   type Statement,
 } from "@typescript/native/ast";
-import type { ParseFile } from "./configuration-files.ts";
+import type { ParseFile } from "./entries/configuration-files.ts";
 import type { Host } from "./host.ts";
 import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.ts";
 import { entriesOf } from "./fs/tree.ts";