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

package/src/text/shell.ts

@@ -0,0 +1,161 @@
+/**
+ * Shell command lines read as text, never run: the commands a line runs, the tokens the
+ * Contract splits a command into, and the words POSIX token recognition reads.
+ */
+
+/**
+ * The shell's list and pipeline operators, each of which ends one command. An `&` beside a
+ * redirection's `<` or `>` (`2>&1`, and bash's `&>log`) is part of the redirection.
+ */
+const COMMAND_OPERATORS = /&&|\|\||;|\||(?<![<>])&(?!>)/u;
+
+/** Where a command splits into tokens: white space and the operators the Contract names. */
+const TOKEN_SEPARATORS = /\s+|&&|\|\||;|\|/u;
+
+/** A text written inside one pair of quotes. */
+const QUOTED = /^(["'])(.*)\1$/su;
+
+/** The commands one line runs, the text between two of the shell's list and pipeline operators. */
+export function commandsOf(line: string): readonly string[] {
+  return line.split(COMMAND_OPERATORS);
+}
+
+/** One text with one pair of enclosing quotes removed. */
+export function unquoted(text: string): string {
+  return text.replace(QUOTED, "$2");
+}
+
+/**
+ * Every token one script's command line holds, each with one pair of enclosing quotes
+ * removed. A token holding a wildcard is a pattern rather than a path, and names no
+ * entry point.
+ */
+export function scriptTokens(command: string): readonly string[] {
+  return command
+    .split(TOKEN_SEPARATORS)
+    .map(unquoted)
+    .filter((token) => token !== "" && !token.includes("*"));
+}
+
+/** One shell line up to its comment: a `#` that starts a word outside quotes. */
+export function withoutComment(line: string): string {
+  let quote = "";
+  for (let at = 0; at < line.length; at += 1) {
+    const char = line[at];
+    if (quote !== "") {
+      if (char === quote) {
+        quote = "";
+      } else if (char === "\\" && quote === '"') {
+        at += 1;
+      }
+    } else if (char === "'" || char === '"') {
+      quote = char;
+    } else if (char === "\\") {
+      at += 1;
+    } else if (char === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
+      return line.slice(0, at);
+    }
+  }
+  return line;
+}
+
+/** The characters that end a word outside quotes and separate nothing: blanks. */
+// Stryker disable next-line Regex: its \v to \V mutant is no valid escape under the u flag, so the whole module fails to parse
+const BLANK = /[ \t\r\f\v]/u;
+
+/** The characters that end a word outside quotes and begin an operator: newline included. */
+const OPERATOR = /[\n;&|()<>]/u;
+
+/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
+const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
+
+/**
+ * The words of one command line, as POSIX token recognition reads quotes, backslashes,
+ * line continuations, comments and operators. A word an expansion may change (an unquoted
+ * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
+ * is computed, and so is the rest of a line whose quote is never closed. A computed word
+ * and each operator are undefined, so a flag's file is never read across them.
+ */
+export function shellWords(command: string): readonly (string | undefined)[] {
+  const words: (string | undefined)[] = [];
+  let word: string | undefined;
+  let computed = false;
+  const end = (): void => {
+    if (word !== undefined) {
+      words.push(computed ? undefined : word);
+    }
+    word = undefined;
+    computed = false;
+  };
+  for (let at = 0; at < command.length; at += 1) {
+    const char = command.charAt(at);
+    if (char === "\\" && command.charAt(at + 1) === "\n") {
+      at += 1;
+    } else if (BLANK.test(char)) {
+      end();
+    } else if (OPERATOR.test(char)) {
+      end();
+      words.push(undefined);
+    } else if (char === "#" && word === undefined) {
+      const newline = command.indexOf("\n", at);
+      at = newline < 0 ? command.length : newline - 1;
+    } else if (char === "\\") {
+      at += 1;
+      word = (word ?? "") + command.charAt(at);
+    } else if (char === "'" || char === '"') {
+      const close = closingQuote(command, at);
+      if (close < 0) {
+        word ??= "";
+        computed = true;
+        break;
+      }
+      const quoted =
+        char === "'"
+          ? { text: command.slice(at + 1, close), computed: false }
+          : doubleQuoted(command.slice(at + 1, close));
+      word = (word ?? "") + quoted.text;
+      computed ||= quoted.computed;
+      at = close;
+    } else {
+      computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
+      word = (word ?? "") + char;
+    }
+  }
+  end();
+  return words;
+}
+
+/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
+function doubleQuoted(inner: string): { readonly text: string; readonly computed: boolean } {
+  let text = "";
+  let computed = false;
+  for (let at = 0; at < inner.length; at += 1) {
+    const char = inner.charAt(at);
+    const next = inner.charAt(at + 1);
+    if (char === "\\" && next === "\n") {
+      at += 1;
+    } else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
+      text += next;
+      at += 1;
+    } else {
+      computed ||= char === "$" || char === "`";
+      text += char;
+    }
+  }
+  return { text, computed };
+}
+
+/** The index of the quote that closes the one at `open`, or -1 where none does. */
+function closingQuote(command: string, open: number): number {
+  const quote = command.charAt(open);
+  for (let at = open + 1; at < command.length; at += 1) {
+    const char = command.charAt(at);
+    if (char === quote) {
+      return at;
+    }
+    if (quote === '"' && char === "\\") {
+      at += 1;
+    }
+  }
+  return -1;
+}

package/src/{yaml-document.ts → text/yaml.ts}

@@ -6,6 +6,8 @@
  * as a JSON document that does not parse has none.
  */
 
+import { isRecord } from "../json-document.ts";
+
 /** One line of the document with its comment removed, by its indentation and its content. */
 interface Line {
   readonly indent: number;
@@ -375,3 +377,47 @@ export function yamlDocument(text: string): unknown {
     throw error;
   }
 }
+
+/** What one top-level key of a YAML document holds, read by {@link yamlKey}. */
+type YamlKey =
+  | { readonly kind: "value"; readonly value: unknown }
+  | { readonly kind: "absent" }
+  | { readonly kind: "refused"; readonly reason: string };
+
+/** The key one line of the document's top-level mapping opens, or undefined where it opens none. */
+function topLevelKey(raw: string): string | undefined {
+  const content = withoutComment(raw).trimEnd();
+  const end = /^\s/u.test(content) ? -1 : keyEnd(content);
+  if (end < 0) {
+    return undefined;
+  }
+  try {
+    const key = scalar(content.slice(0, end));
+    return typeof key === "object" && key !== null ? undefined : String(key);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The value of one key of a document's top-level block mapping, read from that key's lines
+ * alone, so a document whose other keys lie outside the subset still yields it. A key
+ * declared twice, or one whose own lines lie outside the subset, is refused.
+ */
+export function yamlKey(text: string, key: string): YamlKey {
+  const lines = text.replace(/^\uFEFF/u, "").split(/\r?\n/u);
+  const starts = lines.flatMap((line, at) => (topLevelKey(line) === undefined ? [] : [at]));
+  const named = starts.filter((at) => topLevelKey(lines[at] ?? "") === key);
+  const [start] = named;
+  if (start === undefined) {
+    return { kind: "absent" };
+  }
+  if (named.length > 1) {
+    return { kind: "refused", reason: `the ${key} key is declared more than once` };
+  }
+  const end = starts.find((at) => at > start) ?? lines.length;
+  const value = yamlDocument(lines.slice(start, end).join("\n"));
+  return isRecord(value)
+    ? { kind: "value", value: value[key] }
+    : { kind: "refused", reason: `the value of ${key} is outside the YAML subset read here` };
+}

package/src/type-errors.ts

@@ -21,12 +21,21 @@ import { packageOfSpecifier } from "./dependencies.ts";
 import type { LocatedDiagnostic } from "./discover.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import {
+  ancestors,
+  dirnamePath,
+  isAbsolutePath,
+  joinPath,
+  relativePath,
+  resolvePath,
+} from "./paths.ts";
 import { isAnswered } from "./query.ts";
 import type { TypeErrorSkip } from "./report.ts";
 import type { Engine, ProjectView } from "./session.ts";
 import type { SetupFailure } from "./setup-failure.ts";
 import { findWorkspace, type Workspace } from "./workspace.ts";
+import { entriesOf } from "./fs/tree.ts";
+import { INSTALLED_PACKAGES, MANIFEST, manifestAt } from "./fs/manifest.ts";
 
 /** The compiler's codes for an import whose module it cannot find. */
 const MODULE_NOT_FOUND: ReadonlySet<number> = new Set([2307, 2792]);
@@ -38,7 +47,6 @@ const MODULE_NOT_FOUND: ReadonlySet<number> = new Set([2307, 2792]);
  */
 const CONFIGURATION_LEVEL: ReadonlySet<number> = new Set([5055, 5056, 6059, 6307]);
 
-const MANIFEST = "package.json";
 const MANIFEST_SECTIONS = [
   "dependencies",
   "devDependencies",
@@ -156,13 +164,9 @@ function provided(host: Host, path: string, fileOnly: boolean): boolean {
   }
   const dir = dirnamePath(path);
   const stem = `${path.slice(dir.length + 1)}.`;
-  try {
-    return host
-      .readDirectory(dir)
-      .some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
-  } catch {
-    return false;
-  }
+  return entriesOf(host, dir).some(
+    (entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)),
+  );
 }
 
 /** The manifest at or above `dir`, no higher than the target root, that declares `name`. */
@@ -172,28 +176,18 @@ function declaringManifest(
   targetRoot: string,
   name: string,
 ): string | undefined {
-  for (let at = dir; ; at = dirnamePath(at)) {
-    const path = joinPath(at, MANIFEST);
-    let manifest: unknown;
-    try {
-      manifest = JSON.parse(host.readFile(path)) as unknown;
-    } catch {
-      manifest = undefined;
-    }
-    if (typeof manifest === "object" && manifest !== null) {
-      const sections = manifest as Record<string, unknown>;
-      for (const section of MANIFEST_SECTIONS) {
-        const declared = sections[section];
-        if (typeof declared === "object" && declared !== null && Object.hasOwn(declared, name)) {
-          return path;
-        }
+  const chain = ancestors(dir, targetRoot);
+  // A directory outside the target root reads its own manifest alone.
+  for (const at of chain.length > 0 ? chain : [dir]) {
+    const manifest = manifestAt(host, at);
+    for (const section of MANIFEST_SECTIONS) {
+      const declared = manifest?.[section];
+      if (typeof declared === "object" && declared !== null && Object.hasOwn(declared, name)) {
+        return joinPath(at, MANIFEST);
       }
     }
-    // The target root is not below itself, so the walk stops after reading its manifest.
-    if (relativePath(targetRoot, at) === undefined) {
-      return undefined;
-    }
   }
+  return undefined;
 }
 
 /**
@@ -201,14 +195,9 @@ function declaringManifest(
  * `dir` or of any ancestor, above the target root too, as Node and the compiler look.
  */
 function installed(host: Host, dir: string, name: string): boolean {
-  for (let at = dir; ; at = dirnamePath(at)) {
-    if (host.kindOf(joinPath(at, "node_modules", name)) === "directory") {
-      return true;
-    }
-    if (dirnamePath(at) === at) {
-      return false;
-    }
-  }
+  return ancestors(dir).some(
+    (at) => host.kindOf(joinPath(at, INSTALLED_PACKAGES, name)) === "directory",
+  );
 }
 
 /**

package/src/unseen-loads.ts

@@ -6,13 +6,10 @@
  */
 
 import {
-  isAsExpression,
   isBinaryExpression,
   isCallExpression,
   isIdentifier,
   isNoSubstitutionTemplateLiteral,
-  isParenthesizedExpression,
-  isSatisfiesExpression,
   isStringLiteral,
   isTemplateExpression,
   SyntaxKind,
@@ -23,6 +20,7 @@ import { renderPosition, type Position } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { sourceFilesOf } from "./source-files.ts";
+import { unwrapped } from "./unwrap.ts";
 
 /** One load the analysis cannot resolve, in the configuration whose production file writes it. */
 export interface UnseenLoad {
@@ -31,15 +29,6 @@ export interface UnseenLoad {
   readonly position: Position;
 }
 
-/** 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 literal text a computed path starts with: a template's head, or a concatenation's first literal. */
 export function leadingLiteral(node: Node): string | undefined {
   const at = unwrapped(node);

package/src/unwrap.ts

@@ -0,0 +1,34 @@
+import {
+  isAsExpression,
+  isNonNullExpression,
+  isParenthesizedExpression,
+  isSatisfiesExpression,
+  type Expression,
+  type Node,
+} from "@typescript/native/ast";
+
+/** The expression inside every pair of parentheses around `node`. */
+export function parenthesesRemoved<T extends Node>(node: T): T | Expression {
+  let at: T | Expression = node;
+  while (isParenthesizedExpression(at)) {
+    at = at.expression;
+  }
+  return at;
+}
+
+/**
+ * The expression inside every wrapper around `node` that changes no value it evaluates to:
+ * parentheses, `as` and `satisfies` assertions and the non-null assertion.
+ */
+export function unwrapped<T extends Node>(node: T): T | Expression {
+  let at: T | Expression = node;
+  while (
+    isParenthesizedExpression(at) ||
+    isAsExpression(at) ||
+    isSatisfiesExpression(at) ||
+    isNonNullExpression(at)
+  ) {
+    at = at.expression;
+  }
+  return at;
+}

package/src/verbs/analyze.ts

@@ -23,7 +23,6 @@ import type { NotBuilt } from "../discover.ts";
 import { partialNotes } from "../partial.ts";
 import {
   buildReport,
-  LANGUAGE,
   capFindings,
   sortFindings,
   type ReportConfiguration,
@@ -39,6 +38,8 @@ import { resolve } from "../resolve.ts";
 import { otherSchemeRows, rowReason, writeBaseline, type Recorded } from "../suppress-file.ts";
 import type { UnseenLoad } from "../unseen-loads.ts";
 import { type Verb, type VerbOptions } from "./verb.ts";
+import { bytewise } from "../text/compare.ts";
+import { diagnose, LANGUAGE, message } from "../product.ts";
 
 /** The options `analyze` takes beside the ones every verb takes. */
 export const ANALYZE_OPTIONS: VerbOptions = {
@@ -60,7 +61,7 @@ class ReportPathError extends Error {
 
 /** The formats this analyzer renders, for a message that names them. */
 function formatNames(): string {
-  return [...RENDERINGS.keys()].sort().join(", ");
+  return [...RENDERINGS.keys()].sort(bytewise).join(", ");
 }
 
 /** The renderings one invocation writes: the ones it named, else the configuration's. */
@@ -200,11 +201,7 @@ function templateOf(
   try {
     source = host.readFile(resolvePath(invoked, named));
   } catch (error: unknown) {
-    throw new ConfigError(
-      "malformed",
-      "",
-      `--template=${named}: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    throw new ConfigError("malformed", "", `--template=${named}: ${message(error)}`);
   }
   try {
     return parseTemplate(source);
@@ -268,7 +265,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   try {
     version = host.analyzerVersion();
   } catch (error: unknown) {
-    err.write(`deadset-ts: ${error instanceof Error ? error.message : String(error)}\n`);
+    diagnose(err, message(error));
     return EXIT_FAILURE;
   }
 
@@ -349,7 +346,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
     if (!(error instanceof ReportPathError)) {
       throw error;
     }
-    err.write(`deadset-ts: ${error.message}\n`);
+    diagnose(err, error.message);
     return EXIT_FAILURE;
   }
 
@@ -382,38 +379,42 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       );
     }
   } catch (error: unknown) {
-    err.write(`deadset-ts: ${error instanceof Error ? error.message : String(error)}\n`);
+    diagnose(err, message(error));
     return EXIT_FAILURE;
   }
 
   for (const note of partial) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   for (const line of [...unread, ...unfound]) {
-    err.write(`deadset-ts: ${line}\n`);
+    diagnose(err, line);
   }
   for (const warning of warnings) {
-    err.write(
-      `deadset-ts: ${warning.path}:${String(warning.line)}: a <script> start tag that begins a line is not read as a block: ${warning.reason}\n`,
+    diagnose(
+      err,
+      `${warning.path}:${String(warning.line)}: a <script> start tag that begins a line is not read as a block: ${warning.reason}`,
     );
   }
   for (const skip of report.type_error_skips) {
-    err.write(
-      `deadset-ts: ${skip.path}:${String(skip.line)}: ${skip.message}: the function or statement holding this type error is not evaluated\n`,
+    diagnose(
+      err,
+      `${skip.path}:${String(skip.line)}: ${skip.message}: the function or statement holding this type error is not evaluated`,
     );
   }
   if (report.totals.pending > 0) {
-    err.write(
-      `deadset-ts: ${counted(report.totals.pending, "pending finding")}: the report names a declared cross-language edge, and no merge has resolved it\n`,
+    diagnose(
+      err,
+      `${counted(report.totals.pending, "pending finding")}: the report names a declared cross-language edge, and no merge has resolved it`,
     );
   }
   if (report.totals.stale_suppressions > 0) {
-    err.write(`deadset-ts: ${counted(report.totals.stale_suppressions, "stale suppression")}\n`);
+    diagnose(err, counted(report.totals.stale_suppressions, "stale suppression"));
   }
   if (exitCode === EXIT_CODE_OFF) {
     if (verdict !== EXIT_CLEAN) {
-      err.write(
-        `deadset-ts: the exit code is configured off: the verdict of this run is ${String(verdict)}\n`,
+      diagnose(
+        err,
+        `the exit code is configured off: the verdict of this run is ${String(verdict)}`,
       );
     }
     return EXIT_CLEAN;

package/src/verbs/describe.ts

@@ -6,8 +6,8 @@ import {
   SCHEMA_VERSIONS,
 } from "../contract/contract.generated.ts";
 import { CONFORMANCE, type Conformance } from "../conformance.ts";
-import { ANALYZER_NAME, LANGUAGE } from "../report.ts";
 import { type Verb } from "./verb.ts";
+import { diagnose, LANGUAGE, message, PRODUCT } from "../product.ts";
 
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
@@ -16,7 +16,7 @@ import { type Verb } from "./verb.ts";
  */
 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,
@@ -37,14 +37,14 @@ export function describeDocument(version: string, recorded: Conformance | undefi
 /** Writes this analyzer's description to the output stream, and nothing to the error 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`);
+    diagnose(err, `describe: ${message(error)}`);
     return EXIT_FAILURE;
   }
   out.write(describeDocument(version, CONFORMANCE));

package/src/verbs/explain.ts

@@ -14,6 +14,8 @@ import type { Reference } from "../references.ts";
 import { resolve } from "../resolve.ts";
 import type { Root } from "../roots.ts";
 import { type Verb, type VerbOptions } from "./verb.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
@@ -102,7 +104,7 @@ 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) };
 }
 
@@ -381,7 +383,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`);
     }
@@ -392,7 +394,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-projects.ts

@@ -4,6 +4,7 @@ import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolveUnkinded } 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
@@ -24,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

@@ -5,6 +5,7 @@ import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.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
@@ -28,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

@@ -4,6 +4,7 @@ import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.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
@@ -42,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/version.ts

@@ -1,8 +1,9 @@
 import { CONTRACT_VERSION, EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { type Verb } from "./verb.ts";
+import { PRODUCT } from "../product.ts";
 
 /** 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} ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
   return EXIT_CLEAN;
 };