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

package/dist/src/{workflow-steps.js → entries/workflow-steps.js}

@@ -4,11 +4,11 @@
  * it runs in. A workflow or hook manager file is read by `text/yaml.ts`, and one it does not
  * read gives no command; each command is read by `commands/read.ts`.
  */
-import { pathsNamed, readCommands } from "./commands/read.js";
-import { isRecord } from "./json-document.js";
-import { joinPath, resolvePath } from "./paths.js";
-import { filesIn } from "./fs/tree.js";
-import { yamlDocument } from "./text/yaml.js";
+import { pathsNamed, readCommands } from "../commands/read.js";
+import { isRecord } from "../json-document.js";
+import { joinPath, resolvePath } from "../paths.js";
+import { filesIn } from "../fs/tree.js";
+import { yamlDocument } from "../text/yaml.js";
 const WORKFLOWS = ".github/workflows";
 /** The directories whose every file is a git hook script, run as the shell runs it. */
 const HOOK_DIRS = [".husky", ".githooks"];
@@ -144,14 +144,24 @@ export function commandFileTexts(host, targetRoot) {
         ...[makefileAt(host, root) ?? []].flat(),
     ].flatMap((path) => readText(host, path) ?? []);
 }
+/** Reads the target root's workflow steps, git hooks, hook managers and makefile. */
+export function readWorkflows(host, targetRoot) {
+    return {
+        readings: workflowCommands(host, targetRoot).map(({ text, dir, writtenDirectory }) => {
+            const reading = readCommands(text, dir);
+            return { ...reading, held: [reading.held, writtenDirectory ?? ""].join("\n") };
+        }),
+        texts: commandFileTexts(host, targetRoot),
+    };
+}
 /**
  * The own files the target root's workflow steps, git hooks and recipes run or name, as
  * `pathsNamed` reads each command.
  */
-export function workflowEntries(host, targetRoot, files) {
+export function workflowEntries(workflows, files) {
     const found = [];
-    for (const { text, dir } of workflowCommands(host, targetRoot)) {
-        for (const { path, written } of pathsNamed(readCommands(text, dir))) {
+    for (const reading of workflows.readings) {
+        for (const { path, written } of pathsNamed(reading)) {
             for (const file of files.named(path)) {
                 found.push({ file, source: written });
             }

package/dist/src/extensions.js

@@ -0,0 +1,37 @@
+/** The extension lists the analysis reads files by, each written once. */
+/**
+ * The extensions tried, in order, after a path written without one: a relative specifier
+ * of a configuration file (`roots.5`) and a path a command runs or loads (`roots.13`).
+ */
+export const APPENDED_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+];
+/** The extensions of a module a tool runs or loads as its configuration (`roots.2`). */
+export const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+/** The extensions of a file a build writes from a source file. */
+export const OUTPUT_EXTENSIONS = [
+    ".js",
+    ".mjs",
+    ".cjs",
+    ".jsx",
+    ".d.ts",
+    ".d.mts",
+    ".d.cts",
+];
+/** One list as a glob's brace list, its dots dropped: `{js,mjs}`. */
+export function braced(extensions) {
+    return `{${extensions.map((one) => one.slice(1)).join(",")}}`;
+}
+/** The extension of one list a name ends with, the longest where several do. */
+export function extensionOf(name, extensions) {
+    return extensions
+        .filter((one) => name.endsWith(one))
+        .reduce((longest, one) => (one.length > (longest?.length ?? 0) ? one : longest), undefined);
+}

package/dist/src/facts.js

@@ -0,0 +1,38 @@
+/**
+ * The facts document `--facts` writes, `bindings.1` and `bindings.2`: the run's generated
+ * files under the one decision the generated-file class reads. It carries no binding
+ * record, so it states `evaluated: false`.
+ */
+import { FACTS_VERSION } from "./contract/contract.generated.js";
+import { LANGUAGE, PRODUCT } from "./product.js";
+import { bytewise } from "./text/compare.js";
+/** The facts document of one run, as the text written to the path `--facts` names. */
+export function factsDocument(version, generated) {
+    const document = {
+        facts_version: FACTS_VERSION,
+        analyzer: { name: PRODUCT, version },
+        language: LANGUAGE,
+        evaluated: false,
+        generated: [...generated]
+            .sort(([a], [b]) => bytewise(a, b))
+            .map(([path, fact]) => ({
+            path,
+            line: fact.line,
+            evidence: fact.evidence,
+            detail: fact.detail,
+            ...(fact.generator === undefined
+                ? {}
+                : {
+                    generator: {
+                        row: fact.generator.row,
+                        ...(fact.generator.version === undefined
+                            ? {}
+                            : { version: fact.generator.version }),
+                    },
+                    schema_files: fact.generator.schemaFiles,
+                }),
+        })),
+        bindings: [],
+    };
+    return `${JSON.stringify(document, null, 2)}\n`;
+}

package/dist/src/findings/emitters.js

@@ -96,16 +96,13 @@ function atPossible(input) {
  */
 function dialledOver(input, suppressed, found, unmarked) {
     const would = [...unmarked, ...found];
-    const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
     const unanswered = heldKeys(input);
+    const heldIds = new Set(input.swept.heldByUnanswered);
+    const keyOf = (finding) => declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
+    const held = (finding) => unanswered.has(keyOf(finding)) || insideSkipped(input.swept.skipped, finding.position);
+    const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked), { withholds: held, holdsRecord: (record) => heldIds.has(record.bound) });
     const markup = markupKeys(input);
-    const candidates = found.filter((finding) => {
-        const key = declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
-        return (!ledger.withheld(finding) &&
-            !unanswered.has(key) &&
-            !markup.has(key) &&
-            !insideSkipped(input.swept.skipped, finding.position));
-    });
+    const candidates = found.filter((finding) => !ledger.withheld(finding) && !held(finding) && !markup.has(keyOf(finding)));
     const kept = reportable(input, candidates);
     const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
     return {

package/dist/src/findings/self-check.js

@@ -1,7 +1,7 @@
-import { CODE } from "../contract/contract.generated.js";
+import { CODE, REMEDIES } from "../contract/contract.generated.js";
 import { REPOSITORY_DOCUMENT } from "../config.js";
 import { FIXED_SEVERITY_CODES } from "../kinds.js";
-import { isDependencyCode, isUnsuppressibleCode, } from "../suppress.js";
+import { names, subjectOfCode, } from "../suppress.js";
 import { bytewise } from "../text/compare.js";
 /** The subject kind of a finding about a configured declaration. */
 const DECLARATION_SUBJECT = "configured-declaration";
@@ -24,6 +24,39 @@ export function fileRefsOf(symbols) {
         .map((symbol) => [symbol.position.path, symbol.ref]));
     return (path) => byPath.get(path);
 }
+/**
+ * Why a record of `mechanism` naming `codes` can match nothing, one clause per subject whose
+ * findings kinds.json's remedies table lets no record of that mechanism name, in subject order.
+ */
+function unnameable(codes, mechanism) {
+    return Object.keys(REMEDIES).flatMap((subject) => {
+        const named = codes.filter((code) => subjectOfCode(code) === subject);
+        if (named.length === 0 || names(subject, mechanism)) {
+            return [];
+        }
+        const { names: what, suppressions } = REMEDIES[subject];
+        const reports = `${spelled(named)} ${named.length === 1 ? "reports" : "each report"} ${what}`;
+        if (suppressions.length > 0) {
+            const records = suppressions.map((one) => articled(WRITTEN[one]));
+            return [`${reports}, which only ${spelledOr(records)} can name`];
+        }
+        const settable = named.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
+        const remedy = settable.length === 0
+            ? "fix what the finding names instead"
+            : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+        return [`${reports}, which no suppression can name; ${remedy}`];
+    });
+}
+/** A record's written name with its indefinite article. */
+function articled(name) {
+    return `${/^[aeiou]/u.test(name) ? "an" : "a"} ${name}`;
+}
+/** A list as a sentence names alternatives. */
+function spelledOr(items) {
+    return items.length < 2
+        ? items.join("")
+        : `${items.slice(0, -1).join(", ")} or ${items.at(-1) ?? ""}`;
+}
 /** A list of codes as a sentence names them. */
 function spelled(codes) {
     if (codes.length < 2) {
@@ -85,25 +118,8 @@ export function staleSuppressions(stale, files) {
         const reports = [...new Set(records.flatMap((one) => one.reports))]
             .filter((code) => !codes.includes(code))
             .sort(bytewise);
-        const rows = codes.filter(isUnsuppressibleCode);
-        const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
-        const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
-        const remedy = settable.length === 0
-            ? "fix what the finding names instead"
-            : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
         const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
-        const because = [
-            ...(rows.length > 0
-                ? [
-                    `${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}`,
-                ]
-                : []),
-            ...(dependencies.length > 0
-                ? [
-                    `${spelled(dependencies)} ${dependencies.length === 1 ? "reports a dependency row" : "report dependency rows"}, which only an ignore entry or a baseline row can name`,
-                ]
-                : []),
-        ];
+        const because = unnameable(codes, first.mechanism);
         const instead = because.length > 0
             ? `, because ${because.join("; ")}${declared === "" ? "" : `; ${declared}`}`
             : declared === ""

package/dist/src/findings-pass.js

@@ -7,7 +7,7 @@ import { EXIT_CLEAN, EXIT_FINDINGS, EXIT_PENDING } from "./contract/contract.gen
 import { fails } from "./config.js";
 import { decidedFindings } from "./findings/emitters.js";
 import { fileRefsOf, staleSuppressions, } from "./findings/self-check.js";
-import { isDependencySubject, isRowSubject, pairs, suppressionCounts, } from "./suppress.js";
+import { namesKind, pairs, suppressionCounts } from "./suppress.js";
 import { bytewise } from "./text/compare.js";
 import { PRODUCT } from "./product.js";
 /** The canonical order: path, line, column, code, then the symbol reference. */
@@ -71,15 +71,14 @@ export function verdictOf(result, config) {
 }
 /**
  * The rows one round of a baseline write records from its findings, in their order. A
- * finding about a row of a document other than a dependency row is not recorded: no record
- * withholds one, so a row recording it would be stale on the first read back. Two findings
- * that would record the same row, two parts of one declaration under one code, record it
- * once.
+ * finding no baseline row can name is not recorded: a row recording it would be stale on
+ * the first read back. Two findings that would record the same row, two parts of one
+ * declaration under one code, record it once.
  */
 export function recordedFindings(findings) {
     const rows = new Map();
     for (const finding of findings) {
-        if (isRowSubject(finding.symbol.kind) && !isDependencySubject(finding.symbol.kind)) {
+        if (!namesKind(finding.symbol.kind, "baseline")) {
             continue;
         }
         const row = { code: finding.code, symbol: finding.symbol.ref, path: finding.position.path };

package/dist/src/framework-lifecycle.js

@@ -9,7 +9,7 @@ import { isClassDeclaration, isClassExpression, isHeritageClause, SyntaxKind, }
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, callsOf, classesPassed, decoratedClasses, decoratorCallee } from "./calls.js";
 import { classMembers, memberComponent, typesAt } from "./class-members.js";
-import { entriesAt, names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { entriesAt, names, namesADeclaration, resolveEntries, spelledEntry, } from "./roots/configured-declarations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";

package/dist/src/fs/manifest.js

@@ -16,22 +16,27 @@ export const DEPENDENCY_SECTIONS = [
 export function inInstalledPackages(path) {
     return path.split("/").includes(INSTALLED_PACKAGES);
 }
-/** One JSON file's text and decoded value, or undefined where it cannot be read or parsed. */
-export function readDocument(host, path) {
+/** One JSON file, read and parsed, as {@link JSONRead} tells its states apart. */
+export function readJSONFile(host, path) {
     let text;
     try {
         text = host.readFile(path);
     }
-    catch {
-        return undefined;
+    catch (error) {
+        return { kind: "unread", reason: message(error) };
     }
     try {
-        return { text, value: JSON.parse(text) };
+        return { kind: "read", text, value: JSON.parse(text) };
     }
     catch {
-        return undefined;
+        return { kind: "malformed" };
     }
 }
+/** One JSON file's text and decoded value, or undefined where it cannot be read or parsed. */
+export function readDocument(host, path) {
+    const read = readJSONFile(host, path);
+    return read.kind === "read" ? { text: read.text, value: read.value } : undefined;
+}
 /** One JSON file's decoded value, or undefined where it cannot be read or parsed. */
 export function readJSON(host, path) {
     return readDocument(host, path)?.value;
@@ -50,21 +55,11 @@ export function readManifestAt(host, dir) {
     if (!holdsManifest(host, dir)) {
         return { kind: "absent" };
     }
-    let text;
-    try {
-        text = host.readFile(joinPath(dir, MANIFEST));
-    }
-    catch (error) {
-        return { kind: "unread", reason: message(error) };
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        return { kind: "malformed" };
+    const read = readJSONFile(host, joinPath(dir, MANIFEST));
+    if (read.kind !== "read") {
+        return read;
     }
-    return isRecord(value) ? { kind: "read", manifest: value } : { kind: "malformed" };
+    return isRecord(read.value) ? { kind: "read", manifest: read.value } : { kind: "malformed" };
 }
 /** Whether one directory holds a manifest file. */
 export function holdsManifest(host, dir) {

package/dist/src/generated-file.js

@@ -2,9 +2,13 @@
  * The generated-file class on TypeScript: every declaration in a file that marks itself
  * generated, below a directory an applied convention row names as generated, or minified,
  * is retained, because a generator owns the file and a deletion there is undone at the next
- * generation.
+ * generation. The same decision is each `generated` entry of the facts document.
  */
-import { minified } from "./javascript-file.js";
+import { isIdentifier, isImportDeclaration, isPropertyAssignment, isStringLiteralLikeNode, isVariableStatement, NodeFlags, } from "@typescript/native/ast";
+import { GENERATORS } from "./contract/contract.generated.js";
+import { minifiedBy } from "./javascript-file.js";
+import { bytewise } from "./text/compare.js";
+import { satisfies } from "./version-range.js";
 /** The generated-code header, matched against each line of a leading comment. */
 const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
 /** The documentation tag `@generated` as a word of a comment. */
@@ -15,9 +19,17 @@ const GENERATED_BY = /^\/\/ Generated by \S/u;
 const GENERATED_WORD = /\bgenerated\b/iu;
 /** The phrases a generator's notice asks a reader not to edit the file by. */
 const KEEP_OUT = /\b(?:do not edit|will be overwritten|should not make any changes)\b/iu;
-/** The comments before a text's first token, a leading hashbang line skipped. */
+/** The comments before a text's first token, a leading hashbang line skipped, each as its lines. */
 function leadingComments(text) {
     const comments = [];
+    const lineAt = (offset) => text.slice(0, offset).split(/\r\n|[\n\r\u2028\u2029]/u).length;
+    const lines = (from, to) => {
+        const first = lineAt(from);
+        return text
+            .slice(from, to)
+            .split(/\r\n|[\n\r\u2028\u2029]/u)
+            .map((one, index) => ({ text: one, line: first + index }));
+    };
     let at = text.startsWith("\uFEFF") ? 1 : 0;
     if (text.startsWith("#!", at)) {
         const end = text.indexOf("\n", at);
@@ -30,7 +42,7 @@ function leadingComments(text) {
         if (text.startsWith("//", at)) {
             const end = text.slice(at).search(/[\r\n\u2028\u2029]/u);
             const stop = end === -1 ? text.length : at + end;
-            comments.push(text.slice(at, stop));
+            comments.push(lines(at, stop));
             at = stop;
         }
         else if (text.startsWith("/*", at)) {
@@ -38,7 +50,7 @@ function leadingComments(text) {
             if (end === -1) {
                 return comments;
             }
-            comments.push(text.slice(at, end + 2));
+            comments.push(lines(at, end + 2));
             at = end + 2;
         }
         else {
@@ -46,43 +58,168 @@ function leadingComments(text) {
         }
     }
 }
-/** The detail a file's leading comments mark it generated by, or undefined where they mark nothing. */
-export function generatedByComment(text) {
-    const comments = leadingComments(text);
-    if (comments.some((one) => one.split(/\r?\n/u).some((line) => HEADER_LINE.test(line)))) {
-        return "generated by the header line its leading comments hold";
+/** The mark one file's leading comments make it generated by, or undefined where they mark nothing. */
+export function generatedMark(text) {
+    const lines = leadingComments(text).flat();
+    const header = lines.find((one) => HEADER_LINE.test(one.text));
+    if (header !== undefined) {
+        return { evidence: "header", line: header.line, detail: header.text };
     }
-    if (comments.some((one) => GENERATED_TAG.test(one))) {
-        return "generated by the @generated tag its leading comments hold";
+    const tag = lines.find((one) => GENERATED_TAG.test(one.text));
+    if (tag !== undefined) {
+        return { evidence: "tag", line: tag.line, detail: tag.text };
     }
-    const notice = comments.join("\n");
-    if (GENERATED_BY.test(comments[0] ?? "") ||
-        (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice))) {
-        return "generated by the notice its leading comments hold";
+    const [first] = lines;
+    if (first !== undefined && GENERATED_BY.test(first.text)) {
+        return { evidence: "notice", line: first.line, detail: first.text };
+    }
+    const notice = lines.map((one) => one.text).join("\n");
+    if (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice)) {
+        const marked = lines.find((one) => GENERATED_WORD.test(one.text) || KEEP_OUT.test(one.text));
+        return marked === undefined
+            ? undefined
+            : { evidence: "notice", line: marked.line, detail: marked.text };
+    }
+    return undefined;
+}
+/** What one form's first group captures, for each line the form matches. */
+function after(lines, form) {
+    return lines.flatMap((one) => form.exec(one.text)?.[1] ?? []);
+}
+/**
+ * Where each plugin's output states its version and its schema files, as `references-ts.36`
+ * states: a plugin missing here states no version, and one with no schema form names none.
+ */
+const STATEMENTS = {
+    "protoc-gen-es": {
+        version: /^\/\/ @generated by protoc-gen-es (\S+)/u,
+        schemaFiles: /^\/\/ @generated from file (\S+)/u,
+    },
+    "protoc-gen-connect-es": {
+        version: /^\/\/ @generated by protoc-gen-connect-es (\S+)/u,
+        schemaFiles: /^\/\/ @generated from file (\S+)/u,
+    },
+    "protobuf-ts": {
+        version: /^\/\/ @generated by protobuf-ts (\S+)/u,
+        schemaFiles: /^\/\/ @generated from protobuf file "([^"]+)"/u,
+    },
+    "ts-proto": {
+        version: /^\/\/\s+protoc-gen-ts_proto\s+(\S+)$/u,
+        schemaFiles: /^\/\/ source: (.+)$/u,
+    },
+    "protoc-gen-grpc-web": {
+        version: /^\/\/\s+protoc-gen-grpc-web\s+(\S+)$/u,
+        schemaFiles: /^\/\/ source: (.+)$/u,
+    },
+    "protoc-gen-js": { schemaFiles: /^\/\/ source: (.+)$/u },
+    "ts-protoc-gen": { schemaFiles: /^\/\/ file: (.+)$/u },
+};
+/** A ts-proto service path literal: `/<package>.<service>/<method>`. */
+const SERVICE_PATH = /^\/(?:\w+\.)+\w+\/\w+$/u;
+/** Whether one ts-proto file writes a service path, as `references-ts.36` reads one. */
+function writesServicePath(file) {
+    const named = file.statements.some((statement) => isVariableStatement(statement) &&
+        (statement.declarationList.flags & NodeFlags.Const) !== 0 &&
+        statement.declarationList.declarations.some((one) => isIdentifier(one.name) &&
+            one.name.text.endsWith("ServiceName") &&
+            one.initializer !== undefined &&
+            isStringLiteralLikeNode(one.initializer)));
+    let found = named;
+    const visit = (node) => {
+        if (found) {
+            return;
+        }
+        if (isPropertyAssignment(node) &&
+            isIdentifier(node.name) &&
+            node.name.text === "path" &&
+            isStringLiteralLikeNode(node.initializer) &&
+            SERVICE_PATH.test(node.initializer.text)) {
+            found = true;
+            return;
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/** Whether one file imports a module by its specifier. */
+function imports(file, module) {
+    return file.statements.some((statement) => isImportDeclaration(statement) &&
+        isStringLiteralLikeNode(statement.moduleSpecifier) &&
+        statement.moduleSpecifier.text === module);
+}
+/** The option sets the rows of `references-ts.36` name, by row; every other row's is met by any output. */
+const OPTION_SETS = {
+    "ts-proto-2-output-schema": (file) => imports(file, "ts-proto-descriptors"),
+    "ts-proto-2": writesServicePath,
+    "ts-proto-2-types": (file) => !writesServicePath(file),
+};
+/** The first generator row one file matches, in `generators.json`'s order, as `bindings.3` reads it. */
+export function generatorOf(file) {
+    const lines = leadingComments(file.text).flat();
+    for (const row of GENERATORS) {
+        const header = new RegExp(row.header, "u");
+        if (!lines.some((one) => header.test(one.text))) {
+            continue;
+        }
+        const statements = STATEMENTS[row.plugin] ?? {};
+        const [version] = statements.version === undefined ? [] : after(lines, statements.version);
+        if ("versions" in row &&
+            (version === undefined ||
+                !satisfies(version.replace(/^v/u, ""), `>=${row.versions.min.replace(/^v/u, "")} <=${row.versions.max.replace(/^v/u, "")}`))) {
+            continue;
+        }
+        if (OPTION_SETS[row.id]?.(file) === false) {
+            continue;
+        }
+        const schemaFiles = statements.schemaFiles === undefined
+            ? []
+            : [
+                ...new Set(after(lines, statements.schemaFiles).filter((one) => one.endsWith(".proto"))),
+            ].sort(bytewise);
+        return { row: row.id, ...(version === undefined ? {} : { version }), schemaFiles };
     }
     return undefined;
 }
 /**
- * Every own file of one project that is generated, by its path below the target root,
- * with the detail a retention in it names: its leading comments' mark, else the row
- * naming its directory as generated, else its minified text.
+ * Every own file of one project that is generated, by its path below the target root, with
+ * what decided it: its leading comments' mark, else the row naming its directory as
+ * generated, else its minified name or text; and the generator row it matches.
  */
 export function generatedFilesOf(files, byRow) {
     const found = new Map();
     for (const [path, file] of files.byPath) {
         const row = byRow.get(path);
-        const detail = generatedByComment(file.text) ??
+        const minified = row === undefined ? minifiedBy(file.fileName, file.text) : undefined;
+        const fact = generatedMark(file.text) ??
             (row === undefined
-                ? minified(file.fileName, file.text)
-                    ? "generated as a minified JavaScript file"
-                    : undefined
-                : `generated below a directory the convention row ${row} names`);
-        if (detail !== undefined) {
-            found.set(path, detail);
+                ? minified === undefined
+                    ? undefined
+                    : { evidence: "minified", line: 1, detail: minified }
+                : { evidence: "convention", line: 1, detail: row });
+        if (fact === undefined) {
+            continue;
         }
+        const generator = generatorOf(file);
+        found.set(path, generator === undefined ? fact : { ...fact, generator });
     }
     return found;
 }
+/** The detail a retention in a generated file names, from what decided the file. */
+function retentionDetail(fact) {
+    switch (fact.evidence) {
+        case "header":
+            return "generated by the header line its leading comments hold";
+        case "tag":
+            return "generated by the @generated tag its leading comments hold";
+        case "notice":
+            return "generated by the notice its leading comments hold";
+        case "convention":
+            return `generated below a directory the convention row ${fact.detail} names`;
+        case "minified":
+            return "generated as a minified JavaScript file";
+    }
+}
 /** The generated-file detector, recording each file's first line. */
 export function generatedFile(input) {
     const generated = input.generated;
@@ -90,9 +227,15 @@ export function generatedFile(input) {
         return [];
     }
     return input.held.symbols.flatMap((symbol) => {
-        const detail = generated.get(symbol.position.path);
-        return symbol.kind === "file" || detail === undefined
+        const fact = generated.get(symbol.position.path);
+        return symbol.kind === "file" || fact === undefined
             ? []
-            : [{ id: symbol.id, detail, site: { path: symbol.position.path, line: 1, column: 1 } }];
+            : [
+                {
+                    id: symbol.id,
+                    detail: retentionDetail(fact),
+                    site: { path: symbol.position.path, line: 1, column: 1 },
+                },
+            ];
     });
 }

package/dist/src/graph.js

@@ -32,8 +32,8 @@ const SWEPT = {
 };
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads what it loads and what its strings name, a runtime runs a test, setup or
- * worker file, a page's module script, a command, a script or a workflow step, the manifest
+ * tool reads what it loads and what its strings name, a runtime runs a test or setup
+ * file, a page's module script, a command, a script or a workflow step, the manifest
  * names what enters the package, an alias global stands for its export, an outside
  * declaration names a global interface merging into it, and an entry file, a configured root
  * and a pattern assert a caller. A published API supposes a consumer: reachability alone.
@@ -54,8 +54,6 @@ const NAMES_A_CALLER = {
     "configuration-string": true,
     "bundler-entry": true,
     "test-runner": true,
-    "browser-tests": true,
-    worker: true,
     "html-entry": true,
     "workflow-step": true,
     "document-import": true,

package/dist/src/index.js

@@ -1,5 +1,5 @@
 export { run, SETTING_OPTIONS } from "./run.js";
-export { DECLINED_CONVENTIONS } from "./entry-point-gaps.js";
+export { DECLINED_CONVENTIONS } from "./roots/entry-point-gaps.js";
 export { byPosition, positionKey, PositionError, renderPosition, } from "./position.js";
 export { computedComponent, isRef, nameComponent, REF_EXPRESSIONS, renderRef, } from "./ref.js";
 export { CONTRACT_VERSION } from "./contract/contract.generated.js";

package/dist/src/injection-container.js

@@ -10,7 +10,7 @@ import { isClassDeclaration, isClassExpression, isConstructorDeclaration, isGetA
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, callsOf, classesPassed, decoratorsOf, spelledDecorator } from "./calls.js";
 import { classMembers } from "./class-members.js";
-import { entriesAt, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { entriesAt, namesADeclaration, resolveEntries, spelledEntry, } from "./roots/configured-declarations.js";
 import { isParameterProperty, nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 /** Whether one member declaration is a parameter property, or a property or accessor carrying a decorator. */