@avi2dg/checks 0.21.0 → 0.23.0

package/scripts/test.ts

@@ -3,20 +3,10 @@ import { Config, Console, Effect, FileSystem, Path, Schema } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 import { TEST_ENTRY_POINT } from "./gates.ts";
 import { runMain, Usage } from "./main.ts";
+import { readSkipDeclarations, type Environment, type SkipDeclaration, type TestTier } from "./test-skips.ts";
 import { NAME_SEPARATOR, parseReport, ReportError, reporterArgs, type TestResult } from "./test-report.ts";
 
-const Environment = Schema.Literals(["ci", "local"]);
-
-export type Environment = typeof Environment.Type;
-
-const SkipDeclaration = Schema.Struct({
-  file: Schema.NonEmptyString,
-  test: Schema.NonEmptyString,
-  reason: Schema.NonEmptyString,
-  when: Schema.optionalKey(Environment),
-});
-
-export type SkipDeclaration = typeof SkipDeclaration.Type;
+export type { Environment, SkipDeclaration } from "./test-skips.ts";
 
 export type Verdict = {
   readonly environment: Environment;
@@ -31,15 +21,23 @@ export class SkipGateError extends Schema.TaggedError<SkipGateError>()("SkipGate
 }) {}
 
 const NAME = TEST_ENTRY_POINT.bin;
-const DECLARATIONS = "package.json testSkips";
-const USAGE = `usage: ${NAME} takes no arguments, since a narrowed run skips every test it leaves out; run bun test --randomize <args> for one`;
-
-const decodeManifest = Schema.decodeUnknownEffect(
-  Schema.fromJsonString(Schema.Struct({ testSkips: Schema.optionalKey(Schema.Array(SkipDeclaration)) })),
-);
+const USAGE = `usage: ${NAME} takes no arguments except --tier=live or --tier=pixel`;
+const TIERS = new Map<string, TestTier>([
+  ["--tier=live", "live"],
+  ["--tier=pixel", "pixel"],
+]);
 
 function matches(declaration: SkipDeclaration, result: TestResult): boolean {
-  return declaration.file === result.file && declaration.test === result.name;
+  const { name } = declaration;
+  return (
+    declaration.file === result.file &&
+    declaration.line === result.line &&
+    (result.name === name || result.name.endsWith(`${NAME_SEPARATOR}${name}`))
+  );
+}
+
+function skippedOutcome(result: TestResult): boolean {
+  return result.outcome === "skipped" || result.outcome === "todo";
 }
 
 function byPlace(a: TestResult, b: TestResult): number {
@@ -51,7 +49,7 @@ export function judgeSkips(
   declarations: readonly SkipDeclaration[],
   environment: Environment,
 ): Verdict {
-  const skipped = results.filter((result) => result.outcome === "skipped" || result.outcome === "todo");
+  const skipped = results.filter(skippedOutcome);
   const applying = declarations.filter((declaration) => (declaration.when ?? environment) === environment);
   return {
     environment,
@@ -71,7 +69,7 @@ export function passes(verdict: Verdict): boolean {
 }
 
 function staleLine(declaration: SkipDeclaration): string {
-  return `  ${declaration.file}${NAME_SEPARATOR}${declaration.test}: declared, but no such test skipped; delete the declaration`;
+  return `  ${declaration.file}:${declaration.line}: no test skipped with this declaration; reason: ${declaration.reason}`;
 }
 
 function verdictLines(verdict: Verdict): readonly string[] {
@@ -80,15 +78,18 @@ function verdictLines(verdict: Verdict): readonly string[] {
   if (passes(verdict)) {
     const other = environment === "ci" ? "local" : "ci";
     const aside = unjudged === 0 ? "" : `; ${unjudged} declaration(s) for ${other} not judged in ${run}`;
-    return [skipped === 0 ? `${NAME}: no test skipped${aside}` : `${NAME}: ${skipped} skipped test(s), each declared in ${DECLARATIONS}${aside}`];
+    return [skipped === 0 ? `${NAME}: no test skipped${aside}` : `${NAME}: ${skipped} skipped test(s), each declared at its test site${aside}`];
   }
   const stale = refusedStale(verdict);
   const counted = environment === "ci" ? ` and ${stale.length} declaration(s) matching no skipped test` : "";
   return [
     `${NAME}: ${undeclared.length} skipped test(s) undeclared${counted} in ${run}:`,
     ...undeclared.map((result) => {
-      const kind = result.outcome === "todo" ? "a todo" : "skipped";
-      return `  ${result.file}:${result.line} ${result.name}: ${kind} with no declaration; run it, or declare it in ${DECLARATIONS} with its reason`;
+      const [kind, usage] =
+        result.outcome === "todo"
+          ? ["a todo", "test.todo(skipReason(reason, name))"]
+          : ["skipped", "test.skipIf(condition)(skipReason(reason, name), fn)"];
+      return `  ${result.file}:${result.line} ${result.name}: ${kind} with no reason at its test site; use ${usage}`;
     }),
     ...stale.map(staleLine),
   ];
@@ -106,37 +107,31 @@ export function report(verdict: Verdict): string {
   return [...verdictLines(verdict), ...warning].join("\n");
 }
 
-const readDeclarations = Effect.fn("readDeclarations")(function* (root: string) {
-  const manifest = (yield* Path.Path).join(root, "package.json");
-  const { testSkips } = yield* (yield* FileSystem.FileSystem).readFileString(manifest).pipe(
-    Effect.flatMap(decodeManifest),
-    Effect.mapError((cause) => new SkipGateError({ message: `cannot read ${DECLARATIONS}: ${cause.message}` })),
-  );
-  return testSkips ?? [];
-});
-
 const environmentOf = Config.Boolean("CI").pipe(
   Config.withDefault(false),
   Config.map((ci): Environment => (ci ? "ci" : "local")),
   Effect.mapError((cause) => new SkipGateError({ message: `cannot tell a ci run from a local one: ${cause.message}` })),
 );
 
-const runSuite = Effect.fn("runSuite")(function* (outfile: string) {
+const runSuite = Effect.fn("runSuite")(function* (outfile: string, tier: TestTier | undefined) {
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-  const args = ["test", "--randomize", ...reporterArgs(outfile)];
+  const tierArgs = tier === undefined ? [] : ["--path-ignore-patterns", "", `./tests/${tier}`];
+  const args = ["test", "--randomize", ...tierArgs, ...reporterArgs(outfile)];
   return yield* spawner.exitCode(
     ChildProcess.make(process.execPath, args, { stdin: "ignore", stdout: "inherit", stderr: "inherit" }),
   );
 });
 
 const testEntry = Effect.gen(function* () {
-  if (process.argv.length > 2) return yield* new Usage({ message: USAGE });
+  const args = process.argv.slice(2);
+  const tier = args.length === 0 ? undefined : args.length === 1 ? TIERS.get(args[0] ?? "") : undefined;
+  if (args.length > 0 && tier === undefined) return yield* new Usage({ message: USAGE });
   const fs = yield* FileSystem.FileSystem;
-  const declarations = yield* readDeclarations(process.cwd());
+  const declarations = yield* readSkipDeclarations(process.cwd(), tier);
   const environment = yield* environmentOf;
 
   const outfile = (yield* Path.Path).join(yield* fs.makeTempDirectoryScoped({ prefix: "checks-test-" }), "junit.xml");
-  const suitePassed = (yield* runSuite(outfile)) === ChildProcessSpawner.ExitCode(0);
+  const suitePassed = (yield* runSuite(outfile, tier)) === ChildProcessSpawner.ExitCode(0);
   if (!(yield* fs.exists(outfile))) {
     if (!suitePassed) {
       yield* Console.error(`${NAME}: bun test failed before it wrote a report, so no skip was judged`);

package/scripts/vendor.ts

@@ -1,12 +1,10 @@
 #!/usr/bin/env bun
 import { Console, Effect, FileSystem, Option, Path, Schema } from "effect";
-import { QUALITY_FILE } from "./gates.ts";
 import { git } from "./git.ts";
 import { runMain, Usage } from "./main.ts";
-import { readQuality, type Library } from "./quality-file.ts";
 
 const NAME = "checks-vendor";
-const USAGE = `usage: ${NAME} takes no arguments, since quality.json names the libraries`;
+const USAGE = `usage: ${NAME} [--library <name> --package <package> --repository <remote> --tag <template> [--path <manifest>]]...`;
 const CACHE_HOME = ".cache/avi2dg-checks";
 const RECORD_SUFFIX = ".commit";
 const LINKS = "repos";
@@ -23,6 +21,55 @@ export class Unreachable extends Schema.TaggedError<Unreachable>()("Unreachable"
   message: Schema.String,
 }) {}
 
+const Library = Schema.Struct({
+  name: Schema.String.check(Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)),
+  package: Schema.NonEmptyString,
+  repository: Schema.NonEmptyString,
+  tag: Schema.String.check(Schema.isPattern(/\{version\}/)),
+  path: Schema.optionalKey(Schema.String.check(Schema.isPattern(/^(?:[\w.@+-]+\/)*[\w.@+-]+\.\w+$/))),
+});
+type Library = typeof Library.Type;
+
+const Libraries = Schema.Array(Library).check(
+  Schema.makeFilter((libraries) => {
+    const names = libraries.map(({ name }) => name);
+    const repeated = names.find((name, index) => names.indexOf(name) !== index);
+    return repeated === undefined || `--library ${repeated} appears more than once`;
+  }),
+);
+
+const OPENER = "--library";
+const FIELDS = new Map<string, keyof Library>([
+  ["--package", "package"],
+  ["--repository", "repository"],
+  ["--tag", "tag"],
+  ["--path", "path"],
+]);
+
+function misuse(message: string): Usage {
+  return new Usage({ message: `${message}\n${USAGE}` });
+}
+
+const librariesFrom = Effect.fn("librariesFrom")(function* (args: readonly string[]) {
+  const groups: Record<string, string>[] = [];
+  for (let index = 0; index < args.length; index += 2) {
+    const flag = args[index] ?? "";
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith("--")) return yield* misuse(`${flag} takes a value`);
+    if (flag === OPENER) {
+      groups.push({ name: value });
+      continue;
+    }
+    const field = FIELDS.get(flag);
+    const current = groups.at(-1);
+    if (field === undefined) return yield* misuse(`${flag} is not an argument`);
+    if (current === undefined) return yield* misuse(`${flag} comes before any ${OPENER}`);
+    if (field in current) return yield* misuse(`${flag} appears twice for ${OPENER} ${current["name"]}`);
+    current[field] = value;
+  }
+  return yield* Schema.decodeUnknownEffect(Libraries)(groups).pipe(Effect.mapError((cause) => misuse(cause.message)));
+});
+
 export function tagFor(template: string, version: string): string {
   return template.replaceAll(VERSION_TOKEN, version);
 }
@@ -296,8 +343,11 @@ const cacheRoot = Effect.fn("cacheRoot")(function* () {
 });
 
 const main = Effect.gen(function* () {
-  const [extra] = process.argv.slice(2);
-  if (extra !== undefined) return yield* new Usage({ message: USAGE });
+  const libraries = yield* librariesFrom(process.argv.slice(2));
+  if (libraries.length === 0) {
+    yield* Console.error(`${NAME}: no ${OPENER} argument names a library, so nothing is pinned`);
+    return true;
+  }
   const toplevel = yield* git(["rev-parse", "--show-toplevel"]).pipe(
     Effect.map((output) => Option.some(output.trim())),
     Effect.catchTag("GitFailure", (failure) =>
@@ -308,12 +358,6 @@ const main = Effect.gen(function* () {
   );
   if (Option.isNone(toplevel)) return true;
   const root = toplevel.value;
-  const { quality } = yield* readQuality(root);
-  const libraries = quality.sources?.libraries ?? [];
-  if (libraries.length === 0) {
-    yield* Console.error(`${NAME}: ${QUALITY_FILE} declares no libraries, so nothing is pinned`);
-    return true;
-  }
   const cache = yield* cacheRoot();
   let passed = true;
   for (const library of libraries) {

package/dist/feature-rules.js

@@ -1,354 +0,0 @@
-// scripts/feature-rules.ts
-import { Schema as Schema4 } from "effect";
-
-// scripts/quality-file.ts
-import { Console, Effect, FileSystem, JsonSchema, Path, Schema as Schema3 } from "effect";
-
-// scripts/gates.ts
-import { Schema } from "effect";
-var EVERY_REPOSITORY = "every repository";
-var QUALITY_FILE = "quality.json";
-var TYPESCRIPT_SOURCE = { pathspecs: ["*.ts", "*.tsx"], content: "TypeScript source" };
-var QUALITY_DECLARATION = { pathspecs: [QUALITY_FILE], content: `a ${QUALITY_FILE}` };
-var KIT_GATES = [
-  { bin: "checks-lint-coverage", script: "lint-coverage.sh", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
-  { bin: "checks-test-layout", script: "test-layout.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
-  { bin: "checks-commit-identity", script: "commit-identity.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
-  { bin: "checks-comment-gate", script: "comment-gate.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
-  { 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-docs", script: "docs.ts", reads: "range", 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-repetition", script: "repetition.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
-  { bin: "checks-feature-owners", script: "feature-owners.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
-  { bin: "checks-quarantine-clock", script: "quarantine-clock.ts", reads: "range", appliesTo: EVERY_REPOSITORY }
-];
-var UNCONDITIONAL = KIT_GATES.filter((gate) => gate.appliesTo === EVERY_REPOSITORY).map((gate) => gate.bin);
-var LintGates = Schema.Array(Schema.Literals(KIT_GATES.map((gate) => gate.bin))).check(Schema.makeFilter((selected) => {
-  const missing = UNCONDITIONAL.filter((bin) => !selected.includes(bin));
-  if (missing.length === 0)
-    return true;
-  const verb = missing.length === 1 ? "applies" : "apply";
-  return `checks-lint must run ${missing.join(", ")}, which ${verb} to ${EVERY_REPOSITORY}`;
-}, { toJsonSchema: () => ({ allOf: UNCONDITIONAL.map((bin) => ({ contains: { const: bin } })) }) }));
-
-// scripts/size-rules.ts
-import { Schema as Schema2 } from "effect";
-var TESTS_DIRECTORY = "tests";
-var COUNTED = { skipBlankLines: false, skipComments: false };
-var FILE_LINES = {
-  key: "fileLines",
-  rule: "max-lines",
-  options: COUNTED,
-  measured: /has too many lines \((\d+)\)/,
-  limits: "The most lines a file may hold, blank and comment lines counted"
-};
-var FUNCTION_LINES = {
-  key: "functionLines",
-  rule: "max-lines-per-function",
-  options: COUNTED,
-  measured: /has too many lines \((\d+)\)/,
-  limits: "The most lines a function may span, blank and comment lines counted"
-};
-var STATEMENTS = {
-  key: "statements",
-  rule: "max-statements",
-  options: {},
-  measured: /has too many statements \((\d+)\)/,
-  limits: "The most statements a function may hold"
-};
-var COMPLEXITY = {
-  key: "complexity",
-  rule: "cognitive-complexity",
-  plugin: "effect-channel",
-  options: {},
-  measured: /has a cognitive complexity of (\d+)/,
-  limits: "The highest cognitive complexity a function may reach, a switch counted once"
-};
-var DEPTH = {
-  key: "depth",
-  rule: "max-depth",
-  options: {},
-  measured: /nested too deeply \((\d+)\)/,
-  limits: "The deepest a block may nest inside a function"
-};
-var APPLIES = ["ratchet", "all"];
-var SIZE_DEFAULTS = {
-  applies: "ratchet",
-  production: { fileLines: 400, functionLines: 100, statements: 30, complexity: 15, depth: 4 },
-  tests: { fileLines: 600, statements: 50, complexity: 15, depth: 4 }
-};
-var Limit = Schema2.Int.check(Schema2.isGreaterThan(0));
-function limit({ limits }, fallback) {
-  return Schema2.optionalKey(Limit.annotate({ description: `${limits}; ${fallback} when absent` }));
-}
-var ProductionBudget = Schema2.Struct({
-  fileLines: limit(FILE_LINES, SIZE_DEFAULTS.production.fileLines),
-  functionLines: limit(FUNCTION_LINES, SIZE_DEFAULTS.production.functionLines),
-  statements: limit(STATEMENTS, SIZE_DEFAULTS.production.statements),
-  complexity: limit(COMPLEXITY, SIZE_DEFAULTS.production.complexity),
-  depth: limit(DEPTH, SIZE_DEFAULTS.production.depth)
-});
-var TestBudget = Schema2.Struct({
-  fileLines: limit(FILE_LINES, SIZE_DEFAULTS.tests.fileLines),
-  statements: limit(STATEMENTS, SIZE_DEFAULTS.tests.statements),
-  complexity: limit(COMPLEXITY, SIZE_DEFAULTS.tests.complexity),
-  depth: limit(DEPTH, SIZE_DEFAULTS.tests.depth)
-});
-var Size = Schema2.Struct({
-  applies: Schema2.optionalKey(Schema2.Literals(APPLIES).annotate({
-    description: `Which production and test files the budget holds: ratchet, the ones a range adds or changes, to no more overrun per rule than at the range's base; all, every one. ${SIZE_DEFAULTS.applies} when absent. The rest are listed as advisory`,
-    message: "Expected ratchet or all, and ratchet replaces changed"
-  })),
-  production: Schema2.optionalKey(ProductionBudget.annotate({
-    description: `The budget of the files under sources.production, and of the files listed as advisory outside ${TESTS_DIRECTORY}/`
-  })),
-  tests: Schema2.optionalKey(TestBudget.annotate({ description: `The budget of the files under ${TESTS_DIRECTORY}/, which sets no limit on a function's lines` }))
-}).annotate({
-  description: "The size budget oxlint holds production and test files to, read by checks-size-budget",
-  messageUnexpectedKey: "Expected only applies, production and tests, since each limit is set inside production or tests"
-});
-
-// scripts/quality-file.ts
-var SEGMENT = String.raw`(?!\.\.?(?:/|$))(?:\*\*|(?:[\w.@+-]|\*(?!\*))+)`;
-var FILE = String.raw`(?:[\w.@+-]|\*(?!\*))*\.\w+`;
-var PathGlob = Schema3.String.check(Schema3.isPattern(new RegExp(`^${SEGMENT}(?:/${SEGMENT})*/${FILE}$`), {
-  expected: "a glob from the repository root such as src/**/*.ts: a directory first, * within a segment, ** as a whole one, a file name with an extension last"
-})).annotate({
-  identifier: "PathGlob",
-  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 ./"
-});
-var DocGlob = Schema3.String.check(Schema3.isPattern(new RegExp(`^(?:${SEGMENT}/)*${FILE}$`), {
-  expected: "a glob from the repository root such as README.md or docs/**/*.md: * within a segment, ** as a whole one, a file name with an extension last"
-})).annotate({
-  identifier: "DocGlob",
-  description: "A glob from the repository root that checks-docs reads: * within a segment, ** as a whole one, a file name with an extension last"
-});
-var LITERAL_SEGMENT = String.raw`(?!\.\.?(?:/|$))[\w.@+-]+`;
-var DirectoryPath = Schema3.String.check(Schema3.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" });
-var FilePath = Schema3.String.check(Schema3.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" });
-var PROOF_DIRECTORY = "tests/e2e/";
-var ProofPath = Schema3.String.check(Schema3.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" });
-var Command = Schema3.NonEmptyString.annotate({ identifier: "Command" });
-var RuleName = Schema3.String.check(Schema3.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { expected: "a Rule name in kebab case" })).annotate({ identifier: "RuleName" });
-var Identity = Schema3.Struct({ name: Schema3.NonEmptyString, email: Schema3.NonEmptyString }).annotate({
-  identifier: "Identity"
-});
-var CommitIdentity = Schema3.Struct({
-  authors: Schema3.NonEmptyArray(Identity).annotate({
-    description: "The identities allowed to author and commit, in place of the kit's default owner"
-  })
-});
-var Gates = Schema3.Struct({
-  ci: Schema3.optionalKey(Schema3.NonEmptyArray(Command).annotate({
-    description: "The commands CI runs on every pull request to the default branch, each one plain command"
-  })),
-  scheduled: Schema3.optionalKey(Schema3.Array(Command).annotate({ description: "The commands a cron-scheduled workflow runs" })),
-  lint: Schema3.optionalKey(LintGates)
-});
-var RunsOn = Schema3.NonEmptyArray(Schema3.NonEmptyString).annotate({
-  identifier: "RunsOn",
-  description: "The runner labels every job the kit generates runs on; ubuntu-latest when absent"
-});
-var EffectSources = Schema3.Struct({
-  paths: Schema3.NonEmptyArray(PathGlob).annotate({
-    description: "Where source is written in Effect, held to the Effect rules of oxlint and the language service"
-  }),
-  exempt: Schema3.optionalKey(Schema3.Array(PathGlob).annotate({ description: "Files under paths the Effect rules pass over" }))
-});
-var Library = Schema3.Struct({
-  name: Schema3.String.check(Schema3.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { expected: "a library name in kebab case" })).annotate({ description: "The link checks-vendor manages under repos/" }),
-  package: Schema3.NonEmptyString.annotate({ description: "The npm package whose installed version picks the tag" }),
-  repository: Schema3.NonEmptyString.annotate({ description: "The git remote checks-vendor clones the tag from" }),
-  tag: Schema3.String.check(Schema3.isPattern(/\{version\}/, { expected: "a tag template holding {version}" })).annotate({
-    description: "The tag template, with {version} for the installed version"
-  }),
-  path: Schema3.optionalKey(FilePath.annotate({ description: "The manifest inside the clone holding the version; package.json when absent" }))
-}).annotate({ identifier: "Library" });
-var Sources = Schema3.Struct({
-  production: Schema3.optionalKey(Schema3.Array(PathGlob).annotate({ description: "The source the repository ships, as against tests and tooling" })),
-  libraries: Schema3.optionalKey(Schema3.Array(Library).check(Schema3.makeFilter((libraries) => {
-    const repeated = duplicates(libraries.map((library) => library.name));
-    return repeated === undefined || `names ${repeated} more than once`;
-  })).annotate({ description: "The libraries checks-vendor pins to a shared read-only clone" })),
-  effect: Schema3.optionalKey(EffectSources)
-});
-var Feature = Schema3.Struct({
-  name: Schema3.String.check(Schema3.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: Schema3.NonEmptyArray(FilePath).annotate({
-    description: "The files under root that code outside it imports the feature through"
-  }),
-  allowFrom: Schema3.optionalKey(Schema3.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(Schema3.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}`;
-}));
-function nests(outer, inner) {
-  return outer === inner || inner.startsWith(`${outer}/`);
-}
-function duplicates(names) {
-  const repeated = names.filter((name, index) => names.indexOf(name) !== index);
-  return repeated.length === 0 ? undefined : [...new Set(repeated)].join(", ");
-}
-var Features = Schema3.Array(Feature).check(Schema3.makeFilter((features) => {
-  const repeated = duplicates(features.map((feature) => feature.name));
-  if (repeated !== undefined)
-    return `names ${repeated} 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;
-}));
-var AgentRules = Schema3.Struct({
-  on: Schema3.optionalKey(Schema3.Array(RuleName).annotate({ description: "Catalogued Rules switched on here" })),
-  off: Schema3.optionalKey(Schema3.Array(RuleName).annotate({ description: "Catalogued Rules switched off here" }))
-}).check(Schema3.makeFilter(({ on = [], off = [] }) => {
-  const both = on.filter((rule) => off.includes(rule));
-  return both.length === 0 || `switches ${both.join(", ")} both on and off`;
-}));
-var pagesIn = (mode) => Schema3.optionalKey(Schema3.Array(PathGlob).annotate({ description: `The pages written as ${mode}` }));
-var Docs = Schema3.Struct({
-  pages: Schema3.optionalKey(Schema3.Struct({
-    tutorial: pagesIn("a tutorial, which teaches by building one thing"),
-    "how-to": pagesIn("a how-to, which walks one task"),
-    reference: pagesIn("reference, which describes a thing to be looked up"),
-    explanation: pagesIn("an explanation, which says why")
-  }).annotate({
-    description: "The Diátaxis mode of each page, whose template checks-docs holds the page to; a page under docs/ needs one"
-  })),
-  forConsumers: Schema3.optionalKey(Schema3.Array(DocGlob).annotate({
-    description: "The living docs that speak to a repository installing this one, whose bun run commands checks-docs does not hold to this package.json"
-  }))
-});
-var Quality = Schema3.Struct({
-  $schema: Schema3.optionalKey(Schema3.String),
-  defaultBranch: Schema3.optionalKey(Schema3.NonEmptyString.annotate({ description: "The branch pull requests merge into; main when absent" })),
-  gates: Schema3.optionalKey(Gates),
-  runsOn: Schema3.optionalKey(RunsOn),
-  commitIdentity: Schema3.optionalKey(CommitIdentity),
-  sources: Schema3.optionalKey(Sources),
-  size: Schema3.optionalKey(Size),
-  features: Schema3.optionalKey(Features.annotate({
-    description: "The feature owners dependency-cruiser holds to their entries and checks-feature-owners maps a change to"
-  })),
-  changeSignal: Schema3.optionalKey(Schema3.Literal("advisory").annotate({
-    description: "Report which feature owners a change touches, without failing on it"
-  })),
-  agentRules: Schema3.optionalKey(AgentRules),
-  docs: Schema3.optionalKey(Docs.annotate({ description: "What checks-docs reads to map a doc file to its template" }))
-}).annotate({
-  title: QUALITY_FILE,
-  description: "What a repository has opted into from @avi2dg/checks, read by its bins and agent Rule selection"
-}).check(Schema3.makeFilter(({ size, sources }) => size === undefined || (sources?.production ?? []).length > 0 || "declares size, which holds no production file without sources.production", {
-  toJsonSchema: () => ({
-    if: { required: ["size"] },
-    then: { required: ["sources"], properties: { sources: { required: ["production"], properties: { production: { minItems: 1 } } } } }
-  })
-}), Schema3.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 } } }
-  })
-}));
-var LegacyManifest = Schema3.Struct({
-  ciWiring: Schema3.optionalKey(Schema3.Struct({
-    gates: Schema3.optionalKey(Schema3.NonEmptyArray(Command)),
-    scheduled: Schema3.optionalKey(Schema3.Array(Command)),
-    lintGates: Schema3.optionalKey(LintGates),
-    defaultBranch: Schema3.optionalKey(Schema3.NonEmptyString)
-  })),
-  commitIdentity: Schema3.optionalKey(CommitIdentity)
-});
-var LEGACY_KEYS = ["ciWiring", "commitIdentity"];
-
-class QualityUnreadable extends Schema3.TaggedError()("QualityUnreadable", {
-  message: Schema3.String
-}) {
-}
-var MANIFEST = "package.json";
-var decodeQualityJson = Schema3.decodeUnknownEffect(Schema3.fromJsonString(Quality), { onExcessProperty: "error" });
-var decodeManifestJson = Schema3.decodeUnknownEffect(Schema3.fromJsonString(LegacyManifest));
-var decodeQuality = (text, source) => decodeQualityJson(text).pipe(Effect.mapError((cause) => new QualityUnreadable({ message: `${source}: ${cause.message}` })));
-function fromLegacy({ ciWiring, commitIdentity }) {
-  const gates = {
-    ...ciWiring?.gates === undefined ? {} : { ci: ciWiring.gates },
-    ...ciWiring?.scheduled === undefined ? {} : { scheduled: ciWiring.scheduled },
-    ...ciWiring?.lintGates === undefined ? {} : { lint: ciWiring.lintGates }
-  };
-  return {
-    ...ciWiring?.defaultBranch === undefined ? {} : { defaultBranch: ciWiring.defaultBranch },
-    ...Object.keys(gates).length === 0 ? {} : { gates },
-    ...commitIdentity === undefined ? {} : { commitIdentity }
-  };
-}
-var decodeManifest = (text, source) => decodeManifestJson(text).pipe(Effect.map((manifest) => ({
-  keys: LEGACY_KEYS.filter((key) => manifest[key] !== undefined),
-  quality: fromLegacy(manifest)
-})), Effect.mapError((cause) => new QualityUnreadable({ message: `${source}: ${cause.message}` })));
-var UNDECLARED = { keys: [], quality: {} };
-var readQuality = Effect.fn("readQuality")(function* (root) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const read = (file) => fs.readFileString(path.join(root, file)).pipe(Effect.mapError((cause) => new QualityUnreadable({ message: `cannot read ${file}: ${cause.message}` })));
-  const legacy = (yield* fs.exists(path.join(root, MANIFEST))) ? yield* decodeManifest(yield* read(MANIFEST), MANIFEST) : UNDECLARED;
-  const keys = legacy.keys.join(" and ");
-  if (yield* fs.exists(path.join(root, QUALITY_FILE))) {
-    if (legacy.keys.length > 0) {
-      return yield* new QualityUnreadable({
-        message: `${MANIFEST} still sets ${keys}, which ${QUALITY_FILE} replaces; move what it holds there`
-      });
-    }
-    return { source: QUALITY_FILE, quality: yield* decodeQuality(yield* read(QUALITY_FILE), QUALITY_FILE) };
-  }
-  if (legacy.keys.length > 0) {
-    const them = legacy.keys.length === 1 ? "it" : "them";
-    yield* Console.error(`${MANIFEST} sets ${keys}, which a later minor release stops reading; move ${them} into ${QUALITY_FILE}`);
-  }
-  return { source: MANIFEST, quality: legacy.quality };
-});
-
-// scripts/feature-rules.ts
-var TESTS = "^tests/";
-function escaped(literal) {
-  return literal.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-}
-function globPattern(glob) {
-  const segments = glob.split("/");
-  const body = segments.map((segment, index) => {
-    if (segment === "**")
-      return "(?:[^/]+/)*";
-    const pattern = segment.split("*").map(escaped).join("[^/]*");
-    return index === segments.length - 1 ? pattern : `${pattern}/`;
-  });
-  return `^${body.join("")}$`;
-}
-function rulesFor(features) {
-  return features.map(({ name, root, entries, allowFrom = [] }) => ({
-    name: `feature-${name}-entries`,
-    severity: "error",
-    comment: `Outside ${root}/, ${name} is imported through ${entries.join(", ")}. Import one of those, or list the importer in the feature's allowFrom in quality.json.`,
-    from: { pathNot: [`^${escaped(root)}/`, TESTS, ...allowFrom.map(globPattern)] },
-    to: { path: `^${escaped(root)}/`, pathNot: entries.map((entry) => `^${escaped(entry)}$`) }
-  }));
-}
-var decode = Schema4.decodeUnknownSync(Quality);
-function featureRules(quality) {
-  return rulesFor(decode(quality, { onExcessProperty: "error" }).features ?? []);
-}
-export {
-  globPattern,
-  featureRules
-};