@avi2dg/checks 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 Every release of `@avi2dg/checks`, newest first, written by the release from its conventional commits.
 
+## 0.16.0
+
+Released 2026-09-25.
+
+### Features
+
+- **scripts:** add checks-repetition to hold new repetition in production code (#46)
+- **scripts:** add the recommended size limits, a tests budget and an overrun ratchet (#45)
+
 ## 0.15.0
 
 Released 2026-09-25.

package/README.md

@@ -16,6 +16,7 @@ A repository declares what it opts into once, in `quality.json`, and each check
   - `@swc/core` 1.16.2
   - `dependency-cruiser` 18.4.0
   - `effect` 4.0.0-rc.115
+  - `jscpd` 5.3.2
   - `oxlint` 1.83.0
   - `oxlint-tsgolint` 7.0.2002
 
@@ -30,7 +31,7 @@ To consume the kit from a repository:
    <!-- generated install: bun run build writes it from package.json and scripts/doc-blocks.ts -->
 
    ```sh
-   bun add -d @avi2dg/checks @effect/tsgo@0.45.0 @swc/core@1.16.2 dependency-cruiser@18.4.0 effect@4.0.0-rc.115 oxlint@1.83.0 oxlint-tsgolint@7.0.2002 typescript@7.0.2
+   bun add -d @avi2dg/checks @effect/tsgo@0.45.0 @swc/core@1.16.2 dependency-cruiser@18.4.0 effect@4.0.0-rc.115 jscpd@5.3.2 oxlint@1.83.0 oxlint-tsgolint@7.0.2002 typescript@7.0.2
    ```
 
    <!-- end generated install -->
@@ -120,6 +121,7 @@ A repository leaves out a gate that does not apply to it through `gates.lint`, a
 | [`checks-docs`](docs/gates/checks-docs.md) | the range | every repository |
 | [`checks-quality`](docs/gates/checks-quality.md) | the working tree | a repository tracking `quality.json` |
 | [`checks-size-budget`](docs/gates/checks-size-budget.md) | the range | a repository tracking `*.ts` or `*.tsx` |
+| [`checks-repetition`](docs/gates/checks-repetition.md) | the range | a repository tracking `*.ts` or `*.tsx` |
 | [`checks-feature-owners`](docs/gates/checks-feature-owners.md) | the range | a repository tracking `*.ts` or `*.tsx` |
 
 <!-- end generated gates -->

package/dist/feature-rules.js

@@ -1,8 +1,8 @@
 // scripts/feature-rules.ts
-import { Schema as Schema3 } from "effect";
+import { Schema as Schema4 } from "effect";
 
 // scripts/quality-file.ts
-import { Console, Effect, FileSystem, JsonSchema, Path, Schema as Schema2 } from "effect";
+import { Console, Effect, FileSystem, JsonSchema, Path, Schema as Schema3 } from "effect";
 
 // scripts/gates.ts
 import { Schema } from "effect";
@@ -20,6 +20,7 @@ var KIT_GATES = [
   { 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 }
 ];
 var UNCONDITIONAL = KIT_GATES.filter((gate) => gate.appliesTo === EVERY_REPOSITORY).map((gate) => gate.bin);
@@ -31,87 +32,153 @@ var LintGates = Schema.Array(Schema.Literals(KIT_GATES.map((gate) => gate.bin)))
   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: "complexity",
+  options: { variant: "modified" },
+  measured: /has a complexity of (\d+)/,
+  limits: "The highest cyclomatic 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 = Schema2.String.check(Schema2.isPattern(new RegExp(`^${SEGMENT}(?:/${SEGMENT})*/${FILE}$`), {
+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 = Schema2.String.check(Schema2.isPattern(new RegExp(`^(?:${SEGMENT}/)*${FILE}$`), {
+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 = Schema2.String.check(Schema2.isPattern(new RegExp(`^${LITERAL_SEGMENT}(?:/${LITERAL_SEGMENT})*$`), {
+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 = Schema2.String.check(Schema2.isPattern(new RegExp(`^(?:${LITERAL_SEGMENT}/)*[\\w.@+-]*\\.\\w+$`), {
+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 = Schema2.String.check(Schema2.isPattern(new RegExp(`^${PROOF_DIRECTORY}(?:${LITERAL_SEGMENT}/)*[\\w.@+-]+\\.test\\.tsx?$`), {
+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 = Schema2.NonEmptyString.annotate({ identifier: "Command" });
-var RuleName = Schema2.String.check(Schema2.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { expected: "a Rule name in kebab case" })).annotate({ identifier: "RuleName" });
-var Identity = Schema2.Struct({ name: Schema2.NonEmptyString, email: Schema2.NonEmptyString }).annotate({
+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 = Schema2.Struct({
-  authors: Schema2.NonEmptyArray(Identity).annotate({
+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 = Schema2.Struct({
-  ci: Schema2.optionalKey(Schema2.NonEmptyArray(Command).annotate({
+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: Schema2.optionalKey(Schema2.Array(Command).annotate({ description: "The commands a cron-scheduled workflow runs" })),
-  lint: Schema2.optionalKey(LintGates)
+  scheduled: Schema3.optionalKey(Schema3.Array(Command).annotate({ description: "The commands a cron-scheduled workflow runs" })),
+  lint: Schema3.optionalKey(LintGates)
 });
-var EffectSources = Schema2.Struct({
-  paths: Schema2.NonEmptyArray(PathGlob).annotate({
+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: Schema2.optionalKey(Schema2.Array(PathGlob).annotate({ description: "Files under paths the Effect rules pass over" }))
+  exempt: Schema3.optionalKey(Schema3.Array(PathGlob).annotate({ description: "Files under paths the Effect rules pass over" }))
 });
-var Sources = Schema2.Struct({
-  production: Schema2.optionalKey(Schema2.Array(PathGlob).annotate({ description: "The source the repository ships, as against tests and tooling" })),
-  effect: Schema2.optionalKey(EffectSources)
-});
-var LineBudget = Schema2.Int.check(Schema2.isGreaterThan(0));
-var Size = Schema2.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: Schema2.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"
-  })
+var Sources = Schema3.Struct({
+  production: Schema3.optionalKey(Schema3.Array(PathGlob).annotate({ description: "The source the repository ships, as against tests and tooling" })),
+  effect: Schema3.optionalKey(EffectSources)
 });
-var Feature = Schema2.Struct({
-  name: Schema2.String.check(Schema2.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" }),
+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: Schema2.NonEmptyArray(FilePath).annotate({
+  entries: Schema3.NonEmptyArray(FilePath).annotate({
     description: "The files under root that code outside it imports the feature through"
   }),
-  allowFrom: Schema2.optionalKey(Schema2.Array(PathGlob).annotate({
+  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(Schema2.makeFilter(({ root, 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}/`);
 }
-var Features = Schema2.Array(Feature).check(Schema2.makeFilter((features) => {
+var Features = Schema3.Array(Feature).check(Schema3.makeFilter((features) => {
   const names = features.map((feature) => feature.name);
   const repeated = names.filter((name, index) => names.indexOf(name) !== index);
   if (repeated.length > 0)
@@ -123,16 +190,16 @@ var Features = Schema2.Array(Feature).check(Schema2.makeFilter((features) => {
   }
   return true;
 }));
-var AgentRules = Schema2.Struct({
-  on: Schema2.optionalKey(Schema2.Array(RuleName).annotate({ description: "Catalogued Rules switched on here" })),
-  off: Schema2.optionalKey(Schema2.Array(RuleName).annotate({ description: "Catalogued Rules switched off here" }))
-}).check(Schema2.makeFilter(({ on = [], off = [] }) => {
+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) => Schema2.optionalKey(Schema2.Array(PathGlob).annotate({ description: `The pages written as ${mode}` }));
-var Docs = Schema2.Struct({
-  pages: Schema2.optionalKey(Schema2.Struct({
+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"),
@@ -140,57 +207,57 @@ var Docs = Schema2.Struct({
   }).annotate({
     description: "The Diátaxis mode of each page, whose template checks-docs holds the page to; a page under docs/ needs one"
   })),
-  forConsumers: Schema2.optionalKey(Schema2.Array(DocGlob).annotate({
+  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 = Schema2.Struct({
-  $schema: Schema2.optionalKey(Schema2.String),
-  defaultBranch: Schema2.optionalKey(Schema2.NonEmptyString.annotate({ description: "The branch pull requests merge into; main when absent" })),
-  gates: Schema2.optionalKey(Gates),
-  commitIdentity: Schema2.optionalKey(CommitIdentity),
-  sources: Schema2.optionalKey(Sources),
-  size: Schema2.optionalKey(Size.annotate({ description: "The line budget oxlint holds production files to, read by checks-size-budget" })),
-  features: Schema2.optionalKey(Features.annotate({
+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),
+  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: Schema2.optionalKey(Schema2.Literal("advisory").annotate({
+  changeSignal: Schema3.optionalKey(Schema3.Literal("advisory").annotate({
     description: "Report which feature owners a change touches, without failing on it"
   })),
-  agentRules: Schema2.optionalKey(AgentRules),
-  docs: Schema2.optionalKey(Docs.annotate({ description: "What checks-docs reads to map a doc file to its template" }))
+  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(Schema2.makeFilter(({ size, sources }) => size === undefined || (sources?.production ?? []).length > 0 || "declares size, which holds nothing without sources.production", {
+}).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 } } } } }
   })
-}), Schema2.makeFilter(({ changeSignal, features = [] }) => changeSignal === undefined || features.length > 0 || "declares changeSignal, which maps a change to no owner without features", {
+}), 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 = Schema2.Struct({
-  ciWiring: Schema2.optionalKey(Schema2.Struct({
-    gates: Schema2.optionalKey(Schema2.NonEmptyArray(Command)),
-    scheduled: Schema2.optionalKey(Schema2.Array(Command)),
-    lintGates: Schema2.optionalKey(LintGates),
-    defaultBranch: Schema2.optionalKey(Schema2.NonEmptyString)
+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: Schema2.optionalKey(CommitIdentity)
+  commitIdentity: Schema3.optionalKey(CommitIdentity)
 });
 var LEGACY_KEYS = ["ciWiring", "commitIdentity"];
 
-class QualityUnreadable extends Schema2.TaggedError()("QualityUnreadable", {
-  message: Schema2.String
+class QualityUnreadable extends Schema3.TaggedError()("QualityUnreadable", {
+  message: Schema3.String
 }) {
 }
 var MANIFEST = "package.json";
-var decodeQualityJson = Schema2.decodeUnknownEffect(Schema2.fromJsonString(Quality), { onExcessProperty: "error" });
-var decodeManifestJson = Schema2.decodeUnknownEffect(Schema2.fromJsonString(LegacyManifest));
+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 = {
@@ -254,7 +321,7 @@ function rulesFor(features) {
     to: { path: `^${escaped(root)}/`, pathNot: entries.map((entry) => `^${escaped(entry)}$`) }
   }));
 }
-var decode = Schema3.decodeUnknownSync(Quality);
+var decode = Schema4.decodeUnknownSync(Quality);
 function featureRules(quality) {
   return rulesFor(decode(quality, { onExcessProperty: "error" }).features ?? []);
 }

package/docs/configs/quality-file.md

@@ -19,7 +19,7 @@ The kit's bins find the file at the git root and read it there:
     "production": ["src/**/*.ts"],
     "effect": { "paths": ["src/**/*.ts"], "exempt": ["src/host/*.ts"] }
   },
-  "size": { "fileLines": 400, "functionLines": 100, "applies": "changed" },
+  "size": { "applies": "ratchet", "tests": { "fileLines": 800 } },
   "features": [
     {
       "name": "billing",
@@ -44,9 +44,9 @@ The kit's bins find the file at the git root and read it there:
 | `gates.scheduled` | `checks-ci-wiring` | the commands a schedule runs |
 | `gates.lint` | `checks-lint`, `checks-ci-wiring` | the gates `checks-lint` runs when not all apply, as [Gate selection](../gates/checks-lint.md#gate-selection) says |
 | `commitIdentity.authors` | `checks-commit-identity` | the identities allowed to author and commit, as [checks-commit-identity](../gates/checks-commit-identity.md) says |
-| `sources.production` | `checks-size-budget`, `checks-quality` | the source the repository ships, as [checks-size-budget](../gates/checks-size-budget.md) says |
+| `sources.production` | `checks-size-budget`, `checks-repetition`, `checks-quality` | the source the repository ships, as [checks-size-budget](../gates/checks-size-budget.md) and [checks-repetition](../gates/checks-repetition.md) say |
 | `sources.effect` | `checks-quality` | the paths held to the Effect rules, and the files under them that are not, as [The Effect rules](effect-rules.md) says |
-| `size` | `checks-size-budget` | the line budget, and which production files it holds |
+| `size` | `checks-size-budget` | the size budget of production and test files, and how a change is held to it, as [checks-size-budget](../gates/checks-size-budget.md) says |
 | `features` | `featureRules`, `checks-feature-owners` | each feature's root, entries, exempt importers and proof, as [checks-feature-owners](../gates/checks-feature-owners.md) says |
 | `changeSignal` | `checks-feature-owners` | `advisory` to list the feature owners a change touches |
 | `agentRules.on` | agent Rule selection, not the kit | catalogued Rules switched on for this repository |

package/docs/design.md

@@ -14,6 +14,13 @@ Each entry below is a choice in the kit's shape and the constraint that forced i
 - `featureRules` ships compiled as `dist/feature-rules.js` for the same reason, with `effect` left out of the bundle so it resolves the consumer's own copy.
   dependency-cruiser uses a config's export as it is and never awaits it, so the declaration decodes synchronously, and `quality.json` exempts that one file from the Effect rules.
 - `checks-size-budget` writes the head commit's files to a temporary directory and runs oxlint there, with a configuration that sets no plugin and turns every category off, so the consumer's own `.oxlintrc.json`, its ignore files and its other rules never reach the count.
+- `checks-size-budget` ratchets against the base of the range rather than a committed baseline such as `oxlint-suppressions.json`.
+  A suppression file stores a count of sites per file and rule, and `max-lines` reports a file once however long it grows, so the count stays at one while the file doubles.
+  The gate sums how far each site runs over its limit instead, which grows with the file.
+  The base commit already holds that sum, so nothing is generated, committed or pruned.
+- `checks-repetition` writes the production files of both ends of the range to temporary directories and runs jscpd in each, so the consumer's `.jscpd.json` and ignore files never reach the count.
+  It compares each file's count of repeated lines rather than using jscpd's `--baseline-from-ref`.
+  That flag reports a repeated block as new once its text changes, so a change that shortens a grandfathered block would fail.
 - `dist/` is committed.
   No `prepack` or `prepublishOnly` builds it, so a publish ships whatever bundle the publishing worktree holds.
   Rebuild it after pulling with `bun run build`.

package/docs/gates/checks-lint.md

@@ -64,7 +64,7 @@ It prints the range, the declared selection if there is one, each gate's own rep
 ```
 checks-lint: range 2504acf098d120e73a8ece3c96f22b934f35c6a8..10ba7d8935b73ed72624120a1542e51bd21ca7c7 from HEAD against origin/main
 ...
-checks-lint: 3 of 10 gate(s) failed: checks-commit-identity, checks-comment-gate, checks-suppressions-ratchet
+checks-lint: 3 of 11 gate(s) failed: checks-commit-identity, checks-comment-gate, checks-suppressions-ratchet
 ```
 
 ## Opting out
@@ -74,7 +74,7 @@ A repository that runs its gates without `checks-lint` calls each gate's bin in
 
 ## Gate selection
 
-A repository with no TypeScript source gives `checks-lint-coverage`, `checks-test-layout`, `checks-size-budget` and `checks-feature-owners` nothing to check, and test-layout would still refuse its missing `bun test` script and `bunfig.toml`.
+A repository with no TypeScript source gives `checks-lint-coverage`, `checks-test-layout`, `checks-size-budget`, `checks-repetition` and `checks-feature-owners` nothing to check, and test-layout would still refuse its missing `bun test` script and `bunfig.toml`.
 It declares the gates `checks-lint` runs as `gates.lint`:
 
 ```json
@@ -100,10 +100,11 @@ Both `checks-lint` and `checks-ci-wiring` exit 2 on a `gates.lint` that names an
 `checks-ci-wiring` exits 1 when the selection leaves out a gate the repository's tracked files make applicable, and names the gate and the files:
 
 ```
-ci-wiring: quality.json gates.lint leaves out 4 gate(s) this repository's contents make applicable:
+ci-wiring: quality.json gates.lint leaves out 5 gate(s) this repository's contents make applicable:
   checks-lint-coverage: the repository tracks TypeScript source (src/widget.ts)
   checks-test-layout: the repository tracks TypeScript source (src/widget.ts)
   checks-size-budget: the repository tracks TypeScript source (src/widget.ts)
+  checks-repetition: the repository tracks TypeScript source (src/widget.ts)
   checks-feature-owners: the repository tracks TypeScript source (src/widget.ts)
 ```
 

package/docs/gates/checks-quality.md

@@ -34,7 +34,7 @@ A rule only this repository needs stays in its own `.oxlintrc.json`, whose overr
 - A fragment is missing, or differs from what `generate` would write from `quality.json` and the installed kit's presets.
 - A fragment is left over once `quality.json` stops declaring `sources.effect`.
 - `.oxlintrc.json` or `tsconfig.json` does not list its fragment in `extends`, so the tool never reads it.
-- A `sources.effect.paths` glob, or a `sources.production` glob while `size` is declared, matches no tracked or untracked file, so it holds nothing.
+- A `sources.effect.paths` or `sources.production` glob matches no tracked or untracked file, so it holds nothing.
 
 Two details of the fragments are easy to get wrong, so the kit's tests pin both:
 

package/docs/gates/checks-repetition.md

@@ -0,0 +1,72 @@
+# checks-repetition
+
+`checks-repetition` is the gate that fails a change adding repeated lines to production code, and a reader looks it up when a production file repeats more lines than it did where the range starts.
+
+## What it checks
+
+It runs jscpd over the files `quality.json` declares as production:
+
+```json
+"sources": { "production": ["src/**/*.ts"] }
+```
+
+jscpd finds each block of at least 50 tokens and 5 lines that appears twice, within one file or across two.
+A repeated line is a line of a file inside such a block.
+The gate counts the repeated lines of each production file at the head and where the range starts, and fails when a file counts more at the head.
+A renamed file is compared with its count under the old path.
+A block counts only when both copies are in production files, so a test that copies production code changes no count.
+Each file whose count rose is listed with the blocks it repeats and where the other copy is.
+
+Every other file that repeats lines is listed as advisory and never fails the gate.
+The advisory list names the production files whose count did not rise, and every other tracked `.ts` or `.tsx` file that repeats a block within itself or from another such file.
+`.d.ts` files are not measured.
+Nothing is committed as a baseline, because each run measures where the range starts as well as the head.
+
+## What it reads
+
+It reads each file from the commits at the two ends of the range rather than the working tree, so an uncommitted edit neither fails nor passes a range, and a pull request's merge checkout measures what the pull request holds.
+It reads `sources.production` from `quality.json`.
+jscpd must be on `PATH`, as it is under a package script.
+
+## Arguments
+
+```sh
+checks-repetition <base-ref> <head-ref>
+checks-repetition <ref>
+```
+
+With two arguments the range starts where the head branched from the base, at their merge-base.
+With one it is that commit against its parent, or against the empty tree for a repository's first commit.
+
+## Exit codes
+
+| Code | When |
+| --- | --- |
+| 0 | no production file repeats more lines than where the range starts |
+| 1 | a production file repeats more lines than where the range starts |
+| 2 | `quality.json` does not decode, a ref does not resolve, or jscpd cannot run |
+
+## Sample output
+
+```
+repetition: 1 production file(s) repeat more lines than where the range starts, at 50 tokens and 5 lines:
+  src/billing/refund.ts: 11 repeated line(s), up from 0
+    src/billing/refund.ts:1-11 repeats src/billing/legacy.ts:1-11
+repetition: advisory, 4 file(s) repeat lines the hold does not fail:
+  src/billing/ledger.ts: 11 repeated line(s)
+  src/billing/legacy.ts: 21 repeated line(s)
+  tests/one.test.ts: 11 repeated line(s)
+  tests/two.test.ts: 11 repeated line(s)
+```
+
+## Opting out
+
+A repository that declares no `sources.production` passes.
+`checks-quality` refuses a `sources.production` glob that matches no file.
+A repository that tracks no `.ts` or `.tsx` file leaves it out of `gates.lint`, as [Gate selection](checks-lint.md#gate-selection) says.
+
+## Related topics
+
+- [The quality file](../configs/quality-file.md)
+- [checks-size-budget](checks-size-budget.md)
+- [checks-lint](checks-lint.md)

package/docs/gates/checks-size-budget.md

@@ -1,26 +1,66 @@
 # checks-size-budget
 
-`checks-size-budget` is the gate that holds production files to the line budget `quality.json` declares, and a reader looks it up when a file or a function runs over it.
+`checks-size-budget` is the gate that holds production and test files to the size budget `quality.json` declares, and a reader looks it up when a file or a function runs over it.
 
 ## What it checks
 
-It holds production files to the line budget `quality.json` declares, and lists every other file over it without failing:
+It holds production and test files to the size budget, and lists every other file over it without failing:
 
 ```json
 "sources": { "production": ["src/**/*.ts"] },
-"size": { "fileLines": 400, "functionLines": 100, "applies": "changed" }
+"size": { "applies": "ratchet" }
 ```
 
-It runs oxlint with a configuration of two rules and nothing else, `max-lines` at `fileLines` and `max-lines-per-function` at `functionLines`, both counting blank and comment lines.
-With `applies` set to `changed` it holds the files under `sources.production` that the range adds or changes, a rename that edits the file included.
-With `all` it holds every file under `sources.production`.
+A production file is one under `sources.production`, and a test file is a tracked `.ts` or `.tsx` file under `tests/`.
+A test file keeps to the tests budget, and every other file keeps to the production budget.
+It runs oxlint with a configuration of five rules and nothing else, one for each limit.
+The kit sets each limit:
+
+<!-- generated size-limits: bun run build writes it from SIZE_RULES and SIZE_DEFAULTS in scripts/size-rules.ts and scripts/doc-blocks.ts -->
+
+| Key | Limits | oxlint rule | Production | Tests |
+| --- | --- | --- | --- | --- |
+| `fileLines` | The most lines a file may hold, blank and comment lines counted | `max-lines` | 400 | 600 |
+| `functionLines` | The most lines a function may span, blank and comment lines counted | `max-lines-per-function` | 100 | none |
+| `statements` | The most statements a function may hold | `max-statements` | 30 | 50 |
+| `complexity` | The highest cyclomatic complexity a function may reach, a switch counted once | `complexity` | 15 | 15 |
+| `depth` | The deepest a block may nest inside a function | `max-depth` | 4 | 4 |
+
+<!-- end generated size-limits -->
+
+`size.production` and `size.tests` state only a limit that differs from the kit's:
+
+```json
+"size": {
+  "applies": "ratchet",
+  "production": { "complexity": 12 },
+  "tests": { "fileLines": 800 }
+}
+```
+
+`applies` decides which files the gate holds and what fails them:
+
+- `ratchet` holds each production and test file the range adds or changes, a rename that edits the file included.
+  For each file and each rule, it sums how far every site runs over its limit, and fails when that sum is higher at the head than at the base of the range.
+  A file the range adds starts from zero, so it has to keep within the budget.
+  A file already over the budget passes while its overrun does not grow, and an edit that shrinks the overrun passes.
+  An edited rename is compared with the file it was renamed from.
+  Nothing is committed as a baseline, because the base of the range holds it.
+- `all` holds every production and test file, and fails on any overrun in them.
+
+`applies` is `ratchet` when `size` leaves it out.
 A file the range deletes or only renames is not held.
-Every other tracked `.ts` or `.tsx` file over the budget, tests and unchanged production files alike, is listed as advisory and never fails the gate.
+Every other tracked `.ts` or `.tsx` file over the budget, tooling and unchanged files alike, is listed as advisory and never fails the gate.
+Under `ratchet` the advisory list also names each site in a held file whose overrun did not grow.
 `.d.ts` files are not measured.
 
+`quality.json` refuses `applies: "changed"`, which `ratchet` replaces.
+It refuses a limit set directly under `size`, since each limit goes in `size.production` or `size.tests`.
+
 ## What it reads
 
 It reads each file from the head commit rather than the working tree, so an uncommitted edit neither fails nor passes a range, and a pull request's merge checkout measures what the pull request holds.
+Under `ratchet` it also reads each held file from the base of the range, under the path the file has at the head, so a file keeps the same budget at both ends.
 It reads `sources.production` and `size` from `quality.json`.
 oxlint must be on `PATH`, as it is under a package script.
 
@@ -38,25 +78,28 @@ With one it is that commit against its parent, or against the empty tree for a r
 
 | Code | When |
 | --- | --- |
-| 0 | every file it holds keeps within the budget |
-| 1 | a file it holds runs over the budget |
+| 0 | every file it holds keeps within the budget, or under `ratchet` no file's overrun grows |
+| 1 | a file it holds runs over the budget, or under `ratchet` a file's overrun grows |
 | 2 | `quality.json` does not decode, a ref does not resolve, or oxlint cannot run |
 
 ## Sample output
 
 ```
-size-budget: 1 overrun(s) of 400 lines per file and 100 per function in the production files the range adds or changes:
-  src/billing/ledger.ts:12: The function `settle` has too many lines (131). Maximum allowed is 100.
+size-budget: 2 overrun(s) grew past the base in the production and test files the range adds or changes:
+  src/billing/invoice.ts: max-lines over by 31 in total, up from 19
+    src/billing/invoice.ts: File has too many lines (431). Maximum allowed is 400.
+  src/billing/ledger.ts: complexity over by 3 in total, up from 0
+    src/billing/ledger.ts:12: function `settle` has a complexity of 18. Maximum allowed is 15.
 size-budget: advisory, 1 overrun(s) where the budget does not hold yet:
-  tests/e2e/billing.test.ts: File has too many lines (512).
+  tests/e2e/billing.test.ts: File has too many lines (612). Maximum allowed is 600.
 ```
 
 ## Opting out
 
 A repository that declares no `size` passes.
-`quality.json` refuses a `size` without `sources.production`, which would hold nothing, and with `size` declared `checks-quality` refuses a `sources.production` glob that matches no file.
+`quality.json` refuses a `size` without `sources.production`, and `checks-quality` refuses a `sources.production` glob that matches no file.
 A repository that tracks no `.ts` or `.tsx` file leaves it out of `gates.lint`, as [Gate selection](checks-lint.md#gate-selection) says.
-Moving `applies` from `changed` to `all` tightens the budget to every production file, once the advisory list names none.
+Moving `applies` from `ratchet` to `all` tightens the budget to every production and test file, once the advisory list names none.
 
 ## Related topics