@avi2dg/checks 0.5.0 → 0.8.0

package/scripts/lint.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+import { Config, Console, Effect, FileSystem, Option, Path, Schema } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { DEFAULT_BRANCH, KIT_GATES, type KitGate } from "./gates.ts";
+import { git } from "./git.ts";
+import { runMain, Usage } from "./main.ts";
+
+type Range = {
+  readonly refs: readonly [tip: string] | readonly [base: string, head: string];
+  readonly source: string;
+};
+
+type Outcome = "passed" | "violated" | "undecided";
+
+class RangeUnresolved extends Schema.TaggedError<RangeUnresolved>()("RangeUnresolved", {
+  message: Schema.String,
+}) {}
+
+class GatesUndecided extends Schema.TaggedError<GatesUndecided>()("GatesUndecided", {
+  message: Schema.String,
+}) {}
+
+const NAME = "checks-lint";
+const USAGE = "usage: lint.ts [<base-ref> <head-ref>]";
+const PULL_REQUEST_EVENT = "pull_request";
+const SHALLOW_HINT = "a CI checkout needs actions/checkout fetch-depth: 0";
+
+const decodePullRequestEvent = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(
+    Schema.Struct({
+      pull_request: Schema.Struct({
+        number: Schema.Int,
+        base: Schema.Struct({ ref: Schema.String }),
+        head: Schema.Struct({ sha: Schema.String }),
+      }),
+    }),
+  ),
+);
+
+const pullRequestEnds = Effect.fn("pullRequestEnds")(function* (eventPath: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const { pull_request: pullRequest } = yield* fs.readFileString(eventPath).pipe(
+    Effect.flatMap(decodePullRequestEvent),
+    Effect.mapError(
+      (cause) => new RangeUnresolved({ message: `cannot read the pull request from ${eventPath}: ${cause.message}` }),
+    ),
+  );
+  return {
+    base: `origin/${pullRequest.base.ref}`,
+    head: pullRequest.head.sha,
+    source: `pull request #${pullRequest.number} into ${pullRequest.base.ref}`,
+  };
+});
+
+const decodeManifest = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(
+    Schema.Struct({
+      ciWiring: Schema.optionalKey(Schema.Struct({ defaultBranch: Schema.optionalKey(Schema.NonEmptyString) })),
+    }),
+  ),
+);
+
+const declaredDefaultBranch = Effect.gen(function* () {
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  const manifest = (yield* Path.Path).join(root, "package.json");
+  const { ciWiring } = yield* (yield* FileSystem.FileSystem).readFileString(manifest).pipe(Effect.flatMap(decodeManifest));
+  return ciWiring?.defaultBranch ?? DEFAULT_BRANCH;
+}).pipe(
+  Effect.mapError((cause) => new RangeUnresolved({ message: `cannot read ciWiring.defaultBranch: ${cause.message}` })),
+);
+
+const localEnds = git(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]).pipe(
+  Effect.map((ref) => ref.trim()),
+  Effect.catchTag("GitFailure", () => declaredDefaultBranch.pipe(Effect.map((branch) => `origin/${branch}`))),
+  Effect.map((base) => ({ base, head: "HEAD", source: `HEAD against ${base}` })),
+);
+
+const endsOf = Effect.fn("endsOf")(function* (args: readonly string[]) {
+  const [base, head, ...extra] = args;
+  if (base !== undefined && head !== undefined && extra.length === 0) {
+    return { base, head, source: `${head} against ${base}` };
+  }
+  if (base !== undefined) return yield* new Usage({ message: USAGE });
+
+  const event = yield* Config.all({
+    name: Config.option(Config.String("GITHUB_EVENT_NAME")),
+    path: Config.option(Config.String("GITHUB_EVENT_PATH")),
+  }).pipe(Effect.mapError((cause) => new RangeUnresolved({ message: cause.message })));
+  if (Option.isSome(event.name) && event.name.value === PULL_REQUEST_EVENT) {
+    if (Option.isNone(event.path)) {
+      return yield* new RangeUnresolved({ message: `${PULL_REQUEST_EVENT} sets no GITHUB_EVENT_PATH` });
+    }
+    return yield* pullRequestEnds(event.path.value);
+  }
+  return yield* localEnds;
+});
+
+const commitOf = (ref: string) =>
+  git(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]).pipe(
+    Effect.map((sha) => sha.trim()),
+    Effect.mapError(
+      (cause) => new RangeUnresolved({ message: `${ref} is not a commit in this clone; ${SHALLOW_HINT}: ${cause.message}` }),
+    ),
+  );
+
+// From the base branch's tip, every range gate would charge the head with the commits the base
+// branch gained after the head branched off.
+const resolveRange = Effect.fn("resolveRange")(function* (args: readonly string[]) {
+  const ends = yield* endsOf(args);
+  const head = yield* commitOf(ends.head);
+  const base = yield* git(["merge-base", yield* commitOf(ends.base), head]).pipe(
+    Effect.map((sha) => sha.trim()),
+    Effect.mapError(
+      () => new RangeUnresolved({ message: `${ends.base} and ${ends.head} share no commit in this clone; ${SHALLOW_HINT}` }),
+    ),
+  );
+  return { refs: base === head ? [head] : [base, head], source: ends.source } satisfies Range;
+});
+
+function describe({ refs }: Range): string {
+  return refs.length === 1 ? `tip ${refs[0]}` : `range ${refs[0]}..${refs[1]}`;
+}
+
+function outcomeOf(exitCode: number): Outcome {
+  if (exitCode === 0) return "passed";
+  return exitCode === 1 ? "violated" : "undecided";
+}
+
+const runGate = Effect.fn("runGate")(function* (gate: KitGate, range: Range) {
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const script = (yield* Path.Path).join(import.meta.dir, gate.script);
+  const program = gate.script.endsWith(".sh") ? "sh" : process.execPath;
+  const args = gate.reads === "range" ? [script, ...range.refs] : [script];
+  const exitCode = yield* spawner
+    .exitCode(ChildProcess.make(program, args, { stdin: "ignore", stdout: "inherit", stderr: "inherit" }))
+    .pipe(
+      Effect.catch((cause) =>
+        Console.error(`${NAME}: cannot run ${gate.bin}: ${cause.message}`).pipe(Effect.as(ChildProcessSpawner.ExitCode(2))),
+      ),
+    );
+  return { gate, outcome: outcomeOf(exitCode) };
+});
+
+const lint = Effect.gen(function* () {
+  const range = yield* resolveRange(process.argv.slice(2));
+  yield* Console.log(`${NAME}: ${describe(range)} from ${range.source}`);
+
+  const verdicts = yield* Effect.forEach(KIT_GATES, (gate) => runGate(gate, range));
+  const failed = verdicts.filter((verdict) => verdict.outcome !== "passed");
+  if (failed.length === 0) {
+    yield* Console.log(`${NAME}: ${KIT_GATES.length} gate(s) pass`);
+    return true;
+  }
+  const summary = `${failed.length} of ${KIT_GATES.length} gate(s) failed: ${failed.map((verdict) => verdict.gate.bin).join(", ")}`;
+  if (failed.every((verdict) => verdict.outcome === "undecided")) {
+    return yield* new GatesUndecided({ message: summary });
+  }
+  yield* Console.error(`${NAME}: ${summary}`);
+  return false;
+});
+
+if (import.meta.main) runMain(NAME, lint);

package/scripts/main.ts

@@ -0,0 +1,28 @@
+import { BunRuntime, BunServices } from "@effect/platform-bun";
+import { Cause, Console, Effect, Exit, Schema } from "effect";
+
+const PASSED = 0;
+const VIOLATED = 1;
+const UNDECIDED = 2;
+const INTERRUPTED = 130;
+
+export class Usage extends Schema.TaggedError<Usage>()("Usage", {
+  message: Schema.String,
+}) {}
+
+function statusOf<A, E>(exit: Exit.Exit<A, E>): number {
+  if (Exit.isSuccess(exit)) return typeof exit.value === "number" ? exit.value : UNDECIDED;
+  return Cause.hasInterruptsOnly(exit.cause) ? INTERRUPTED : UNDECIDED;
+}
+
+export function runMain<E extends { readonly message: string }>(
+  name: string,
+  passes: Effect.Effect<boolean, E, BunServices.BunServices>,
+): void {
+  const program = passes.pipe(
+    Effect.map((passed) => (passed ? PASSED : VIOLATED)),
+    Effect.catch((failure) => Console.error(`${name}: ${failure.message}`).pipe(Effect.as(UNDECIDED))),
+    Effect.provide(BunServices.layer),
+  );
+  BunRuntime.runMain(program, { teardown: (exit, onExit) => onExit(statusOf(exit)) });
+}

package/scripts/mutation-compare.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
-import { readFile } from "node:fs/promises";
+import { Console, Effect, FileSystem, Schema } from "effect";
+import { runMain, Usage } from "./main.ts";
 
 export type Tally = {
   readonly killed: number;
@@ -25,42 +26,31 @@ export type Options = {
   readonly advisory: boolean;
 };
 
-export class ReportError extends Error {}
+export class ReportError extends Schema.TaggedError<ReportError>()("ReportError", {
+  message: Schema.String,
+}) {}
 
 const DETECTED = new Set(["Killed", "Timeout"]);
 const UNDETECTED = new Set(["Survived", "NoCoverage"]);
 const USAGE = "usage: mutation-compare.ts [--advisory] <base-report> <head-report>";
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-export function parseReport(text: string): Map<string, readonly string[]> {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    throw new ReportError("mutation-compare: report is not valid JSON");
-  }
-  if (!isRecord(parsed) || !isRecord(parsed["files"])) {
-    throw new ReportError("mutation-compare: report has no files table");
-  }
-  const files = new Map<string, readonly string[]>();
-  for (const [path, entry] of Object.entries(parsed["files"])) {
-    if (!isRecord(entry) || !Array.isArray(entry["mutants"])) {
-      throw new ReportError(`mutation-compare: ${path} has no mutants list`);
-    }
-    const statuses: string[] = [];
-    for (const mutant of entry["mutants"]) {
-      if (!isRecord(mutant) || typeof mutant["status"] !== "string") {
-        throw new ReportError(`mutation-compare: ${path} carries a mutant without a status`);
-      }
-      statuses.push(mutant["status"]);
-    }
-    files.set(path, statuses);
-  }
-  return files;
-}
+const Report = Schema.fromJsonString(
+  Schema.Struct({
+    files: Schema.Record(
+      Schema.String,
+      Schema.Struct({ mutants: Schema.Array(Schema.Struct({ status: Schema.String })) }),
+    ),
+  }),
+);
+const decodeReport = Schema.decodeUnknownEffect(Report);
+
+export const parseReport = (source: string, text: string): Effect.Effect<Map<string, readonly string[]>, ReportError> =>
+  decodeReport(text).pipe(
+    Effect.map(
+      ({ files }) => new Map(Object.entries(files).map(([path, { mutants }]) => [path, mutants.map(({ status }) => status)])),
+    ),
+    Effect.mapError((cause) => new ReportError({ message: `${source} is not a Stryker mutation report: ${cause.message}` })),
+  );
 
 function tally(statuses: readonly string[]): Tally {
   let killed = 0;
@@ -136,38 +126,34 @@ export function formatComparison(comparison: Comparison, advisory: boolean): str
   return lines.join("\n");
 }
 
-export function parseArgs(argv: readonly string[]): Options {
+export const parseArgs = Effect.fnUntraced(function* (argv: readonly string[]): Effect.fn.Return<Options, Usage> {
   let advisory = false;
   const paths: string[] = [];
   for (const arg of argv) {
     if (arg === "--advisory") advisory = true;
-    else if (arg.startsWith("--")) throw new ReportError(`${USAGE}: unknown flag ${arg}`);
+    else if (arg.startsWith("--")) return yield* new Usage({ message: `${USAGE}: unknown flag ${arg}` });
     else paths.push(arg);
   }
-  if (paths.length !== 2 || paths[0] === undefined || paths[1] === undefined) throw new ReportError(USAGE);
-  return { basePath: paths[0], headPath: paths[1], advisory };
-}
+  const [basePath, headPath, ...extra] = paths;
+  if (basePath === undefined || headPath === undefined || extra.length > 0) return yield* new Usage({ message: USAGE });
+  return { basePath, headPath, advisory };
+});
 
-export function exitFor(comparison: Comparison, advisory: boolean): number {
-  return comparison.regression && !advisory ? 1 : 0;
+export function passes(comparison: Comparison, advisory: boolean): boolean {
+  return advisory || !comparison.regression;
 }
 
-async function load(path: string): Promise<string> {
-  try {
-    return await readFile(path, "utf8");
-  } catch {
-    throw new ReportError(`mutation-compare: cannot read ${path}`);
-  }
-}
+const load = Effect.fn("load")(function* (path: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const text = yield* fs.readFileString(path).pipe(Effect.mapError(() => new ReportError({ message: `cannot read ${path}` })));
+  return yield* parseReport(path, text);
+});
 
-if (import.meta.main) {
-  try {
-    const options = parseArgs(process.argv.slice(2));
-    const comparison = compareReports(parseReport(await load(options.basePath)), parseReport(await load(options.headPath)));
-    console.log(formatComparison(comparison, options.advisory));
-    process.exit(exitFor(comparison, options.advisory));
-  } catch (error) {
-    console.error(error instanceof ReportError ? error.message : `mutation-compare: ${String(error)}`);
-    process.exit(2);
-  }
-}
+const compare = Effect.gen(function* () {
+  const options = yield* parseArgs(process.argv.slice(2));
+  const comparison = compareReports(yield* load(options.basePath), yield* load(options.headPath));
+  yield* Console.log(formatComparison(comparison, options.advisory));
+  return passes(comparison, options.advisory);
+});
+
+if (import.meta.main) runMain("mutation-compare", compare);

package/scripts/suppressions-ratchet.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env bun
+import { Console, Effect, Schema } from "effect";
+import { git } from "./git.ts";
+import { runMain, Usage } from "./main.ts";
+
+export const SUPPRESSIONS = "oxlint-suppressions.json";
+
+export type Suppressions = ReadonlyMap<string, ReadonlyMap<string, number>>;
+
+export type Rise =
+  | { readonly kind: "rose"; readonly file: string; readonly rule: string; readonly base: number; readonly head: number }
+  | { readonly kind: "appeared"; readonly file: string; readonly rule: string; readonly head: number };
+
+export type Ratchet = {
+  readonly counted: number;
+  readonly lowered: number;
+  readonly rises: readonly Rise[];
+};
+
+export class SuppressionsError extends Schema.TaggedError<SuppressionsError>()("SuppressionsError", {
+  message: Schema.String,
+}) {}
+
+const USAGE = "usage: suppressions-ratchet.ts <ref> | <base-ref> <head-ref>";
+
+const parseJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+const decodeObject = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
+const decodeEntry = Schema.decodeUnknownEffect(Schema.Struct({ count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) }));
+
+export const parseSuppressions = Effect.fn("parseSuppressions")(function* (
+  text: string,
+  where: string,
+): Effect.fn.Return<Suppressions, SuppressionsError> {
+  const refuse = (reason: string) => () => new SuppressionsError({ message: `${where} ${reason}` });
+  const parsed = yield* parseJson(text).pipe(Effect.mapError(refuse("is not valid JSON")));
+  const files = yield* decodeObject(parsed).pipe(Effect.mapError(refuse("is not an object of files")));
+  const suppressions = new Map<string, ReadonlyMap<string, number>>();
+  for (const [file, rules] of Object.entries(files)) {
+    const entries = yield* decodeObject(rules).pipe(Effect.mapError(refuse(`holds ${file} without an object of rules`)));
+    const counts = new Map<string, number>();
+    for (const [rule, entry] of Object.entries(entries)) {
+      const { count } = yield* decodeEntry(entry).pipe(
+        Effect.mapError(refuse(`holds ${file} ${rule} without a whole count`)),
+      );
+      counts.set(rule, count);
+    }
+    suppressions.set(file, counts);
+  }
+  return suppressions;
+});
+
+export function compareSuppressions(base: Suppressions, head: Suppressions): Ratchet {
+  const rises: Rise[] = [];
+  let counted = 0;
+  for (const [file, rules] of head) {
+    for (const [rule, count] of rules) {
+      counted += 1;
+      const before = base.get(file)?.get(rule);
+      if (before === undefined) {
+        if (count > 0) rises.push({ kind: "appeared", file, rule, head: count });
+      } else if (count > before) {
+        rises.push({ kind: "rose", file, rule, base: before, head: count });
+      }
+    }
+  }
+  let lowered = 0;
+  for (const [file, rules] of base) {
+    for (const [rule, count] of rules) {
+      if ((head.get(file)?.get(rule) ?? 0) < count) lowered += 1;
+    }
+  }
+  rises.sort((a, b) => a.file.localeCompare(b.file) || a.rule.localeCompare(b.rule));
+  return { counted, lowered, rises };
+}
+
+function describeRise(rise: Rise): string {
+  const change = rise.kind === "rose" ? `rose from ${rise.base} to ${rise.head}` : `appeared with ${rise.head}`;
+  return `${rise.file} ${rise.rule} ${change}`;
+}
+
+export function report({ counted, lowered, rises }: Ratchet): string {
+  if (rises.length === 0) {
+    return `suppressions-ratchet: no count in ${SUPPRESSIONS} rose or appeared (${counted} at the head, ${lowered} lowered)`;
+  }
+  return [
+    `suppressions-ratchet: ${rises.length} count(s) in ${SUPPRESSIONS} rose or appeared; fix the site instead of suppressing it:`,
+    ...rises.map((rise) => `  ${describeRise(rise)}`),
+  ].join("\n");
+}
+
+const commitOf = Effect.fn("commitOf")(function* (rev: string) {
+  return (yield* git(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
+});
+
+const mergeBase = Effect.fn("mergeBase")(function* (base: string, head: string) {
+  const commit = yield* git(["merge-base", base, head]).pipe(
+    Effect.mapError(() => new SuppressionsError({ message: `${base} and ${head} share no commit` })),
+  );
+  return commit.trim();
+});
+
+const suppressionsAt = Effect.fn("suppressionsAt")(function* (commit: string) {
+  const blob = (yield* git(["ls-tree", "--object-only", commit, "--", SUPPRESSIONS])).trim();
+  if (blob === "") return new Map() satisfies Suppressions;
+  return yield* parseSuppressions(yield* git(["cat-file", "blob", blob]), `${SUPPRESSIONS} at ${commit}`);
+});
+
+export const runRange = Effect.fn("runRange")(function* (base: string, head: string) {
+  const headCommit = yield* commitOf(head);
+  // At the base tip, a count the base branch lowered after the head branched off would read as a rise at the head.
+  const branchPoint = yield* mergeBase(yield* commitOf(base), headCommit);
+  return compareSuppressions(yield* suppressionsAt(branchPoint), yield* suppressionsAt(headCommit));
+});
+
+const ratchet = Effect.gen(function* () {
+  const [first, second, ...extra] = process.argv.slice(2);
+  if (first === undefined || extra.length > 0) return yield* new Usage({ message: USAGE });
+
+  const result = second !== undefined ? yield* runRange(first, second) : yield* runRange(`${first}^`, first);
+
+  yield* Console.log(report(result));
+  return result.rises.length === 0;
+});
+
+if (import.meta.main) runMain("suppressions-ratchet", ratchet);

package/scripts/test-layout.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env bun
-import { parseSync } from "@swc/core";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { parse } from "@swc/core";
+import { Console, Effect, FileSystem, Path, Schema } from "effect";
+import { git } from "./git.ts";
+import { runMain } from "./main.ts";
+import { ENTRY_POINT } from "./gates.ts";
 
 export type Violation = {
   readonly file: string;
@@ -44,11 +45,21 @@ const REQUIRED_TEST_TABLE: Record<string, unknown> = {
 };
 export const LAYOUT_CHECK_MARK = "scripts/test-layout.ts";
 export const LAYOUT_CHECK_BIN = "checks-test-layout";
+const OWN_ENTRY_POINT = `scripts/${ENTRY_POINT.script}`;
+
+export class LayoutError extends Schema.TaggedError<LayoutError>()("LayoutError", {
+  message: Schema.String,
+}) {}
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
 
+function runsLayoutCheck(lint: string): boolean {
+  if (lint.includes(LAYOUT_CHECK_MARK) || lint.includes(LAYOUT_CHECK_BIN)) return true;
+  return lint.split(/[\s|&;()]+/).some((word) => word === ENTRY_POINT.bin || word === OWN_ENTRY_POINT);
+}
+
 function startsWithAny(file: string, prefixes: readonly string[]): boolean {
   return prefixes.some((prefix) => file.startsWith(prefix));
 }
@@ -177,8 +188,11 @@ function outOfProcessUse(node: Record<string, unknown>): string | undefined {
   return undefined;
 }
 
-export function isolationViolations(file: string, source: string): readonly Violation[] {
-  const module = parseSync(source, { syntax: "typescript", tsx: file.endsWith(".tsx"), target: "esnext" });
+export const isolationViolations = Effect.fn("isolationViolations")(function* (file: string, source: string) {
+  const module = yield* Effect.tryPromise({
+    try: () => parse(source, { syntax: "typescript", tsx: file.endsWith(".tsx"), target: "esnext" }),
+    catch: (error) => new LayoutError({ message: `cannot parse ${file}: ${String(error)}` }),
+  });
   const violations: Violation[] = [];
   const seen = new Set<unknown>();
 
@@ -204,7 +218,7 @@ export function isolationViolations(file: string, source: string): readonly Viol
 
   visit(module);
   return violations;
-}
+});
 
 export function scriptViolations(manifest: unknown): readonly Violation[] {
   const file = "package.json";
@@ -219,11 +233,11 @@ export function scriptViolations(manifest: unknown): readonly Violation[] {
       message: `scripts.test must be exactly "${REQUIRED_TEST_SCRIPT}", found ${JSON.stringify(test ?? null)}`,
     });
   }
-  if (typeof lint !== "string" || (!lint.includes(LAYOUT_CHECK_MARK) && !lint.includes(LAYOUT_CHECK_BIN))) {
+  if (typeof lint !== "string" || !runsLayoutCheck(lint)) {
     violations.push({
       file,
       line: undefined,
-      message: `scripts.lint must run the layout check: add "${LAYOUT_CHECK_BIN}"`,
+      message: `scripts.lint must run the layout check: add "${ENTRY_POINT.bin}"`,
     });
   }
   return violations;
@@ -255,30 +269,38 @@ export function bunfigViolations(consumer: unknown, preset: unknown): readonly V
   return violations;
 }
 
-async function workingTreeFiles(root: string): Promise<readonly string[]> {
-  const listed = Bun.spawnSync(["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: root });
-  if (listed.exitCode !== 0) {
-    throw new Error(`test-layout: git ls-files failed in ${root}: ${listed.stderr.toString()}`);
-  }
-  const listedFiles = listed.stdout.toString().split("\0").filter(Boolean);
-  const present = await Promise.all(listedFiles.map((file) => Bun.file(join(root, file)).exists()));
-  return listedFiles.filter((_, index) => present[index]);
-}
-
-async function parsedToml(path: string): Promise<unknown> {
-  const imported: unknown = await import(path);
-  return isRecord(imported) ? (imported["default"] ?? imported) : imported;
-}
-
-async function readManifest(root: string): Promise<unknown> {
-  const text = await readFile(join(root, "package.json"), "utf8");
-  return JSON.parse(text) as unknown;
-}
+const workingTreeFiles = Effect.fn("workingTreeFiles")(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const listed = yield* git(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], root);
+  return yield* Effect.filter(listed.split("\0").filter(Boolean), (file) => fs.exists(path.join(root, file)), {
+    concurrency: "unbounded",
+  });
+});
+
+const parsedToml = Effect.fn("parsedToml")(function* (file: string) {
+  const text = yield* (yield* FileSystem.FileSystem).readFileString(file);
+  return yield* Effect.try({
+    try: (): unknown => Bun.TOML.parse(text),
+    catch: (error) => new LayoutError({ message: `cannot parse ${file}: ${String(error)}` }),
+  });
+});
+
+const parseJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+
+const readManifest = Effect.fn("readManifest")(function* (file: string) {
+  const text = yield* (yield* FileSystem.FileSystem).readFileString(file);
+  return yield* parseJson(text).pipe(
+    Effect.mapError((cause) => new LayoutError({ message: `cannot read ${file} as JSON: ${cause.message}` })),
+  );
+});
 
 export type Result = { readonly files: number; readonly violations: readonly Violation[] };
 
-export async function run(root: string, presetPath: string): Promise<Result> {
-  const files = await workingTreeFiles(root);
+export const run = Effect.fn("run")(function* (root: string, presetPath: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const files = yield* workingTreeFiles(root);
   const violations: Violation[] = [...placementViolations(files)];
 
   const inProcess = files.filter(
@@ -289,19 +311,18 @@ export async function run(root: string, presetPath: string): Promise<Result> {
       !file.startsWith(DATA_DIR),
   );
   for (const file of inProcess) {
-    const source = await readFile(join(root, file), "utf8");
-    violations.push(...isolationViolations(file, source));
+    const source = yield* fs.readFileString(path.join(root, file));
+    violations.push(...(yield* isolationViolations(file, source)));
   }
 
-  violations.push(...scriptViolations(await readManifest(root)));
+  violations.push(...scriptViolations(yield* readManifest(path.join(root, "package.json"))));
 
-  const consumerBunfig = (await Bun.file(join(root, "bunfig.toml")).exists())
-    ? await parsedToml(join(root, "bunfig.toml"))
-    : undefined;
-  violations.push(...bunfigViolations(consumerBunfig, await parsedToml(presetPath)));
+  const bunfig = path.join(root, "bunfig.toml");
+  const consumerBunfig = (yield* fs.exists(bunfig)) ? yield* parsedToml(bunfig) : undefined;
+  violations.push(...bunfigViolations(consumerBunfig, yield* parsedToml(presetPath)));
 
   return { files: files.length, violations };
-}
+});
 
 export function report({ files, violations }: Result): string {
   if (violations.length === 0) return `test-layout: ${files} files satisfy the layout`;
@@ -312,10 +333,12 @@ export function report({ files, violations }: Result): string {
   return [`test-layout: ${violations.length} violation(s)`, ...lines].join("\n");
 }
 
-if (import.meta.main) {
+const layout = Effect.gen(function* () {
+  const path = yield* Path.Path;
   const root = process.argv[2] ?? process.cwd();
-  const preset = fileURLToPath(new URL("../bunfig.toml", import.meta.url));
-  const result = await run(root, preset);
-  console.log(report(result));
-  process.exit(result.violations.length === 0 ? 0 : 1);
-}
+  const result = yield* run(root, path.join(import.meta.dir, "..", "bunfig.toml"));
+  yield* Console.log(report(result));
+  return result.violations.length === 0;
+});
+
+if (import.meta.main) runMain("test-layout", layout);