@cplieger/deadset-ts 3.6.0 → 3.8.0

package/src/edges.ts

@@ -0,0 +1,241 @@
+/**
+ * Declared cross-language edges: the sides of the target's edges document that name a
+ * symbol of this language, and the evaluation the report publishes for each. This analyzer
+ * never resolves the paired symbol: the other language's analyzer decides whether the
+ * pairing is a use, and the merge reads the two evaluations together.
+ */
+
+import { ConfigError } from "./config.ts";
+import type { Finding } from "./finding.ts";
+import type { EdgeSide, EdgeSideName } from "./findings/boundary.ts";
+import type { Host } from "./host.ts";
+import type { InventorySymbol } from "./inventory.ts";
+import { positionAt, walkDocument } from "./json-document.ts";
+import { joinPath } from "./paths.ts";
+import { positionKey } from "./position.ts";
+
+/** The name and the location the Contract fixes for the edges document. */
+export const EDGES_FILE = "deadset-edges.json";
+
+/** The language prefix of every reference this analyzer evaluates. */
+const OWN_PREFIX = "ts://";
+
+/** The closed key list of the document and of one edge. */
+const DOCUMENT_KEYS: ReadonlySet<string> = new Set(["description", "edges"]);
+const EDGE_KEYS: ReadonlySet<string> = new Set(["id", "because", "provides", "used_by"]);
+
+/** An edge identifier: solidus-separated segments of ASCII letters, digits, `_`, `.` and `-`. */
+const ID_FORM = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*$/u;
+
+/** A reference naming one symbol of some language: `<language>://<scope>#<fragment>`. */
+const REFERENCE_FORM = /^[a-z][a-z0-9]*:\/\/[^ \t\r\n#]+#[^ \t\r\n]*$/u;
+
+const DOCUMENT_WANT = "an object carrying the edges array, and an optional description";
+const EDGE_WANT = "an edge naming id, provides and used_by, each a string, and an optional because";
+const ID_WANT =
+  "one or more solidus-separated segments of ASCII letters, digits, underscore, full stop and hyphen";
+const REFERENCE_WANT =
+  "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
+
+/** An edges document the Contract refuses: a malformed input, answered with the usage code. */
+export class EdgesError extends ConfigError {
+  constructor(at: string, text: string, want: string) {
+    super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
+    this.name = "EdgesError";
+  }
+}
+
+/**
+ * Whether a reference carries a wildcard outside a quoted or a computed component, which
+ * would name a set of symbols rather than one.
+ */
+function carriesWildcard(ref: string): boolean {
+  let quoted = false;
+  let computed = false;
+  let escaped = false;
+  for (const char of ref) {
+    if (escaped) {
+      escaped = false;
+    } else if (quoted && char === "\\") {
+      escaped = true;
+    } else if (quoted) {
+      quoted = char !== "'";
+    } else if (computed) {
+      computed = char !== "]";
+    } else if (char === "'") {
+      quoted = true;
+    } else if (char === "[") {
+      computed = true;
+    } else if (char === "*") {
+      return true;
+    }
+  }
+  return false;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** One edge, checked: the closed key list, the value types and the value forms. */
+function readEdge(value: unknown, at: string): { id: string; provides: string; usedBy: string } {
+  const refuse = (text: string, want: string): never => {
+    throw new EdgesError(at, text, want);
+  };
+  if (!isObject(value)) {
+    return refuse(JSON.stringify(value), EDGE_WANT);
+  }
+  for (const [key, held] of Object.entries(value)) {
+    if (!EDGE_KEYS.has(key) || typeof held !== "string") {
+      refuse(`the member ${JSON.stringify(key)} holding ${JSON.stringify(held)}`, EDGE_WANT);
+    }
+  }
+  const edge = value as Readonly<Record<string, string | undefined>>;
+  const id = edge["id"] ?? refuse("an edge naming no id", EDGE_WANT);
+  const provides = edge["provides"] ?? refuse("an edge naming no provides side", EDGE_WANT);
+  const usedBy = edge["used_by"] ?? refuse("an edge naming no used_by side", EDGE_WANT);
+  if (!ID_FORM.test(id)) {
+    refuse(JSON.stringify(id), ID_WANT);
+  }
+  for (const ref of [provides, usedBy]) {
+    if (!REFERENCE_FORM.test(ref) || carriesWildcard(ref)) {
+      refuse(JSON.stringify(ref), REFERENCE_WANT);
+    }
+  }
+  return { id, provides, usedBy };
+}
+
+/**
+ * Every side of a declared edge that names a symbol of this language, in document order,
+ * `provides` before `used_by` within an edge. An absent document declares no edge. The
+ * document is strict JSON with a closed key list at both levels, and a defect in it is an
+ * {@link EdgesError}.
+ */
+export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide[] {
+  const file = joinPath(targetRoot, EDGES_FILE);
+  if (host.kindOf(file) === "absent") {
+    return [];
+  }
+  const text = host.readFile(file);
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error: unknown) {
+    throw new EdgesError(
+      EDGES_FILE,
+      error instanceof Error ? error.message : String(error),
+      DOCUMENT_WANT,
+    );
+  }
+  if (!isObject(parsed)) {
+    throw new EdgesError(EDGES_FILE, JSON.stringify(parsed), DOCUMENT_WANT);
+  }
+  const walk = walkDocument(text, "edges");
+  if (walk.twice !== undefined) {
+    throw new EdgesError(
+      positionKey(positionAt(text, EDGES_FILE, walk.twice.offset)),
+      `the member ${JSON.stringify(walk.twice.name)} is written twice, so neither value is chosen`,
+      DOCUMENT_WANT,
+    );
+  }
+  const unknown = Object.keys(parsed).find((key) => !DOCUMENT_KEYS.has(key));
+  const description = parsed["description"];
+  const edges = parsed["edges"];
+  if (
+    unknown !== undefined ||
+    (description !== undefined && typeof description !== "string") ||
+    !Array.isArray(edges)
+  ) {
+    throw new EdgesError(
+      EDGES_FILE,
+      unknown === undefined ? EDGES_FILE : `the member ${JSON.stringify(unknown)}`,
+      DOCUMENT_WANT,
+    );
+  }
+
+  const sides: EdgeSide[] = [];
+  (edges as readonly unknown[]).forEach((value, index) => {
+    const offset = walk.opened[index];
+    const at =
+      offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
+    const edge = readEdge(value, at);
+    const named: readonly [EdgeSideName, string][] = [
+      ["provides", edge.provides],
+      ["used_by", edge.usedBy],
+    ];
+    for (const [side, symbol] of named) {
+      if (symbol.startsWith(OWN_PREFIX)) {
+        sides.push({ edge: edge.id, side, symbol });
+      }
+    }
+  });
+  return sides;
+}
+
+/** One side's verdict, as an evaluation names it. */
+export type EdgeState = "live" | "dead" | "absent";
+
+/** One edge evaluation: one side of this language, its state, and the finding it holds. */
+export interface EdgeEvaluation<F extends Finding = Finding> extends EdgeSide {
+  readonly state: EdgeState;
+  /** Present exactly when the state is `dead`: the finding a live paired symbol cancels. */
+  readonly finding?: F;
+}
+
+/** The findings a report publishes, and one evaluation per declared side of this language. */
+export interface Evaluated<F extends Finding> {
+  readonly findings: readonly F[];
+  /** Ordered by edge, then by side, each compared bytewise. */
+  readonly evaluations: readonly EdgeEvaluation<F>[];
+}
+
+/** Two strings ordered bytewise. */
+function compare(a: string, b: string): number {
+  if (a === b) {
+    return 0;
+  }
+  return a < b ? -1 : 1;
+}
+
+/**
+ * Evaluates every declared side of this language over the run's findings. A side naming a
+ * symbol the run enumerates nothing under is `absent`; one naming a symbol the run holds a
+ * finding about is `dead` and carries that finding, pending until a merge reads the other
+ * side and reported nowhere else, a narrowing finding included; any other is `live`.
+ */
+export function evaluateEdges<F extends Finding>(
+  findings: readonly F[],
+  sides: readonly EdgeSide[],
+  symbols: readonly InventorySymbol[],
+): Evaluated<F> {
+  if (sides.length === 0) {
+    return { findings, evaluations: [] };
+  }
+  const byRef = new Map<string, string>();
+  for (const symbol of symbols) {
+    if (symbol.kind !== "file" && !byRef.has(symbol.ref)) {
+      byRef.set(symbol.ref, symbol.id);
+    }
+  }
+  const held = new Map<string, number>();
+  findings.forEach((finding, at) => {
+    held.set(positionKey(finding.position), at);
+  });
+
+  const pending = new Set<number>();
+  const evaluations = sides.map((side): EdgeEvaluation<F> => {
+    const id = byRef.get(side.symbol);
+    if (id === undefined) {
+      return { ...side, state: "absent" };
+    }
+    const at = held.get(id);
+    const finding = at === undefined ? undefined : findings[at];
+    if (at === undefined || finding === undefined) {
+      return { ...side, state: "live" };
+    }
+    pending.add(at);
+    return { ...side, state: "dead", finding };
+  });
+  evaluations.sort((a, b) => compare(a.edge, b.edge) || compare(a.side, b.side));
+  return { findings: findings.filter((_finding, at) => !pending.has(at)), evaluations };
+}

package/src/finding.ts

@@ -1,13 +1,14 @@
+import type { Confidence, Severity } from "./config.ts";
+import type { Fixability } from "./kinds.ts";
+import type { DependencySection } from "./ref.ts";
+import type { Relation } from "./sweep.ts";
+
 /**
- * The members of a finding its emitter decides: the code, where the subject is,
- * what the subject is, and the sentence the finding reports. They are the
- * Contract's finding members of the same names, spelled in this language's case.
- *
- * Every other member the finding schema requires follows from these and from the
- * run: the kind's name, its fixability and its ceiling come from the code's row of
- * the issue-kind vocabulary, the severity and the confidence from the resolved
- * configuration, the language from the analyzer. A report completes them, so an
- * emitter cannot state one that disagrees with the vocabulary.
+ * The finding: what an emitter decides about one subject, and every member the
+ * Contract's finding schema requires, spelled in this language's case. An emitter states
+ * the code, where the subject is, what it is, the sentence, and the details its code
+ * carries; the completion step reads every other member from the run and from the code's
+ * row of the issue-kind vocabulary, so no emitter states one that disagrees with either.
  */
 
 /** Where the subject of a finding is. */
@@ -34,10 +35,75 @@ export interface FindingSubject {
   readonly sizeLines: number;
 }
 
-/** One finding, as its emitter states it. */
+/** A declaration a finding names beside the subject, with where it is written. */
+export interface PositionedSymbol {
+  readonly ref: string;
+  readonly name: string;
+  readonly position: FindingPosition;
+}
+
+/**
+ * What only some codes carry. The finding schema's branches decide which code carries
+ * which member, and every member is absent under every other code.
+ */
+export interface FindingDetails {
+  /**
+   * On `DS1101` and `DS1104`: the widest scope that holds every reference to the
+   * subject, which is the visibility its references support.
+   */
+  readonly narrowerVisibility?: "file" | "package";
+  /** On `DS1201` and `DS1203`: the classes implementing the interface, in site order. */
+  readonly implementations?: readonly PositionedSymbol[];
+  /** On `DS1301`: every position the subject is written at, in site order. */
+  readonly writePositions?: readonly FindingPosition[];
+  /** On `DS1601`: the manifest section that declares the dependency. */
+  readonly dependencyClass?: DependencySection;
+}
+
+/** One finding as its emitter states it. */
 export interface Finding {
   readonly code: string;
   readonly position: FindingPosition;
   readonly symbol: FindingSubject;
   readonly message: string;
+  /** Absent where the code carries nothing. */
+  readonly details?: FindingDetails;
+}
+
+/** The dead component a finding names, as the finding schema spells its members. */
+export interface FindingComponent {
+  readonly id: string;
+  /** Whether the subject is a root member of the component. */
+  readonly root: boolean;
+  /** The number of the component's members. */
+  readonly symbolCount: number;
+  readonly deletableLines: number;
+}
+
+/** One finding with every member the finding schema requires. */
+export interface CompletedFinding extends Finding {
+  /** The name of the code's row of the issue-kind vocabulary. */
+  readonly kind: string;
+  readonly language: "ts";
+  readonly reachabilityClass: Confidence;
+  /** The reachability class capped by the code's ceiling. */
+  readonly confidence: Confidence;
+  /**
+   * The relation that decided the subject: present on a declaration the sweep judged
+   * dead, absent on a live one and on a subject that is no declaration.
+   */
+  readonly livenessRelation?: Relation;
+  /** Whether every reference to the subject comes from a test file. */
+  readonly testOnly: boolean;
+  readonly generated: boolean;
+  readonly component: FindingComponent;
+  /** Empty on every finding: a declaration an exemption holds back is not reported. */
+  readonly retainedBy: readonly string[];
+  /** The configurations the finding holds in, in the run's order. */
+  readonly configurations: readonly string[];
+  /** The consumers the run loaded beside the target. */
+  readonly consumersLoaded: readonly string[];
+  readonly fixability: Fixability;
+  readonly severity: Severity;
+  readonly details: FindingDetails;
 }

package/src/findings/boundary.ts

@@ -1,5 +1,3 @@
-import type { Finding } from "../finding.ts";
-
 /** Which side of a declared cross-language edge, as the edges document spells it. */
 export type EdgeSideName = "provides" | "used_by";
 
@@ -12,15 +10,6 @@ export interface EdgeSide {
   readonly symbol: string;
 }
 
-/**
- * One finding a declared edge holds back: the finding the analyzer would report about
- * the symbol one side of the edge names, which a report carries only inside that side's
- * evaluation, because the code that may use the symbol is in the other language.
- */
-export interface PendingFinding extends EdgeSide {
-  readonly finding: Finding;
-}
-
 /** What the run knows about the code outside the target that can reach its declarations. */
 export interface Boundary {
   readonly consumers: {

package/src/findings/completion.ts

@@ -1,50 +1,24 @@
 /**
- * What a finding about a declaration carries beyond what its emitter decides, read from
- * the run: the reachability class and the confidence, the relation that decided the
- * subject, the dead component it falls in, the configurations it holds in, and the
- * severity the configuration gives its code. The dials withhold what they name and
- * every finding that falls with a root they withhold.
+ * What every finding carries beyond what its emitter decides, read from the run and from
+ * the code's row of the issue-kind vocabulary, and the dials that withhold a finding
+ * together with every finding that falls with a root they withhold.
  */
 
 import type { RunSweep } from "../analysis.ts";
 import { componentId, type Component } from "../components.ts";
 import type { Confidence, Config, Severity } from "../config.ts";
-import type { Finding } from "../finding.ts";
+import type { CompletedFinding, Finding, FindingComponent } from "../finding.ts";
+import { OUTSIDE } from "../graph.ts";
+import { KINDS } from "../kinds.ts";
 import { FAMILY_KEY_LENGTH } from "../resolve.ts";
-import type { Relation } from "../sweep.ts";
-
-/** The dead component a finding names, as the finding schema spells its members. */
-export interface FindingComponent {
-  readonly id: string;
-  /** Whether the subject is a root member of the component. */
-  readonly root: boolean;
-  /** The number of the component's members. */
-  readonly symbolCount: number;
-  readonly deletableLines: number;
-}
-
-/** One finding with the members the run decides, in this language's case. */
-export interface CompletedFinding extends Finding {
-  readonly reachabilityClass: Confidence;
-  /** The reachability class capped by the code's ceiling. */
-  readonly confidence: Confidence;
-  /** The relation that decided the subject, absent where none did. */
-  readonly livenessRelation?: Relation;
-  /** Whether every reference to the subject comes from a test file. */
-  readonly testOnly: boolean;
-  readonly component: FindingComponent;
-  /** The configurations the finding holds in, in the run's order. */
-  readonly configurations: readonly string[];
-  readonly severity: Severity;
-  /** The per-code members of the finding schema's `details`, empty for a code with none. */
-  readonly details: Readonly<Record<string, unknown>>;
-}
+import type { Dials } from "../suppress.ts";
+import type { EmitterInput } from "./emitter.ts";
 
 /** The classes ranked by the claim each makes, the strongest highest. */
-export const RANK: Readonly<Record<Confidence, number>> = { certain: 3, probable: 2, possible: 1 };
+const RANK: Readonly<Record<Confidence, number>> = { certain: 3, probable: 2, possible: 1 };
 
 /** The weaker of two classes, which is a class capped by a ceiling. */
-export function capped(found: Confidence, ceiling: Confidence): Confidence {
+function capped(found: Confidence, ceiling: Confidence): Confidence {
   return RANK[found] <= RANK[ceiling] ? found : ceiling;
 }
 
@@ -52,7 +26,7 @@ export function capped(found: Confidence, ceiling: Confidence): Confidence {
  * The severity the configuration gives one code: the key naming the code, else the key
  * naming its family, else the code's default.
  */
-export function severityOf(config: Config, code: string, fallback: Severity): Severity {
+function severityOf(config: Config, code: string, fallback: Severity): Severity {
   return (
     config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH)) ?? fallback
   );
@@ -65,7 +39,7 @@ export function severityOf(config: Config, code: string, fallback: Severity): Se
  * in the loaded program, a private member and a `#private` name among them, and is
  * `certain`.
  */
-export function reachabilityClasses(swept: RunSweep): (id: string) => Confidence {
+function reachabilityClasses(swept: RunSweep): (id: string) => Confidence {
   const union = swept.matrix.union;
   const published = new Set(
     union.rooted
@@ -76,7 +50,7 @@ export function reachabilityClasses(swept: RunSweep): (id: string) => Confidence
 }
 
 /** The component each dead declaration of the run falls in, and none for a live one. */
-export function findingComponents(swept: RunSweep): (id: string) => FindingComponent | undefined {
+function findingComponents(swept: RunSweep): (id: string) => FindingComponent | undefined {
   const held = new Map<string, Component>();
   for (const component of swept.sweep.components) {
     for (const member of component.members) {
@@ -96,56 +70,128 @@ export function findingComponents(swept: RunSweep): (id: string) => FindingCompo
   };
 }
 
-/** One finding with the component it names. */
-export type PlacedFinding = Finding & { readonly component: FindingComponent };
-
 /**
- * Every finding of the run, each with its component, in the order given: the dead
- * component its subject falls in. A subject in none, a live declaration, a file no
- * program builds or a manifest row, falls with nothing and is given a component of its
- * own, numbered past the run's computed components in the order the findings come, so
- * no two families mint one identifier.
+ * Every finding of the run completed, in the order given. A dead declaration carries its
+ * candidate's relation, counts, configurations and component; a live one carries no
+ * relation and holds where it is declared; a file or a manifest row is `certain` and
+ * holds in every configuration. A subject in no dead component gets one of its own,
+ * numbered past the computed ones in finding order, so no two families mint one.
  */
-export function placed(swept: RunSweep, findings: readonly Finding[]): readonly PlacedFinding[] {
+export function completed(
+  input: EmitterInput,
+  findings: readonly Finding[],
+): readonly CompletedFinding[] {
+  const { swept } = input;
+  const union = swept.matrix.union;
+  const positions = new Map(union.symbols.map((symbol, at) => [symbol.ref, at]));
+  const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
+  const classOf = reachabilityClasses(swept);
   const componentOf = findingComponents(swept);
-  const ids = new Map(swept.matrix.union.symbols.map((symbol) => [symbol.ref, symbol.id]));
   let minted = swept.sweep.components.length;
-  return findings.map((finding) => {
-    const id = ids.get(finding.symbol.ref);
-    const component = id === undefined ? undefined : componentOf(id);
-    if (component !== undefined) {
-      return { ...finding, component };
+
+  return findings.map((finding): CompletedFinding => {
+    const row = KINDS.get(finding.code);
+    if (row === undefined) {
+      throw new Error(`${finding.code} names no live row of the issue-kind vocabulary`);
     }
-    minted += 1;
-    return {
-      ...finding,
-      component: {
+    const at = positions.get(finding.symbol.ref) ?? OUTSIDE;
+    const symbol = union.symbols[at];
+    const judged = union.subject[at] === true ? symbol : undefined;
+    const candidate = judged === undefined ? undefined : candidates.get(judged.id);
+    const found = symbol === undefined ? undefined : componentOf(symbol.id);
+    if (candidate !== undefined && found === undefined) {
+      throw new Error(`${candidate.id} is judged dead and falls in no dead component`);
+    }
+    let component = found;
+    if (component === undefined) {
+      minted += 1;
+      component = {
         id: componentId(minted),
         root: true,
         symbolCount: 1,
         deletableLines: finding.symbol.sizeLines,
-      },
+      };
+    }
+    const counts =
+      candidate === undefined
+        ? union.made[at]
+        : { production: candidate.productionRefs, test: candidate.testRefs };
+    const reachabilityClass = judged === undefined ? "certain" : classOf(judged.id);
+    return {
+      code: finding.code,
+      kind: row.name,
+      language: "ts",
+      position: finding.position,
+      symbol: finding.symbol,
+      reachabilityClass,
+      confidence: capped(reachabilityClass, row.maxClass),
+      ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
+      testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
+      generated: false,
+      component,
+      retainedBy: [],
+      configurations:
+        candidate?.configurations ??
+        (judged === undefined ? swept.matrix.configurations : (swept.matrix.heldIn[at] ?? [])),
+      consumersLoaded: input.boundary.consumers.loaded,
+      fixability: row.fixability,
+      severity: severityOf(input.config, finding.code, row.defaultSeverity),
+      message: finding.message,
+      details: finding.details ?? {},
     };
   });
 }
 
+/** Whether the dials withhold a finding by its own severity or confidence. */
+function dialed(
+  finding: Pick<CompletedFinding, "severity" | "confidence">,
+  minConfidence: Confidence,
+): boolean {
+  return finding.severity === "allow" || RANK[finding.confidence] < RANK[minConfidence];
+}
+
 /**
- * The findings no dial withholds. A finding at `allow` or below the minimum confidence
- * is withheld, and so is every finding of the component of a root the dials withhold,
- * because a symbol that falls with a root is dead only through it and its deletion
- * does not compile while the root stays. A withheld finding that is no root withholds
- * itself alone.
+ * The configuration's dials over one run's completed findings. A finding at `allow` or
+ * below the minimum confidence is withheld, and so is every finding of the component of a
+ * root the dials withhold, because a symbol that falls with a root is dead only through it
+ * and its deletion does not compile while the root stays. A withheld finding that is no
+ * root withholds itself alone. A code is withheld from a declaration when the finding it
+ * would report there, completed, is withheld by its own severity or confidence.
  */
-export function reportable(
+export function dialsOf(
+  input: EmitterInput,
   findings: readonly CompletedFinding[],
-  minConfidence: Confidence,
-): readonly CompletedFinding[] {
-  const dialed = (finding: CompletedFinding): boolean =>
-    finding.severity === "allow" || RANK[finding.confidence] < RANK[minConfidence];
+): Dials<CompletedFinding> {
+  const minConfidence = input.config.analysis.minConfidence;
+  const classOf = reachabilityClasses(input.swept);
   const components = new Set(
     findings
-      .filter((finding) => finding.component.root && dialed(finding))
+      .filter((finding) => finding.component.root && dialed(finding, minConfidence))
       .map((finding) => finding.component.id),
   );
-  return findings.filter((finding) => !dialed(finding) && !components.has(finding.component.id));
+  return {
+    withholdsCode: (code, id) => {
+      const row = KINDS.get(code);
+      return (
+        row !== undefined &&
+        dialed(
+          {
+            severity: severityOf(input.config, code, row.defaultSeverity),
+            confidence: capped(classOf(id), row.maxClass),
+          },
+          minConfidence,
+        )
+      );
+    },
+    withholds: (finding) => dialed(finding, minConfidence) || components.has(finding.component.id),
+  };
+}
+
+/** The findings of one run's completed findings that no dial withholds, in the order given. */
+export function reportable(
+  input: EmitterInput,
+  findings: readonly CompletedFinding[],
+): readonly CompletedFinding[] {
+  const dials = dialsOf(input, findings);
+  return findings.filter((finding) => !dials.withholds(finding));
 }

package/src/findings/dependencies-and-module-machinery.ts

@@ -1,26 +1,16 @@
-import type { Config, Severity } from "../config.ts";
 import type { Dependencies } from "../dependencies.ts";
 import type { Finding } from "../finding.ts";
 import { renderRef, type DependencySection } from "../ref.ts";
-import { severityOf } from "./completion.ts";
 import type { Emitter } from "./emitter.ts";
 
 const UNUSED_DEPENDENCY = "DS1601";
 
-/** The severity the kind ships at, which the configuration's keys override. */
-const UNUSED_DEPENDENCY_SEVERITY: Severity = "deny";
-
 const MESSAGES: Readonly<Record<DependencySection, string>> = {
   dependency: "no import in the target needs the declared dependency",
   "dev-dependency": "no import in the target needs the declared development dependency",
   "peer-dependency": "no import in the target needs the declared peer dependency",
 };
 
-/** An unused-dependency finding, with the section that declares the dependency. */
-export interface UnusedDependencyFinding extends Finding {
-  readonly details: { readonly dependencyClass: DependencySection };
-}
-
 /**
  * The dependencies the target needs: every package the projects' uses name, every
  * declared dependency that ships a command, which a script, a workflow or a shell
@@ -48,14 +38,9 @@ function neededBy(dependencies: Dependencies): ReadonlySet<string> {
 
 /**
  * A dependency, development dependency or peer dependency of the target's manifest
- * that the target does not need, at the position of its key. Nothing is reported at
- * `allow`. Every subject is a manifest entry, which is `certain` whatever the
- * consumers, so no minimum confidence withholds one.
+ * that the target does not need, at the position of its key.
  */
-function unusedDependencies(config: Config, dependencies: Dependencies): UnusedDependencyFinding[] {
-  if (severityOf(config, UNUSED_DEPENDENCY, UNUSED_DEPENDENCY_SEVERITY) === "allow") {
-    return [];
-  }
+function unusedDependencies(dependencies: Dependencies): Finding[] {
   const needed = neededBy(dependencies);
   return dependencies.declared
     .filter((dependency) => !needed.has(dependency.name))
@@ -78,5 +63,5 @@ function unusedDependencies(config: Config, dependencies: Dependencies): UnusedD
 }
 
 /** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */
-export const dependenciesAndModuleMachinery: Emitter = ({ config, dependencies }) =>
-  unusedDependencies(config, dependencies);
+export const dependenciesAndModuleMachinery: Emitter = ({ dependencies }) =>
+  unusedDependencies(dependencies);