@avi2dg/checks 0.25.0 → 0.27.0

package/docs/gates/checks-unused.md

@@ -4,7 +4,7 @@ audience: consumers
 ---
 # checks-unused
 
-`checks-unused` is the gate that refuses a TypeScript file no entry point reaches, and a reader looks it up when a file seems dead but every other check passes.
+`checks-unused` is the gate that refuses a TypeScript file no entry point reaches.
 
 ## What it checks
 
@@ -54,10 +54,10 @@ A passing run counts the files it judged:
 unused: no unreferenced files among 110 tracked .ts/.tsx file(s)
 ```
 
-## Opting out
+## When it runs
 
-`checks-lint` runs this gate only when the repository tracks `.ts` or `.tsx` files.
-A repository that tracks one names its entries in a Knip configuration.
+`checks-lint` runs it when the repository tracks a `.ts` or `.tsx` file.
+Such a repository names its entries in a Knip configuration.
 
 ## Related topics
 

package/docs/gates/checks-vendor.md

@@ -102,10 +102,10 @@ A consumer whose `tsconfig.json` has no explicit `include` keeps the trees out w
 { "exclude": ["node_modules", "repos"] }
 ```
 
-## Opting out
+## When it runs
 
-It pins sources only for the libraries its arguments name.
-A run with no arguments reports nothing to pin and changes nothing.
+The repository's `prepare` script runs it, as [Wiring](#wiring) shows.
+It pins only the libraries its arguments name, and a run with no arguments changes nothing.
 A repository that pins no library needs no `prepare` entry for it.
 
 ## Related topics

package/oxlintrc.json

@@ -1,6 +1,6 @@
 {
   "plugins": ["typescript", "oxc", "eslint", "import"],
-  "jsPlugins": ["./dist/effect-channel/index.js", "./dist/readability/index.js"],
+  "jsPlugins": ["./dist/effect-channel/index.js", "./dist/readability/index.js", "./dist/data-shape/index.js"],
   "categories": { "correctness": "error", "suspicious": "error" },
   "rules": {
     "effect-channel/no-error-channel-escape": "error",
@@ -18,5 +18,25 @@
     "typescript/no-non-null-assertion": "error",
     "typescript/no-deprecated": "error",
     "typescript/consistent-return": "off"
-  }
+  },
+  "overrides": [
+    {
+      "files": ["**/*.ts", "**/*.tsx"],
+      "rules": {
+        "data-shape/readonly-collection-param": "error"
+      }
+    },
+    {
+      "files": ["**/*.ts", "**/*.tsx"],
+      "excludeFiles": ["tests/**"],
+      "rules": {
+        "data-shape/schema-twin": "error",
+        "typescript/no-unsafe-assignment": "error",
+        "typescript/no-unsafe-member-access": "error",
+        "typescript/no-unsafe-argument": "error",
+        "typescript/no-unsafe-return": "error",
+        "typescript/no-unsafe-call": "error"
+      }
+    }
+  ]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@avi2dg/checks",
-  "version": "0.25.0",
-  "description": "Deterministic checks shared across the captain's TypeScript repos",
+  "version": "0.27.0",
+  "description": "Deterministic checks shared across a set of TypeScript repositories",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -47,6 +47,8 @@
     "src/complexity/suppressions-ratchet.ts",
     "src/complexity/repetition.ts",
     "src/complexity/unused.ts",
+    "src/complexity/exports.ts",
+    "src/complexity/knip.ts",
     "src/testing/quarantine-clock.ts",
     "src/docs/docs.ts",
     "src/dependencies/vendor.ts",
@@ -56,14 +58,17 @@
     "src/docs/doc-references.ts",
     "src/docs/doc-snapshot.ts",
     "src/docs/doc-templates.ts",
-    "templates/",
-    "presets/effect.oxlint.json",
-    "presets/effect.language-service.json",
+    "src/docs/doc-names.ts",
+    "dist/templates/",
+    "src/quality/presets/effect.oxlint.json",
+    "src/quality/presets/effect.language-service.json",
     "oxlintrc.json",
     "stryker.preset.js",
     "tsconfig.effect.json",
+    "ts-reset.d.ts",
     "dist/effect-channel/index.js",
-    "dist/readability/index.js"
+    "dist/readability/index.js",
+    "dist/data-shape/index.js"
   ],
   "exports": {
     "./dependency-cruiser.config.js": "./dependency-cruiser.config.js",
@@ -72,6 +77,7 @@
     "./scripts/comment-matchers.ts": "./src/quality/comment-matchers.ts",
     "./scripts/prose-matchers.ts": "./src/docs/prose-matchers.ts",
     "./stryker.preset.js": "./stryker.preset.js",
+    "./templates/*": "./dist/templates/*",
     "./tsconfig.effect.json": "./tsconfig.effect.json"
   },
   "bin": {
@@ -91,13 +97,14 @@
     "checks-suppressions-ratchet": "src/complexity/suppressions-ratchet.ts",
     "checks-repetition": "src/complexity/repetition.ts",
     "checks-unused": "src/complexity/unused.ts",
+    "checks-exports": "src/complexity/exports.ts",
     "checks-quarantine-clock": "src/testing/quarantine-clock.ts",
     "checks-docs": "src/docs/docs.ts",
     "checks-vendor": "src/dependencies/vendor.ts"
   },
   "scripts": {
     "prepare": "bun src/dependencies/vendor.ts --library effect --package effect --repository https://github.com/Effect-TS/effect.git --tag 'effect@{version}' --path packages/effect/package.json",
-    "build": "bun build src/quality/effect-channel/index.ts --outdir dist/effect-channel --target node --format esm && bun build src/complexity/readability/index.ts --outdir dist/readability --target node --format esm && bun scripts/doc-templates-write.ts && bun src/delivery/changelog-write.ts && bun scripts/doc-blocks-write.ts",
+    "build": "bun build src/quality/effect-channel/index.ts --outdir dist/effect-channel --target node --format esm && bun build src/complexity/readability/index.ts --outdir dist/readability --target node --format esm && bun build src/quality/data-shape/index.ts --outdir dist/data-shape --target node --format esm && bun scripts/doc-templates-write.ts && bun src/delivery/changelog-write.ts && bun scripts/doc-blocks-write.ts",
     "lint": "oxlint --type-aware && bun src/core/lint.ts && depcruise --config .dependency-cruiser.cjs .",
     "typecheck": "tsc --noEmit && effect-tsgo diagnostics --project tsconfig.json --format text --strict",
     "test": "bun src/testing/test.ts"
@@ -109,14 +116,14 @@
     "effect": "4.0.0-rc.115",
     "jscpd": "5.3.2",
     "oxlint": "1.83.0",
-    "oxlint-tsgolint": "7.0.2002"
+    "oxlint-tsgolint": "7.0.2002",
+    "typescript": "7.0.2"
   },
   "devDependencies": {
     "@effect/tsgo": "0.45.0",
     "@oxlint/plugins": "1.83.0",
     "@swc/core": "1.16.2",
     "@types/bun": "^1.3.0",
-    "ajv": "8.20.0",
     "dependency-cruiser": "18.4.0",
     "effect": "4.0.0-rc.115",
     "jscpd": "5.3.2",
@@ -129,6 +136,7 @@
     "@commitlint/config-conventional": "21.2.3",
     "@effect/platform-bun": "4.0.0-rc.115",
     "@effect/platform-node-shared": "4.0.0-rc.115",
+    "@total-typescript/ts-reset": "0.6.1",
     "knip": "6.38.0"
   }
 }

package/src/complexity/exports.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env bun
+import { Console, Effect, FileSystem, Path, Schema } from "effect";
+import { checkoutFiles, commitOf, git, pathsAt, rangeEnds, refArgs } from "../core/git.ts";
+import { runMain } from "../core/main.ts";
+import { knipReport, scanTree } from "./knip.ts";
+
+const UnusedSymbolSchema = Schema.Struct({
+  file: Schema.String,
+  kind: Schema.Literals(["export", "type"]),
+  name: Schema.String,
+});
+
+export type UnusedSymbol = typeof UnusedSymbolSchema.Type;
+
+export type Baseline = readonly UnusedSymbol[];
+
+export type Held = {
+  readonly reported: readonly UnusedSymbol[];
+  readonly base: Baseline;
+  readonly head: Baseline;
+  readonly unusedAtBase: readonly UnusedSymbol[];
+};
+
+export type Drift = {
+  readonly unlisted: readonly UnusedSymbol[];
+  readonly added: readonly UnusedSymbol[];
+  readonly stale: readonly UnusedSymbol[];
+};
+
+const NAME = "exports";
+export const BASELINE_FILE = "exports-baseline.json";
+const INCLUDED = ["--include", "exports,types"];
+const WRITE = "--write";
+const USAGE = `usage: exports.ts <ref> | <base-ref> <head-ref> | ${WRITE}`;
+
+class ExportsError extends Schema.TaggedError<ExportsError>()("ExportsError", {
+  message: Schema.String,
+}) {}
+
+const KnipSymbol = Schema.Struct({ name: Schema.String });
+
+const decodeKnipReport = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(
+    Schema.Struct({
+      issues: Schema.Array(
+        Schema.Struct({
+          file: Schema.String,
+          exports: Schema.optional(Schema.Array(KnipSymbol)),
+          types: Schema.optional(Schema.Array(KnipSymbol)),
+        }),
+      ),
+    }),
+  ),
+);
+
+const decodeBaseline = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Array(UnusedSymbolSchema)));
+
+function byPosition(a: UnusedSymbol, b: UnusedSymbol): number {
+  return a.file.localeCompare(b.file) || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name);
+}
+
+export const symbolsOf = Effect.fn("symbolsOf")(function* (stdout: string) {
+  const { issues } = yield* decodeKnipReport(stdout).pipe(
+    Effect.mapError((cause) => new ExportsError({ message: `knip's JSON report does not decode: ${cause.message}` })),
+  );
+  return issues
+    .flatMap(({ file, exports = [], types = [] }): readonly UnusedSymbol[] => [
+      ...exports.map(({ name }): UnusedSymbol => ({ file, kind: "export", name })),
+      ...types.map(({ name }): UnusedSymbol => ({ file, kind: "type", name })),
+    ])
+    .toSorted(byPosition);
+});
+
+export const baselineOf = Effect.fn("baselineOf")(function* (text: string, where: string) {
+  return yield* decodeBaseline(text).pipe(
+    Effect.mapError((cause) => new ExportsError({ message: `${where} does not decode: ${cause.message}` })),
+  );
+});
+
+const baselinePath = Effect.fn("baselinePath")(function* (root: string) {
+  return (yield* Path.Path).join(root, BASELINE_FILE);
+});
+
+const baselineInTree = Effect.fn("baselineInTree")(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const at = yield* baselinePath(root);
+  if (!(yield* fs.exists(at))) return [] satisfies Baseline;
+  return yield* fs.readFileString(at).pipe(Effect.flatMap((text) => baselineOf(text, BASELINE_FILE)));
+});
+
+const baselineAt = Effect.fn("baselineAt")(function* (treeish: string, root: string) {
+  const blob = (yield* git(["ls-tree", "--object-only", treeish, "--", BASELINE_FILE], root)).trim();
+  if (blob === "") return [] satisfies Baseline;
+  return yield* baselineOf(yield* git(["cat-file", "blob", blob], root), `${BASELINE_FILE} at ${treeish}`);
+});
+
+const keyOf = ({ file, kind, name }: UnusedSymbol): string => `${kind}\0${file}\0${name}`;
+
+function outside(symbols: readonly UnusedSymbol[], others: readonly UnusedSymbol[]): readonly UnusedSymbol[] {
+  const known = new Set(others.map(keyOf));
+  return symbols.filter((symbol) => !known.has(keyOf(symbol))).toSorted(byPosition);
+}
+
+export function driftOf({ reported, base, head, unusedAtBase }: Held): Drift {
+  return {
+    unlisted: outside(reported, head),
+    added: outside(head, [...base, ...unusedAtBase]),
+    stale: outside(head, reported),
+  };
+}
+
+function describe(symbol: UnusedSymbol): string {
+  return `  ${symbol.file}: ${symbol.name} (${symbol.kind})`;
+}
+
+export function report(head: Baseline, { unlisted, added, stale }: Drift): string {
+  const sections = [
+    { symbols: unlisted, what: `unused export(s) not in ${BASELINE_FILE}:` },
+    { symbols: added, what: `${BASELINE_FILE} export(s) the range adds that its base did not leave unused, remove the export instead:` },
+    { symbols: stale, what: `${BASELINE_FILE} export(s) no longer reported, remove them:` },
+  ].filter(({ symbols }) => symbols.length > 0);
+  if (sections.length > 0) {
+    return sections.flatMap(({ symbols, what }) => [`${NAME}: ${symbols.length} ${what}`, ...symbols.map(describe)]).join("\n");
+  }
+  return head.length === 0
+    ? `${NAME}: no unused exports or types`
+    : `${NAME}: ${head.length} unused export(s) in ${BASELINE_FILE}, and no new ones`;
+}
+
+const scan = scanTree(NAME, INCLUDED).pipe(Effect.mapError((cause) => new ExportsError({ message: cause.message })));
+
+// Knip loads the configuration's imports, such as the kit's knip-base.json, from a node_modules the checkout lacks.
+const unusedAt = Effect.fn("unusedAt")(
+  function* (rev: string, root: string) {
+    const files = yield* pathsAt(rev, [], root);
+    if (files.length === 0) return [] satisfies readonly UnusedSymbol[];
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const tree = yield* checkoutFiles(rev, files, yield* fs.makeTempDirectoryScoped({ prefix: "checks-exports-" }), root);
+    const modules = path.join(root, "node_modules");
+    if (yield* fs.exists(modules)) yield* fs.symlink(modules, path.join(tree, "node_modules"));
+    const reported = yield* knipReport(tree, INCLUDED).pipe(
+      Effect.mapError((cause) => new ExportsError({ message: `at ${rev}: ${cause.message}` })),
+    );
+    return reported.kind === "unconfigured" ? [] : yield* symbolsOf(reported.stdout);
+  },
+  Effect.scoped,
+);
+
+// Knip scans the checked-out tree, and a pull request's merge checkout holds the base branch tip beside the range head.
+const judgedBase = Effect.fn("judgedBase")(function* (first: string, second: string | undefined, root: string) {
+  const { base } = yield* rangeEnds(first, second, root);
+  if (second === undefined) return base;
+  const head = yield* commitOf(second, root);
+  const parents = (yield* git(["rev-parse", "HEAD^@"], root)).split("\n").filter((line) => line !== "");
+  const [other, ...rest] = parents.filter((parent) => parent !== head);
+  return parents.includes(head) && other !== undefined && rest.length === 0 ? other : base;
+});
+
+const check = Effect.fn("check")(function* (first: string, second: string | undefined) {
+  const { root, reported } = yield* scan;
+  if (reported.kind === "unconfigured") return false;
+  const baseRev = yield* judgedBase(first, second, root);
+  const base = yield* baselineAt(baseRev, root);
+  const head = yield* baselineInTree(root);
+  const unusedAtBase = outside(head, base).length === 0 ? [] : yield* unusedAt(baseRev, root);
+  const drift = driftOf({ reported: yield* symbolsOf(reported.stdout), base, head, unusedAtBase });
+  yield* Console.log(report(head, drift));
+  return drift.unlisted.length === 0 && drift.added.length === 0 && drift.stale.length === 0;
+});
+
+const seed = Effect.gen(function* () {
+  const { root, reported } = yield* scan;
+  if (reported.kind === "unconfigured") return false;
+  const symbols = yield* symbolsOf(reported.stdout);
+  yield* (yield* FileSystem.FileSystem).writeFileString(yield* baselinePath(root), `${JSON.stringify(symbols, null, 2)}\n`);
+  yield* Console.log(`${NAME}: wrote ${symbols.length} unused export(s) to ${BASELINE_FILE}`);
+  return true;
+});
+
+const gate = Effect.gen(function* () {
+  const args = process.argv.slice(2);
+  if (args.length === 1 && args[0] === WRITE) return yield* seed;
+  const { first, second } = yield* refArgs(args, USAGE);
+  return yield* check(first, second);
+});
+
+if (import.meta.main) runMain(NAME, gate);

package/src/complexity/knip.ts

@@ -0,0 +1,70 @@
+import { Console, Effect, FileSystem, Path, Schema } from "effect";
+import { collect, git } from "../core/git.ts";
+
+class KnipError extends Schema.TaggedError<KnipError>()("KnipError", {
+  message: Schema.String,
+}) {}
+
+const CONFIGS = [
+  ".knip.json",
+  ".knip.jsonc",
+  "knip.json",
+  "knip.jsonc",
+  "knip.js",
+  "knip.ts",
+  "knip.config.js",
+  "knip.config.ts",
+] as const;
+
+const TYPESCRIPT = ["*.ts", "*.tsx"];
+
+const hasKnipConfig = Effect.fn("hasKnipConfig")(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  for (const name of CONFIGS) {
+    if (yield* fs.exists(path.join(root, name))) return true;
+  }
+  const manifest: unknown = yield* fs.readFileString(path.join(root, "package.json")).pipe(
+    Effect.flatMap((text) =>
+      Effect.try({
+        try: () => JSON.parse(text),
+        catch: () => new KnipError({ message: "package.json does not parse as JSON" }),
+      })
+    ),
+  );
+  return typeof manifest === "object" && manifest !== null && "knip" in manifest;
+});
+
+const knipBinary = Effect.fn("knipBinary")(function* () {
+  const path = yield* Path.Path;
+  const main = yield* Effect.try({
+    try: () => new URL("../bin/knip.js", import.meta.resolve("knip")),
+    catch: () => new KnipError({ message: "cannot resolve knip from the installed kit" }),
+  });
+  return yield* path.fromFileUrl(main);
+});
+
+export const knipReport = Effect.fn("knipReport")(function* (root: string, args: readonly string[]) {
+  if (!(yield* hasKnipConfig(root))) return { kind: "unconfigured" } as const;
+  const run = yield* collect(process.execPath, [yield* knipBinary(), ...args, "--reporter", "json"], root).pipe(
+    Effect.mapError((cause) => new KnipError({ message: `cannot run knip: ${cause.message}` })),
+  );
+  if (run.exitCode !== 0 && run.exitCode !== 1) {
+    return yield* new KnipError({ message: `knip exits ${run.exitCode}: ${(run.stdout + run.stderr).trim()}` });
+  }
+  return { kind: "reported", stdout: run.stdout } as const;
+});
+
+export const scanTree = Effect.fn("scanTree")(function* (name: string, args: readonly string[]) {
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  const tracked = (yield* git(["ls-files", "--", ...TYPESCRIPT], root))
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line !== "");
+  if (tracked.length === 0) return yield* new KnipError({ message: "no tracked .ts or .tsx files to scan" });
+  const reported = yield* knipReport(root, args);
+  if (reported.kind === "unconfigured") {
+    yield* Console.log(`${name}: no knip configuration names entry files, so add one extending the kit's knip-base.json`);
+  }
+  return { root, tracked: tracked.length, reported };
+});

package/src/complexity/unused.ts

@@ -1,22 +1,11 @@
 #!/usr/bin/env bun
-import { Console, Effect, FileSystem, Path, Schema } from "effect";
-import { collect, git } from "../core/git.ts";
+import { Console, Effect, Schema } from "effect";
 import { runMain } from "../core/main.ts";
+import { scanTree } from "./knip.ts";
 
 export type Scan = { readonly tracked: number; readonly files: readonly string[] };
 
 const NAME = "unused";
-const CONFIGS = [
-  ".knip.json",
-  ".knip.jsonc",
-  "knip.json",
-  "knip.jsonc",
-  "knip.js",
-  "knip.ts",
-  "knip.config.js",
-  "knip.config.ts",
-] as const;
-const TYPESCRIPT = ["*.ts", "*.tsx"];
 const JUDGED = /\.tsx?$/;
 
 class UnusedError extends Schema.TaggedError<UnusedError>()("UnusedError", {
@@ -46,51 +35,13 @@ export function report({ tracked, files }: Scan): string {
   return [`${NAME}: ${files.length} unreferenced file(s):`, ...files.map((file) => `  ${file}`)].join("\n");
 }
 
-const hasConfig = Effect.fn("hasConfig")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  for (const name of CONFIGS) {
-    if (yield* fs.exists(path.join(root, name))) return true;
-  }
-  const manifest: unknown = yield* fs.readFileString(path.join(root, "package.json")).pipe(
-    Effect.flatMap((text) =>
-      Effect.try({
-        try: () => JSON.parse(text) as unknown,
-        catch: () => new UnusedError({ message: "package.json does not parse as JSON" }),
-      })
-    ),
-  );
-  return typeof manifest === "object" && manifest !== null && "knip" in manifest;
-});
-
-const knip = Effect.fn("knip")(function* () {
-  const path = yield* Path.Path;
-  const main = yield* Effect.try({
-    try: () => new URL("../bin/knip.js", import.meta.resolve("knip")),
-    catch: () => new UnusedError({ message: "cannot resolve knip from the installed kit" }),
-  });
-  return yield* path.fromFileUrl(main);
-});
-
 const unused = Effect.gen(function* () {
-  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  const tracked = (yield* git(["ls-files", "--", ...TYPESCRIPT], root))
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line !== "");
-  if (tracked.length === 0) return yield* new UnusedError({ message: "no tracked .ts or .tsx files to scan" });
-  if (!(yield* hasConfig(root))) {
-    yield* Console.log(`${NAME}: no knip configuration names entry files, so add one extending the kit's knip-base.json`);
-    return false;
-  }
-  const run = yield* collect(process.execPath, [yield* knip(), "--files", "--reporter", "json"], root).pipe(
-    Effect.mapError((cause) => new UnusedError({ message: `cannot run knip: ${cause.message}` })),
+  const { tracked, reported } = yield* scanTree(NAME, ["--files"]).pipe(
+    Effect.mapError((cause) => new UnusedError({ message: cause.message })),
   );
-  if (run.exitCode !== 0 && run.exitCode !== 1) {
-    return yield* new UnusedError({ message: `knip exits ${run.exitCode}: ${(run.stdout + run.stderr).trim()}` });
-  }
-  const files = yield* filesOf(run.stdout);
-  yield* Console.log(report({ tracked: tracked.length, files }));
+  if (reported.kind === "unconfigured") return false;
+  const files = yield* filesOf(reported.stdout);
+  yield* Console.log(report({ tracked, files }));
   return files.length === 0;
 });
 

package/src/core/gates.ts

@@ -12,7 +12,7 @@ export const EVERY_REPOSITORY = "every repository";
 
 export const VECTORS = ["complexity", "quality", "testing", "docs", "delivery", "dependencies"] as const;
 
-export type Vector = (typeof VECTORS)[number];
+type Vector = (typeof VECTORS)[number];
 
 export type KitGate = {
   readonly bin: string;
@@ -41,5 +41,6 @@ export const KIT_GATES = [
   { bin: "checks-docs", vector: "docs", file: "docs.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-repetition", vector: "complexity", file: "repetition.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
   { bin: "checks-unused", vector: "complexity", file: "unused.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
+  { bin: "checks-exports", vector: "complexity", file: "exports.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
   { bin: "checks-quarantine-clock", vector: "testing", file: "quarantine-clock.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
 ] as const satisfies readonly KitGate[];

package/src/core/swc.ts

@@ -1,7 +1,7 @@
 import { parse } from "@swc/core";
 import { Effect, Schema } from "effect";
 
-export class TypeScriptParseError extends Schema.TaggedError<TypeScriptParseError>()("TypeScriptParseError", {
+class TypeScriptParseError extends Schema.TaggedError<TypeScriptParseError>()("TypeScriptParseError", {
   message: Schema.String,
 }) {}
 

package/src/delivery/ci-wiring.ts

@@ -200,7 +200,7 @@ function gapsAmong(gates: readonly Gate[], steps: readonly RunStep[], lintGates:
     const blocked = invoking.flatMap(({ location, blocker }) =>
       blocker === undefined ? [] : [{ location, blocker }],
     );
-    return [{ gate: gate.command, entryPoint: entryPoint?.join(" "), blocked }];
+    return [{ gate: gate.command, ...(entryPoint === undefined ? {} : { entryPoint: entryPoint.join(" ") }), blocked }];
   });
 }
 

package/src/dependencies/vendor.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { Console, Effect, FileSystem, Option, Path, Schema } from "effect";
+import { Config, Console, Effect, FileSystem, Option, Path, Schema } from "effect";
 import { git } from "../core/git.ts";
 import { runMain } from "../core/main.ts";
 import { librariesFrom, NAME, OPENER, type Library } from "./vendor-args.ts";
@@ -305,10 +305,9 @@ const vend = Effect.fn("vend")(function* (root: string, cache: string, library:
 
 const cacheRoot = Effect.fn("cacheRoot")(function* () {
   const path = yield* Path.Path;
-  const home = process.env.HOME;
-  if (home === undefined || home === "") {
-    return yield* new VendorError({ message: "HOME is missing, so the shared cache has no root" });
-  }
+  const home = yield* Config.NonEmptyString("HOME").pipe(
+    Effect.mapError(() => new VendorError({ message: "HOME is missing, so the shared cache has no root" })),
+  );
   return path.join(home, CACHE_HOME);
 });