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

package/src/report-schema.ts

@@ -7,6 +7,8 @@
  */
 
 import { REPORT_SCHEMAS, type Report } from "./contract/report.generated.ts";
+import { bytewise } from "./text/compare.ts";
+import { isRecord } from "./json-document.ts";
 
 /** One value a schema refuses: its JSON Pointer, the keyword, and why. */
 interface SchemaRefusal {
@@ -41,10 +43,6 @@ function pattern(source: string): RegExp {
   return held;
 }
 
-function isObject(value: unknown): value is Readonly<Record<string, unknown>> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
 function typeOf(value: unknown): string {
   if (value === null) {
     return "null";
@@ -68,9 +66,9 @@ function canonical(value: unknown): string {
   if (Array.isArray(value)) {
     return `[${value.map(canonical).join(",")}]`;
   }
-  if (isObject(value)) {
+  if (isRecord(value)) {
     return `{${Object.keys(value)
-      .sort()
+      .sort(bytewise)
       .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
       .join(",")}}`;
   }
@@ -101,11 +99,11 @@ class Checker {
     const target = file === "" ? doc : file;
     let schema: unknown = this.documents[target];
     for (const token of pointer.split("/").filter((one) => one !== "")) {
-      schema = isObject(schema)
+      schema = isRecord(schema)
         ? schema[token.replaceAll("~1", "/").replaceAll("~0", "~")]
         : undefined;
     }
-    if (!isObject(schema)) {
+    if (!isRecord(schema)) {
       throw new Error(`report schema: ${ref} names no schema`);
     }
     return [target, schema];
@@ -141,7 +139,7 @@ class Checker {
     this.checkValue(schema, value, refuse);
     if (Array.isArray(value)) {
       this.checkArray(doc, schema, value, at, found, refuse);
-    } else if (isObject(value)) {
+    } else if (isRecord(value)) {
       this.checkObject(doc, schema, value, at, found, refuse);
     }
     this.checkApplicators(doc, schema, value, at, found, refuse);
@@ -188,19 +186,19 @@ class Checker {
     found: SchemaRefusal[],
     refuse: (keyword: string, reason: string) => void,
   ): void {
-    const properties = isObject(schema["properties"]) ? schema["properties"] : {};
+    const properties = isRecord(schema["properties"]) ? schema["properties"] : {};
     const additional = schema["additionalProperties"];
-    for (const name of Object.keys(value).sort()) {
+    for (const name of Object.keys(value).sort(bytewise)) {
       const member = `${at}/${escape(name)}`;
       const declared = properties[name];
-      if (isObject(declared)) {
+      if (isRecord(declared)) {
         this.check(doc, declared, value[name], member, found);
       } else if (additional === false) {
         refuse(
           "additionalProperties",
           `the member ${JSON.stringify(name)} is not one the schema declares`,
         );
-      } else if (isObject(additional)) {
+      } else if (isRecord(additional)) {
         this.check(doc, additional, value[name], member, found);
       }
     }
@@ -227,7 +225,7 @@ class Checker {
     refuse: (keyword: string, reason: string) => void,
   ): void {
     const items = schema["items"];
-    if (isObject(items)) {
+    if (isRecord(items)) {
       value.forEach((item, i) => {
         this.check(doc, items, item, `${at}/${String(i)}`, found);
       });
@@ -273,12 +271,12 @@ class Checker {
         `the value matches ${String(matching("oneOf"))} of the alternatives, want exactly one`,
       );
     }
-    if (isObject(schema["not"]) && this.matches(doc, schema["not"], value, at)) {
+    if (isRecord(schema["not"]) && this.matches(doc, schema["not"], value, at)) {
       refuse("not", "the value matches a schema it must not match");
     }
-    if (isObject(schema["if"])) {
+    if (isRecord(schema["if"])) {
       const branch = this.matches(doc, schema["if"], value, at) ? schema["then"] : schema["else"];
-      if (isObject(branch)) {
+      if (isRecord(branch)) {
         this.check(doc, branch, value, at, found);
       }
     }

package/src/report.ts

@@ -19,12 +19,8 @@ import type { AppliedConvention } from "./conventions.ts";
 import type { PassResult } from "./findings-pass.ts";
 import type { StaleSuppression } from "./findings/self-check.ts";
 import type { TestFileRule } from "./references.ts";
-
-/** The name this analyzer writes every document under and mints every identifier with. */
-export const ANALYZER_NAME = "deadset-ts";
-
-/** The language this analyzer claims. */
-export const LANGUAGE = "ts";
+import { bytewise } from "./text/compare.ts";
+import { LANGUAGE, PRODUCT } from "./product.ts";
 
 /** One project configuration of the matrix a run analyzed. */
 export interface ReportConfiguration {
@@ -131,14 +127,6 @@ function componentsOf(
   return [...listed.values()];
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 function wirePosition(position: FindingPosition): wire.Position {
   return {
     path: position.path,
@@ -257,22 +245,22 @@ function wireStale(stale: StaleSuppression): wire.StaleSuppressionsEntry {
 /** The canonical key over two findings: path, line, column, code, then the symbol reference. */
 function canonical(a: wire.Finding, b: wire.Finding): number {
   return (
-    compare(a.position.path, b.position.path) ||
+    bytewise(a.position.path, b.position.path) ||
     a.position.line - b.position.line ||
     a.position.column - b.position.column ||
-    compare(a.code, b.code) ||
-    compare(a.symbol.ref, b.symbol.ref)
+    bytewise(a.code, b.code) ||
+    bytewise(a.symbol.ref, b.symbol.ref)
   );
 }
 
 /** The canonical key over two stale suppressions, each component from the record's own member. */
 function canonicalStale(a: wire.StaleSuppressionsEntry, b: wire.StaleSuppressionsEntry): number {
   return (
-    compare(a.position.path, b.position.path) ||
+    bytewise(a.position.path, b.position.path) ||
     a.position.line - b.position.line ||
     a.position.column - b.position.column ||
-    compare(a.code, b.code) ||
-    compare(a.symbol, b.symbol)
+    bytewise(a.code, b.code) ||
+    bytewise(a.symbol, b.symbol)
   );
 }
 
@@ -289,9 +277,9 @@ function wireGap(gap: DeclaredGap): wire.DeclaredGapsEntry {
 /** Edge evaluations by edge, then side, then their compact encodings. */
 function byEdge(a: wire.EdgeEvaluationsEntry, b: wire.EdgeEvaluationsEntry): number {
   return (
-    compare(a.edge, b.edge) ||
-    compare(a.side, b.side) ||
-    compare(JSON.stringify(a), JSON.stringify(b))
+    bytewise(a.edge, b.edge) ||
+    bytewise(a.side, b.side) ||
+    bytewise(JSON.stringify(a), JSON.stringify(b))
   );
 }
 
@@ -346,16 +334,16 @@ export function buildReport(input: ReportInput): wire.Report {
     one.finding === undefined ? [] : [[wireFinding(one.finding), one.finding] as const],
   );
   const unavailable = [...new Map(input.unavailable.map((one) => [one.id, one])).values()]
-    .sort((a, b) => compare(a.id, b.id))
+    .sort((a, b) => bytewise(a.id, b.id))
     .map((one) => ({ id: one.id, role: "consumer" as const, reason: one.reason }));
   const loaded = [...input.loaded]
-    .sort((a, b) => compare(a.id, b.id) || compare(a.path, b.path))
+    .sort((a, b) => bytewise(a.id, b.id) || bytewise(a.path, b.path))
     .map((one) => ({ id: one.id, role: "consumer" as const, path: one.path }));
   return {
     schema_version: SCHEMA_VERSION,
     contract_version: input.contractVersion,
     analyzer: {
-      name: ANALYZER_NAME,
+      name: PRODUCT,
       version: input.version,
       languages: [LANGUAGE],
       schema_versions_accepted: SCHEMA_VERSIONS,
@@ -367,10 +355,10 @@ export function buildReport(input: ReportInput): wire.Report {
     },
     target: { kind: input.target.kind, root: input.target.root, identity: input.target.identity },
     configurations: [...input.configurations]
-      .sort((a, b) => compare(a.id, b.id))
+      .sort((a, b) => bytewise(a.id, b.id))
       .map((one) => ({ id: one.id, project: one.project })),
     configurations_not_built: [...input.notBuilt]
-      .sort((a, b) => compare(a.id, b.id))
+      .sort((a, b) => bytewise(a.id, b.id))
       .map((one) => ({ id: one.id, project: one.project, error: one.error })),
     consumers: { declared: loaded.length + unavailable.length, loaded, unavailable },
     findings,
@@ -383,10 +371,10 @@ export function buildReport(input: ReportInput): wire.Report {
     // name, so the compact encodings alone order them.
     declared_gaps: input.declaredGaps
       .map(wireGap)
-      .sort((a, b) => compare(JSON.stringify(a), JSON.stringify(b))),
+      .sort((a, b) => bytewise(JSON.stringify(a), JSON.stringify(b))),
     excluded_by_cgo: [],
     test_file_rules: [...input.testFileRules]
-      .sort((a, b) => compare(a.rule, b.rule) || a.matched - b.matched)
+      .sort((a, b) => bytewise(a.rule, b.rule) || a.matched - b.matched)
       .map((one) => ({ rule: one.rule, matched: one.matched })),
     type_error_skips: [
       ...new Map(
@@ -396,16 +384,18 @@ export function buildReport(input: ReportInput): wire.Report {
         }),
       ),
     ]
-      .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
+      .sort(([a, x], [b, y]) => bytewise(x.path, y.path) || x.line - y.line || bytewise(a, b))
       .map(([, skip]) => skip),
     notes: [...new Map((input.notes ?? []).map((one) => [JSON.stringify(one), one])).entries()]
-      .sort(([a, x], [b, y]) => compare(x.kind, y.kind) || compare(x.path, y.path) || compare(a, b))
+      .sort(
+        ([a, x], [b, y]) => bytewise(x.kind, y.kind) || bytewise(x.path, y.path) || bytewise(a, b),
+      )
       .map(([, note]) => note),
     unanswered_questions: [...input.unanswered]
       .sort(
         (a, b) =>
-          compare(a.configuration, b.configuration) ||
-          compare(JSON.stringify(a), JSON.stringify(b)),
+          bytewise(a.configuration, b.configuration) ||
+          bytewise(JSON.stringify(a), JSON.stringify(b)),
       )
       .map((one) => ({
         configuration: one.configuration,

package/src/reporters/sarif.ts

@@ -12,6 +12,8 @@ import { lineHashes, symbolFingerprint } from "./fingerprint.ts";
 import { RenderError, type RenderOptions } from "./reporter.ts";
 import { utf8Bytes } from "./sha256.ts";
 import { withheldLine } from "./text.ts";
+import { bytewise } from "../text/compare.ts";
+import { message } from "../product.ts";
 
 const SCHEMA =
   "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json";
@@ -133,9 +135,7 @@ function lineHashCache(read: (path: string) => string): (at: Located) => string
       try {
         text = read(at.path);
       } catch (error: unknown) {
-        throw new RenderError(
-          `read ${at.path} for its line fingerprint: ${error instanceof Error ? error.message : String(error)}`,
-        );
+        throw new RenderError(`read ${at.path} for its line fingerprint: ${message(error)}`);
       }
       hashes = lineHashes(text);
       held.set(at.path, hashes);
@@ -292,7 +292,7 @@ export function sarif(report: Report, options: RenderOptions): Iterable<string>
     ...report.findings.map((found) => findingResult(found, index, hashOf, members)),
     ...report.stale_suppressions.map((stale) => staleResult(stale, index, hashOf)),
   ];
-  const languages = [...report.analyzer.languages].sort().join("+");
+  const languages = [...report.analyzer.languages].sort(bytewise).join("+");
   const withheld = withheldLine(report.totals);
   const log = {
     $schema: SCHEMA,

package/src/reporters/template.ts

@@ -10,6 +10,7 @@
 import { CHUNK_LENGTH } from "../json-chunks.ts";
 import { RenderError } from "./reporter.ts";
 import { utf8Bytes } from "./sha256.ts";
+import { bytewise } from "../text/compare.ts";
 
 /** A template that does not parse, which refuses the invocation before any analysis. */
 export class TemplateError extends Error {
@@ -618,7 +619,7 @@ function formatted(value: Value, nested: boolean): string {
   }
   const object: ValueObject = value;
   const entries = Object.keys(object)
-    .sort()
+    .sort(bytewise)
     .map((key) => `${key}:${formatted(object[key] ?? null, true)}`);
   return `map[${entries.join(" ")}]`;
 }
@@ -647,28 +648,11 @@ function compareBasic(name: string, a: Value, b: Value): number {
     return Number.NaN;
   }
   if (kind === "string") {
-    return byCodePoints(a as string, b as string);
+    return bytewise(a as string, b as string);
   }
   return (a as number) < (b as number) ? -1 : 1;
 }
 
-/**
- * Two strings ordered by the bytes of their UTF-8 encodings, which is the order of their
- * code points: the order of their UTF-16 code units differs above U+FFFF.
- */
-function byCodePoints(a: string, b: string): number {
-  let at = 0;
-  while (at < a.length && at < b.length) {
-    const x = a.codePointAt(at) ?? 0;
-    const y = b.codePointAt(at) ?? 0;
-    if (x !== y) {
-      return x < y ? -1 : 1;
-    }
-    at += x > 0xffff ? 2 : 1;
-  }
-  return a.length - b.length;
-}
-
 /** The escapes `%q` writes for the control characters that have one of their own. */
 const QUOTED_ESCAPES: Readonly<Record<string, string>> = {
   '"': '\\"',
@@ -1022,7 +1006,7 @@ class Execution {
         entries = value.map((one, i) => [i, one]);
       } else if (isObject(value)) {
         entries = Object.keys(value)
-          .sort()
+          .sort(bytewise)
           .map((key) => [key, value[key] ?? null]);
       } else {
         throw new RenderError(`range cannot iterate over a ${kindOf(value)}`);

package/src/resolve.ts

@@ -30,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,
@@ -39,12 +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";
 
 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;
@@ -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

@@ -15,6 +15,7 @@ import { describeVerb } from "./verbs/describe.ts";
 import { EXPLAIN_OPTIONS, explainVerb } from "./verbs/explain.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 {
@@ -37,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
@@ -141,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)}`);
   }
 }
 
@@ -209,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;
   }
@@ -228,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;
@@ -274,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;
   }
@@ -282,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) {
@@ -292,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`);