@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/findings-pass.js

@@ -3,27 +3,20 @@
  * applied and the declared edges evaluated, and the stale suppressions, the totals and the
  * verdict a report carries beside them.
  */
+import { EXIT_CLEAN, EXIT_FINDINGS, EXIT_PENDING } from "./contract/contract.generated.js";
 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 { EXIT_CLEAN, EXIT_FINDINGS } from "./verbs/verb.js";
-/** The exit code of a report holding at least one pending finding. */
-export const EXIT_PENDING = 4;
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
+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. */
 function canonical(a, b) {
-    return (compare(a.position.path, b.position.path) ||
+    return (bytewise(a.position.path, b.position.path) ||
         a.position.line - b.position.line ||
         a.position.column - b.position.column ||
-        compare(a.code, b.code) ||
-        compare(a.symbol.ref, b.symbol.ref));
+        bytewise(a.code, b.code) ||
+        bytewise(a.symbol.ref, b.symbol.ref));
 }
 /**
  * The pass over one run. The emitter table decides every record against every finding the
@@ -73,20 +66,19 @@ export function verdictOf(result, config) {
     if (result.totals.staleSuppressions > 0) {
         return EXIT_FINDINGS;
     }
-    const failing = result.findings.some((finding) => fails(finding.severity, config.reporters.failOn));
+    const failing = result.findings.some((finding) => fails(finding.severity, config.reporters.fail_on));
     return failing ? EXIT_FINDINGS : EXIT_CLEAN;
 }
 /**
  * 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 };
@@ -100,5 +92,5 @@ export function rowKey(row) {
 }
 /** The analyzer identity a baseline this analyzer writes names as its rows' provenance. */
 export function analyzerProvenance(version) {
-    return { analyzer: "deadset-ts", version };
+    return { analyzer: PRODUCT, version };
 }

package/dist/src/framework-lifecycle.js

@@ -1,23 +1,47 @@
 /**
- * The framework-lifecycle class: a member a `ts.lifecycle_contracts` entry lists is held
- * back on each class that is the entry's component, being a class a decorator or a call
- * the entry's `components` name is attached to or passes, or one extending, directly or
- * through a chain, a class its `bases` name. A component's members are its type's, so a
- * member a base class declares answers for every subclass.
+ * The framework-lifecycle class: a member a lifecycle contract lists is held back on each
+ * class that is the contract's component, being a class a decorator or a call the
+ * contract's `components` name is attached to or passes, or one extending, directly or
+ * through a chain, a class its `bases` name. The contracts are the platform's custom
+ * elements and each `ts.lifecycle_contracts` entry. A component's members are its type's,
+ * so a member a base class declares answers for every subclass.
  */
 import { isClassDeclaration, isClassExpression, isHeritageClause, SyntaxKind, } from "@typescript/native/ast";
 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";
+/**
+ * The platform's own contract (references-ts.38): `CustomElementRegistry.define` reads
+ * these members off the class it registers, its constructor's and its prototype's
+ * (https://html.spec.whatwg.org/multipage/custom-elements.html#dom-customelementregistry-define),
+ * and calls each callback as a custom element reaction.
+ */
+const CUSTOM_ELEMENTS = {
+    components: [{ global: "CustomElementRegistry.define" }],
+    members: [
+        "observedAttributes:static",
+        "disabledFeatures:static",
+        "formAssociated:static",
+        "connectedCallback",
+        "disconnectedCallback",
+        "connectedMoveCallback",
+        "adoptedCallback",
+        "attributeChangedCallback",
+        "formAssociatedCallback",
+        "formResetCallback",
+        "formDisabledCallback",
+        "formStateRestoreCallback",
+    ],
+};
 /** Every contract's components and bases, resolved in one pass over the entries. */
 function resolveContracts(project, held, contracts) {
     const entries = contracts.flatMap((contract) => [
-        ...contract.components,
-        ...contract.bases,
+        ...(contract.components ?? []),
+        ...(contract.bases ?? []),
     ]);
     const resolved = resolveEntries(project, held, entries);
     let next = 0;
@@ -28,8 +52,8 @@ function resolveContracts(project, held, contracts) {
     };
     return contracts.map((contract) => ({
         contract,
-        components: take(contract.components.length),
-        bases: take(contract.bases.length),
+        components: take(contract.components?.length ?? 0),
+        bases: take(contract.bases?.length ?? 0),
     }));
 }
 /** The classes a decorator or a call the contracts' components name makes a component. */
@@ -155,16 +179,17 @@ function byBases(project, held, chains, contracts) {
 }
 /**
  * The framework-lifecycle detector: each member a contract lists, on each class that
- * is a component of that contract's framework, recorded where the class was found to
- * be one.
+ * is a component of that contract's framework, recorded once per place where the class
+ * was found to be one.
  */
 export function frameworkLifecycle(input) {
     const { project, held, targetRoot } = input;
-    if (input.ts.lifecycleContracts.length === 0) {
+    const declared = [CUSTOM_ELEMENTS, ...input.ts.lifecycle_contracts];
+    const contracts = resolveContracts(project, held, declared);
+    if (contracts.every((one) => one.components.length === 0 && one.bases.length === 0)) {
         return [];
     }
     const chains = aliasChains(project, held);
-    const contracts = resolveContracts(project, held, input.ts.lifecycleContracts);
     const components = [
         ...byComponents(project, held, chains, contracts),
         ...byBases(project, held, chains, contracts),
@@ -173,22 +198,24 @@ export function frameworkLifecycle(input) {
         return [];
     }
     const ids = new Set(components.map((one) => one.id));
-    const sides = input.ts.lifecycleContracts.some((contract) => contract.members.some((name) => name.endsWith(":static")))
+    const sides = declared.some((contract) => contract.members.some((name) => name.endsWith(":static")))
         ? ["instance", "static"]
         : ["instance"];
     const members = sides.map((side) => classMembers(project, held, ids, side));
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
-    const found = [];
+    const found = new Map();
     for (const component of components) {
         const listed = new Set(component.contract.members);
         const site = renderPosition(component.site.getSourceFile(), targetRoot, component.site.getStart());
         for (const member of members.flatMap((side) => side.get(component.id) ?? [])) {
             const symbol = byId.get(member.id);
             const spelled = symbol === undefined ? undefined : memberComponent(symbol, byId);
-            if (spelled !== undefined && listed.has(spelled)) {
-                found.push({ id: member.id, detail: component.detail, site });
+            // A configured contract may name the platform's registry too; one record answers both.
+            const key = `${member.id}\0${component.detail}\0${site.path}:${String(site.line)}:${String(site.column)}`;
+            if (spelled !== undefined && listed.has(spelled) && !found.has(key)) {
+                found.set(key, { id: member.id, detail: component.detail, site });
             }
         }
     }
-    return found;
+    return [...found.values()];
 }

package/dist/src/fs/document.js

@@ -0,0 +1,52 @@
+/**
+ * The one read of a document the target holds at its root, which a checkout under analysis
+ * controls: the repository configuration, the ignore file, the baseline and the edges
+ * document. The read stays inside the target root, takes a regular file alone, and holds no
+ * more of it than the Contract's document bound.
+ */
+import { CONFIG_MAX_BYTES } from "../contract/config.generated.js";
+import { failureExit } from "../failure.js";
+import { joinPath, relativePath } from "../paths.js";
+import { message } from "../product.js";
+import { utf8Bytes } from "../reporters/sha256.js";
+import { UsageError } from "../usage.js";
+function unreadable(label, reason) {
+    return failureExit("unreadable-document", `${label}: ${reason}: make it a regular file inside the target root that the run can read, or remove it`);
+}
+/** Refuses a document past the Contract's bound with the usage code, naming it `label`. */
+export function refuseOverBound(label, text) {
+    if (utf8Bytes(text).length > CONFIG_MAX_BYTES) {
+        throw new UsageError(`${label}: holds more than ${String(CONFIG_MAX_BYTES)} bytes`);
+    }
+}
+/**
+ * The text of the document `name` at the absolute `targetRoot`, undefined where nothing is
+ * there. One whose name resolves outside the target root or to anything but a regular file,
+ * or whose read fails, is refused by `refuse` naming it `label`, nothing read from it. A
+ * document past the bound is read one byte past it and refused as {@link refuseOverBound} does.
+ */
+export function readTargetDocument(host, targetRoot, name, label = name, refuse = unreadable) {
+    const attempt = (read) => {
+        try {
+            return read();
+        }
+        catch (error) {
+            throw refuse(label, message(error));
+        }
+    };
+    const path = joinPath(targetRoot, name);
+    const kind = attempt(() => host.kindOf(path));
+    if (kind === "absent") {
+        return undefined;
+    }
+    const real = attempt(() => host.realPath(path));
+    if (relativePath(attempt(() => host.realPath(targetRoot)), real) === undefined) {
+        throw refuse(label, `resolves to ${real}, outside the target root`);
+    }
+    if (kind !== "file") {
+        throw refuse(label, "is not a regular file");
+    }
+    const text = attempt(() => host.readFile(real, CONFIG_MAX_BYTES + 1));
+    refuseOverBound(label, text);
+    return text;
+}

package/dist/src/fs/manifest.js

@@ -0,0 +1,67 @@
+import { isRecord } from "../json-document.js";
+import { joinPath } from "../paths.js";
+import { message } from "../product.js";
+/** The file a package's manifest is read from. */
+export const MANIFEST = "package.json";
+/** The directory a package manager installs packages into, whose files are no project's own. */
+export const INSTALLED_PACKAGES = "node_modules";
+/** The manifest members a package declares the packages it depends on under. */
+export const DEPENDENCY_SECTIONS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+/** Whether one path passes through an installed-packages directory. */
+export function inInstalledPackages(path) {
+    return path.split("/").includes(INSTALLED_PACKAGES);
+}
+/** 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 (error) {
+        return { kind: "unread", reason: message(error) };
+    }
+    try {
+        return { kind: "read", text, value: JSON.parse(text) };
+    }
+    catch {
+        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;
+}
+/**
+ * The manifest in one directory, decoded, or undefined where none reads as an object. A
+ * manifest this program cannot read declares nothing, the same answer as an absent one:
+ * the package manager owns the refusal of a manifest it rejects.
+ */
+export function manifestAt(host, dir) {
+    const value = readJSON(host, joinPath(dir, MANIFEST));
+    return isRecord(value) ? value : undefined;
+}
+/** The manifest in one directory, as {@link ManifestRead} tells its states apart. */
+export function readManifestAt(host, dir) {
+    if (!holdsManifest(host, dir)) {
+        return { kind: "absent" };
+    }
+    const read = readJSONFile(host, joinPath(dir, MANIFEST));
+    if (read.kind !== "read") {
+        return read;
+    }
+    return isRecord(read.value) ? { kind: "read", manifest: read.value } : { kind: "malformed" };
+}
+/** Whether one directory holds a manifest file. */
+export function holdsManifest(host, dir) {
+    return host.kindOf(joinPath(dir, MANIFEST)) === "file";
+}

package/dist/src/fs/tree.js

@@ -0,0 +1,88 @@
+import { ancestors, joinPath, resolvePath } from "../paths.js";
+import { LANGUAGE_ROWS } from "../contract/contract.generated.js";
+import { LANGUAGE } from "../product.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+/** The directories no walk of the tree enters, by the patterns the language's row names. */
+const SKIPPED_DIRECTORIES = LANGUAGE_ROWS[LANGUAGE].skippedDirectories.map(globExpression);
+function skipped(name) {
+    return SKIPPED_DIRECTORIES.some((pattern) => pattern.test(name));
+}
+/** One file's text without its line ending, or undefined where it cannot be read. */
+function lineOf(host, path) {
+    try {
+        return host.readFile(path).replace(/\r?\n$/u, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The repository whose working tree holds `dir`: the nearest directory at or above it with a
+ * `.git`. A `.git` file, which a linked worktree or a submodule holds, names the repository's
+ * directory on its `gitdir:` line; that directory's `commondir` file, where it has one, names
+ * the directory shared with the main worktree, which holds `info/exclude`:
+ * https://git-scm.com/docs/gitrepository-layout
+ */
+export function repositoryOf(host, dir) {
+    for (const root of ancestors(dir)) {
+        const dotGit = joinPath(root, ".git");
+        const kind = host.kindOf(dotGit);
+        if (kind === "directory") {
+            return { root, exclude: joinPath(dotGit, "info/exclude") };
+        }
+        if (kind === "file") {
+            const named = /^gitdir: (.+)$/u.exec(lineOf(host, dotGit) ?? "")?.[1];
+            const gitDir = named === undefined ? undefined : resolvePath(root, named);
+            const common = gitDir === undefined ? undefined : lineOf(host, joinPath(gitDir, "commondir"));
+            const shared = gitDir === undefined || common === undefined ? gitDir : resolvePath(gitDir, common);
+            return { root, exclude: shared === undefined ? undefined : joinPath(shared, "info/exclude") };
+        }
+    }
+    return undefined;
+}
+/** The entries of one directory, none where it cannot be read. */
+export function entriesOf(host, dir) {
+    try {
+        return host.readDirectory(dir);
+    }
+    catch {
+        return [];
+    }
+}
+/** The names of the files directly in `dir` whose name `accepts`, in bytewise order. */
+export function filesIn(host, dir, accepts) {
+    return entriesOf(host, dir)
+        .filter((entry) => !entry.directory && accepts(entry.name))
+        .map((entry) => entry.name)
+        .sort(bytewise);
+}
+/** The names of the directories directly in `dir` a walk enters, in bytewise order. */
+export function directoriesIn(host, dir) {
+    return entriesOf(host, dir)
+        .filter((entry) => entry.directory && !skipped(entry.name))
+        .map((entry) => entry.name)
+        .sort(bytewise);
+}
+/**
+ * Every file below `root` whose name `accepts`, by its path relative to `root` in bytewise
+ * order, read in no skipped directory.
+ */
+export function filesBelow(host, root, accepts) {
+    const found = [];
+    const pending = [""];
+    for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
+        for (const entry of entriesOf(host, joinPath(root, dir))) {
+            const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+            if (!entry.directory) {
+                if (accepts(entry.name)) {
+                    found.push(path);
+                }
+            }
+            else if (!skipped(entry.name)) {
+                pending.push(path);
+            }
+        }
+    }
+    return found.sort(bytewise);
+}

package/dist/src/generated-file.js

@@ -1,9 +1,14 @@
 /**
  * The generated-file class on TypeScript: every declaration in a file that marks itself
- * generated, or below a directory an applied convention row names as generated, is
- * retained, because a generator owns the file and a deletion there is undone at the next
- * generation.
+ * 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. The same decision is each `generated` entry of the facts document.
  */
+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. */
@@ -14,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);
@@ -29,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)) {
@@ -37,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 {
@@ -45,41 +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.
+ * 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
-                ? 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;
@@ -87,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 },
+                },
+            ];
     });
 }