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

package/src/verbs/describe.ts

@@ -1,20 +1,29 @@
+import {
+  CONTRACT_VERSION,
+  EXIT_CLEAN,
+  EXIT_USAGE,
+  FACTS_VERSION,
+  SCHEMA_VERSIONS,
+} from "../contract/contract.generated.ts";
 import { CONFORMANCE, type Conformance } from "../conformance.ts";
-import { ANALYZER_NAME, LANGUAGE, SCHEMA_VERSIONS_ACCEPTED } from "../report.ts";
-import { CONTRACT_VERSION } from "../version.ts";
-import { EXIT_CLEAN, EXIT_FAILURE, EXIT_USAGE, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
+import { diagnose, LANGUAGE, PRODUCT } from "../product.ts";
+import { ownVersion } from "./version.ts";
 
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
- * report schema versions it reads, the languages it claims, and its recorded result over
- * the conformance corpus, a member the document omits where no run is recorded.
+ * report schema versions it reads, the languages it claims, the facts version it writes,
+ * and its recorded result over the conformance corpus, a member the document omits where
+ * no run is recorded.
  */
 export function describeDocument(version: string, recorded: Conformance | undefined): string {
   const document = {
-    name: ANALYZER_NAME,
+    name: PRODUCT,
     version,
     contract_version: CONTRACT_VERSION,
-    schema_versions_accepted: SCHEMA_VERSIONS_ACCEPTED,
+    schema_versions_accepted: SCHEMA_VERSIONS,
     languages: [LANGUAGE],
+    facts_version_written: FACTS_VERSION,
     ...(recorded === undefined
       ? {}
       : {
@@ -28,19 +37,12 @@ export function describeDocument(version: string, recorded: Conformance | undefi
   return `${JSON.stringify(document, null, 2)}\n`;
 }
 
-/** Writes this analyzer's description to the output stream, and nothing to the error stream. */
+/** Writes this analyzer's description to the output stream. */
 export const describeVerb: Verb = ({ out, err, host, args }) => {
   if (args.length > 0) {
-    err.write(`deadset-ts: describe takes no argument, got ${JSON.stringify(args[0])}\n`);
+    diagnose(err, `describe takes no argument, got ${JSON.stringify(args[0])}`);
     return EXIT_USAGE;
   }
-  let version: string;
-  try {
-    version = host.analyzerVersion();
-  } catch (error: unknown) {
-    err.write(`deadset-ts: describe: ${error instanceof Error ? error.message : String(error)}\n`);
-    return EXIT_FAILURE;
-  }
-  out.write(describeDocument(version, CONFORMANCE));
+  out.write(describeDocument(ownVersion(host), CONFORMANCE));
   return EXIT_CLEAN;
 };

package/src/verbs/explain.ts

@@ -1,18 +1,21 @@
-import { runAnalysis, type RunAnalysis } from "../analysis.ts";
-import { listing } from "../components.ts";
+import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.ts";
+import { productionMode, runAnalysis, type RunAnalysis } from "../analysis.ts";
+import { listing } from "../liveness/components.ts";
 import type { Cascade } from "../config.ts";
-import { ConfigError } from "../config.ts";
 import type { CompletedFinding } from "../finding.ts";
-import { OUTSIDE, swept as judged } from "../graph.ts";
+import { swept as judged, type Edge, type Graph } from "../liveness/graph.ts";
+import type { Origin } from "../liveness/sweep.ts";
 import type { InventorySymbol } from "../inventory.ts";
-import { referenceKey, type Configured } from "../matrix.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { positionKey } from "../position.ts";
 import type { Reference } from "../references.ts";
+import { madeByTestCode } from "../tests/file-class.ts";
 import { resolve } from "../resolve.ts";
-import type { Root } from "../roots.ts";
-import { EXIT_CLEAN, EXIT_USAGE, type Verb, type VerbOptions } from "./verb.ts";
+import { type Verb, type VerbOptions } from "./verb.ts";
+import { UsageError } from "../usage.ts";
+import { bytewise } from "../text/compare.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * The three spellings of an explanation request, each naming the symbol to explain. They are
@@ -44,16 +47,12 @@ function namedSymbol(option: (name: string) => string | undefined): string {
   });
   const [only, ...more] = named;
   if (only === undefined) {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       "explain explains the symbol --why, --why-live or --why-not names, and none was named",
     );
   }
   if (more.length > 0) {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       `explain explains one symbol, and ${named.map((one) => `--${one.name}`).join(", ")} each name one`,
     );
   }
@@ -101,141 +100,32 @@ function subjectOf(
         symbol.ref.toLowerCase().includes(folded) || symbol.name.toLowerCase().includes(folded),
     )
     .map(described)
-    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    .sort(bytewise);
   return { candidates: partial.slice(0, MAX_PARTIAL_MATCHES) };
 }
 
-/** Every reference of the run once, a reference several configurations make counted once. */
-function referencesOf(configured: readonly Configured[]): readonly Reference[] {
-  const seen = new Set<string>();
-  const held: Reference[] = [];
-  for (const reference of configured.flatMap((one) => one.references)) {
-    const key = referenceKey(reference);
-    if (!seen.has(key)) {
-      seen.add(key);
-      held.push(reference);
-    }
-  }
-  return held;
-}
-
-/** Every root of the run once per reason, in the order the projects name them. */
-function rootsOf(configured: readonly Configured[]): readonly Root[] {
-  const seen = new Set<string>();
-  return configured
-    .flatMap((one) => one.roots)
-    .filter((root) => {
-      const key = [root.id, root.kind, root.source].join("\u0000");
-      if (seen.has(key)) {
-        return false;
-      }
-      seen.add(key);
-      return true;
-    });
-}
-
-/**
- * One step of a path: a reference, or a reference that reads a module and so reaches a
- * declaration the module exports.
- */
-type Hop =
-  | { readonly k: "reference"; readonly reference: Reference }
-  | { readonly k: "export"; readonly reference: Reference; readonly to: string };
-
-/** Where a path starts: a root of the run, or a reference a loaded consumer makes. */
-type Origin =
-  | { readonly k: "root"; readonly root: Root }
-  | { readonly k: "consumer"; readonly consumer: string };
-
-/**
- * The shortest path from a root or a loaded consumer to one declaration, walked breadth first
- * from every root at once in the order the run names them, a consumer's reference being the
- * first hop of a path of its own, and following the references the sweep follows: a
- * reference that reads a module reaches what the module exports, and an evaluation or a root
- * reaches the module alone. Under `production` no reference a test file made is followed,
- * which is the set the report's sweep counts.
- */
-function shortestPath(
-  analysis: RunAnalysis,
-  to: string,
-  production: boolean,
-): { readonly origin: Origin; readonly path: readonly Hop[] } | undefined {
-  const graph = analysis.swept.matrix.union;
-  const out = new Map<string, Reference[]>();
-  const consumed: (Reference & { readonly consumer: string })[] = [];
-  for (const reference of referencesOf(analysis.configured)) {
-    if (production && reference.test) {
-      continue;
-    }
-    const { consumer } = reference;
-    if (consumer !== undefined) {
-      consumed.push({ ...reference, consumer });
-      continue;
-    }
-    const held = out.get(reference.from);
-    if (held === undefined) {
-      out.set(reference.from, [reference]);
-    } else {
-      held.push(reference);
-    }
-  }
-  interface Step {
-    readonly at: string;
-    readonly hop: Hop | undefined;
-    readonly previous: number;
-    readonly origin: Origin;
-  }
-  const steps: Step[] = [];
-  const seen = new Set<string>();
-  const expanded = new Set<string>();
-  const enter = (step: Step): void => {
-    if (!seen.has(step.at)) {
-      seen.add(step.at);
-      steps.push(step);
-    }
-  };
-  const follow = (reference: Reference, previous: number, origin: Origin): void => {
-    enter({ at: reference.to, hop: { k: "reference", reference }, previous, origin });
-    const target = graph.at(reference.to);
-    if (reference.use === "evaluation" || target === OUTSIDE || expanded.has(reference.to)) {
-      return;
-    }
-    expanded.add(reference.to);
-    for (const exported of graph.exportsOf[target] ?? []) {
-      const id = graph.symbols[exported]?.id;
-      if (id !== undefined) {
-        enter({ at: id, hop: { k: "export", reference, to: id }, previous, origin });
-      }
-    }
-  };
-  for (const root of rootsOf(analysis.configured)) {
-    enter({ at: root.id, hop: undefined, previous: -1, origin: { k: "root", root } });
-  }
-  // A consumer's reference is one hop long, so it joins the walk where the roots' first
-  // hops do.
-  const firstHops = steps.length;
-  for (let head = 0; ; head += 1) {
-    if (head === firstHops) {
-      for (const reference of consumed) {
-        follow(reference, -1, { k: "consumer", consumer: reference.consumer });
-      }
-    }
-    const step = steps[head];
-    if (step === undefined) {
-      break;
-    }
-    if (step.at === to) {
-      const path: Hop[] = [];
-      for (let at: Step | undefined = step; at?.hop !== undefined; at = steps[at.previous]) {
-        path.unshift(at.hop);
+/** Where a path starts, as a line names it. */
+function originText(origin: Origin, graph: Graph): string {
+  const id = (at: number): string => graph.symbols[at]?.id ?? "";
+  switch (origin.k) {
+    case "root":
+      return `root ${origin.rooted.kind} ${id(origin.rooted.at)}`;
+    case "consumed": {
+      const reference = graph.references[origin.edge.reference];
+      if (reference?.consumer !== undefined) {
+        return `consumer ${reference.consumer}`;
       }
-      return { origin: step.origin, path };
-    }
-    for (const reference of out.get(step.at) ?? []) {
-      follow(reference, head, step.origin);
+      return reference?.unheld === true
+        ? `test file no project holds ${reference.from.replace(/#$/u, "")}`
+        : `declaration no configuration judges ${reference?.from ?? ""}`;
     }
+    case "exemption":
+      return `exemption ${origin.record.class} ${positionKey(origin.record.site)}`;
+    case "mark":
+      return `suppression of ${id(origin.at)}`;
+    case "unanswered":
+      return `unanswered question about ${id(origin.at)}`;
   }
-  return undefined;
 }
 
 /** What made a reference: a declaration of the target, or a loaded consumer. */
@@ -243,39 +133,74 @@ function madeBy(reference: Reference): string {
   return reference.consumer === undefined ? reference.from : `consumer ${reference.consumer}`;
 }
 
-function referenceLine(reference: Reference, tail: string): string {
-  return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${reference.test ? "\tfrom a test file" : ""}\n`;
+/**
+ * One reference of an answer, marked where test code made it, a test-support file's included,
+ * and naming the configurations that make it where they are not every one of the run.
+ */
+function referenceLine(
+  reference: Reference,
+  tail: string,
+  support: ReadonlySet<string>,
+  configurations: { readonly making: readonly string[]; readonly run: readonly string[] },
+): string {
+  const partial = configurations.making.length < configurations.run.length;
+  return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${madeByTestCode(reference, support) ? "\tfrom a test file" : ""}${partial ? `\tmade in ${configurations.making.join(" ")}` : ""}\n`;
 }
 
 /** Why a declaration no finding names and no exemption held back is live, or how it fell. */
 function liveness(analysis: RunAnalysis, subject: InventorySymbol, cascade: Cascade): string {
-  const { sweep } = analysis.swept;
+  const { matrix, sweep } = analysis.swept;
+  const graph = matrix.union;
   const candidate = sweep.candidates.find((one) => one.id === subject.id);
   if (candidate === undefined && !judged(subject.kind)) {
     return `answer: unjudged\n  unjudged: neither liveness relation judges a ${subject.kind}\n`;
   }
   let text = `answer: ${candidate === undefined ? "live" : "dead"}\n`;
   text += `  live under: ${listed(sweep.liveUnder.get(subject.id) ?? [])}\n`;
-  for (const root of rootsOf(analysis.configured).filter((one) => one.id === subject.id)) {
-    text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+  const at = graph.at(subject.id);
+  const seen = new Set<string>();
+  for (const root of graph.rooted.filter((one) => one.at === at)) {
+    const key = `${root.kind}\u0000${root.source}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+    }
   }
-  const found =
-    shortestPath(analysis, subject.id, true) ?? shortestPath(analysis, subject.id, false);
-  if (found !== undefined && found.path.length > 0) {
-    const { origin } = found;
-    text += `  reached from: ${origin.k === "root" ? `root ${origin.root.kind} ${origin.root.id}` : `consumer ${origin.consumer}`}\n`;
-    for (const hop of found.path) {
-      text += referenceLine(hop.reference, `${madeBy(hop.reference)} -> ${hop.reference.to}`);
+  const support = new Set(analysis.configured.flatMap((one) => one.supportFiles ?? []));
+  const line = (edge: Edge, tail: (reference: Reference) => string): string => {
+    const reference = graph.references[edge.reference];
+    return reference === undefined
+      ? ""
+      : referenceLine(reference, tail(reference), support, {
+          making: graph.configurations[edge.reference] ?? [],
+          run: matrix.configurations,
+        });
+  };
+  const found = sweep.path(subject.id);
+  if (found !== undefined && found.hops.length > 0) {
+    text += `  reached from: ${originText(found.origin, graph)}\n`;
+    for (const hop of found.hops) {
+      text += line(hop.edge, (reference) => `${madeBy(reference)} -> ${reference.to}`);
       if (hop.k === "export") {
-        text += `  export: ${hop.reference.to} -> ${hop.to}\n`;
+        const reference = graph.references[hop.edge.reference];
+        text += `  export: ${reference?.to ?? ""} -> ${graph.symbols[hop.to]?.id ?? ""}\n`;
       }
     }
   } else if (found === undefined) {
-    const references = referencesOf(analysis.configured).filter((one) => one.to === subject.id);
-    text += "  unreachable: no path of references reaches it from a root or a loaded consumer\n";
+    const references = graph.references.flatMap((one, place) =>
+      one.to === subject.id ? [place] : [],
+    );
+    text +=
+      "  unreachable: no path of references reaches it from a root, a loaded consumer or a test file no project holds\n";
     text += `  references: ${String(references.length)}\n`;
-    for (const reference of references) {
-      text += referenceLine(reference, `from ${madeBy(reference)}`);
+    for (const place of references) {
+      const reference = graph.references[place];
+      if (reference !== undefined) {
+        text += referenceLine(reference, `from ${madeBy(reference)}`, support, {
+          making: graph.configurations[place] ?? [],
+          run: matrix.configurations,
+        });
+      }
     }
   }
   if (candidate !== undefined) {
@@ -341,7 +266,7 @@ function explanation(analysis: RunAnalysis, subject: InventorySymbol, cascade: C
   text += `position: ${subject.id}\n`;
   text += `configurations: ${listed(analysis.swept.matrix.heldIn[at] ?? [])}\n`;
   const found = analysis.result.findings.find((one) => positionKey(one.position) === subject.id);
-  const retained = analysis.swept.retained.filter((one) => one.id === subject.id);
+  const retained = analysis.swept.sweep.retained.filter((one) => one.id === subject.id);
   if (found !== undefined) {
     text += reported(found);
   } else if (retained.length > 0) {
@@ -349,7 +274,7 @@ function explanation(analysis: RunAnalysis, subject: InventorySymbol, cascade: C
     for (const one of retained) {
       text += `  class: ${one.class}\t${positionKey(one.site)}\t${one.detail}\n`;
     }
-  } else if (analysis.swept.heldByUnanswered.includes(subject.id)) {
+  } else if (analysis.swept.sweep.held.includes(subject.id)) {
     text +=
       "answer: held\n  held by: a question the checker did not answer, which could have kept it live, so no finding names it\n";
   } else {
@@ -361,18 +286,17 @@ function explanation(analysis: RunAnalysis, subject: InventorySymbol, cascade: C
 /**
  * Explains one symbol from the analysis the report is built from: why a reported symbol is
  * reported, which exemption classes held a retained one back, that an unanswered question held
- * a held one, and for any other declaration the relations that hold it live and the shortest
- * path from a root or a loaded consumer, or the references it has where no path reaches it. A
- * request naming no one declaration exits with the usage code and names what partially
+ * a held one, and for any other declaration the relations that hold it live and the path the
+ * sweep's strongest tier reaching it follows, or the references it has where no path reaches
+ * it. A request naming no one declaration exits with the usage code and names what partially
  * matches it. Where the analysis was partial, the error stream says so.
  */
 export const explainVerb: Verb = ({ out, err, host, inputs, scope, openClient, option }) => {
   const named = namedSymbol(option);
   const { config, provenance } = resolve(inputs());
   const scoped = scope();
-  const analysis = runAnalysis(openClient(config), host, scoped, config, provenance, {
-    production: true,
-  });
+  const mode = productionMode(config);
+  const analysis = runAnalysis(openClient(config), host, scoped, config, provenance, mode);
   const { subject, candidates } = subjectOf(analysis.swept.matrix.union.symbols, named);
   const notes = partialNotes({
     notBuilt: analysis.run.notBuilt,
@@ -380,7 +304,7 @@ export const explainVerb: Verb = ({ out, err, host, inputs, scope, openClient, o
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   });
   if (subject === undefined) {
-    err.write(`deadset-ts: ${JSON.stringify(named)} names no one symbol of the target\n`);
+    diagnose(err, `${JSON.stringify(named)} names no one symbol of the target`);
     for (const candidate of candidates) {
       err.write(`  ${candidate}\n`);
     }
@@ -391,7 +315,7 @@ export const explainVerb: Verb = ({ out, err, host, inputs, scope, openClient, o
     out.write(explanation(analysis, subject, config.reporters.cascade));
   }
   for (const note of notes) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return subject === undefined ? EXIT_USAGE : EXIT_CLEAN;
 };

package/src/verbs/print-config.ts

@@ -1,6 +1,7 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { printConfig } from "../print.ts";
 import { resolve } from "../resolve.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
 
 /** Writes the resolved configuration with the source of every setting. */
 export const printConfigVerb: Verb = ({ out, inputs }) => {

package/src/verbs/print-projects.ts

@@ -1,8 +1,10 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { runProjects } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
-import { resolveUnkinded } from "../resolve.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { resolvePartial } from "../resolve.ts";
+import { type Verb } from "./verb.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * Writes the name of every project one run analyzes, one per line: the identifier the
@@ -12,7 +14,7 @@ import { EXIT_CLEAN, type Verb } from "./verb.ts";
  * instead, and one that fails the analysis fails this command the same way.
  */
 export const printProjectsVerb: Verb = ({ out, err, host, inputs, scope, openClient }) => {
-  const config = resolveUnkinded(inputs());
+  const config = resolvePartial(inputs());
   const scoped = scope();
   const answer = runProjects(openClient(config), host, scoped, config);
   for (const id of answer.configurations) {
@@ -23,7 +25,7 @@ export const printProjectsVerb: Verb = ({ out, err, host, inputs, scope, openCli
     unanswered: answer.unanswered,
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   })) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return EXIT_CLEAN;
 };

package/src/verbs/print-retained.ts

@@ -1,9 +1,11 @@
-import { runSweep } from "../analysis.ts";
+import { EXIT_CLEAN } from "../contract/contract.generated.ts";
+import { productionMode, runSweep } from "../analysis.ts";
 import { retainedLines } from "../exempt.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * Writes every declaration an exemption held back in the production sweep a report is
@@ -17,9 +19,9 @@ export const printRetainedVerb: Verb = ({ out, err, host, inputs, scope, openCli
   const scoped = scope();
   const swept = runSweep(openClient(config), host, scoped, config, {
     marked: [],
-    mode: { production: true },
+    mode: productionMode(config),
   });
-  for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
+  for (const line of retainedLines(swept.matrix.union.symbols, swept.sweep.retained)) {
     out.write(`${line}\n`);
   }
   for (const note of partialNotes({
@@ -27,7 +29,7 @@ export const printRetainedVerb: Verb = ({ out, err, host, inputs, scope, openCli
     unanswered: swept.unanswered,
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   })) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return EXIT_CLEAN;
 };

package/src/verbs/print-roots.ts

@@ -1,8 +1,10 @@
+import { EXIT_CLEAN, EXIT_FINDINGS } from "../contract/contract.generated.ts";
 import { runRoots, type RunRoot } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
-import { EXIT_CLEAN, EXIT_FINDINGS, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * One root as a line: the declaration's reference, why it is a root, and the string
@@ -41,7 +43,7 @@ export const printRootsVerb: Verb = ({ out, err, host, inputs, scope, openClient
     unanswered: answer.unanswered,
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   })) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
 };

package/src/verbs/verb.ts

@@ -1,15 +1,9 @@
-import type { Config, Inputs } from "../config.ts";
+import type { Inputs, PartialConfig } from "../config.ts";
 import type { Host } from "../host.ts";
 import type { Writer } from "../run.ts";
 import type { Scope } from "../scope.ts";
 import type { Engine } from "../session.ts";
 
-/** The exit codes the Contract's exit-code table names. */
-export const EXIT_CLEAN = 0;
-export const EXIT_FINDINGS = 1;
-export const EXIT_USAGE = 2;
-export const EXIT_FAILURE = 3;
-
 /**
  * What one verb is handed: the streams it writes, the platform it reads, and the
  * options that follow its name, read only when the verb asks for what they name, so
@@ -27,7 +21,7 @@ interface Invocation {
    * Opens the compiler client for a run under `config`. A client the verb opened is
    * closed if the verb throws.
    */
-  readonly openClient: (config: Config) => Engine;
+  readonly openClient: (config: PartialConfig) => Engine;
   /** The arguments after the verb's name, as written. */
   readonly args: readonly string[];
   /** The last value one of the verb's own options was given, undefined where none was. */

package/src/verbs/version.ts

@@ -1,8 +1,20 @@
-import { CONTRACT_VERSION } from "../version.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { CONTRACT_VERSION, EXIT_CLEAN } from "../contract/contract.generated.ts";
+import { productFault } from "../failure.ts";
+import type { Host } from "../host.ts";
+import { type Verb } from "./verb.ts";
+import { message, PRODUCT } from "../product.ts";
+
+/** The version the host reports for this analyzer; one it cannot read is a fault of the analyzer. */
+export function ownVersion(host: Host): string {
+  try {
+    return host.analyzerVersion();
+  } catch (error: unknown) {
+    throw productFault(`cannot read its own version: ${message(error)}`);
+  }
+}
 
 /** Writes the version the host reports and the Contract version this analyzer implements. */
 export const versionVerb: Verb = ({ out, host }) => {
-  out.write(`deadset-ts ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
+  out.write(`${PRODUCT} ${ownVersion(host)}\ncontract ${CONTRACT_VERSION}\n`);
   return EXIT_CLEAN;
 };

package/dist/src/base-url.js

@@ -1,18 +0,0 @@
-import { resolvePath } from "./paths.js";
-/**
- * The `paths` one configuration's resolved options map under the compilers before version
- * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
- * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
- * options' own `paths` stand. Version 7 reads no `baseUrl`:
- * https://github.com/microsoft/TypeScript/issues/62207
- */
-export function baseUrlPaths(options) {
-    const baseUrl = Reflect.get(options, "baseUrl");
-    if (typeof baseUrl !== "string") {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
-        key,
-        targets.map((target) => resolvePath(baseUrl, target)),
-    ]));
-}