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

package/src/resolve.ts

@@ -1,21 +1,28 @@
+import {
+  SEVERITIES,
+  LANGUAGES,
+  CONFIDENCES,
+  FORMATS,
+  type Confidence,
+  type Format,
+  type Language,
+  type Severity,
+  FAMILY_KEY_LENGTH,
+} from "./contract/contract.generated.ts";
 import {
   ConfigError,
   defaultConfig,
   type BuildConfiguration,
   type Cascade,
   type Config,
-  type Confidence,
   type ConsumerTests,
   type DeclarationEntry,
-  type Format,
   type GeneratedFiles,
   type Inputs,
-  type Language,
   type LifecycleContract,
   type Origin,
   type Provenance,
   type Provider,
-  type Severity,
   type Sort,
   type Source,
   type TargetKind,
@@ -23,6 +30,7 @@ import {
   type TemplateDelimiters,
 } from "./config.ts";
 import { CONVENTION_ROWS } from "./convention-rows.ts";
+import { EXEMPTION_CLASS_NAMES, type ExemptionClass } from "./exempt-classes.ts";
 import { FIXED_SEVERITY_CODES, LIVE_CODES } from "./kinds.ts";
 import {
   checkDocument,
@@ -32,15 +40,14 @@ import {
   SEVERITY_SECTION,
   type KeyNode,
 } from "./schema.ts";
+import { bytewise } from "./text/compare.ts";
+import { isRecord } from "./json-document.ts";
+import { message } from "./product.ts";
 
 /** Names the command-line flags in a refusal, where a document is named by its path. */
 const FLAGS_LABEL = "the command-line flags";
 
-/** The length of a severity key naming a whole family: the prefix and two digits. */
-export const FAMILY_KEY_LENGTH = 4;
-
 const SEVERITY_KEY = /^DS[0-9]{2}([0-9]{2})?$/u;
-const EXEMPTION_CLASS = /^[a-z][a-z0-9-]*$/u;
 const CONTRACT_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/u;
 const ANALYZER_NAME = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/u;
 const PROVIDER_SOURCE = /^(go|npm):[^ \t\r\n]+$/u;
@@ -69,12 +76,8 @@ const PROJECT_SEGMENT = String.raw`(?:[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.[^/
 const PROJECT_PATH = new RegExp(`^${PROJECT_SEGMENT}(?:/${PROJECT_SEGMENT})*$`, "u");
 
 const TARGET_KINDS: readonly TargetKind[] = ["application", "library"];
-const CONFIDENCES: readonly Confidence[] = ["certain", "probable", "possible"];
 const GENERATED_FILES: readonly GeneratedFiles[] = ["exclude", "include"];
 const CONSUMER_TESTS: readonly ConsumerTests[] = ["test", "production"];
-const LANGUAGES: readonly Language[] = ["go", "ts"];
-const SEVERITIES: readonly Severity[] = ["allow", "warn", "deny"];
-const FORMATS: readonly Format[] = ["text", "json", "github", "sarif", "template"];
 const SORTS: readonly Sort[] = ["position", "size"];
 const CASCADES: readonly Cascade[] = ["roots", "full"];
 
@@ -98,7 +101,7 @@ interface Doc {
   readonly consumersComplete: boolean | undefined;
   readonly rootPatterns: readonly string[] | undefined;
   readonly severity: ReadonlyMap<string, Severity> | undefined;
-  readonly exemptionsDisabled: readonly string[] | undefined;
+  readonly exemptionsDisabled: readonly ExemptionClass[] | undefined;
   readonly formats: readonly Format[] | undefined;
   readonly sort: Sort | undefined;
   readonly cascade: Cascade | undefined;
@@ -134,10 +137,6 @@ function originOf(source: DocSource, path: string): Origin {
   return { source: source.kind, label: source.label };
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 function member(parent: Record<string, unknown> | undefined, name: string): unknown {
   if (parent === undefined || !Object.hasOwn(parent, name)) {
     return undefined;
@@ -505,7 +504,7 @@ function fixedByContract(code: string): string[] {
   return FIXED_SEVERITY_CODES.filter(
     (candidate) =>
       code === candidate || (code.length === FAMILY_KEY_LENGTH && candidate.startsWith(code)),
-  ).sort();
+  ).sort(bytewise);
 }
 
 /** The codes a refusal names: one on its own, and several with the last joined by and. */
@@ -543,7 +542,7 @@ function readSeverity(
     return undefined;
   }
   const severity = new Map<string, Severity>();
-  for (const code of Object.keys(object).sort()) {
+  for (const code of Object.keys(object).sort(bytewise)) {
     const path = `${SEVERITY_SECTION}.${code}`;
     if (!SEVERITY_KEY.test(code)) {
       throw unimplementedSeverityKey(
@@ -577,26 +576,20 @@ function readSeverity(
   return severity;
 }
 
-/** The exemption classes named for switching off. */
+/** The exemption classes named for switching off, each one the vocabulary holds. */
 function readExemptions(
   document: Record<string, unknown> | undefined,
   label: string,
-): readonly string[] | undefined {
+): readonly ExemptionClass[] | undefined {
   const exemptions = section(document, "exemptions", "exemptions", label);
-  const disabled = readStrings(exemptions, "disabled", "exemptions.disabled", label, 0);
-  if (disabled === undefined) {
-    return undefined;
-  }
-  for (const entry of disabled) {
-    if (!EXEMPTION_CLASS.test(entry)) {
-      throw malformed(
-        label,
-        "exemptions.disabled",
-        `${JSON.stringify(entry)} is not an exemption class name`,
-      );
-    }
-  }
-  return disabled;
+  return readStrings(
+    exemptions,
+    "disabled",
+    "exemptions.disabled",
+    label,
+    0,
+    EXEMPTION_CLASS_NAMES,
+  );
 }
 
 /** The members that name a declaration, each belonging to exactly one shape. */
@@ -905,7 +898,7 @@ function parseDocument(text: string, node: KeyNode, label: string): unknown {
   try {
     value = JSON.parse(text);
   } catch (error: unknown) {
-    throw malformed(label, "", error instanceof Error ? error.message : String(error));
+    throw malformed(label, "", message(error));
   }
   checkDocument(text, node, label);
   return value;
@@ -1002,7 +995,7 @@ function settleSeverity(
     }
   }
   const severity = new Map<string, Severity>();
-  for (const code of [...codes].sort()) {
+  for (const code of [...codes].sort(bytewise)) {
     const path = `${SEVERITY_SECTION}.${code}`;
     for (const source of sources) {
       const value = source.doc.severity?.get(code);
@@ -1044,7 +1037,7 @@ function describeSource(
  * print a provenance value the closed key list refuses to read back.
  */
 function checkLabels(provenance: ReadonlyMap<string, Origin>): void {
-  for (const path of [...provenance.keys()].sort()) {
+  for (const path of [...provenance.keys()].sort(bytewise)) {
     const origin = provenance.get(path);
     if (origin !== undefined && origin.source !== "default" && origin.label === "") {
       throw malformed(

package/src/roots.ts

@@ -43,17 +43,19 @@ import {
 } from "./configuration-files.ts";
 import { conventionEntries, type Conventions } from "./conventions.ts";
 import { entryPoints, type EntryRule } from "./entry-points.ts";
-import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import type { Manifest, ManifestEntry } from "./manifest.ts";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { byPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
 import { sourceFilesOf, type SourceFiles } from "./source-files.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
+import { bytewise } from "./text/compare.ts";
+import { holdsManifest } from "./fs/manifest.ts";
+import { globExpression } from "./text/glob.ts";
 
 /** Why one declaration is a root. */
 export type RootKind =
@@ -197,15 +199,8 @@ const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
 
 /** Whether no `package.json` sits between one file and the manifest's directory, which holds it. */
 function ofPackage(host: Host, dir: string, file: string): boolean {
-  for (let at = dirnamePath(file); at !== dir; at = dirnamePath(at)) {
-    if (
-      relativePath(dir, at) === undefined ||
-      host.kindOf(joinPath(at, "package.json")) === "file"
-    ) {
-      return false;
-    }
-  }
-  return true;
+  const between = ancestors(dirnamePath(file), dir);
+  return between.length > 0 && !between.slice(0, -1).some((at) => holdsManifest(host, at));
 }
 
 /**
@@ -331,14 +326,6 @@ export function matchRef(pattern: string, ref: string): boolean {
   return matchGlob(Array.from(pattern), Array.from(ref));
 }
 
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /** The members of one declaration, indexed by the container that holds them. */
 function childrenOf(held: Inventory): ReadonlyMap<string, readonly InventorySymbol[]> {
   const byParent = new Map<string, InventorySymbol[]>();
@@ -561,7 +548,7 @@ export function roots<Brand>(
     const left = sites.get(a.id);
     const right = sites.get(b.id);
     const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
-    return site || compare(a.kind, b.kind) || compare(a.source, b.source);
+    return site || bytewise(a.kind, b.kind) || bytewise(a.source, b.source);
   });
 
   return {

package/src/run.ts

@@ -1,3 +1,4 @@
+import { EXIT_FAILURE, EXIT_USAGE } from "./contract/contract.generated.ts";
 import { ConfigError, REPOSITORY_DOCUMENT, type Inputs } from "./config.ts";
 import { DiscoveryError, renderDiagnostic } from "./discover.ts";
 import type { Host } from "./host.ts";
@@ -12,8 +13,9 @@ import { printRootsVerb } from "./verbs/print-roots.ts";
 import { ANALYZE_OPTIONS, analyzeVerb } from "./verbs/analyze.ts";
 import { describeVerb } from "./verbs/describe.ts";
 import { EXPLAIN_OPTIONS, explainVerb } from "./verbs/explain.ts";
-import { EXIT_FAILURE, EXIT_USAGE, type Verb, type VerbOptions } from "./verbs/verb.ts";
+import { type Verb, type VerbOptions } from "./verbs/verb.ts";
 import { versionVerb } from "./verbs/version.ts";
+import { diagnose, message, PRODUCT } from "./product.ts";
 
 /** One output stream of the command line. `process.stdout` and `process.stderr` satisfy it. */
 export interface Writer {
@@ -36,7 +38,7 @@ const VERBS: readonly {
   { name: "version", run: versionVerb },
 ];
 
-const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
+const USAGE = `usage: ${PRODUCT} <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
 
 /**
  * The tokens whose presence in an option's name makes that option a request to
@@ -140,11 +142,7 @@ function readFileOr(host: Host, path: string, orUndefined: boolean): string | un
     if (orUndefined) {
       return undefined;
     }
-    throw new ConfigError(
-      "malformed",
-      "",
-      `${path}: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    throw new ConfigError("malformed", "", `${path}: ${message(error)}`);
   }
 }
 
@@ -208,9 +206,7 @@ export function run(
 ): number {
   const editing = sourceEditOption(args);
   if (editing !== undefined) {
-    err.write(
-      `deadset-ts: ${editing} is not supported: deadset-ts reports and never edits a source file\n`,
-    );
+    diagnose(err, `${editing} is not supported: ${PRODUCT} reports and never edits a source file`);
     err.write(USAGE);
     return EXIT_USAGE;
   }
@@ -227,7 +223,7 @@ export function run(
     );
   }
   if (name !== undefined) {
-    err.write(`deadset-ts: unknown verb ${JSON.stringify(name)}\n`);
+    diagnose(err, `unknown verb ${JSON.stringify(name)}`);
   }
   err.write(USAGE);
   return EXIT_USAGE;
@@ -273,7 +269,7 @@ function invoke(
 /** Turns one refusal into the exit code the Contract's table gives it. */
 function refuse(error: unknown, err: Writer): number {
   if (error instanceof ConfigError) {
-    err.write(`deadset-ts: ${error.message}\n`);
+    diagnose(err, error.message);
     err.write(USAGE);
     return EXIT_USAGE;
   }
@@ -281,7 +277,7 @@ function refuse(error: unknown, err: Writer): number {
     for (const diagnostic of error.diagnostics) {
       err.write(`${renderDiagnostic(diagnostic)}\n`);
     }
-    err.write(`deadset-ts: ${error.message}\n`);
+    diagnose(err, error.message);
     return EXIT_FAILURE;
   }
   if (error instanceof SetupError) {
@@ -291,7 +287,7 @@ function refuse(error: unknown, err: Writer): number {
     return EXIT_FAILURE;
   }
   if (error instanceof ScopeError) {
-    err.write(`deadset-ts: ${error.message}\n`);
+    diagnose(err, error.message);
     return EXIT_FAILURE;
   }
   throw error;

package/src/schema.ts

@@ -1,4 +1,5 @@
 import { ConfigError } from "./config.ts";
+import { bytewise } from "./text/compare.ts";
 
 /**
  * How one node of the closed key list is written: `leaf`, a scalar or an array of
@@ -157,7 +158,7 @@ function collect(node: KeyNode, at: string, keys: string[], settingsOnly: boolea
 export function declaredKeys(): string[] {
   const keys: string[] = [];
   collect(SCHEMA_ROOT, "", keys, false);
-  return keys.sort();
+  return keys.sort(bytewise);
 }
 
 /**
@@ -169,7 +170,7 @@ export function declaredKeys(): string[] {
 export function settingPaths(): string[] {
   const paths: string[] = [];
   collect(SCHEMA_ROOT, "", paths, true);
-  return paths.sort();
+  return paths.sort(bytewise);
 }
 
 /**
@@ -445,7 +446,7 @@ export function checkDocument(text: string, node: KeyNode, label: string): void
  */
 export function nestFlags(flat: Readonly<Record<string, unknown>>, label: string): unknown {
   const nested: Record<string, unknown> = {};
-  for (const path of Object.keys(flat).sort()) {
+  for (const path of Object.keys(flat).sort(bytewise)) {
     if (!declaresSetting(path)) {
       throw unimplementedKey(label, path);
     }

package/src/scope.ts

@@ -2,6 +2,8 @@ import { ConfigError } from "./config.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
 import { checkDocument, type KeyNode } from "./schema.ts";
+import { isRecord } from "./json-document.ts";
+import { message } from "./product.ts";
 
 /** The roles a scope document declares for a module. */
 const ROLE_TARGET = "target";
@@ -60,10 +62,6 @@ const SCOPE_ROOT: KeyNode = {
   },
 };
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 /**
  * One string member, or undefined where the document omits it. A member the
  * document writes is a string holding at least one character, so `null` and `""`
@@ -145,9 +143,7 @@ export function readScope(host: Host, file: string): Scope {
   try {
     text = host.readFile(absolute);
   } catch (error: unknown) {
-    throw new ScopeError(
-      `scope: ${file}: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    throw new ScopeError(`scope: ${file}: ${message(error)}`);
   }
   if (text.length > MAX_DOCUMENT_LENGTH) {
     throw new ScopeError(`scope: ${file} is longer than ${String(MAX_DOCUMENT_LENGTH)} characters`);
@@ -156,9 +152,7 @@ export function readScope(host: Host, file: string): Scope {
   try {
     value = JSON.parse(text);
   } catch (error: unknown) {
-    throw new ScopeError(
-      `scope: ${file}: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    throw new ScopeError(`scope: ${file}: ${message(error)}`);
   }
   if (!isRecord(value)) {
     throw new ScopeError(`scope: ${file} is not one JSON object`);

package/src/serialization-contract.ts

@@ -53,6 +53,7 @@ import {
   type SourceFile,
   type SpreadAssignment,
 } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.ts";
 import {
   SignatureKind,
   SymbolFlags,
@@ -227,12 +228,6 @@ interface MethodForm {
   readonly invocation: Invocation;
 }
 
-function unparenthesized(expression: Expression): Expression {
-  return isParenthesizedExpression(expression)
-    ? unparenthesized(expression.expression)
-    : expression;
-}
-
 /**
  * The invocation a call writes through a method of `Function.prototype`, read from
  * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
@@ -241,12 +236,12 @@ function unparenthesized(expression: Expression): Expression {
  * carries. Whether the method is the prototype's is resolution's to say.
  */
 function throughMethod(call: CallExpression): MethodForm | undefined {
-  const expression = unparenthesized(call.expression);
+  const expression = parenthesesRemoved(call.expression);
   if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
     const [, ...rest] = call.arguments;
     let passed: readonly Expression[] = rest;
     if (expression.name.text === "apply") {
-      const list = rest[0] === undefined ? undefined : unparenthesized(rest[0]);
+      const list = rest[0] === undefined ? undefined : parenthesesRemoved(rest[0]);
       passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
     }
     return {
@@ -255,7 +250,7 @@ function throughMethod(call: CallExpression): MethodForm | undefined {
     };
   }
   if (isCallExpression(expression)) {
-    const bound = unparenthesized(expression.expression);
+    const bound = parenthesesRemoved(expression.expression);
     if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
       return {
         method: bound.name,

package/src/session.ts

@@ -26,6 +26,7 @@ import {
   type Queries,
   type UnansweredQuestion,
 } from "./query.ts";
+import { MANIFEST } from "./fs/manifest.ts";
 
 /**
  * The compiler the analysis reads through: a client over a protocol to a separate
@@ -115,7 +116,7 @@ export function openEngine(options: EngineOptions): Engine {
   if (components !== undefined && components.extensions.length > 0) {
     const made = components.host.temporaryDirectory();
     try {
-      components.host.writeDocument(joinPath(made.path, "package.json"), [
+      components.host.writeDocument(joinPath(made.path, MANIFEST), [
         mapperManifest(components.host.componentMapperCommand()),
       ]);
     } catch (error: unknown) {

package/src/setup-failure.ts

@@ -1,15 +1,13 @@
+import { SETUP_FAILURE_PREFIX, type SETUP_CLASSES } from "./contract/contract.generated.ts";
+
 /**
  * A setup failure: a file or a component the analysis needs and the project does not
  * provide. Each one names what is missing and the fix, on one line of the error stream
  * that starts with its class.
  */
 
-/** The classes of setup failure this analyzer meets. */
-type SetupClass =
-  | "missing-module"
-  | "missing-consumer"
-  | "workspace-member-without-source"
-  | "convention-not-literal";
+/** A class of setup failure the Contract names. */
+type SetupClass = (typeof SETUP_CLASSES)[number]["class"];
 
 export interface SetupFailure {
   readonly setupClass: SetupClass;
@@ -19,7 +17,7 @@ export interface SetupFailure {
 
 /** The failure as the one line of the error stream that names it. */
 export function setupLine(failure: SetupFailure): string {
-  return `setup failure: ${failure.setupClass}: ${failure.detail}`;
+  return `${SETUP_FAILURE_PREFIX}${failure.setupClass}: ${failure.detail}`;
 }
 
 /**

package/src/suppress-file.ts

@@ -5,18 +5,17 @@
  * ignore file by gaining a maintainer's reason.
  */
 
+import { CODE } from "./contract/contract.generated.ts";
 import type { Host } from "./host.ts";
 import type { InventorySymbol } from "./inventory.ts";
 import { jsonChunks } from "./json-chunks.ts";
 import { joinPath } from "./paths.ts";
-import { positionAt, walkDocument } from "./json-document.ts";
+import { isRecord, positionAt, walkDocument } from "./json-document.ts";
 import type { Position } from "./position.ts";
 import { declarationKey } from "./ref.ts";
 import {
   CODE_FORM,
-  SUPPRESSION_WITHOUT_REASON,
   SuppressionError,
-  UNSCOPED_ENTRY,
   blankReason,
   isEntryPath,
   isPartKind,
@@ -27,6 +26,7 @@ import {
   type SuppressionRecord,
   type Suppressions,
 } from "./suppress.ts";
+import { message } from "./product.ts";
 
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
@@ -80,10 +80,6 @@ function documentSite(shape: Shape): Position {
   return { path: shape.file, line: 0, column: 0 };
 }
 
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 /** What one entry or row resolves to. */
 interface Read {
   readonly records: readonly SuppressionRecord[];
@@ -101,7 +97,7 @@ function readRecord(value: unknown, site: Position, byReference: ByReference, sh
   const refuse = (text: string, want: string): never => {
     throw new SuppressionError(shape.mechanism, siteText(site), text, want);
   };
-  if (!isObject(value)) {
+  if (!isRecord(value)) {
     return refuse(JSON.stringify(value), shape.recordWant);
   }
   for (const [key, held] of Object.entries(value)) {
@@ -148,10 +144,10 @@ function readRecord(value: unknown, site: Position, byReference: ByReference, sh
   };
   const refusals: Refusal[] = [];
   if (blankReason(reason)) {
-    refusals.push({ ...written, reported: SUPPRESSION_WITHOUT_REASON });
+    refusals.push({ ...written, reported: CODE.suppressionWithoutReason });
   }
   if (written.path === "") {
-    refusals.push({ ...written, reported: UNSCOPED_ENTRY });
+    refusals.push({ ...written, reported: CODE.unscopedIgnoreEntry });
   }
   if (refusals.length > 0) {
     return { records: [], refusals };
@@ -201,9 +197,9 @@ function readDocument(
   try {
     parsed = JSON.parse(text);
   } catch (error: unknown) {
-    return malformed(`${shape.file}: ${error instanceof Error ? error.message : String(error)}`);
+    return malformed(`${shape.file}: ${message(error)}`);
   }
-  if (!isObject(parsed)) {
+  if (!isRecord(parsed)) {
     return malformed(shape.file);
   }
   const walk = walkDocument(text, shape.array);
@@ -329,9 +325,9 @@ export function otherSchemeRows(text: string, own: string = OWN_SCHEME): readonl
   try {
     parsed = JSON.parse(text);
   } catch (error: unknown) {
-    return refuse(error instanceof Error ? error.message : String(error));
+    return refuse(message(error));
   }
-  const held = isObject(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
+  const held = isRecord(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
   if (!Array.isArray(held)) {
     return refuse(BASELINE_SHAPE.documentWant);
   }
@@ -339,7 +335,7 @@ export function otherSchemeRows(text: string, own: string = OWN_SCHEME): readonl
     try {
       readRecord(value, documentSite(BASELINE_SHAPE), new Map(), BASELINE_SHAPE);
     } catch (error: unknown) {
-      return refuse(error instanceof Error ? error.message : String(error));
+      return refuse(message(error));
     }
     // readRecord has checked every member is a string and the code and symbol are present.
     const { code, symbol, path, reason } = value as Readonly<Record<string, string>>;

package/src/suppress-inline.ts

@@ -4,6 +4,7 @@
  * below it, or on its own line where it trails a token there.
  */
 
+import { CODE } from "./contract/contract.generated.ts";
 import {
   isConstructorDeclaration,
   SyntaxKind,
@@ -18,7 +19,6 @@ import type { ProjectView } from "./session.ts";
 import { signatureOf } from "./signatures.ts";
 import {
   isPartKind,
-  SUPPRESSION_WITHOUT_REASON,
   SuppressionError,
   siteText,
   type Refusal,
@@ -354,7 +354,7 @@ export function inlineSuppressions(
       case "no-reason":
         for (const code of directive.codes) {
           refusals.push({
-            reported: SUPPRESSION_WITHOUT_REASON,
+            reported: CODE.suppressionWithoutReason,
             code,
             symbol: "",
             path: site.path,