codictator 0.0.0-stage → 0.1.2

package/dist/features/records/bug-grammar.js

@@ -0,0 +1,128 @@
+// SPEC §7.7: the bug registry grammar — title line, blank line, the exact
+// header row and one row per defect in id order. Pure over caller-supplied
+// text: base revisions arrive from the Git port at the enforcer layer,
+// never from here.
+import { normalizeText } from "../../kernel/index.js";
+const BUG_HEADER = "| Id | Status | Title | Found | Fix | Regression test |";
+const BUG_SEPARATOR = "|---|---|---|---|---|---|";
+const BUG_ID = /^BUG-(\d{4})$/;
+const FOUND_CELL = /^(\d{4}-\d{2}-\d{2}), (T-\d{4}|none)$/;
+const FIX_CELL = /^(T-\d{4}|none), (.+)$/;
+function splitRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|") || !trimmed.endsWith("|")) {
+        return undefined;
+    }
+    const cells = [];
+    let current = "";
+    let escaped = false;
+    for (const char of trimmed.slice(1, -1)) {
+        if (escaped) {
+            current += char === "|" ? "|" : `\\${char}`;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === "|") {
+            cells.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    cells.push(current.trim());
+    return cells;
+}
+function toStatus(value) {
+    if (value === "open" || value === "fixed" || value === "wontfix") {
+        return value;
+    }
+    return undefined;
+}
+// SPEC §7.7: the Bugs file holds its title line, a blank line, exactly the
+// header row and one row per defect in id order.
+export function parseBugFile(text) {
+    const errors = [];
+    const lines = normalizeText(text).split("\n");
+    const title = /^# Bugs — (\d{4})\s*$/.exec(lines[0]?.trim() ?? "");
+    if (title === null) {
+        return {
+            file: undefined,
+            errors: ["bug file misses its `# Bugs — <YYYY>` title line"],
+        };
+    }
+    if ((lines[1] ?? "x").trim() !== "") {
+        errors.push("bug file misses the blank line after its title");
+    }
+    if ((lines[2] ?? "").trim() !== BUG_HEADER) {
+        errors.push("bug file misses exactly the specified header row");
+    }
+    if ((lines[3] ?? "").trim() !== BUG_SEPARATOR) {
+        errors.push("bug file misses exactly the specified separator row");
+    }
+    const rows = [];
+    for (const line of lines.slice(4)) {
+        if (line.trim() === "") {
+            continue;
+        }
+        const cells = splitRow(line);
+        if (cells === undefined || cells.length !== 6) {
+            errors.push(`bug row outside the six-column grammar: "${line.trim()}"`);
+            continue;
+        }
+        const status = toStatus(cells[1] ?? "");
+        if (BUG_ID.exec(cells[0] ?? "") === null) {
+            errors.push(`bug id outside BUG-####: "${cells[0] ?? ""}"`);
+            continue;
+        }
+        if (status === undefined) {
+            errors.push(`bug status outside open/fixed/wontfix: "${cells[1] ?? ""}"`);
+            continue;
+        }
+        if (!FOUND_CELL.test(cells[3] ?? "")) {
+            errors.push(`bug Found cell outside "<YYYY-MM-DD>, <T-#### or none>": "${cells[3] ?? ""}"`);
+            continue;
+        }
+        if (status === "open") {
+            if ((cells[4] ?? "") !== "" || (cells[5] ?? "") !== "") {
+                errors.push(`open bug row ${cells[0] ?? ""} fills Fix or Regression test`);
+                continue;
+            }
+        }
+        else if (status === "fixed") {
+            const fix = FIX_CELL.exec(cells[4] ?? "");
+            if (fix === null || (fix[2] ?? "").trim() === "") {
+                errors.push(`fixed bug row ${cells[0] ?? ""} misses its "<T-#### or none>, <subject>" Fix`);
+                continue;
+            }
+            if ((cells[5] ?? "").trim() === "") {
+                errors.push(`fixed bug row ${cells[0] ?? ""} misses its regression test path`);
+                continue;
+            }
+        }
+        else if ((cells[4] ?? "").trim().length < 20) {
+            errors.push(`wontfix bug row ${cells[0] ?? ""} needs a reason of at least 20 characters`);
+            continue;
+        }
+        rows.push({
+            id: cells[0] ?? "",
+            status,
+            title: cells[2] ?? "",
+            found: cells[3] ?? "",
+            fix: cells[4] ?? "",
+            regressionTest: cells[5] ?? "",
+        });
+    }
+    const ids = rows.map((row) => row.id);
+    const sorted = [...ids].sort();
+    if (ids.join("\n") !== sorted.join("\n")) {
+        errors.push("bug rows outside id order");
+    }
+    return {
+        file: { year: title[1] ?? "", rows },
+        errors,
+    };
+}

package/dist/features/records/bug-registry.d.ts

@@ -0,0 +1,9 @@
+import type { Finding } from "../engine/index.ts";
+import type { BugRow } from "./bug-grammar.ts";
+export interface TaskRef {
+    readonly type: string;
+    readonly bug: string | undefined;
+    readonly diagnosis: string | undefined;
+}
+export declare function checkBugRegistry(task: TaskRef, rows: ReadonlyArray<BugRow>, regressionExists: (path: string) => boolean, path: string): Array<Finding>;
+export declare function checkDiagnoseBeforeFix(task: TaskRef, path: string): Array<Finding>;

package/dist/features/records/bug-registry.js

@@ -0,0 +1,67 @@
+// SPEC §4.9.4 core/bug-registry: a fix names an existing row, and after the
+// commit that row is fixed with a regression test whose path exists.
+export function checkBugRegistry(task, rows, regressionExists, path) {
+    if (task.type !== "fix") {
+        return [];
+    }
+    if (task.bug === undefined || task.bug === "") {
+        return [
+            {
+                ruleId: "core/bug-registry",
+                path,
+                message: "fix task names no bug row",
+                remediation: `Name the registry row in the history entry Bug field, e.g. Bug: BUG-0001, and fix that row in ${path}.`,
+            },
+        ];
+    }
+    const row = rows.find((entry) => entry.id === task.bug);
+    if (row === undefined) {
+        return [
+            {
+                ruleId: "core/bug-registry",
+                path,
+                message: `fix task names unknown bug row ${task.bug}`,
+                remediation: `Add the ${task.bug} row to ${path} first, or name the existing row the fix covers.`,
+            },
+        ];
+    }
+    if (row.status !== "fixed") {
+        return [
+            {
+                ruleId: "core/bug-registry",
+                path,
+                message: `fix task row ${task.bug} is ${row.status}, want fixed`,
+                remediation: `Move ${task.bug} to fixed in ${path} with its Fix cell and regression test.`,
+            },
+        ];
+    }
+    if (row.regressionTest === "" || !regressionExists(row.regressionTest)) {
+        return [
+            {
+                ruleId: "core/bug-registry",
+                path,
+                message: `fix task row ${task.bug} names a missing regression test`,
+                remediation: `Add the regression test for ${task.bug} and name its repo path in ${path}.`,
+            },
+        ];
+    }
+    return [];
+}
+// SPEC §4.9.4 core/diagnose-before-fix: a fix task carries diagnosis,
+// reproduction and root cause, in its record.
+export function checkDiagnoseBeforeFix(task, path) {
+    if (task.type !== "fix") {
+        return [];
+    }
+    if (task.diagnosis !== undefined && task.diagnosis.trim() !== "") {
+        return [];
+    }
+    return [
+        {
+            ruleId: "core/diagnose-before-fix",
+            path,
+            message: "fix task enters implementation without diagnosis",
+            remediation: "Record the reproduction and root cause in the task diagnosis before implementing.",
+        },
+    ];
+}

package/dist/features/records/bug-rows-immutable.d.ts

@@ -0,0 +1,3 @@
+import type { Finding } from "../engine/index.ts";
+import type { BugRow } from "./bug-grammar.ts";
+export declare function checkBugRowsImmutable(base: ReadonlyArray<BugRow>, head: ReadonlyArray<BugRow>, path: string): Array<Finding>;

package/dist/features/records/bug-rows-immutable.js

@@ -0,0 +1,52 @@
+export function checkBugRowsImmutable(base, head, path) {
+    const findings = [];
+    const before = new Map(base.map((row) => [row.id, row]));
+    for (const row of head) {
+        const prior = before.get(row.id);
+        before.delete(row.id);
+        if (prior === undefined) {
+            if (row.status !== "open") {
+                findings.push(immutableFinding(path, `bug row ${row.id} added as ${row.status}, want open`));
+            }
+            continue;
+        }
+        if (row.id !== prior.id ||
+            row.title !== prior.title ||
+            row.found !== prior.found) {
+            findings.push(immutableFinding(path, `bug row ${row.id} changes its immutable cells`));
+        }
+        if (row.status === prior.status) {
+            if (row.fix !== prior.fix ||
+                row.regressionTest !== prior.regressionTest) {
+                findings.push(immutableFinding(path, `bug row ${row.id} changes without a status transition`));
+            }
+            continue;
+        }
+        if (prior.status !== "open") {
+            findings.push(immutableFinding(path, `bug row ${row.id} moves from ${prior.status}, only open rows transition`));
+            continue;
+        }
+        if (row.status !== "fixed" && row.status !== "wontfix") {
+            findings.push(immutableFinding(path, `bug row ${row.id} moves to ${row.status}, want fixed or wontfix`));
+            continue;
+        }
+        if (row.fix.trim() === "") {
+            findings.push(immutableFinding(path, `bug row ${row.id} transitions without its Fix cell`));
+        }
+        if (row.status === "fixed" && row.regressionTest.trim() === "") {
+            findings.push(immutableFinding(path, `bug row ${row.id} fixes without its regression test`));
+        }
+    }
+    for (const missing of before.keys()) {
+        findings.push(immutableFinding(path, `bug row ${missing} disappears; a recurring defect gets a new row`));
+    }
+    return findings;
+}
+function immutableFinding(path, message) {
+    return {
+        ruleId: "core/bug-rows-immutable",
+        path,
+        message,
+        remediation: `Revert the ${path} edit: rows move once from open to fixed or wontfix, filling Fix and the regression test, and never disappear.`,
+    };
+}

package/dist/features/records/bugs.d.ts

@@ -0,0 +1,2 @@
+import type { CheckContext, Finding } from "../engine/index.ts";
+export declare function checkBugs(ctx: CheckContext, text: string, baseText?: string): Promise<Array<Finding>>;

package/dist/features/records/bugs.js

@@ -0,0 +1,24 @@
+import { parseBugFile } from "./bug-grammar.js";
+import { checkBugRowsImmutable } from "./bug-rows-immutable.js";
+function bugFileOf(files) {
+    return [...files].filter((file) => file.startsWith("docs/BUGS/")).sort()[0];
+}
+// The evaluation-path entry: grammar over the head text, rows-immutable
+// when the base text is supplied.
+export function checkBugs(ctx, text, baseText) {
+    const path = bugFileOf(ctx.scope.files) ?? "docs/BUGS/";
+    const parsed = parseBugFile(text);
+    const findings = parsed.errors.map((message) => ({
+        ruleId: "core/bug-registry",
+        path,
+        message: `bug file grammar: ${message}`,
+        remediation: `Write ${path} per the SPEC §7.7 bug grammar: title line, blank line, the exact header, one row per defect in id order.`,
+    }));
+    if (baseText !== undefined && parsed.file !== undefined) {
+        const base = parseBugFile(baseText);
+        if (base.file !== undefined) {
+            findings.push(...checkBugRowsImmutable(base.file.rows, parsed.file.rows, path));
+        }
+    }
+    return Promise.resolve(findings);
+}

package/dist/features/records/docs-lines.d.ts

@@ -0,0 +1,16 @@
+export interface DocFile {
+    readonly path: string;
+    readonly text: string;
+}
+export interface DocLimits {
+    readonly maxBytes: number;
+    readonly maxLines: number;
+    readonly maxH2: number;
+    readonly maxFilesPerFolder: number;
+    readonly maxSentenceWords: number;
+    readonly maxParagraphSentences: number;
+}
+export declare function isTableRow(line: string): boolean;
+export declare function isHeading(line: string): boolean;
+export declare function isLinkOnlyLine(line: string): boolean;
+export declare function stripFences(text: string): string;

package/dist/features/records/docs-lines.js

@@ -0,0 +1,36 @@
+// SPEC §4.9.2: shared doc line vocabulary — the file/limit types plus
+// the fence and line classifiers every doc check imports. Types and
+// pure functions only; no runtime consts. Never touches the filesystem
+// (SPEC §3.3, §10.3 item 3).
+import { normalizeText } from "../../kernel/index.js";
+export function isTableRow(line) {
+    return line.trimStart().startsWith("|");
+}
+export function isHeading(line) {
+    return /^#{1,6}\s/.test(line.trimStart());
+}
+export function isLinkOnlyLine(line) {
+    const stripped = line.trim();
+    if (stripped === "") {
+        return false;
+    }
+    const withoutLinks = stripped.replace(/!?\[.*?\]\(.*?\)/g, "").trim();
+    // \x60 keeps the literal backtick out of the class: the pack lexer
+    // has no regex awareness, so a backtick would hide later code.
+    return withoutLinks.replace(/[*_~\x60|>\s-]/g, "") === "";
+}
+export function stripFences(text) {
+    return normalizeText(text)
+        .split("\n")
+        .filter((_, index, all) => {
+        let fenced = false;
+        for (let scan = 0; scan < index; scan += 1) {
+            if (all[scan]?.trimStart().startsWith("```") === true) {
+                fenced = !fenced;
+            }
+        }
+        const line = all[index] ?? "";
+        return !fenced && !line.trimStart().startsWith("```");
+    })
+        .join("\n");
+}

package/dist/features/records/docs-prose.d.ts

@@ -0,0 +1,14 @@
+import type { Finding } from "../engine/index.ts";
+import type { DocFile, DocLimits } from "./docs-lines.ts";
+export declare function wordsOf(sentence: string): Array<string>;
+export declare function splitSentences(paragraph: string): Array<string>;
+export declare function densityParagraphs(text: string): Array<string>;
+export declare function checkDocDensity(files: ReadonlyArray<DocFile>, limits?: DocLimits): Array<Finding>;
+export declare function githubSlug(heading: string): string;
+export interface DocLink {
+    readonly target: string;
+    readonly anchor: string | undefined;
+    readonly line: number;
+}
+export declare function checkDocLinksValid(files: ReadonlyArray<DocFile>, known: ReadonlyMap<string, string>): Array<Finding>;
+export declare function checkDocNoCorpusCounts(files: ReadonlyArray<DocFile>): Array<Finding>;

package/dist/features/records/docs-prose.js

@@ -0,0 +1,252 @@
+// SPEC §4.9.2: doc prose checks — sentence splitting, density, link
+// validity, corpus counts. All functions are pure over caller-supplied
+// trees; this module never touches the filesystem (SPEC §3.3, §10.3 item 3).
+import { normalizeText } from "../../kernel/index.js";
+import { isHeading, isLinkOnlyLine, isTableRow, stripFences, } from "./docs-lines.js";
+import { DEFAULT_DOC_LIMITS } from "./docs-structure.js";
+const ABBREVIATIONS = new Set([
+    "e.g.",
+    "i.e.",
+    "etc.",
+    "vs.",
+    "cf.",
+]);
+// \x60 keeps literal backticks out of the span patterns: the pack lexer
+// blanks template bodies without regex awareness, so a backtick char
+// would hide later code.
+export function wordsOf(sentence) {
+    return sentence
+        .replace(/\x60[^\x60]*\x60/g, "X")
+        .split(/\s+/)
+        .filter((token) => /[A-Za-z0-9]/.test(token));
+}
+function shouldSplitAt(masked, index) {
+    const char = masked[index] ?? "";
+    if (char !== "." && char !== "!" && char !== "?") {
+        return false;
+    }
+    const rest = masked.slice(index + 1);
+    if (rest.trim() !== "" && /^[ \t]+([^a-z])/.exec(rest) === null) {
+        return false;
+    }
+    const before = masked
+        .slice(0, index + 1)
+        .split(/\s+/)
+        .pop() ?? "";
+    return !ABBREVIATIONS.has(before.toLowerCase());
+}
+// SPEC §4.9.2 core/doc-density: tables, code, headings and link-only lines
+// are excluded; each list item is one paragraph. A sentence ends at . ! ?
+// followed by whitespace and then anything but a lowercase letter, or at the
+// paragraph end; never inside a code span or after the listed abbreviations.
+export function splitSentences(paragraph) {
+    const masked = paragraph.replace(/\x60[^\x60]*\x60/g, (span) => "X".repeat(span.length));
+    const sentences = [];
+    let start = 0;
+    const flush = (end) => {
+        const piece = paragraph.slice(start, end).trim();
+        if (piece !== "") {
+            sentences.push(piece);
+        }
+        start = end;
+    };
+    for (let index = 0; index < masked.length; index += 1) {
+        if (shouldSplitAt(masked, index)) {
+            flush(index + 1);
+        }
+    }
+    flush(paragraph.length);
+    return sentences;
+}
+export function densityParagraphs(text) {
+    const paragraphs = [];
+    let current = [];
+    const flush = () => {
+        if (current.length > 0) {
+            paragraphs.push(current.join(" "));
+            current = [];
+        }
+    };
+    for (const raw of stripFences(text).split("\n")) {
+        const line = raw.trim();
+        if (line === "" || isHeading(raw) || isTableRow(raw)) {
+            flush();
+            continue;
+        }
+        const noSpans = raw.replace(/\x60[^\x60]*\x60/g, "X").trim();
+        if (noSpans !== "" && isLinkOnlyLine(raw)) {
+            continue;
+        }
+        if (/^\s*([-*+]|\d+[.)])\s+/.test(raw)) {
+            flush();
+            paragraphs.push(raw.trim());
+            continue;
+        }
+        current.push(raw.trim());
+    }
+    flush();
+    return paragraphs.filter((paragraph) => paragraph !== "");
+}
+export function checkDocDensity(files, limits = DEFAULT_DOC_LIMITS) {
+    const findings = [];
+    for (const file of files) {
+        for (const paragraph of densityParagraphs(file.text)) {
+            const sentences = splitSentences(paragraph);
+            if (sentences.length > limits.maxParagraphSentences) {
+                findings.push({
+                    ruleId: "core/doc-density",
+                    path: file.path,
+                    message: `paragraph over the sentence limit in ${file.path}: ${sentences.length} sentences, limit ${limits.maxParagraphSentences}`,
+                    remediation: `Split the paragraph in ${file.path} under ${limits.maxParagraphSentences} sentences.`,
+                });
+            }
+            for (const sentence of sentences) {
+                const count = wordsOf(sentence).length;
+                if (count > limits.maxSentenceWords) {
+                    findings.push({
+                        ruleId: "core/doc-density",
+                        path: file.path,
+                        message: `sentence over the word limit in ${file.path}: ${count} words, limit ${limits.maxSentenceWords}`,
+                        remediation: `Split the sentence in ${file.path} under ${limits.maxSentenceWords} words.`,
+                    });
+                }
+            }
+        }
+    }
+    return findings;
+}
+export function githubSlug(heading) {
+    return heading
+        .trim()
+        .toLowerCase()
+        .replace(/\x60[^\x60]*\x60/g, "")
+        .replace(/[^\w\s-]/g, "")
+        .trim()
+        .replace(/\s+/g, "-");
+}
+function editDistance(a, b) {
+    const previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i += 1) {
+        let diagonal = previous[0] ?? 0;
+        previous[0] = i;
+        for (let j = 1; j <= b.length; j += 1) {
+            const above = previous[j] ?? 0;
+            const left = previous[j - 1] ?? 0;
+            previous[j] =
+                a[i - 1] === b[j - 1] ? diagonal : Math.min(diagonal, above, left) + 1;
+            diagonal = above;
+        }
+    }
+    return previous[b.length] ?? 0;
+}
+function nearestSlug(wanted, slugs) {
+    return [...slugs]
+        .sort((a, b) => editDistance(wanted, a) - editDistance(wanted, b) || (a < b ? -1 : 1))
+        .slice(0, 3)
+        .join(", ");
+}
+function headingSlugs(text) {
+    const slugs = new Set();
+    for (const line of stripFences(text).split("\n")) {
+        const match = /^#{1,6}\s+(.+?)\s*$/.exec(line.trim());
+        if (match !== null) {
+            slugs.add(githubSlug(match[1] ?? ""));
+        }
+    }
+    return slugs;
+}
+function docLinks(text) {
+    const links = [];
+    normalizeText(text)
+        .split("\n")
+        .forEach((line, index) => {
+        const pattern = /\[.*?\]\(([^)\s]+)\)/g;
+        let match = pattern.exec(line);
+        while (match !== null) {
+            const raw = match[1] ?? "";
+            if (!/^(https?|mailto):/.test(raw)) {
+                const hash = raw.indexOf("#");
+                links.push({
+                    target: hash < 0 ? raw : raw.slice(0, hash),
+                    anchor: hash < 0 ? undefined : raw.slice(hash + 1),
+                    line: index + 1,
+                });
+            }
+            match = pattern.exec(line);
+        }
+    });
+    return links;
+}
+function resolveRelative(from, target) {
+    if (target === "") {
+        return from;
+    }
+    const parts = from.split("/").slice(0, -1);
+    for (const piece of target.split("/")) {
+        if (piece === "." || piece === "") {
+            continue;
+        }
+        if (piece === "..") {
+            parts.pop();
+            continue;
+        }
+        parts.push(piece);
+    }
+    return parts.join("/");
+}
+// SPEC §4.9.2 core/doc-links-valid: every relative link resolves; every
+// anchor matches a GitHub-style heading slug in the target.
+export function checkDocLinksValid(files, known) {
+    const findings = [];
+    for (const file of files) {
+        for (const link of docLinks(file.text)) {
+            const resolved = resolveRelative(file.path, link.target);
+            const targetText = link.target === "" ? file.text : known.get(resolved);
+            if (targetText === undefined) {
+                findings.push({
+                    ruleId: "core/doc-links-valid",
+                    path: file.path,
+                    line: link.line,
+                    message: `link target missing: ${link.target || "(self)"} from ${file.path} resolves to ${resolved}`,
+                    remediation: `Fix the link in ${file.path} line ${link.line} so it resolves to an existing file.`,
+                });
+                continue;
+            }
+            if (link.anchor !== undefined) {
+                const slugs = headingSlugs(targetText);
+                if (!slugs.has(link.anchor.toLowerCase())) {
+                    const nearest = nearestSlug(link.anchor.toLowerCase(), slugs);
+                    findings.push({
+                        ruleId: "core/doc-links-valid",
+                        path: file.path,
+                        line: link.line,
+                        message: `link anchor missing: #${link.anchor} matches no heading in ${resolved}`,
+                        remediation: `Change #${link.anchor} to #${nearest.split(", ")[0] ?? ""} in ${file.path} line ${link.line}${nearest === "" ? "" : ` (nearest: ${nearest})`}.`,
+                    });
+                }
+            }
+        }
+    }
+    return findings;
+}
+const CORPUS_COUNT = /\b(this|the)\s+(corpus|repository|repos|docs?|spec|prd|folder)\s+(has|contains|holds|consists of)\s+\d+/i;
+// SPEC §4.9.2 core/doc-no-corpus-counts: counts rot, so sentences stating
+// them are banned.
+export function checkDocNoCorpusCounts(files) {
+    const findings = [];
+    for (const file of files) {
+        for (const paragraph of densityParagraphs(file.text)) {
+            for (const sentence of splitSentences(paragraph)) {
+                if (CORPUS_COUNT.test(sentence)) {
+                    findings.push({
+                        ruleId: "core/doc-no-corpus-counts",
+                        path: file.path,
+                        message: `corpus count in ${file.path}: "${sentence.slice(0, 80)}"`,
+                        remediation: `Remove the hardcoded count from ${file.path}; point at the source of truth instead.`,
+                    });
+                }
+            }
+        }
+    }
+    return findings;
+}

package/dist/features/records/docs-structure.d.ts

@@ -0,0 +1,17 @@
+import type { Finding } from "../engine/index.ts";
+import type { DocFile, DocLimits } from "./docs-lines.ts";
+export type { DocFile, DocLimits } from "./docs-lines.ts";
+export { isTableRow } from "./docs-lines.ts";
+export declare const DEFAULT_DOC_LIMITS: DocLimits;
+export interface RouterLeaf {
+    readonly name: string;
+    readonly text: string;
+}
+export interface RouterTree {
+    readonly routerPath: string;
+    readonly routerText: string;
+    readonly leaves: ReadonlyArray<RouterLeaf>;
+}
+export declare function checkDocRouterLeaf(tree: RouterTree): Array<Finding>;
+export declare function checkDocSize(files: ReadonlyArray<DocFile>, limits?: DocLimits): Array<Finding>;
+export declare function checkDocBreadth(files: ReadonlyArray<DocFile>, filesPerFolder?: Readonly<Record<string, number>>, limits?: DocLimits): Array<Finding>;