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

package/dist/src/analysis.js

@@ -9,13 +9,14 @@ 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 { generatedFile, generatedFilesOf } from "./generated-file.js";
@@ -32,18 +33,16 @@ import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfac
 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 { 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 { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.js";
 import { supportReferences, testSupportFiles } from "./test-support.js";
 import { accessorsOf, storesOf } from "./stores.js";
@@ -53,6 +52,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 +82,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 +98,17 @@ 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 });
                 return {
                     configuration: planned.id,
                     configFile: project.configFile,
@@ -122,8 +120,8 @@ 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: generatedFilesOf(own, sources.generated),
+                    sources,
                 };
             };
             for (const file of project.ownSourceFiles()) {
@@ -134,12 +132,12 @@ function readProjects(engine, host, scope, config, stage) {
         const consumed = new Map();
         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);
             }
         }
         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()], outsideTests, workflows };
     });
 }
 /**
@@ -267,11 +265,13 @@ 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 resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.test_files,
-            testFileNames: projectRead.testFileNames,
+            testFileNames: projectRead.sources.testFiles,
+            directories,
         });
         const evidence = evidenceRecords({
             project,
@@ -295,7 +295,6 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             testFiles: resolved.testFilePaths,
             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) {
@@ -318,7 +317,10 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 reason: warning.reason,
             }))),
             decoded: decodedMembers(project, projectRead.held, 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);
@@ -332,7 +334,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),
@@ -363,9 +367,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 }),
@@ -431,6 +433,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,
     };
 }
 /**
@@ -582,19 +585,19 @@ 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,
         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.
@@ -658,12 +661,12 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             references: one.configured.references,
             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),
         },
@@ -721,6 +724,7 @@ 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])),
         },
         configured: read.projects.map((one) => one.configured),
         symbols,

package/dist/src/commands/read.js

@@ -1,12 +1,13 @@
 /**
  * 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.js";
 import { shellLine } from "./shell.js";
 import { configurationsOf, preloadTarget, readBuiltin, readTool, } from "./tools.js";
+import { APPENDED_EXTENSIONS } from "../extensions.js";
 /**
  * The outcomes of one pipeline run in `dir`: those of the builtin that is its one member, as
  * `readBuiltin` gives them, a directory the analysis does not know after a part layer 1 does
@@ -104,8 +105,6 @@ export function readCommands(text, dir) {
         held: text,
     };
 }
-/** 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"];
 /**
  * The files `run` loads: its entry, and each preload written as a path. Each may be at its
  * path, with each extension tried, and as a directory's `index` file.
@@ -126,8 +125,8 @@ export function loadsOf(run) {
         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/dist/src/conformance-record.js

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

package/dist/src/consumers.js

@@ -1,3 +1,4 @@
+import { runDirectories } from "./entries/run-directories.js";
 import { inventory } from "./inventory/enumerate.js";
 import { relativePath } from "./paths.js";
 import { references } from "./references.js";
@@ -9,11 +10,12 @@ import { narrowedTo } from "./session.js";
  * own projects give it. A reference from a consumer's test file is a test reference
  * unless the configuration counts it as a production one.
  */
-export function consumerReferences(project, host, targetRoot, consumer, config) {
+export function consumerReferences(project, host, targetRoot, consumer, config, parse) {
     const held = inventory(narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined), host, targetRoot);
     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/dist/src/contract/config.generated.js

@@ -273,7 +273,7 @@ export const SETTINGS = [
         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/dist/src/contract/contract.generated.js

@@ -2,6 +2,7 @@
 export const CONTRACT_VERSION = "8.0.0";
 export const SCHEMA_VERSIONS = ["9.0.0"];
 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;
@@ -25,16 +26,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: [],
     },
 };
 export const EXIT_CLEAN = 0;
@@ -441,8 +445,8 @@ 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.",
-        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.",
+        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 `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",
@@ -708,6 +712,38 @@ export const SYMBOL_SUBJECTS = {
     "configured-declaration": "record",
     edge: "record",
 };
+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",
+    },
+};
 export const EXEMPTION_CLASSES = [
     {
         class: "interface-satisfaction",
@@ -1220,6 +1256,86 @@ export const EVIDENCE = [
         codes: ["DS1801", "DS1802", "DS1803", "DS1804", "DS1805"],
     },
 ];
+/** 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",
+    },
+];
 /** 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: " };
 /** Each failure class the Contract names, and its group. */
@@ -1230,6 +1346,7 @@ 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",