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

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 {
@@ -51,8 +53,9 @@ import { implementations, mergeImplementations } from "./implementations.ts";
 import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
-import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { readManifest, type ManifestEntry } from "./manifest.ts";
+import { type Inventory, type InventorySymbol } from "./inventory.ts";
+import { inventory } from "./inventory/enumerate.ts";
+import { readManifest, type ManifestEntry } from "./roots/manifest.ts";
 import {
   liveFilesAt,
   matrixOf,
@@ -73,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";
@@ -102,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. */
@@ -175,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. */
@@ -195,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;
 }
 
 /**
@@ -215,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,
@@ -232,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,
@@ -256,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()) {
@@ -268,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);
       }
     }
@@ -280,7 +281,7 @@ function readProjects<Answer>(
       ),
       parse,
     );
-    return { answers, references: [...consumed.values()], outsideTests };
+    return { answers, references: [...consumed.values()], outsideTests, workflows };
   });
 }
 
@@ -462,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;
@@ -498,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. */
@@ -563,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;
@@ -571,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(
       {
@@ -604,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);
@@ -640,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);
@@ -657,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),
   );
@@ -698,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 }),
@@ -768,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,
   };
 }
 
@@ -957,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[];
@@ -995,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(
@@ -1011,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
@@ -1100,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,
@@ -1110,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),
     },
@@ -1210,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,
@@ -1316,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";

package/src/commands/read.ts

@@ -1,8 +1,8 @@
 /**
  * The one reader of every command string the analysis reads. Layer 3, the holding rule
- * `roots.ts` applies through `text/named-files.ts`, reads all of the string's text whatever
- * the other two layers make of it; layer 1 parses the string and layer 2 reads each simple
- * command a tool's reader understands, and they only add the files and modules it runs.
+ * `roots/root-set.ts` applies through `text/named-files.ts`, reads all of the string's text
+ * whatever the other two layers make of it; layer 1 parses the string and layer 2 reads each
+ * simple command a tool's reader understands, and they only add the files and modules it runs.
  */
 
 import { joinPath, resolvePath } from "../paths.ts";
@@ -16,6 +16,7 @@ import {
   type Preload,
   type Reading,
 } from "./tools.ts";
+import { APPENDED_EXTENSIONS } from "../extensions.ts";
 
 /** One program a read command runs. */
 interface Run {
@@ -159,9 +160,6 @@ export function readCommands(text: string, dir: string | undefined): CommandRead
   };
 }
 
-/** The extensions a runtime or a loader tries after a path written without one. */
-const TRIED_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"] as const;
-
 /** One file a run loads, as written, and every absolute path it may be at. */
 interface Load {
   readonly written: string;
@@ -188,8 +186,8 @@ export function loadsOf(run: Run): readonly Load[] {
     written: one,
     paths: [
       path,
-      ...TRIED_EXTENSIONS.map((extension) => `${path}${extension}`),
-      ...TRIED_EXTENSIONS.map((extension) => joinPath(path, `index${extension}`)),
+      ...APPENDED_EXTENSIONS.map((extension) => `${path}${extension}`),
+      ...APPENDED_EXTENSIONS.map((extension) => joinPath(path, `index${extension}`)),
     ],
   }));
 }

package/src/conformance-record.ts

@@ -4,7 +4,7 @@ export const RECORD = {
   conformance: {
     corpusVersion: "6.0.0",
     result: "pass",
-    digest: "sha256:58ac31fa90fcbefdbbcbcbd6d2c7a8af6dd4cd883c04d79abfe96f979ffe10e1",
+    digest: "sha256:d8d2a417c5cb9b3829739424d9cfd3bd7b631231d8f420300656f6df86f5a6d1",
   },
   gaps: [],
 } as const;

package/src/consumers.ts

@@ -1,6 +1,8 @@
 import type { PartialConfig } from "./config.ts";
+import type { ParseFile } from "./entries/configuration-files.ts";
+import { runDirectories } from "./entries/run-directories.ts";
 import type { Host } from "./host.ts";
-import { inventory } from "./inventory.ts";
+import { inventory } from "./inventory/enumerate.ts";
 import { relativePath } from "./paths.ts";
 import { references, type ConsumerSide, type Reference } from "./references.ts";
 import { narrowedTo, type ProjectView } from "./session.ts";
@@ -18,6 +20,7 @@ export function consumerReferences<Brand>(
   targetRoot: string,
   consumer: ConsumerSide,
   config: PartialConfig,
+  parse: ParseFile,
 ): readonly Reference[] {
   const held = inventory(
     narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined),
@@ -27,6 +30,7 @@ export function consumerReferences<Brand>(
   const found = references(project, held, targetRoot, {
     testFiles: config.ts.test_files,
     consumer,
+    directories: runDirectories(host, consumer.root, parse),
   }).references;
   if (config.analysis.consumer_tests !== "production") {
     return found;

package/src/contract/config.generated.ts

@@ -291,7 +291,7 @@ export const SETTINGS: readonly SettingRow[] = [
     role: "setting",
     read: true,
     default: [
-      "**/*.test.{ts,tsx,mts,cts}",
+      "**/*.test.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
       "**/*.test-d.{ts,tsx,mts,cts}",
       "**/*.spec-d.{ts,tsx,mts,cts}",
       "**/*.spec.*",

package/src/contract/contract.generated.ts

@@ -3,6 +3,7 @@
 export const CONTRACT_VERSION = "8.0.0";
 export const SCHEMA_VERSIONS = ["9.0.0"] as const;
 export const SCHEMA_VERSION = "9.0.0";
+export const FACTS_VERSION = "1.0.0";
 export const CORPUS_VERSION = "6.0.0";
 export const CODE_PREFIX = "DS";
 export const FAMILY_KEY_LENGTH = 4;
@@ -34,16 +35,19 @@ export const LANGUAGE_ROWS = {
     analyzer: "deadset-go",
     markers: ["go.mod"],
     skippedDirectories: ["node_modules", "testdata", "vendor", ".*", "_*"],
+    skippedFiles: ["_*", ".*"],
   },
   ts: {
     analyzer: "deadset-ts",
     markers: ["tsconfig*.json", "jsconfig*.json"],
     skippedDirectories: ["node_modules", ".git"],
+    skippedFiles: ["*.min.js", "*.min.cjs", "*.min.mjs"],
   },
   proto: {
     analyzer: "deadset-proto",
     markers: ["buf.yaml", "buf.work.yaml"],
     skippedDirectories: ["node_modules", "vendor", ".*"],
+    skippedFiles: [],
   },
 } as const satisfies Readonly<
   Partial<
@@ -53,6 +57,7 @@ export const LANGUAGE_ROWS = {
         readonly analyzer: string;
         readonly markers: readonly string[];
         readonly skippedDirectories: readonly string[];
+        readonly skippedFiles: readonly string[];
       }
     >
   >
@@ -494,9 +499,9 @@ export const KIND_ROWS = [
     languages: ["go", "ts"],
     subject: "dependency",
     holdsLive: false,
-    rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency. On the TypeScript side, a needed dependency whose every use is written inside declarations that are members of the run's dead components, or at the top level of a file reported under DS1602, that no command runs and that no needed dependency used otherwise names as a peer, is reported as well, dead only through that code: at the reachability class possible where one of those declarations belongs to a library's published API, and found under reachability alone where one of those declarations or files is, so at probable unless ts.roots_complete is true. A use the configuration makes, a use an unanswered specifier may make and an import none of whose bindings is used are uses by live code.",
+    rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency. On the TypeScript side, a needed dependency whose every use is written inside declarations that are members of the run's dead components, or at the top level of a file reported under DS1602, that no command runs and that no needed dependency used otherwise names as a peer, is reported as well, dead only through that code: at the reachability class possible where one of those declarations belongs to a library's published API, and found under reachability alone where one of those declarations or files is, so at probable unless ts.roots_complete is true. A use the configuration makes, a use an unanswered specifier or callee may make and an import none of whose bindings is used are uses by live code.",
     precondition:
-      "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and a call of `import.meta.resolve` or of `require.resolve` in them, whatever `require` names, whose first argument is a string literal or a template literal with no substitution needs each dependency an import of that specifier needs. A `@types/<name>` package in a type root of a compiler configuration that lists no `types`, a `node_modules/@types` directory at or above the configuration's directory or a `typeRoots` entry naming one, is needed by a use, in a file of that configuration, of a global name or an ambient module that one of the package's declaration files declares, which resolves to no declaration of the program: a compiler before version 6 includes every package of the type roots where `types` is not listed, and version 6 and later include none, so the program the analysis builds holds none of those declarations. A package's declaration files are the file its `types` or `typings` names, else its `index.d.ts`, and each file a `/// <reference path>` of one of them reaches inside the package. A global is a top-level declaration of such a file that is no module, or a declaration of a `declare global` block of one that is, and an ambient module is a `declare module` with a string name of a file that is no module. A name that names a member, a property or a label is no use of a global. Four more dependencies are needed: one whose command a script entry, a workflow step or a git hook runs, one that a string of a configuration file names, and one that a string names under a manifest key or a package key of an applied convention row, each as grammar/analysis/conventions.md states, and one that a needed dependency names as a peer, as stated below. A command no script entry, workflow step or git hook runs needs nothing. A declared dependency that the installed manifest of a needed declared dependency names in its peerDependencies is needed, and so on until no further dependency joins. A peer dependency is a package the needed dependency expects beside it at a version its manifest states, whether or not it imports the package, and the project's declaration is what keeps that package present at a version the project chooses, so removing the declaration can break the needed dependency where nothing the analysis reads imports the peer. A peer that peerDependenciesMeta marks optional is needed in the same way, because the needed dependency's manifest still names it as a package it works with, and a package manager may leave an optional peer out where the project does not declare it, so the project's declaration is what keeps it present for the needed dependency. A declared dependency that only dependencies nothing needs name as a peer is needed by nothing. A dependency of a manifest whose directory holds source only in configurations the run lists in configurations_not_built is reported at the reachability class possible, because the source that may import it was not analyzed. An installed manifest is the package's manifest in the nearest node_modules directory at or above the directory of the manifest that declares the dependency, and a dependency with none is decided by the import closure alone. On the TypeScript side, the dependencies judged are those of every manifest grammar/analysis/program.md says the analysis reads, a nested package's among them, each read against its own directory: a dependency is needed by a use written in a file at or below the directory of the manifest that declares it where no manifest between them declares a dependency of the same name, so a use below a nested manifest that declares the same dependency needs that nested manifest's declaration only, by a use no one file holds, and as a peer of a needed dependency of the same manifest or of a manifest below it. A dependency a nested package's manifest declares whose installed manifest the analysis cannot find is not judged, because no run requires a nested package to be installed and its commands and peers cannot be read, while a workspace member's and the target's own are judged as above.",
+      "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and a `require()` call as `roots.23` reads one, or a call of `import.meta.resolve`, of `require.resolve`, whatever `require` names, or of `resolve` on another name that is such a `require`, in them, whose first argument is a string literal or a template literal with no substitution needs each dependency an import of that specifier needs. A `@types/<name>` package in a type root of a compiler configuration that lists no `types`, a `node_modules/@types` directory at or above the configuration's directory or a `typeRoots` entry naming one, is needed by a use, in a file of that configuration, of a global name or an ambient module that one of the package's declaration files declares, which resolves to no declaration of the program: a compiler before version 6 includes every package of the type roots where `types` is not listed, and version 6 and later include none, so the program the analysis builds holds none of those declarations. A package's declaration files are the file its `types` or `typings` names, else its `index.d.ts`, and each file a `/// <reference path>` of one of them reaches inside the package. A global is a top-level declaration of such a file that is no module, or a declaration of a `declare global` block of one that is, and an ambient module is a `declare module` with a string name of a file that is no module. A name that names a member, a property or a label is no use of a global. Four more dependencies are needed: one whose command a script entry, a workflow step or a git hook runs, one that a string of a configuration file names, and one that a string names under a manifest key or a package key of an applied convention row, each as grammar/analysis/conventions.md states, and one that a needed dependency names as a peer, as stated below. A command no script entry, workflow step or git hook runs needs nothing. A declared dependency that the installed manifest of a needed declared dependency names in its peerDependencies is needed, and so on until no further dependency joins. A peer dependency is a package the needed dependency expects beside it at a version its manifest states, whether or not it imports the package, and the project's declaration is what keeps that package present at a version the project chooses, so removing the declaration can break the needed dependency where nothing the analysis reads imports the peer. A peer that peerDependenciesMeta marks optional is needed in the same way, because the needed dependency's manifest still names it as a package it works with, and a package manager may leave an optional peer out where the project does not declare it, so the project's declaration is what keeps it present for the needed dependency. A declared dependency that only dependencies nothing needs name as a peer is needed by nothing. A dependency of a manifest whose directory holds source only in configurations the run lists in configurations_not_built is reported at the reachability class possible, because the source that may import it was not analyzed. An installed manifest is the package's manifest in the nearest node_modules directory at or above the directory of the manifest that declares the dependency, and a dependency with none is decided by the import closure alone. On the TypeScript side, the dependencies judged are those of every manifest grammar/analysis/program.md says the analysis reads, a nested package's among them, each read against its own directory: a dependency is needed by a use written in a file at or below the directory of the manifest that declares it where no manifest between them declares a dependency of the same name, so a use below a nested manifest that declares the same dependency needs that nested manifest's declaration only, by a use no one file holds, and as a peer of a needed dependency of the same manifest or of a manifest below it. A dependency a nested package's manifest declares whose installed manifest the analysis cannot find is not judged, because no run requires a nested package to be installed and its commands and peers cannot be read, while a workspace member's and the target's own are judged as above.",
     details: { dependency_class: "required" },
     defaultEnabled: true,
     defaultSeverity: "deny",
@@ -769,6 +774,49 @@ export const SYMBOL_SUBJECTS = {
   edge: "record",
 } as const satisfies Readonly<Record<string, Subject>>;
 
+export const REMEDIES = {
+  declaration: {
+    names: "a declaration",
+    suppressions: ["inline", "ignore", "baseline"],
+    remedy: "delete the symbol, or wire it up so the program uses it",
+  },
+  binding: {
+    names: "an import binding",
+    suppressions: ["inline", "ignore", "baseline"],
+    remedy: "delete the import, or use what it binds",
+  },
+  part: {
+    names: "a part of a declaration",
+    suppressions: ["inline", "ignore", "baseline"],
+    remedy: "remove the part, or use it",
+  },
+  file: {
+    names: "a file",
+    suppressions: [],
+    remedy:
+      "delete the file, name it as a root, or build it in a configuration of the build matrix",
+  },
+  dependency: {
+    names: "a dependency row",
+    suppressions: ["ignore", "baseline"],
+    remedy: "remove the dependency",
+  },
+  record: {
+    names: "a record of deadset's own configuration",
+    suppressions: [],
+    remedy: "correct or remove the record the finding names",
+  },
+} as const satisfies Readonly<
+  Record<
+    Subject,
+    {
+      readonly names: string;
+      readonly suppressions: readonly ("inline" | "ignore" | "baseline")[];
+      readonly remedy: string;
+    }
+  >
+>;
+
 export const EXEMPTION_CLASSES = [
   {
     class: "interface-satisfaction",
@@ -1283,6 +1331,93 @@ export const EVIDENCE = [
   },
 ] as const;
 
+/** The generators whose TypeScript output a generated file is matched against, in the document's order. */
+export const GENERATORS = [
+  {
+    id: "protoc-gen-es-2",
+    plugin: "protoc-gen-es",
+    header: "^// @generated by protoc-gen-es v2\\.",
+    versions: { min: "v2.10.0", max: "v2.16.0" },
+    cell: "exact",
+  },
+  {
+    id: "protoc-gen-es-2-fallback",
+    plugin: "protoc-gen-es",
+    header: "^// @generated by protoc-gen-es v2\\.",
+    cell: "fallback",
+  },
+  {
+    id: "protoc-gen-es-1",
+    plugin: "protoc-gen-es",
+    header: "^// @generated by protoc-gen-es v1\\.",
+    cell: "exact",
+  },
+  {
+    id: "protoc-gen-connect-es-1",
+    plugin: "protoc-gen-connect-es",
+    header: "^// @generated by protoc-gen-connect-es v1\\.",
+    cell: "exact",
+  },
+  {
+    id: "ts-proto-2-output-schema",
+    plugin: "ts-proto",
+    header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+    versions: { min: "v2.11.4", max: "v2.15.0" },
+    cell: "exact",
+  },
+  {
+    id: "ts-proto-2",
+    plugin: "ts-proto",
+    header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+    versions: { min: "v2.11.4", max: "v2.15.0" },
+    cell: "rpc-types-fallback",
+  },
+  {
+    id: "ts-proto-2-types",
+    plugin: "ts-proto",
+    header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+    versions: { min: "v2.11.4", max: "v2.15.0" },
+    cell: "fallback",
+  },
+  {
+    id: "ts-proto-2-fallback",
+    plugin: "ts-proto",
+    header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+    cell: "fallback",
+  },
+  {
+    id: "protoc-gen-js",
+    plugin: "protoc-gen-js",
+    header: "^// GENERATED CODE -- DO NOT EDIT!$",
+    cell: "fallback",
+  },
+  {
+    id: "protoc-gen-grpc-web",
+    plugin: "protoc-gen-grpc-web",
+    header: "^// Code generated by protoc-gen-grpc-web\\. DO NOT EDIT\\.$",
+    cell: "fallback",
+  },
+  {
+    id: "protobuf-ts",
+    plugin: "protobuf-ts",
+    header: "^// @generated by protobuf-ts ",
+    cell: "fallback",
+  },
+  { id: "ts-protoc-gen", plugin: "ts-protoc-gen", header: "^// package: ", cell: "fallback" },
+  {
+    id: "protoc-gen-es-unsupported",
+    plugin: "protoc-gen-es",
+    header: "^// @generated by protoc-gen-es v(?:0|[3-9]|[1-9][0-9]+)\\.",
+    cell: "unsupported",
+  },
+] as const satisfies readonly {
+  readonly id: string;
+  readonly plugin: string;
+  readonly header: string;
+  readonly versions?: { readonly min: string; readonly max: string };
+  readonly cell: string;
+}[];
+
 /** Each group of failure classes, and the text opening the line that names one of its failures. */
 export const FAILURE_PREFIXES = { setup: "setup failure: ", run: "run failure: " } as const;
 
@@ -1294,9 +1429,11 @@ export const FAILURE_CLASSES = {
   "workspace-member-without-source": "setup",
   "convention-not-literal": "setup",
   "no-program": "setup",
+  "unreadable-configuration": "setup",
   "unreadable-document": "setup",
   "missing-import-path": "setup",
   "binding-undecodable": "setup",
+  "unsupported-language": "setup",
   "unwritten-output": "run",
   "unreportable-path": "run",
   "memory-exhausted": "run",