@avi2dg/checks 0.11.0 → 0.12.0

package/quality.schema.json

@@ -44,7 +44,9 @@
               "checks-comment-gate",
               "checks-suppressions-ratchet",
               "checks-ci-wiring",
-              "checks-quality"
+              "checks-quality",
+              "checks-size-budget",
+              "checks-feature-owners"
             ]
           },
           "allOf": [
@@ -137,6 +139,89 @@
       },
       "additionalProperties": false
     },
+    "size": {
+      "type": "object",
+      "properties": {
+        "fileLines": {
+          "type": "integer",
+          "exclusiveMinimum": 0,
+          "description": "The most lines a file may hold, blank and comment lines counted"
+        },
+        "functionLines": {
+          "type": "integer",
+          "exclusiveMinimum": 0,
+          "description": "The most lines a function may span, blank and comment lines counted"
+        },
+        "applies": {
+          "type": "string",
+          "enum": [
+            "changed",
+            "all"
+          ],
+          "description": "Which production files the budget holds: changed, the ones a range adds or changes; all, every one. The rest are reported as advisory"
+        }
+      },
+      "required": [
+        "fileLines",
+        "functionLines",
+        "applies"
+      ],
+      "additionalProperties": false,
+      "description": "The line budget oxlint holds production files to, read by checks-size-budget"
+    },
+    "features": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$",
+            "description": "The owner the dependency rule and the change signal name"
+          },
+          "root": {
+            "$ref": "#/$defs/DirectoryPath"
+          },
+          "entries": {
+            "type": "array",
+            "prefixItems": [
+              {
+                "$ref": "#/$defs/FilePath"
+              }
+            ],
+            "minItems": 1,
+            "items": {
+              "$ref": "#/$defs/FilePath"
+            },
+            "description": "The files under root that code outside it imports the feature through"
+          },
+          "allowFrom": {
+            "type": "array",
+            "items": {
+              "$ref": "#/$defs/PathGlob"
+            },
+            "description": "Files outside root that may import past its entries, such as a CLI or a harness; tests/ always may"
+          },
+          "proof": {
+            "$ref": "#/$defs/ProofPath"
+          }
+        },
+        "required": [
+          "name",
+          "root",
+          "entries",
+          "proof"
+        ],
+        "additionalProperties": false
+      }
+    },
+    "changeSignal": {
+      "type": "string",
+      "enum": [
+        "advisory"
+      ],
+      "description": "Report which feature owners a change touches, without failing on it"
+    },
     "agentRules": {
       "type": "object",
       "properties": {
@@ -161,6 +246,49 @@
   "additionalProperties": false,
   "title": "quality.json",
   "description": "What a repository has opted into from @avi2dg/checks, read by its bins and agent Rule selection",
+  "allOf": [
+    {
+      "if": {
+        "required": [
+          "size"
+        ]
+      },
+      "then": {
+        "required": [
+          "sources"
+        ],
+        "properties": {
+          "sources": {
+            "required": [
+              "production"
+            ],
+            "properties": {
+              "production": {
+                "minItems": 1
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "required": [
+          "changeSignal"
+        ]
+      },
+      "then": {
+        "required": [
+          "features"
+        ],
+        "properties": {
+          "features": {
+            "minItems": 1
+          }
+        }
+      }
+    }
+  ],
   "$defs": {
     "Command": {
       "type": "string",
@@ -189,6 +317,20 @@
       "pattern": "^(?!\\.\\.?(?:\\/|$))(?:\\*\\*|(?:[\\w.@+-]|\\*(?!\\*))+)(?:\\/(?!\\.\\.?(?:\\/|$))(?:\\*\\*|(?:[\\w.@+-]|\\*(?!\\*))+))*\\/(?:[\\w.@+-]|\\*(?!\\*))*\\.\\w+$",
       "description": "A glob from the repository root that oxlint, the Effect language service and git read alike: a directory first, * within a segment, ** as a whole one, a file name with an extension last, and no braces, ?, [ or leading ./"
     },
+    "DirectoryPath": {
+      "type": "string",
+      "pattern": "^(?!\\.\\.?(?:\\/|$))[\\w.@+-]+(?:\\/(?!\\.\\.?(?:\\/|$))[\\w.@+-]+)*$",
+      "description": "The directory the feature owns"
+    },
+    "FilePath": {
+      "type": "string",
+      "pattern": "^(?:(?!\\.\\.?(?:\\/|$))[\\w.@+-]+\\/)*[\\w.@+-]*\\.\\w+$"
+    },
+    "ProofPath": {
+      "type": "string",
+      "pattern": "^tests\\/e2e\\/(?:(?!\\.\\.?(?:\\/|$))[\\w.@+-]+\\/)*[\\w.@+-]+\\.test\\.tsx?$",
+      "description": "The end-to-end test that imports one of entries"
+    },
     "RuleName": {
       "type": "string",
       "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$"

package/scripts/feature-owners.ts

@@ -0,0 +1,142 @@
+#!/usr/bin/env bun
+import { parse } from "@swc/core";
+import { Console, Effect, Path, Schema } from "effect";
+import { changedPaths, git, pathsAt, rangeEnds, type Change } from "./git.ts";
+import { runMain, Usage } from "./main.ts";
+import { PROOF_DIRECTORY, readQuality, type Feature } from "./quality-file.ts";
+
+type Unproven = {
+  readonly feature: string;
+  readonly reason: string;
+};
+
+type Touch = {
+  readonly feature: string;
+  readonly paths: readonly string[];
+};
+
+class ProofUnparsed extends Schema.TaggedError<ProofUnparsed>()("ProofUnparsed", {
+  message: Schema.String,
+}) {}
+
+const NAME = "feature-owners";
+const USAGE = "usage: feature-owners.ts <ref> | <base-ref> <head-ref>";
+const RELATIVE = /^\.\.?\//;
+const SCRIPT_EXTENSIONS = new Map([
+  [".js", [".ts", ".tsx"]],
+  [".jsx", [".tsx"]],
+  [".mjs", [".mts"]],
+  [".cjs", [".cts"]],
+]);
+
+const runtimeSpecifiers = Effect.fn("runtimeSpecifiers")(function* (file: string, source: string) {
+  const module = yield* Effect.tryPromise({
+    try: () => parse(source, { syntax: "typescript", tsx: file.endsWith(".tsx"), target: "esnext" }),
+    catch: (error) => new ProofUnparsed({ message: `${file} does not parse: ${String(error)}` }),
+  });
+  return module.body.flatMap((item) => {
+    if (item.type === "ImportDeclaration" && !item.typeOnly) return [item.source.value];
+    // swc types source as optional, but a local export such as `export { x }` carries null.
+    if (item.type === "ExportNamedDeclaration" && !item.typeOnly && item.source) return [item.source.value];
+    if (item.type === "ExportAllDeclaration") return [item.source.value];
+    return [];
+  });
+});
+
+const candidatesFor = Effect.fn("candidatesFor")(function* (importer: string, specifier: string) {
+  if (!RELATIVE.test(specifier)) return [];
+  const path = yield* Path.Path;
+  const target = path.join(path.dirname(importer), specifier);
+  const extension = path.extname(target);
+  const sources = SCRIPT_EXTENSIONS.get(extension);
+  if (sources !== undefined) return [target, ...sources.map((source) => `${target.slice(0, -extension.length)}${source}`)];
+  if (extension !== "") return [target];
+  return [`${target}.ts`, `${target}.tsx`, `${target}/index.ts`, `${target}/index.tsx`];
+});
+
+const proofImportsAnEntry = Effect.fn("proofImportsAnEntry")(function* (root: string, head: string, feature: Feature) {
+  const source = yield* git(["cat-file", "blob", `${head}:${feature.proof}`], root);
+  const specifiers = yield* runtimeSpecifiers(feature.proof, source);
+  const reached = yield* Effect.forEach(specifiers, (specifier) => candidatesFor(feature.proof, specifier));
+  return reached.flat().some((path) => feature.entries.includes(path));
+});
+
+const unproven = Effect.fn("unproven")(function* (root: string, head: string, features: readonly Feature[]) {
+  const declared = features.flatMap((feature) => [feature.proof, ...feature.entries]);
+  const present = new Set(yield* pathsAt(head, declared.map((path) => `:(literal)${path}`), root));
+  const found: Unproven[] = [];
+  for (const feature of features) {
+    const refuse = (reason: string) => found.push({ feature: feature.name, reason });
+    for (const entry of feature.entries.filter((path) => !present.has(path))) refuse(`entry ${entry} is not in the head commit`);
+    if (!present.has(feature.proof)) {
+      refuse(`proof ${feature.proof} is not in the head commit`);
+      continue;
+    }
+    const reason = yield* proofImportsAnEntry(root, head, feature).pipe(
+      Effect.map((imports) => (imports ? undefined : `proof ${feature.proof} imports none of its entries, ${feature.entries.join(", ")}`)),
+      Effect.catchTag("ProofUnparsed", (error) => Effect.succeed(`proof ${error.message}`)),
+    );
+    if (reason !== undefined) refuse(reason);
+  }
+  return found;
+});
+
+function ownerOf(features: readonly Feature[], path: string): string | undefined {
+  return features.find((feature) => path.startsWith(`${feature.root}/`) || path === feature.proof)?.name;
+}
+
+function touches(features: readonly Feature[], changes: readonly Change[]): readonly Touch[] {
+  const byOwner = new Map<string, string[]>();
+  for (const change of changes) {
+    for (const path of change.kind === "renamed" ? [change.from, change.path] : [change.path]) {
+      const owner = ownerOf(features, path);
+      if (owner === undefined) continue;
+      byOwner.set(owner, [...(byOwner.get(owner) ?? []), path]);
+    }
+  }
+  return features.flatMap((feature) => {
+    const paths = byOwner.get(feature.name);
+    return paths === undefined ? [] : [{ feature: feature.name, paths }];
+  });
+}
+
+function proofReport(features: readonly Feature[], found: readonly Unproven[]): string {
+  if (found.length === 0) {
+    return `${NAME}: ${features.length} feature(s) keep a proof under ${PROOF_DIRECTORY} that imports an entry`;
+  }
+  return [
+    `${NAME}: ${found.length} problem(s) with the features' runnable proofs:`,
+    ...found.map(({ feature, reason }) => `  ${feature}: ${reason}`),
+  ].join("\n");
+}
+
+function signalReport(touched: readonly Touch[]): string {
+  if (touched.length === 0) return `${NAME}: advisory, the range touches no feature owner`;
+  const judge = touched.length > 1 ? "; a reviewer judges whether they make one slice" : "";
+  return [
+    `${NAME}: advisory, the range touches ${touched.length} feature owner(s)${judge}:`,
+    ...touched.map(({ feature, paths }) => `  ${feature}: ${paths.join(", ")}`),
+  ].join("\n");
+}
+
+const owners = Effect.gen(function* () {
+  const [first, second, ...extra] = process.argv.slice(2);
+  if (first === undefined || extra.length > 0) return yield* new Usage({ message: USAGE });
+
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  const { source, quality } = yield* readQuality(root);
+  const features = quality.features ?? [];
+  if (features.length === 0) {
+    yield* Console.log(`${NAME}: ${source} declares no feature`);
+    return true;
+  }
+  const { base, head } = yield* rangeEnds(first, second, root);
+  const found = yield* unproven(root, head, features);
+  yield* Console.log(proofReport(features, found));
+  if (quality.changeSignal === "advisory") {
+    yield* Console.log(signalReport(touches(features, yield* changedPaths(base, head, [], root))));
+  }
+  return found.length === 0;
+});
+
+if (import.meta.main) runMain(NAME, owners);

package/scripts/gates.ts

@@ -38,6 +38,8 @@ export const KIT_GATES = [
   { bin: "checks-suppressions-ratchet", script: "suppressions-ratchet.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-ci-wiring", script: "ci-wiring.ts", reads: "tree", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-quality", script: "quality.ts", reads: "tree", args: ["--check"], appliesTo: QUALITY_DECLARATION },
+  { bin: "checks-size-budget", script: "size-budget.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
+  { bin: "checks-feature-owners", script: "feature-owners.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
 ] as const satisfies readonly KitGate[];
 
 const UNCONDITIONAL = KIT_GATES.filter((gate) => gate.appliesTo === EVERY_REPOSITORY).map((gate) => gate.bin);

package/scripts/git.ts

@@ -8,24 +8,76 @@ export class GitFailure extends Schema.TaggedError<GitFailure>()("GitFailure", {
 const text = <E>(bytes: Stream.Stream<Uint8Array, E>): Effect.Effect<string, E> =>
   bytes.pipe(Stream.decodeText(), Stream.mkString);
 
-// Both pipes drain while git runs: one left unread fills its buffer and stalls git.
-export const git = Effect.fn("git")(
-  function* (args: readonly string[], cwd?: string) {
+export type Feed = {
+  readonly env?: Readonly<Record<string, string>>;
+  readonly input?: string;
+};
+
+// Both pipes drain while the program runs: one left unread fills its buffer and stalls it.
+export const collect = Effect.fn("collect")(
+  function* (program: string, args: readonly string[], cwd?: string, { env, input }: Feed = {}) {
     const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-    const command = `git ${args.join(" ")}`;
-    const failed = (stderr: string): GitFailure => new GitFailure({ message: `${command}: ${stderr.trim()}` });
-    const handle = yield* spawner
-      .spawn(ChildProcess.make("git", args, { cwd }))
-      .pipe(Effect.mapError((cause) => failed(cause.message)));
+    const stdin = input === undefined ? undefined : Stream.make(new TextEncoder().encode(input));
+    const handle = yield* spawner.spawn(ChildProcess.make(program, args, { cwd, env, extendEnv: true, stdin }));
     const [stdout, stderr, exitCode] = yield* Effect.all([text(handle.stdout), text(handle.stderr), handle.exitCode], {
       concurrency: "unbounded",
-    }).pipe(Effect.mapError((cause) => failed(cause.message)));
-    if (exitCode !== ChildProcessSpawner.ExitCode(0)) return yield* failed(stderr);
-    return stdout;
+    });
+    return { stdout, stderr, exitCode };
   },
   Effect.scoped,
 );
 
+export const git = Effect.fn("git")(function* (args: readonly string[], cwd?: string, feed?: Feed) {
+  const failed = (reason: string): GitFailure => new GitFailure({ message: `git ${args.join(" ")}: ${reason.trim()}` });
+  const { stdout, stderr, exitCode } = yield* collect("git", args, cwd, feed).pipe(
+    Effect.mapError((cause) => failed(cause.message)),
+  );
+  if (exitCode !== ChildProcessSpawner.ExitCode(0)) return yield* failed(stderr);
+  return stdout;
+});
+
+export type Change =
+  | { readonly kind: "written" | "deleted"; readonly path: string }
+  | { readonly kind: "renamed"; readonly from: string; readonly path: string; readonly edited: boolean };
+
+const UNCHANGED_RENAME = "R100";
+
+function parseNameStatus(output: string): readonly Change[] {
+  const fields = output.split("\0");
+  const changes: Change[] = [];
+  let index = 0;
+  while (index < fields.length - 1) {
+    const status = fields[index] ?? "";
+    if (status.startsWith("R")) {
+      changes.push({ kind: "renamed", from: fields[index + 1] ?? "", path: fields[index + 2] ?? "", edited: status !== UNCHANGED_RENAME });
+      index += 3;
+    } else if (status.startsWith("C")) {
+      changes.push({ kind: "written", path: fields[index + 2] ?? "" });
+      index += 3;
+    } else {
+      changes.push({ kind: status === "D" ? "deleted" : "written", path: fields[index + 1] ?? "" });
+      index += 2;
+    }
+  }
+  return changes;
+}
+
+export const changedPaths = Effect.fn("changedPaths")(function* (
+  base: string,
+  head: string,
+  pathspecs: readonly string[],
+  cwd?: string,
+) {
+  return parseNameStatus(yield* git(["diff", "--name-status", "-z", "-M", base, head, "--", ...pathspecs], cwd));
+});
+
+const emptyTree = (cwd?: string) => git(["hash-object", "-t", "tree", "/dev/null"], cwd).pipe(Effect.map((sha) => sha.trim()));
+
+export const pathsAt = Effect.fn("pathsAt")(function* (rev: string, pathspecs: readonly string[], cwd?: string) {
+  const listed = yield* git(["diff", "--name-only", "-z", "--no-renames", yield* emptyTree(cwd), rev, "--", ...pathspecs], cwd);
+  return listed.split("\0").filter((path) => path !== "");
+});
+
 function namesAParent(commitObject: string): boolean {
   const [headers = ""] = commitObject.split("\n\n", 1);
   return headers.split("\n").some((header) => header.startsWith("parent "));
@@ -34,8 +86,12 @@ function namesAParent(commitObject: string): boolean {
 // A shallow clone's boundary commit reads as parentless to rev-parse and log, and judged against
 // the empty tree it would carry the whole repository; only the commit object still names its parents.
 export const parentOrEmptyTree = Effect.fn("parentOrEmptyTree")(function* (rev: string, cwd?: string) {
-  if (!namesAParent(yield* git(["cat-file", "commit", rev], cwd))) {
-    return (yield* git(["hash-object", "-t", "tree", "/dev/null"], cwd)).trim();
-  }
+  if (!namesAParent(yield* git(["cat-file", "commit", rev], cwd))) return yield* emptyTree(cwd);
   return (yield* git(["rev-parse", "--verify", `${rev}^`], cwd)).trim();
 });
+
+// From the base branch's tip, a range would charge the head with what the base branch changed after it branched off.
+export const rangeEnds = Effect.fn("rangeEnds")(function* (first: string, second: string | undefined, cwd?: string) {
+  if (second === undefined) return { base: yield* parentOrEmptyTree(first, cwd), head: first };
+  return { base: (yield* git(["merge-base", first, second], cwd)).trim(), head: second };
+});

package/scripts/quality-file.ts

@@ -20,6 +20,28 @@ const PathGlob = Schema.String.check(
     "A glob from the repository root that oxlint, the Effect language service and git read alike: a directory first, * within a segment, ** as a whole one, a file name with an extension last, and no braces, ?, [ or leading ./",
 });
 
+const LITERAL_SEGMENT = String.raw`(?!\.\.?(?:/|$))[\w.@+-]+`;
+
+const DirectoryPath = Schema.String.check(
+  Schema.isPattern(new RegExp(`^${LITERAL_SEGMENT}(?:/${LITERAL_SEGMENT})*$`), {
+    expected: "a directory from the repository root such as src/billing, with no glob and no trailing slash",
+  }),
+).annotate({ identifier: "DirectoryPath" });
+
+const FilePath = Schema.String.check(
+  Schema.isPattern(new RegExp(`^(?:${LITERAL_SEGMENT}/)*[\\w.@+-]*\\.\\w+$`), {
+    expected: "a file from the repository root such as src/billing/index.ts, with no glob",
+  }),
+).annotate({ identifier: "FilePath" });
+
+export const PROOF_DIRECTORY = "tests/e2e/";
+
+const ProofPath = Schema.String.check(
+  Schema.isPattern(new RegExp(`^${PROOF_DIRECTORY}(?:${LITERAL_SEGMENT}/)*[\\w.@+-]+\\.test\\.tsx?$`), {
+    expected: `a test file under ${PROOF_DIRECTORY} such as ${PROOF_DIRECTORY}billing.test.ts`,
+  }),
+).annotate({ identifier: "ProofPath" });
+
 const Command = Schema.NonEmptyString.annotate({ identifier: "Command" });
 
 const RuleName = Schema.String.check(
@@ -65,6 +87,58 @@ const Sources = Schema.Struct({
   effect: Schema.optionalKey(EffectSources),
 });
 
+const LineBudget = Schema.Int.check(Schema.isGreaterThan(0));
+
+const Size = Schema.Struct({
+  fileLines: LineBudget.annotate({ description: "The most lines a file may hold, blank and comment lines counted" }),
+  functionLines: LineBudget.annotate({
+    description: "The most lines a function may span, blank and comment lines counted",
+  }),
+  applies: Schema.Literals(["changed", "all"]).annotate({
+    description:
+      "Which production files the budget holds: changed, the ones a range adds or changes; all, every one. The rest are reported as advisory",
+  }),
+});
+
+const Feature = Schema.Struct({
+  name: Schema.String.check(
+    Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { expected: "a feature name in kebab case" }),
+  ).annotate({ description: "The owner the dependency rule and the change signal name" }),
+  root: DirectoryPath.annotate({ description: "The directory the feature owns" }),
+  entries: Schema.NonEmptyArray(FilePath).annotate({
+    description: "The files under root that code outside it imports the feature through",
+  }),
+  allowFrom: Schema.optionalKey(
+    Schema.Array(PathGlob).annotate({
+      description: "Files outside root that may import past its entries, such as a CLI or a harness; tests/ always may",
+    }),
+  ),
+  proof: ProofPath.annotate({ description: "The end-to-end test that imports one of entries" }),
+}).check(
+  Schema.makeFilter(({ root, entries }) => {
+    const outside = entries.filter((entry) => !entry.startsWith(`${root}/`));
+    return outside.length === 0 || `lists ${outside.join(", ")} among its entries, outside its root ${root}`;
+  }),
+);
+export type Feature = typeof Feature.Type;
+
+function nests(outer: string, inner: string): boolean {
+  return outer === inner || inner.startsWith(`${outer}/`);
+}
+
+const Features = Schema.Array(Feature).check(
+  Schema.makeFilter((features) => {
+    const names = features.map((feature) => feature.name);
+    const repeated = names.filter((name, index) => names.indexOf(name) !== index);
+    if (repeated.length > 0) return `names ${[...new Set(repeated)].join(", ")} more than once`;
+    for (const outer of features) {
+      const inner = features.find((other) => other !== outer && nests(outer.root, other.root));
+      if (inner !== undefined) return `gives ${inner.root} to both ${outer.name} and ${inner.name}`;
+    }
+    return true;
+  }),
+);
+
 const AgentRules = Schema.Struct({
   on: Schema.optionalKey(Schema.Array(RuleName).annotate({ description: "Catalogued Rules switched on here" })),
   off: Schema.optionalKey(Schema.Array(RuleName).annotate({ description: "Catalogued Rules switched off here" })),
@@ -83,11 +157,47 @@ export const Quality = Schema.Struct({
   gates: Schema.optionalKey(Gates),
   commitIdentity: Schema.optionalKey(CommitIdentity),
   sources: Schema.optionalKey(Sources),
+  size: Schema.optionalKey(
+    Size.annotate({ description: "The line budget oxlint holds production files to, read by checks-size-budget" }),
+  ),
+  features: Schema.optionalKey(
+    Features.annotate({
+      description: "The feature owners dependency-cruiser holds to their entries and checks-feature-owners maps a change to",
+    }),
+  ),
+  changeSignal: Schema.optionalKey(
+    Schema.Literal("advisory").annotate({
+      description: "Report which feature owners a change touches, without failing on it",
+    }),
+  ),
   agentRules: Schema.optionalKey(AgentRules),
-}).annotate({
-  title: QUALITY_FILE,
-  description: "What a repository has opted into from @avi2dg/checks, read by its bins and agent Rule selection",
-});
+})
+  .annotate({
+    title: QUALITY_FILE,
+    description: "What a repository has opted into from @avi2dg/checks, read by its bins and agent Rule selection",
+  })
+  .check(
+    Schema.makeFilter(
+      ({ size, sources }) =>
+        size === undefined || (sources?.production ?? []).length > 0 || "declares size, which holds nothing without sources.production",
+      {
+        toJsonSchema: () => ({
+          if: { required: ["size"] },
+          then: { required: ["sources"], properties: { sources: { required: ["production"], properties: { production: { minItems: 1 } } } } },
+        }),
+      },
+    ),
+    Schema.makeFilter(
+      ({ changeSignal, features = [] }) =>
+        changeSignal === undefined || features.length > 0 || "declares changeSignal, which maps a change to no owner without features",
+      {
+        toJsonSchema: () => ({
+          if: { required: ["changeSignal"] },
+          then: { required: ["features"], properties: { features: { minItems: 1 } } },
+        }),
+      },
+    ),
+  );
 export type Quality = typeof Quality.Type;
 
 const LegacyManifest = Schema.Struct({

package/scripts/quality.ts

@@ -119,10 +119,18 @@ const fragmentProblems = Effect.fn("fragmentProblems")(function* (root: string,
 });
 
 const unmatchedPaths = Effect.fn("unmatchedPaths")(function* (root: string, quality: Quality) {
+  const declared = [
+    ...(quality.size === undefined ? [] : (quality.sources?.production ?? [])).map((glob) => ({
+      glob,
+      key: "sources.production",
+      holds: "no source to the size budget",
+    })),
+    ...(quality.sources?.effect?.paths ?? []).map((glob) => ({ glob, key: "sources.effect.paths", holds: "nothing to the Effect rules" })),
+  ];
   const problems: string[] = [];
-  for (const glob of quality.sources?.effect?.paths ?? []) {
+  for (const { glob, key, holds } of declared) {
     const matched = yield* git(["ls-files", "--cached", "--others", "--exclude-standard", "--", `:(glob)${glob}`], root);
-    if (matched.trim() === "") problems.push(`sources.effect.paths ${glob} matches no file, so it holds nothing to the Effect rules`);
+    if (matched.trim() === "") problems.push(`${key} ${glob} matches no file, so it holds ${holds}`);
   }
   return problems;
 });