@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.8

package/src/edges.ts

@@ -5,15 +5,18 @@
  * pairing is a use, and the merge reads the two evaluations together.
  */
 
-import { ConfigError } from "./config.ts";
+import { EDGES_SCHEMA } from "./contract/config.generated.ts";
 import type { Finding } from "./finding.ts";
 import type { EdgeSide, EdgeSideName } from "./findings/boundary.ts";
+import { readTargetDocument } from "./fs/document.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 { dotted, placeIn, positionAt, readStrict, StrictJSONError } from "./json-document.ts";
 import { positionKey } from "./position.ts";
+import { firstRefusal } from "./schema.ts";
 import { isPartSubject } from "./suppress.ts";
+import { bytewise } from "./text/compare.ts";
+import { UsageError } from "./usage.ts";
 
 /** The name and the location the Contract fixes for the edges document. */
 export const EDGES_FILE = "deadset-edges.json";
@@ -21,155 +24,61 @@ 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. */
-class EdgesError extends ConfigError {
-  constructor(at: string, text: string, want: string) {
-    super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
+class EdgesError extends UsageError {
+  constructor(at: string, reason: string) {
+    super(`${at}: ${reason}`);
     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 };
-}
+/** The sides of one edge, in the order a reader yields them. */
+const SIDE_NAMES: readonly EdgeSideName[] = ["provides", "used_by"];
 
 /**
  * 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}.
+ * document is strict JSON held to the Contract's edges schema, and a defect in it is an
+ * {@link EdgesError} at the line and column of the edge it is in, where it is in one.
  */
 export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide[] {
-  const file = joinPath(targetRoot, EDGES_FILE);
-  if (host.kindOf(file) === "absent") {
+  const text = readTargetDocument(host, targetRoot, EDGES_FILE);
+  if (text === undefined) {
     return [];
   }
-  const text = host.readFile(file);
-  let parsed: unknown;
+  let read;
   try {
-    parsed = JSON.parse(text);
+    read = readStrict(text, "edges");
   } 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,
-    );
+    if (!(error instanceof StrictJSONError)) {
+      throw error;
+    }
+    throw new EdgesError(positionKey(positionAt(text, EDGES_FILE, error.offset)), error.message);
   }
-  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 value = read.value;
+  const refused = firstRefusal(EDGES_SCHEMA, value);
+  if (refused !== undefined) {
+    const place = placeIn(value, refused.pointer, refused.member);
+    const offset = place.length > 1 ? read.starts.get(place[1] ?? "") : undefined;
+    const at =
+      offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
+    const where = dotted(place);
+    throw new EdgesError(at, where === "" ? refused.reason : `${where}: ${refused.reason}`);
   }
+  const edges = (
+    value as { readonly edges: Readonly<Record<string, Record<EdgeSideName, string>>> }
+  ).edges;
 
   const sides: EdgeSide[] = [];
-  (edges as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.starts[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 });
+  for (const id of read.starts.keys()) {
+    const edge = String(id);
+    for (const side of SIDE_NAMES) {
+      const symbol = edges[edge]?.[side];
+      if (symbol?.startsWith(OWN_PREFIX) === true) {
+        sides.push({ edge, side, symbol });
       }
     }
-  });
+  }
   return sides;
 }
 
@@ -190,14 +99,6 @@ interface Evaluated<F extends Finding> {
   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`; otherwise it is evaluated once per
@@ -242,6 +143,6 @@ export function evaluateEdges<F extends Finding>(
       return { ...side, state: "dead", finding };
     });
   });
-  evaluations.sort((a, b) => compare(a.edge, b.edge) || compare(a.side, b.side));
+  evaluations.sort((a, b) => bytewise(a.edge, b.edge) || bytewise(a.side, b.side));
   return { findings: findings.filter((_finding, at) => !pending.has(at)), evaluations };
 }

package/src/element-access.ts

@@ -47,6 +47,7 @@ import { renderPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
+import { parenthesesRemoved } from "./unwrap.ts";
 
 type Use = "read" | "write" | "both";
 
@@ -93,13 +94,9 @@ function useOf(node: Node): Use {
   return "read";
 }
 
-function unwrapped(node: Expression): Expression {
-  return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
-
 /** Whether an index is a literal the checker resolves to a member by its own text. */
 function isLiteralIndex(node: Expression): boolean {
-  const at = unwrapped(node);
+  const at = parenthesesRemoved(node);
   return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at);
 }
 
@@ -293,7 +290,7 @@ export function elementAccessReferences<Brand>(
   const parameterOf = new Map<Candidate, { callable: Callable; at: number }>();
   const byCallable = new Map<Identifier, Candidate[]>();
   for (const candidate of candidates) {
-    const index = unwrapped(candidate.access.argumentExpression);
+    const index = parenthesesRemoved(candidate.access.argumentExpression);
     const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
     const callable = fn === undefined ? undefined : callableOf(fn);
     if (callable === undefined || !isIdentifier(index)) {
@@ -353,7 +350,7 @@ export function elementAccessReferences<Brand>(
       continue;
     }
     // An object that is a parameter too is read as the argument each call passes there.
-    const object = unwrapped(candidate.access.expression);
+    const object = parenthesesRemoved(candidate.access.expression);
     const objectAt = isIdentifier(object)
       ? deferred.callable.parameters.findIndex(
           (parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text,

package/src/entry-point-gaps.ts

@@ -8,6 +8,8 @@
  * one at a time: beside a finding, or in a report's declared gaps.
  */
 
+import { bytewise } from "./text/compare.ts";
+
 /** One declined entry-point convention. */
 export interface DeclinedConvention {
   /** The tool the convention belongs to, by the name of the package or service. */
@@ -323,16 +325,8 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   },
 ];
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /** Every declined entry-point convention, ordered by tool and then by convention. */
 export const DECLINED_CONVENTIONS: readonly DeclinedConvention[] = [
   ...UNREAD_TOOLS.map((tool) => ({ tool, convention: EVERY_CONVENTION, reason: UNREAD })),
   ...PARTLY_ENTERED,
-].sort((a, b) => compare(a.tool, b.tool) || compare(a.convention, b.convention));
+].sort((a, b) => bytewise(a.tool, b.tool) || bytewise(a.convention, b.convention));

package/src/entry-points.ts

@@ -13,7 +13,6 @@
 
 import {
   isArrayLiteralExpression,
-  isAsExpression,
   isCallExpression,
   isExportAssignment,
   isIdentifier,
@@ -21,10 +20,8 @@ import {
   isNewExpression,
   isNoSubstitutionTemplateLiteral,
   isObjectLiteralExpression,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isPropertyAssignment,
-  isSatisfiesExpression,
   isStringLiteral,
   SyntaxKind,
   type Node,
@@ -39,7 +36,6 @@ import {
 } from "./configuration-files.ts";
 import type { Selected } from "./conventions.ts";
 import { buildScriptEntries } from "./build-scripts.ts";
-import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { htmlEntries } from "./html-entries.ts";
 import { documentEntries } from "./mdx-entries.ts";
@@ -49,6 +45,8 @@ import type { ProjectView } from "./session.ts";
 import type { SourceFiles } from "./source-files.ts";
 import { computedLoadDirectory, leadingLiteral } from "./unseen-loads.ts";
 import { workflowEntries } from "./workflow-steps.ts";
+import { unwrapped } from "./unwrap.ts";
+import { globExpression } from "./text/glob.ts";
 
 /** Which rule entered a file. */
 export type EntryRule =
@@ -166,15 +164,6 @@ function literalOf(node: Node | undefined): string | undefined {
   return undefined;
 }
 
-/** The expression a wrapper that changes no value holds: parentheses and type assertions. */
-function unwrapped(node: Node): Node {
-  let at = node;
-  while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
-    at = at.expression;
-  }
-  return at;
-}
-
 /**
  * The object literals one configuration file's default export is written as: the
  * literal itself, or each literal argument of the call it is, at any depth of calls.

package/src/enum-group.ts

@@ -18,7 +18,6 @@ import {
   isIdentifier,
   isMethodDeclaration,
   isNoSubstitutionTemplateLiteral,
-  isParenthesizedExpression,
   isParenthesizedTypeNode,
   isPropertyAccessExpression,
   isReturnStatement,
@@ -28,6 +27,7 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.ts";
 import { TypeFlags, type Type } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
@@ -55,15 +55,6 @@ interface Site {
   readonly at: Node;
 }
 
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node: Node): Node {
-  let held = node;
-  while (isParenthesizedExpression(held)) {
-    held = held.expression;
-  }
-  return held;
-}
-
 /**
  * The name node a type node names its declaration by: the identifier of a type
  * reference, the right side of a qualified one, through parentheses. A type that is no
@@ -86,7 +77,7 @@ function typeName(type: Node | undefined): Node | undefined {
 
 /** The name node an expression names an object by: an identifier, or a property access's name. */
 function objectName(expression: Node): Node | undefined {
-  const held = unparenthesized(expression);
+  const held = parenthesesRemoved(expression);
   if (isIdentifier(held)) {
     return held;
   }

package/src/erased-stores.ts

@@ -16,7 +16,6 @@ import {
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
   isObjectLiteralExpression,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isPropertyAssignment,
   isShorthandPropertyAssignment,
@@ -31,6 +30,7 @@ import { SymbolFlags, TypeFlags, type Type } from "@typescript/native/sync";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { checkedTypes } from "./value-reach.ts";
+import { parenthesesRemoved } from "./unwrap.ts";
 
 /** The types that keep nothing of the value they are given. */
 const ERASED = TypeFlags.Any | TypeFlags.Unknown;
@@ -81,10 +81,6 @@ function literalKey(node: Expression): string | undefined {
     : undefined;
 }
 
-function unwrapped(node: Expression): Expression {
-  return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
-
 /**
  * Whether a variable declaration's type can differ from what is stored in it: it carries an
  * annotation, or it has neither an annotation nor an initializer, so its type evolves.
@@ -150,8 +146,8 @@ function propertyAt(source: Expression, name: string): Expression | undefined {
  * here, and a default value is stored in its target too.
  */
 function patternTargets(pattern: Expression, from: Stored, out: Target[]): void {
-  const target = unwrapped(pattern);
-  const source = from.path.length === 0 ? unwrapped(from.value) : from.value;
+  const target = parenthesesRemoved(pattern);
+  const source = from.path.length === 0 ? parenthesesRemoved(from.value) : from.value;
   const into = (element: Expression, step: Step, literal: Expression | undefined): void => {
     patternTargets(
       element,

package/src/exempt-classes.ts

@@ -47,8 +47,3 @@ const VISIBILITY: ReadonlyMap<TSExemptionClass, TypeScriptVisibility> = new Map(
 export function typescriptVisibilityOf(exemptionClass: TSExemptionClass): TypeScriptVisibility {
   return VISIBILITY.get(exemptionClass) ?? { private: false, privateName: false };
 }
-
-/** Whether one name is a class of the vocabulary, whichever language it runs on. */
-export function isExemptionClass(name: string): name is ExemptionClass {
-  return EXEMPTION_CLASSES.some((row) => row.class === name);
-}

package/src/exempt.ts

@@ -8,10 +8,8 @@
  */
 
 import { EXEMPTION_CLASSES } from "./contract/contract.generated.ts";
-import type { Config, TSSection } from "./config.ts";
-import { ConfigError } from "./config.ts";
+import type { ResolvedConfig } from "./config.ts";
 import {
-  isExemptionClass,
   TS_EXEMPTION_CLASSES,
   typescriptVisibilityOf,
   type ExemptionClass,
@@ -25,6 +23,7 @@ import { Unanswerable } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { Templates } from "./template-field.ts";
 import { sweep, type Exemption, type Implementing, type Mode, type SweepInput } from "./sweep.ts";
+import { bytewise } from "./text/compare.ts";
 
 /** One declaration a detector holds back, and where and why. */
 export interface Evidence {
@@ -49,7 +48,7 @@ export interface DetectorInput<Brand> {
   /** The configured templates, read once for the run. */
   readonly templates: Templates;
   /** The `ts` section, whose declarations the configured classes read. */
-  readonly ts: TSSection;
+  readonly ts: ResolvedConfig["ts"];
   /** The absolute path of each declared consumer, whose modules are part of the analysis. */
   readonly consumers: readonly string[];
   /** The project's generated files, by path below the target root, each with the detail its retentions name. */
@@ -73,24 +72,11 @@ interface Holding {
 }
 
 /**
- * The classes `exemptions.disabled` switches off. A name is refused unless the
- * vocabulary holds it; a class that runs on another language only is admitted and
- * switches nothing off here, so one configuration serves every analyzer.
+ * The classes `exemptions.disabled` switches off. A class that runs on another language
+ * only switches nothing off here, so one configuration serves every analyzer.
  */
-export function disabledClasses(config: Config): ReadonlySet<ExemptionClass> {
-  const disabled = new Set<ExemptionClass>();
-  for (const name of config.exemptionsDisabled) {
-    if (!isExemptionClass(name)) {
-      const known = EXEMPTION_CLASSES.map((row) => row.class).join(", ");
-      throw new ConfigError(
-        "malformed",
-        "exemptions.disabled",
-        `exemptions.disabled: ${JSON.stringify(name)} is not an exemption class: the classes are ${known}`,
-      );
-    }
-    disabled.add(name);
-  }
-  return disabled;
+export function disabledClasses(config: ResolvedConfig): ReadonlySet<ExemptionClass> {
+  return new Set(config.exemptions.disabled);
 }
 
 /**
@@ -221,14 +207,6 @@ export function heldRecords(records: readonly Exemption[], holding: Holding): De
   return { records: exemptionsOf(found), inTestFiles };
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * Records as a run holds them: ordered by site, then class, then declaration, and one
  * per declaration, class, detail and file it holds while live, the one at the first
@@ -236,7 +214,7 @@ function compare(a: string, b: string): number {
  */
 export function exemptionsOf(found: readonly Exemption[]): readonly Exemption[] {
   const ordered = [...found].sort(
-    (a, b) => byPosition(a.site, b.site) || compare(a.class, b.class) || compare(a.id, b.id),
+    (a, b) => byPosition(a.site, b.site) || bytewise(a.class, b.class) || bytewise(a.id, b.id),
   );
   const seen = new Set<string>();
   return ordered.filter((record) => {

package/src/file-facts.ts

@@ -5,13 +5,13 @@
  */
 
 import type { SourceFile } from "@typescript/native/ast";
-import { IGNORED_DIRECTORIES } from "./discover.ts";
 import type { Host } from "./host.ts";
 import { packageScope } from "./inventory.ts";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import { renderRef } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
 import type { UnseenLoad } from "./unseen-loads.ts";
+import { filesBelow } from "./fs/tree.ts";
 
 /** A file name the compiler reads as a source file. */
 const SOURCE_FILE = /\.(?:ts|tsx|mts|cts)$/u;
@@ -74,29 +74,11 @@ function lastLine(text: string): number {
  * that cannot be read is skipped, as discovery skips it.
  */
 export function sourcePaths(host: Host, targetRoot: string): readonly string[] {
-  const found: string[] = [];
-  const pending = [""];
-  for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
-    let entries: readonly { readonly name: string; readonly directory: boolean }[];
-    try {
-      entries = host.readDirectory(joinPath(targetRoot, dir));
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
-      if (entry.directory) {
-        if (!IGNORED_DIRECTORIES.has(entry.name)) {
-          pending.push(path);
-        }
-        continue;
-      }
-      if (SOURCE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name)) {
-        found.push(path);
-      }
-    }
-  }
-  return found.sort((a, b) => (a < b ? -1 : 1));
+  return filesBelow(
+    host,
+    targetRoot,
+    (name) => SOURCE_FILE.test(name) && !DECLARATION_FILE.test(name),
+  );
 }
 
 /**

package/src/findings/completion.ts

@@ -65,10 +65,9 @@ function everyDeclaredLoaded(boundary: Boundary): boolean {
  * naming its family, else the code's default.
  */
 function severityOf(input: EmitterInput, code: string, fallback: Severity): Severity {
-  const { config } = input;
-  return (
-    config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH)) ?? fallback
-  );
+  const { severity } = input.config;
+  const key = [code, code.slice(0, FAMILY_KEY_LENGTH)].find((one) => Object.hasOwn(severity, one));
+  return key === undefined ? fallback : (severity[key] ?? fallback);
 }
 
 /**
@@ -225,7 +224,7 @@ function rootsCeiling(
 ): Confidence {
   const unreachable = candidate?.relation === "reachability" || finding.unreachableOnly === true;
   const unseen = new Set((input.files.unseenLoads ?? []).map((load) => load.configuration));
-  const complete = input.config.ts.rootsComplete && !configurations.some((one) => unseen.has(one));
+  const complete = input.config.ts.roots_complete && !configurations.some((one) => unseen.has(one));
   return unreachable && !complete ? "probable" : "certain";
 }
 
@@ -585,7 +584,7 @@ export function dialsOf(
   input: EmitterInput,
   findings: readonly CompletedFinding[],
 ): Dials<CompletedFinding> {
-  const minConfidence = input.config.analysis.minConfidence;
+  const minConfidence = input.config.analysis.min_confidence;
   const components = new Set(
     findings
       .filter(

package/src/findings/emitter.ts

@@ -1,5 +1,5 @@
 import type { RunSweep } from "../analysis.ts";
-import type { Config } from "../config.ts";
+import type { ResolvedConfig } from "../config.ts";
 import type { Dependencies } from "../dependencies.ts";
 import type { FileFacts } from "../file-facts.ts";
 import type { Finding } from "../finding.ts";
@@ -14,7 +14,7 @@ import type { SelfCheckFacts } from "./self-check.ts";
  * the facts about the run each emitter reads beside the sweep.
  */
 export interface EmitterInput {
-  readonly config: Config;
+  readonly config: ResolvedConfig;
   /** The production sweep a report is built from, beside the matrix it judged. */
   readonly swept: RunSweep;
   /** The declarations carrying the deprecation marker in any configuration of the run. */

package/src/findings/emitters.ts

@@ -145,7 +145,7 @@ function atPossible(input: EmitterInput): EmitterInput {
   const { config } = input;
   return {
     ...input,
-    config: { ...config, analysis: { ...config.analysis, minConfidence: "possible" } },
+    config: { ...config, analysis: { ...config.analysis, min_confidence: "possible" } },
   };
 }
 

package/src/findings/intra-function.ts

@@ -127,7 +127,7 @@ export const intraFunction: Emitter = (input) => {
     }),
   );
   const { declared, loaded } = input.boundary.consumers;
-  const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+  const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
   const published = (id: string): boolean => {
     const symbol = byId.get(id);
     return (

package/src/findings/non-code-artifacts.ts

@@ -1,5 +1,5 @@
 import { CODE } from "../contract/contract.generated.ts";
-import type { Config } from "../config.ts";
+import type { ResolvedConfig } from "../config.ts";
 import type { Finding } from "../finding.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
@@ -15,10 +15,10 @@ const FILE_START = 1;
  * completeness and listing no project declares it of a matrix the run derived, and a
  * derived matrix is never complete.
  */
-function completeMatrix(config: Config): boolean {
+function completeMatrix(config: ResolvedConfig): boolean {
   return (
-    config.analysis.matrixComplete &&
-    config.analysis.configurations.some((entry) => entry.shape === "project")
+    config.analysis.matrix.complete &&
+    config.analysis.configurations.some((entry) => "project" in entry)
   );
 }