@cplieger/deadset-ts 8.0.0-dev.7 → 8.0.0-dev.9

package/src/contract/contract.generated.ts

@@ -1135,14 +1135,24 @@ export const EVIDENCE = [
   },
 ] as const;
 
-export const SETUP_CLASSES = [
-  { class: "missing-module", languages: ["go", "ts"] },
-  { class: "incomplete-module-sum", languages: ["go"] },
-  { class: "missing-consumer", languages: ["go", "ts"] },
-  { class: "workspace-member-without-source", languages: ["ts"] },
-  { class: "convention-not-literal", languages: ["ts"] },
-  { class: "no-program", languages: ["go", "ts"] },
-] as const;
+/** Each group of failure classes, and the text opening the line that names one of its failures. */
+export const FAILURE_PREFIXES = { setup: "setup failure: ", run: "run failure: " } as const;
 
-/** The text opening the line of the error stream that names one setup failure. */
-export const SETUP_FAILURE_PREFIX = "setup failure: ";
+/** Each failure class the Contract names, and its group. */
+export const FAILURE_CLASSES = {
+  "missing-module": "setup",
+  "incomplete-module-sum": "setup",
+  "missing-consumer": "setup",
+  "workspace-member-without-source": "setup",
+  "convention-not-literal": "setup",
+  "no-program": "setup",
+  "unreadable-document": "setup",
+  "unwritten-output": "run",
+  "unreportable-path": "run",
+  "memory-exhausted": "run",
+  "missing-analyzer": "run",
+  "unadmitted-analyzer": "run",
+  "unresolved-edge": "run",
+  "interrupted-run": "run",
+  "product-fault": "run",
+} as const;

package/src/contract/report.generated.ts

@@ -589,7 +589,7 @@ export const REPORT_SCHEMAS = {
           additionalProperties: false,
           required: ["edge", "side", "symbol", "state"],
           properties: {
-            edge: { type: "string", pattern: "^[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*$" },
+            edge: { $ref: "finding.schema.json#/$defs/edge_identifier" },
             side: { type: "string", enum: ["provides", "used_by"] },
             symbol: { type: "string" },
             state: { type: "string", enum: ["live", "dead", "absent"] },
@@ -969,7 +969,7 @@ export const REPORT_SCHEMAS = {
             uniqueItems: true,
             items: { type: "string", minLength: 1 },
           },
-          edge: { type: "string", pattern: "^[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*$" },
+          edge: { $ref: "#/$defs/edge_identifier" },
           sides: {
             type: "array",
             minItems: 1,
@@ -1125,6 +1125,7 @@ export const REPORT_SCHEMAS = {
       },
     ],
     $defs: {
+      edge_identifier: { type: "string", pattern: "^[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*$" },
       position: {
         type: "object",
         additionalProperties: false,

package/src/conventions.ts

@@ -61,14 +61,14 @@ import {
   relativePath,
   resolvePath,
 } from "./paths.ts";
-import type { SetupFailure } from "./setup-failure.ts";
+import type { Failure } from "./failure.ts";
 import type { SourceFiles } from "./source-files.ts";
 import { satisfies } from "./version-range.ts";
 import { bytewise } from "./text/compare.ts";
 import { isRecord } from "./json-document.ts";
 import { unwrapped } from "./unwrap.ts";
 import { filesIn } from "./fs/tree.ts";
-import { INSTALLED_PACKAGES, MANIFEST, readJSON } from "./fs/manifest.ts";
+import { DEPENDENCY_SECTIONS, INSTALLED_PACKAGES, MANIFEST, readJSON } from "./fs/manifest.ts";
 import { globExpression } from "./text/glob.ts";
 import { yamlDocument } from "./text/yaml.ts";
 
@@ -115,7 +115,7 @@ interface GeneratedDirectory {
 /** A setup failure a row met, at the directory of the manifest that declared it. */
 interface ConventionFailure {
   readonly dir: string;
-  readonly failure: SetupFailure;
+  readonly failure: Failure;
 }
 
 /** What the rows decided for one run. */
@@ -169,12 +169,6 @@ const JSON_RC = /^\.[\w-]+rc$/u;
 /** The sections an installed package is required by, so its absence fails the run. */
 const REQUIRED_SECTIONS = ["dependencies", "devDependencies"] as const;
 
-const DEPENDENCY_SECTIONS = [
-  ...REQUIRED_SECTIONS,
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
-
 function declares(
   manifest: unknown,
   name: string,
@@ -1094,7 +1088,7 @@ export function readConventions(
         failures.push({
           dir: manifest.dir,
           failure: {
-            setupClass: "missing-module",
+            failureClass: "missing-module",
             detail:
               `${manifest.path} declares ${row.package}, which no node_modules at or ` +
               `above its directory holds: run the package manager's install`,
@@ -1120,7 +1114,7 @@ export function readConventions(
         failures.push({
           dir: manifest.dir,
           failure: {
-            setupClass: "convention-not-literal",
+            failureClass: "convention-not-literal",
             detail: where === "." ? failed : `${where}/${failed}`,
           },
         });
@@ -1241,7 +1235,7 @@ export function conventionFailuresFor(
   conventions: Conventions,
   configFile: string,
   ownFiles: readonly string[],
-): readonly SetupFailure[] {
+): readonly Failure[] {
   return conventions.failures
     .filter(
       ({ dir }) =>

package/src/edges.ts

@@ -5,17 +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 { isRecord, 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 { message } from "./product.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";
@@ -23,147 +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;
-}
-
-/** 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 (!isRecord(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, message(error), DOCUMENT_WANT);
-  }
-  if (!isRecord(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;
 }
 

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 };
 }
-
-/** Every class of the vocabulary, whichever language it runs on, in the vocabulary's order. */
-export const EXEMPTION_CLASS_NAMES: readonly ExemptionClass[] = EXEMPTION_CLASSES.map(
-  (row) => row.class,
-);

package/src/exempt.ts

@@ -8,7 +8,7 @@
  */
 
 import { EXEMPTION_CLASSES } from "./contract/contract.generated.ts";
-import type { Config, TSSection } from "./config.ts";
+import type { ResolvedConfig } from "./config.ts";
 import {
   TS_EXEMPTION_CLASSES,
   typescriptVisibilityOf,
@@ -48,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. */
@@ -75,8 +75,8 @@ interface Holding {
  * 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> {
-  return new Set(config.exemptionsDisabled);
+export function disabledClasses(config: ResolvedConfig): ReadonlySet<ExemptionClass> {
+  return new Set(config.exemptions.disabled);
 }
 
 /**

package/src/failure.ts

@@ -0,0 +1,63 @@
+import { FAILURE_CLASSES, FAILURE_PREFIXES } from "./contract/contract.generated.ts";
+import type { LocatedDiagnostic } from "./load/diagnostics.ts";
+import { PRODUCT } from "./product.ts";
+
+/** A class of failure the Contract's exit-code table names, of either group. */
+type FailureClass = keyof typeof FAILURE_CLASSES;
+
+/** One cause the run ends with the failure code for. */
+export interface Failure {
+  readonly failureClass: FailureClass;
+  /** What fails and the fix, on one line. */
+  readonly detail: string;
+}
+
+/** The failure as a class line of the error stream, opened by its group's prefix. */
+export function failureLine(failure: Failure): string {
+  return `${FAILURE_PREFIXES[FAILURE_CLASSES[failure.failureClass]]}${failure.failureClass}: ${failure.detail}`;
+}
+
+/**
+ * The lines of the error stream that name the failures: the first one's class line, the run's
+ * only one, then each further failure as its class and detail with no group prefix.
+ */
+export function failureLines([first, ...further]: readonly [Failure, ...Failure[]]): string[] {
+  return [failureLine(first), ...further.map((one) => `${one.failureClass}: ${one.detail}`)];
+}
+
+/**
+ * A run the analysis cannot answer. It ends the run with the failure code and no finding
+ * list, printing the compiler's located errors and then the failures' lines.
+ */
+export class FailureExit extends Error {
+  readonly failures: readonly [Failure, ...Failure[]];
+  /** The compiler's errors behind the failures, in the order it reported them. */
+  readonly diagnostics: readonly LocatedDiagnostic[];
+
+  constructor(
+    failures: readonly [Failure, ...Failure[]],
+    diagnostics: readonly LocatedDiagnostic[] = [],
+  ) {
+    super(failureLines(failures).join("\n"));
+    this.name = "FailureExit";
+    this.failures = failures;
+    this.diagnostics = diagnostics;
+  }
+}
+
+/** A failure exit of one failure. */
+export function failureExit(
+  failureClass: FailureClass,
+  detail: string,
+  diagnostics: readonly LocatedDiagnostic[] = [],
+): FailureExit {
+  return new FailureExit([{ failureClass, detail }], diagnostics);
+}
+
+/** A fault of this analyzer itself, `fault` saying what it cannot do. */
+export function productFault(fault: string): FailureExit {
+  return failureExit(
+    "product-fault",
+    `${PRODUCT} ${fault}: reinstall ${PRODUCT}, and report the fault to its maintainers if a reinstalled ${PRODUCT} fails the same way`,
+  );
+}

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)
   );
 }
 

package/src/findings/unused-declarations.ts

@@ -218,7 +218,7 @@ export const unusedDeclarations: Emitter = (input) => [
  */
 function unusedImports(input: EmitterInput): Finding[] {
   const generated =
-    input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+    input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
   return input.intraFunction.imports.flatMap((binding) =>
     binding.used || generated?.has(binding.position.path) === true
       ? []

package/src/findings/visibility-narrowing.ts

@@ -266,13 +266,13 @@ function unreachable(
 export function narrowings(input: EmitterInput): readonly Finding[] {
   const facts = factsOf(input.swept.matrix.union);
   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 world = { closed, writeOnly: writeOnlyDeclarations(input) };
   const candidates = new Map(
     input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]),
   );
   const generated =
-    input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+    input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
 
   const findings: Finding[] = [];
   facts.graph.symbols.forEach((symbol, at) => {

package/src/findings-pass.ts

@@ -6,7 +6,7 @@
 
 import { EXIT_CLEAN, EXIT_FINDINGS, EXIT_PENDING } from "./contract/contract.generated.ts";
 import type { AnalysisInputs } from "./analysis.ts";
-import { fails, type Config } from "./config.ts";
+import { fails, type ResolvedConfig } from "./config.ts";
 import type { EdgeEvaluation } from "./edges.ts";
 import type { CompletedFinding, Finding } from "./finding.ts";
 import { decidedFindings, type Withheld } from "./findings/emitters.ts";
@@ -109,7 +109,7 @@ export function findingsPass(inputs: AnalysisInputs): PassResult {
  * suppression is stale or a finding's severity reaches the configured failing severity;
  * clean otherwise.
  */
-export function verdictOf(result: PassResult, config: Config): number {
+export function verdictOf(result: PassResult, config: ResolvedConfig): number {
   if (result.totals.pending > 0) {
     return EXIT_PENDING;
   }
@@ -117,7 +117,7 @@ export function verdictOf(result: PassResult, config: Config): number {
     return EXIT_FINDINGS;
   }
   const failing = result.findings.some((finding) =>
-    fails(finding.severity, config.reporters.failOn),
+    fails(finding.severity, config.reporters.fail_on),
   );
   return failing ? EXIT_FINDINGS : EXIT_CLEAN;
 }

package/src/framework-lifecycle.ts

@@ -55,8 +55,8 @@ function resolveContracts<Brand>(
   contracts: readonly LifecycleContract[],
 ): readonly ResolvedContract[] {
   const entries: DeclarationEntry[] = contracts.flatMap((contract) => [
-    ...contract.components,
-    ...contract.bases,
+    ...(contract.components ?? []),
+    ...(contract.bases ?? []),
   ]);
   const resolved = resolveEntries(project, held, entries);
   let next = 0;
@@ -67,8 +67,8 @@ function resolveContracts<Brand>(
   };
   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),
   }));
 }
 
@@ -243,11 +243,11 @@ function byBases<Brand>(
  */
 export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
   const { project, held, targetRoot } = input;
-  if (input.ts.lifecycleContracts.length === 0) {
+  if (input.ts.lifecycle_contracts.length === 0) {
     return [];
   }
   const chains = aliasChains(project, held);
-  const contracts = resolveContracts(project, held, input.ts.lifecycleContracts);
+  const contracts = resolveContracts(project, held, input.ts.lifecycle_contracts);
   const components = [
     ...byComponents(project, held, chains, contracts),
     ...byBases(project, held, chains, contracts),
@@ -256,7 +256,7 @@ export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly
     return [];
   }
   const ids = new Set(components.map((one) => one.id));
-  const sides: readonly ClassSide[] = input.ts.lifecycleContracts.some((contract) =>
+  const sides: readonly ClassSide[] = input.ts.lifecycle_contracts.some((contract) =>
     contract.members.some((name) => name.endsWith(":static")),
   )
     ? ["instance", "static"]