@avi2dg/checks 0.25.0 → 0.27.0

package/src/docs/doc-names.ts

@@ -0,0 +1,128 @@
+import { Effect, FileSystem, Option, Path, Schema } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { collect, git, pathsAt } from "../core/git.ts";
+import type { Unresolved } from "./doc-references.ts";
+import { scanMarkdown } from "./prose-matchers.ts";
+
+export type VanishedName = { readonly path: string; readonly line: number; readonly named: string; readonly message: string };
+
+const OUTSIDE_DOCS = [".", ":(exclude)*.md"];
+const NOT_ONE_NAME = /\s|<[^>]*>|^-/;
+const HAS_LETTER = /[A-Za-z]/;
+
+function nameOf(span: string, ownPackage: string | undefined): string | undefined {
+  if (span.length < 3 || !HAS_LETTER.test(span) || NOT_ONE_NAME.test(span)) return undefined;
+  let name = span
+    .replace(/^(["'])(.*)\1$/, "$2")
+    .replace(/^(?:\.|~)\//, "")
+    .replace(/^node_modules\//, "");
+  if (ownPackage !== undefined && name.startsWith(`${ownPackage}/`)) name = name.slice(ownPackage.length + 1);
+  return name.length < 3 ? undefined : name;
+}
+
+function namesIn(texts: ReadonlyMap<string, string>, ownPackage: string | undefined): readonly { path: string; line: number; name: string }[] {
+  return [...texts].flatMap(([path, text]) =>
+    scanMarkdown(text).flatMap((line) =>
+      line.kind === "code" || line.kind === "front-matter"
+        ? []
+        : [...new Set(line.code)].flatMap((span) => {
+            const name = nameOf(span, ownPackage);
+            return name === undefined ? [] : [{ path, line: line.line, name }];
+          }),
+    ),
+  );
+}
+
+class InstalledUnreadable extends Schema.TaggedError<InstalledUnreadable>()("InstalledUnreadable", {
+  message: Schema.String,
+}) {}
+
+const Group = Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown));
+const Manifest = Schema.Struct({
+  name: Schema.optionalKey(Schema.String),
+  dependencies: Group,
+  devDependencies: Group,
+  peerDependencies: Group,
+  optionalDependencies: Group,
+});
+const decodeManifest = Schema.decodeUnknownOption(Schema.fromJsonString(Manifest));
+const NO_MANIFEST: typeof Manifest.Type = {};
+
+// git grep exits 1 when nothing matches, which is an answer rather than a failure.
+const matchedAt = Effect.fn("matchedAt")(function* (root: string, rev: string, names: readonly string[]) {
+  if (names.length === 0) return new Set<string>();
+  const found = yield* git(["grep", "-I", "-F", "-o", "-h", "--no-color", "-f", "-", rev, "--", ...OUTSIDE_DOCS], root, {
+    input: `${names.join("\n")}\n`,
+  }).pipe(Effect.catchTag("GitFailure", () => Effect.succeed("")));
+  const paths = (yield* pathsAt(rev, [], root)).join("\n");
+  return new Set([...found.split("\n"), ...names.filter((name) => paths.includes(name))]);
+});
+
+// -o reports one pattern per match, so a name inside a longer name's match is confirmed on its own.
+const heldAt = Effect.fn("heldAt")(function* (root: string, rev: string, name: string) {
+  return yield* git(["grep", "-I", "-F", "-q", "-e", name, rev, "--", ...OUTSIDE_DOCS], root).pipe(
+    Effect.as(true),
+    Effect.catchTag("GitFailure", () => Effect.succeed(false)),
+  );
+});
+
+const manifestAt = Effect.fn("manifestAt")(function* (root: string, head: string) {
+  const manifest = yield* git(["show", `${head}:package.json`], root).pipe(Effect.catchTag("GitFailure", () => Effect.succeed("")));
+  const { name, dependencies, devDependencies, peerDependencies, optionalDependencies } = Option.getOrElse(decodeManifest(manifest), () => NO_MANIFEST);
+  const deps = [dependencies, devDependencies, peerDependencies, optionalDependencies].flatMap((group) => Object.keys(group ?? {}));
+  return { name, deps: [...new Set(deps)] };
+});
+
+const installedDirs = Effect.fn("installedDirs")(function* (root: string, deps: readonly string[]) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const dirs = deps.map((dep) => `node_modules/${dep}/`);
+  const present = yield* Effect.forEach(dirs, (dir) => fs.exists(path.join(root, dir)), { concurrency: 8 });
+  return dirs.filter((_, index) => present[index] === true);
+});
+
+const installedHolds = Effect.fn("installedHolds")(function* (root: string, dirs: readonly string[], name: string) {
+  if (dirs.length === 0) return false;
+  const { stderr, exitCode } = yield* collect("grep", ["-r", "-I", "-F", "-q", "-e", name, "--", ...dirs], root);
+  if (exitCode === ChildProcessSpawner.ExitCode(0)) return true;
+  if (exitCode === ChildProcessSpawner.ExitCode(1)) return false;
+  return yield* new InstalledUnreadable({ message: `grep for \`${name}\` in ${dirs.join(", ")}: ${stderr.trim()}` });
+});
+
+export const vanishedNames = Effect.fn("vanishedNames")(function* (
+  root: string,
+  base: string,
+  head: string,
+  texts: ReadonlyMap<string, string>,
+  failed: readonly (Unresolved & { readonly path: string })[],
+) {
+  const manifest = yield* manifestAt(root, head);
+  const named = namesIn(texts, manifest.name);
+  const names = [...new Set(named.map(({ name }) => name))];
+  const atHead = yield* matchedAt(root, head, names);
+  const candidates = names.filter((name) => !atHead.has(name));
+  const atBase = yield* matchedAt(root, base, candidates);
+  const heldAtBase = yield* Effect.forEach(candidates, (name) => (atBase.has(name) ? Effect.succeed(true) : heldAt(root, base, name)), {
+    concurrency: 8,
+  });
+  const gone = candidates.filter((_, index) => heldAtBase[index] === true);
+  const confirmed = yield* Effect.forEach(gone, (name) => heldAt(root, head, name), { concurrency: 8 });
+  const unheld = gone.filter((_, index) => confirmed[index] === false);
+  const dirs = yield* installedDirs(root, manifest.deps);
+  const installed = yield* Effect.forEach(unheld, (name) => installedHolds(root, dirs, name), { concurrency: 8 });
+  const vanished = new Set(unheld.filter((_, index) => installed[index] === false));
+  const reported = new Set(
+    failed.flatMap((one) => (one.kind === "path" ? [`${one.path}:${one.line}:${nameOf(one.named, manifest.name) ?? one.named}`] : [])),
+  );
+  return named
+    .filter(({ name }) => vanished.has(name))
+    .filter(({ path, line, name }) => !reported.has(`${path}:${line}:${name}`))
+    .map(
+      ({ path, line, name }): VanishedName => ({
+        path,
+        line,
+        named: name,
+        message: `names \`${name}\`, which the range removed from every file outside the docs. Say what holds now, or drop the line`,
+      }),
+    );
+});

package/src/docs/doc-references.ts

@@ -1,6 +1,6 @@
 import { scanMarkdown, type MarkdownLine } from "./prose-matchers.ts";
 
-export type ReferenceKind = "path" | "link" | "command";
+type ReferenceKind = "path" | "link" | "command";
 
 export type Unresolved = {
   readonly kind: ReferenceKind;

package/src/docs/doc-snapshot.ts

@@ -2,7 +2,7 @@ import { Effect, FileSystem, Path, Schema } from "effect";
 import { anchoredTargets, anchorsOf, PACKAGE_MANIFEST, packagesOf, snapshotOf, type Unresolved } from "./doc-references.ts";
 import { git, pathsAt } from "../core/git.ts";
 
-export class ManifestUnreadable extends Schema.TaggedError<ManifestUnreadable>()("ManifestUnreadable", {
+class ManifestUnreadable extends Schema.TaggedError<ManifestUnreadable>()("ManifestUnreadable", {
   message: Schema.String,
 }) {}
 

package/src/docs/doc-templates.ts

@@ -9,21 +9,21 @@ export type Title =
   | { readonly type: "fixed"; readonly text: string }
   | { readonly type: "open"; readonly placeholder: string; readonly rule: HeadingRule; readonly prefix?: string };
 
-export type Outlined = {
+type Outlined = {
   readonly shape: "outline";
   readonly title: Title;
   readonly lead: readonly string[];
   readonly sections: readonly Slot[];
 };
 
-export type Exact = {
+type Exact = {
   readonly shape: "exact";
   readonly text: string;
 };
 
 export type Template = Outlined | Exact;
 
-export const TEMPLATE_DIRECTORY = "templates";
+export const TEMPLATE_DIRECTORY = "dist/templates";
 
 export const ADR_STATUSES = ["Proposed", "Accepted", "Rejected", "Deprecated", "Superseded", "Retired"] as const;
 
@@ -154,7 +154,7 @@ export const TEMPLATES: Readonly<Record<Kind, Template>> = {
   reference: {
     shape: "outline",
     title: { type: "open", placeholder: "<The thing this page describes, as a noun>", rule: "any" },
-    lead: ["<What the thing is, in one sentence, and when a reader looks it up.>"],
+    lead: ["<What the thing is, in one sentence.>"],
     sections: [
       open("<One part of it, as a noun>", "any", optional("the lead and one table describe all of it"), [
         "<A table, a list or a short description, with no steps and no opinion.>",

package/src/docs/docs.ts

@@ -2,10 +2,11 @@
 import { Console, Effect } from "effect";
 import { rootsOf, unresolvedIn, type Judging, type Unresolved } from "./doc-references.ts";
 import { ADR_DIRECTORY, judge, placementOf, placementProblem, speaksToConsumers, type Placement } from "./doc-rules.ts";
+import { vanishedNames } from "./doc-names.ts";
 import { readTexts, snapshotAt, stillMissing } from "./doc-snapshot.ts";
 import { changedLines, changedPaths, git, pathsAt, rangeEnds, refArgs } from "../core/git.ts";
 import { runMain } from "../core/main.ts";
-import { isLivingDoc, proseFindings, readerOf } from "./prose-matchers.ts";
+import { proseFindings, readerOf } from "./prose-matchers.ts";
 
 type Finding = {
   readonly path: string;
@@ -16,7 +17,7 @@ type Finding = {
 type Judged = {
   readonly held: readonly string[];
   readonly edited: { readonly docs: number; readonly lines: number };
-  readonly living: number;
+  readonly named: number;
   readonly findings: readonly Finding[];
   readonly advisory: ReadonlyMap<string, number>;
   readonly brokenBefore: readonly Finding[];
@@ -74,8 +75,10 @@ const referenceFindings = Effect.fn("referenceFindings")(function* (range: Range
   const elsewhere = found.filter((one) => !onChangedLines(one));
   const before = elsewhere.length === 0 ? new Set<string>() : yield* brokenBeforeRange(range, elsewhere, judging);
   const finding = ({ path, line, message }: Located): Finding => ({ path, line, message });
+  const failed = found.filter((one) => onChangedLines(one) || !before.has(keyOf(one)));
   return {
-    failing: found.filter((one) => onChangedLines(one) || !before.has(keyOf(one))).map(finding),
+    failing: failed.map(finding),
+    failed,
     brokenBefore: elsewhere.filter((one) => before.has(keyOf(one))).map(finding),
   };
 });
@@ -87,7 +90,6 @@ const runDocs = Effect.fn("runDocs")(function* (root: string, base: string, head
   const changed = yield* changedLines(base, head, MARKDOWN, root);
   const present = yield* pathsAt(head, MARKDOWN, root);
   const records = present.filter((path) => path.startsWith(ADR_DIRECTORY));
-  const living = present.filter(isLivingDoc);
   const proseDocs = present.flatMap((path) => {
     const reader = readerOf(path);
     return reader === undefined ? [] : [{ path, reader }];
@@ -104,18 +106,16 @@ const runDocs = Effect.fn("runDocs")(function* (root: string, base: string, head
   const judging = (path: string): Judging => ({ commands: !speaksToConsumers(text(path)) });
   // A directory the range deletes still belongs to this repository, so a path under it is stale rather than another repository's.
   const roots = rootsOf(yield* pathsAt(base, [], root));
-  const references = yield* referenceFindings(
-    { root, base, head, roots, changed, renamedFrom },
-    new Map(living.map((path) => [path, text(path)])),
-    judging,
-  );
+  const referenced = new Map(proseDocs.map(({ path }) => [path, text(path)]));
+  const references = yield* referenceFindings({ root, base, head, roots, changed, renamedFrom }, referenced, judging);
+  const vanished = yield* vanishedNames(root, base, head, referenced, references.failed);
   const advisory = new Map<string, number>();
   for (const { path } of templated.filter((finding) => !touched.has(finding.path))) advisory.set(path, (advisory.get(path) ?? 0) + 1);
   return {
     held: judged.map(({ path }) => path).filter((path) => touched.has(path)),
     edited: { docs: edited.length, lines: edited.reduce((sum, { path }) => sum + (changed.get(path)?.size ?? 0), 0) },
-    living: living.length,
-    findings: [...templated.filter((finding) => touched.has(finding.path)), ...prose, ...references.failing].toSorted(inPathOrder),
+    named: referenced.size,
+    findings: [...templated.filter((finding) => touched.has(finding.path)), ...prose, ...references.failing, ...vanished].toSorted(inPathOrder),
     advisory,
     brokenBefore: references.brokenBefore.toSorted(inPathOrder),
   } satisfies Judged;
@@ -125,13 +125,13 @@ function describe({ path, line, message }: Finding): string {
   return `  ${path}${line === undefined ? "" : `:${line}`}: ${message}`;
 }
 
-export function report({ held, edited, living, findings, advisory, brokenBefore }: Judged): string {
+export function report({ held, edited, named, findings, advisory, brokenBefore }: Judged): string {
   const verdict =
     findings.length === 0
       ? [
           `${NAME}: ${held.length} doc file(s) the range touches hold to their templates`,
           `${NAME}: ${edited.lines} line(s) the range adds or edits in ${edited.docs} living doc(s) or agent file(s) hold to the prose rules`,
-          `${NAME}: the range breaks no path, link or command the ${living} living doc(s) name`,
+          `${NAME}: the range breaks no path, link or command the ${named} living doc(s) or agent file(s) name`,
         ]
       : [`${NAME}: ${findings.length} violation(s):`, ...findings.map(describe)];
   const unconformed =
@@ -144,7 +144,10 @@ export function report({ held, edited, living, findings, advisory, brokenBefore
   const broken =
     brokenBefore.length === 0
       ? []
-      : [`${NAME}: advisory, ${brokenBefore.length} path(s), link(s) or command(s) the living docs name were broken before the range:`, ...brokenBefore.map(describe)];
+      : [
+          `${NAME}: advisory, ${brokenBefore.length} path(s), link(s) or command(s) the living docs or agent files name were broken before the range:`,
+          ...brokenBefore.map(describe),
+        ];
   return [...verdict, ...unconformed, ...broken].join("\n");
 }
 

package/src/docs/prose-matchers.ts

@@ -195,7 +195,7 @@ function unread(line: number, raw: string, kind: LineKind): MarkdownLine {
   return { line, kind, raw, prose: BLANK.repeat(raw.length), code: [], links: [] };
 }
 
-function settext(lines: MarkdownLine[]): MarkdownLine[] {
+function settext(lines: readonly MarkdownLine[]): MarkdownLine[] {
   return lines.map((line, index) => {
     const next = lines[index + 1];
     return line.kind === "prose" && next?.kind === "break" && UNDERLINE.test(next.raw) ? { ...line, kind: "heading" } : line;
@@ -257,6 +257,12 @@ const PROMISES: readonly (readonly [shows: string, pattern: string])[] = [
   ["coming soon", "coming soon"],
   ["in a future release", "in a future (?:release|version)"],
 ];
+const PAST: readonly (readonly [shows: string, pattern: string])[] = [
+  ["formerly", String.raw`former(?:ly)?`], ["previously", "previously"], ["as before", "as before"],
+  ["used to", String.raw`(?<!\b(?:is|are|was|were|be|been|being|get|gets|got|\w+['’](?:s|re))\s(?:(?:also|always|just|never|not|now|often|sometimes|still|then|\w+ly)\s)?)used to`],
+  ["was replaced", String.raw`(?:was|were|has been|have been) (?:replaced|removed|renamed|dropped|deleted|retired|superseded)`],
+  ["moved from", String.raw`(?:renamed|moved) from`], ["new owner", String.raw`new (?:home|owner)`],
+];
 
 const code = (text: string): string => `\`${text}\``;
 const EVERY_READER: readonly Reader[] = ["people", "agents"];
@@ -287,6 +293,10 @@ const RULES: readonly MatchedRule[] = [
     instead: "Say what is true now",
     find: new RegExp(PROMISES.map(([, pattern]) => String.raw`\b${pattern}\b`).join("|"), "gi"),
   },
+  { readers: EVERY_READER, refuses: "a report about the past",
+    example: PAST.map(([shows]) => code(shows)).join(", "),
+    instead: "Say what is true now, and leave what changed to the changelog, a commit message or a decision record",
+    find: new RegExp(PAST.map(([, pattern]) => String.raw`(?<![\w-])${pattern}(?![\w-])`).join("|"), "gi") },
   {
     readers: PEOPLE,
     refuses: "a sentence that opens by talking about the page",

package/src/quality/comments.ts

@@ -1,13 +1,13 @@
 import { Effect, Schema } from "effect";
 import { commentsIn, refusalsIn, syntaxOf, unreadable, type Syntax } from "./comment-matchers.ts";
 
-export { SYNTAXES, syntaxOf, type Comment } from "./comment-matchers.ts";
+export { syntaxOf } from "./comment-matchers.ts";
 
 export class UnreadableCode extends Schema.TaggedError<UnreadableCode>()("UnreadableCode", {
   message: Schema.String,
 }) {}
 
-export function syntaxFor(path: string): Effect.Effect<Syntax, UnreadableCode> {
+function syntaxFor(path: string): Effect.Effect<Syntax, UnreadableCode> {
   const syntax = syntaxOf(path);
   return syntax ? Effect.succeed(syntax) : Effect.fail(new UnreadableCode({ message: unreadable(path) }));
 }

package/src/quality/lint-coverage.sh

@@ -1,5 +1,6 @@
 #!/bin/sh
-# lint-coverage: fail when oxlint silently skips a tracked TypeScript source.
+# lint-coverage: fail when oxlint silently skips a tracked TypeScript source,
+# or when tsconfig.json's program silently drops the ts-reset rules.
 set -eu
 
 tmp="$(mktemp -d)"
@@ -21,13 +22,45 @@ grep -E '\.tsx?$' "$tmp/walk" | LC_ALL=C sort > "$tmp/walked" || true
 
 expected_count="$(wc -l < "$tmp/expected" | tr -d ' ')"
 walked_count="$(grep -c . "$tmp/walked" || true)"
+status=0
 
 comm -23 "$tmp/expected" "$tmp/walked" > "$tmp/missing"
 if [ -s "$tmp/missing" ]; then
   missing_count="$(wc -l < "$tmp/missing" | tr -d ' ')"
   echo "lint-coverage: oxlint skips ${missing_count}/${expected_count} tracked .ts/.tsx files; missing:"
   cat "$tmp/missing"
+  status=1
+else
+  echo "lint-coverage: ${walked_count}/${expected_count} tracked .ts/.tsx files"
+fi
+
+if ! [ -f tsconfig.json ]; then
+  echo "lint-coverage: no tsconfig.json, so no program to hold the ts-reset rules"
+  exit "$status"
+fi
+
+if ! tsc --listFilesOnly -p tsconfig.json > "$tmp/program" 2> "$tmp/program-error"; then
+  echo "lint-coverage: tsc could not list the program tsconfig.json builds:"
+  # tsc lists each file of the program as an absolute path beside its errors.
+  grep -v '^/' "$tmp/program" || true
+  cat "$tmp/program-error"
+  if [ "$status" -eq 1 ]; then
+    exit 1
+  fi
+  exit 2
+fi
+
+dropped=""
+for rule in is-array json-parse; do
+  if ! grep -q "/@total-typescript/ts-reset/dist/${rule}\.d\.ts\$" "$tmp/program"; then
+    dropped="${dropped} ${rule}"
+  fi
+done
+if [ -n "$dropped" ]; then
+  echo "lint-coverage: the program tsconfig.json builds drops the ts-reset rules:${dropped}"
+  echo "  extend @avi2dg/checks/tsconfig.effect.json, and set files or include in tsconfig.json but not both"
   exit 1
 fi
 
-echo "lint-coverage: ${walked_count}/${expected_count} tracked .ts/.tsx files"
+echo "lint-coverage: the program tsconfig.json builds holds the ts-reset rules is-array and json-parse"
+exit "$status"

package/{presets → src/quality/presets}/effect.language-service.json

@@ -3,6 +3,8 @@
     "nodeBuiltinImport": "error",
     "asyncFunction": "error",
     "newPromise": "error",
-    "extendsNativeError": "error"
+    "extendsNativeError": "error",
+    "processEnv": "error",
+    "processEnvInEffect": "error"
   }
 }

package/src/testing/mutation-compare.ts

@@ -2,27 +2,43 @@
 import { Console, Effect, FileSystem, Schema } from "effect";
 import { runMain, Usage } from "../core/main.ts";
 
-export type Location = {
-  readonly start: { readonly line: number; readonly column: number };
-  readonly end: { readonly line: number; readonly column: number };
-};
+const PositionSchema = Schema.Struct({ line: Schema.Finite, column: Schema.Finite });
+const LocationSchema = Schema.Struct({ start: PositionSchema, end: PositionSchema });
+
+export type Location = typeof LocationSchema.Type;
+
+const MutantStatusSchema = Schema.Literals([
+  "Killed",
+  "Survived",
+  "Timeout",
+  "NoCoverage",
+  "Ignored",
+  "CompileError",
+  "RuntimeError",
+  "Pending",
+]);
+
+export type MutantStatus = typeof MutantStatusSchema.Type;
+
+const MutantSchema = Schema.Struct({
+  status: MutantStatusSchema,
+  mutatorName: Schema.String,
+  replacement: Schema.String,
+  killedBy: Schema.optionalKey(Schema.Array(Schema.String)),
+  location: LocationSchema,
+});
 
-export type Mutant = {
-  readonly status: string;
-  readonly mutatorName: string;
-  readonly replacement: string;
-  readonly killedBy?: readonly string[];
-  readonly location: Location;
-};
+export type Mutant = typeof MutantSchema.Type;
 
-export type ReportFile = {
-  readonly source: string;
-  readonly mutants: readonly Mutant[];
-};
+const ReportFileSchema = Schema.Struct({ source: Schema.String, mutants: Schema.Array(MutantSchema) });
 
-export type TestFile = {
-  readonly tests: readonly { readonly id: string; readonly name: string }[];
-};
+export type ReportFile = typeof ReportFileSchema.Type;
+
+const TestFileSchema = Schema.Struct({
+  tests: Schema.Array(Schema.Struct({ id: Schema.String, name: Schema.String })),
+});
+
+export type TestFile = typeof TestFileSchema.Type;
 
 export type KillRun = {
   readonly files: ReadonlyMap<string, ReportFile>;
@@ -35,8 +51,8 @@ export type MutantChange = {
   readonly location: Location;
   readonly mutatorName: string;
   readonly replacement: string;
-  readonly from: string;
-  readonly to: string;
+  readonly from: MutantStatus;
+  readonly to: MutantStatus;
 };
 
 export type UnmatchedMutant = {
@@ -44,7 +60,7 @@ export type UnmatchedMutant = {
   readonly location: Location;
   readonly mutatorName: string;
   readonly replacement: string;
-  readonly status: string;
+  readonly status: MutantStatus;
 };
 
 export type Comparison = {
@@ -65,35 +81,25 @@ export class ReportError extends Schema.TaggedError<ReportError>()("ReportError"
   message: Schema.String,
 }) {}
 
-const DETECTED = new Set(["Killed", "Timeout"]);
-const UNDETECTED = new Set(["Survived", "NoCoverage"]);
-const LEAVES_SCORE = new Set(["CompileError", "RuntimeError", "Ignored", "Pending"]);
+const OUTCOME = {
+  Killed: "detected",
+  Timeout: "detected",
+  Survived: "undetected",
+  NoCoverage: "undetected",
+  CompileError: "leaves-score",
+  RuntimeError: "leaves-score",
+  Ignored: "leaves-score",
+  Pending: "leaves-score",
+} as const satisfies Record<MutantStatus, "detected" | "undetected" | "leaves-score">;
 const USAGE = "usage: mutation-compare.ts [--advisory] <base-report> <head-report>";
 
-const Files = Schema.Record(
-  Schema.String,
-  Schema.Struct({
-    source: Schema.String,
-    mutants: Schema.Array(
-      Schema.Struct({
-        status: Schema.String,
-        mutatorName: Schema.String,
-        replacement: Schema.String,
-        killedBy: Schema.optionalKey(Schema.Array(Schema.String)),
-        location: Schema.Struct({
-          start: Schema.Struct({ line: Schema.Finite, column: Schema.Finite }),
-          end: Schema.Struct({ line: Schema.Finite, column: Schema.Finite }),
-        }),
-      }),
-    ),
-  }),
-);
+const Files = Schema.Record(Schema.String, ReportFileSchema);
 const decodeReport = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ files: Files })));
 const decodeKillRun = Schema.decodeUnknownEffect(
   Schema.fromJsonString(
     Schema.Struct({
       files: Files,
-      testFiles: Schema.Record(Schema.String, Schema.Struct({ tests: Schema.Array(Schema.Struct({ id: Schema.String, name: Schema.String })) })),
+      testFiles: Schema.Record(Schema.String, TestFileSchema),
       config: Schema.optionalKey(Schema.Struct({ disableBail: Schema.optionalKey(Schema.Boolean) })),
     }),
   ),
@@ -211,9 +217,9 @@ function judgeMatch(path: string, mutant: UnmatchedMutant, counterpart: Unmatche
     from: mutant.status,
     to: counterpart.status,
   };
-  if (mutant.status !== counterpart.status && (LEAVES_SCORE.has(mutant.status) || LEAVES_SCORE.has(counterpart.status))) {
+  if (mutant.status !== counterpart.status && (OUTCOME[mutant.status] === "leaves-score" || OUTCOME[counterpart.status] === "leaves-score")) {
     findings.moves.push(change);
-  } else if (DETECTED.has(mutant.status) && UNDETECTED.has(counterpart.status)) {
+  } else if (OUTCOME[mutant.status] === "detected" && OUTCOME[counterpart.status] === "undetected") {
     findings.regressions.push(change);
   }
 }

package/src/testing/test-layout.ts

@@ -177,7 +177,7 @@ function callUse(node: Record<string, unknown>): string | undefined {
   const callee = node["callee"];
   const calleeName = identifierName(callee);
   if (calleeName !== undefined && BANNED_GLOBAL_CALLS.includes(calleeName)) return `calls ${calleeName}`;
-  const argument = Array.isArray(node["arguments"]) ? node["arguments"][0] : undefined;
+  const argument: unknown = Array.isArray(node["arguments"]) ? node["arguments"][0] : undefined;
   const specifier = isRecord(argument) ? stringValue(argument["expression"]) : undefined;
   const banned = specifier === undefined ? undefined : bannedModule(specifier);
   if (banned === undefined) return undefined;

package/src/testing/test-report.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 
-export type Outcome = "passed" | "failed" | "skipped" | "todo";
+type Outcome = "passed" | "failed" | "skipped" | "todo";
 
 export type TestResult = {
   readonly file: string;

package/ts-reset.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="@total-typescript/ts-reset/is-array" />
+/// <reference types="@total-typescript/ts-reset/json-parse" />

package/tsconfig.effect.json

@@ -1,6 +1,9 @@
 {
+  "files": ["./ts-reset.d.ts"],
+  "include": ["${configDir}/**/*", "./ts-reset.d.ts"],
   "compilerOptions": {
     "erasableSyntaxOnly": true,
+    "exactOptionalPropertyTypes": true,
     "plugins": [
       {
         "name": "@effect/language-service",