@sema-agent/wiki-gate 0.0.0-stage → 7.67.0

package/dist/coverage.js

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { citationsOf, splitPage } from "./page.js";
+import { generate, generatorOf } from "./check.js";
+import { coverageSourcesOf, repoOf } from "./tree.js";
+import { FEATURE_ROWS, genreRow } from "./genre.js";
+export const COVERED_FEAT_STATUSES = Object.freeze(["shipped", "verified"]);
+export function readFeatRows(repoWord, { commsRoot, candidates = [] } = {}) {
+    const tried = commsRoot ? [commsRoot] : [...candidates];
+    const root = tried.find((c) => existsSync(c));
+    if (root === undefined)
+        return { absent: tried };
+    const dir = join(root, "feats");
+    const files = existsSync(dir) ? readdirSync(dir).filter((f) => /^F-\d+\.md$/.test(f)).sort() : [];
+    if (files.length === 0)
+        return { error: `${dir} holds no F-<n>.md row` };
+    return {
+        rows: files.map((f) => {
+            const { fm } = splitPage(readFileSync(join(dir, f), "utf8"));
+            return { id: f.replace(/\.md$/, ""), status: String(fm?.[`status-${repoWord}`] ?? "").replace(/^"|"$/g, "").trim() };
+        }),
+    };
+}
+export function rootExportsSource() {
+    return { items: (tree) => Object.keys(tree.snapshot().exports).map((id) => ({ id })), refKind: "export", coversKey: "exports" };
+}
+export function stableRootExportsSource() {
+    return {
+        items: (tree) => {
+            const s = tree.snapshot();
+            return Object.keys(s.exports)
+                .filter((n) => s.tiers[n] === "stable")
+                .map((id) => ({ id }));
+        },
+        refKind: "export",
+        coversKey: "exports",
+    };
+}
+export function liveClosedSetsSource() {
+    return { items: (tree) => tree.closedSetRows().filter((r) => r.status === "live").map((r) => ({ id: r.set, file: r.file })), refKind: "set", coversKey: "sets" };
+}
+export function contractSentencesSource() {
+    return { items: (tree) => tree.contractRows().map((r) => ({ id: r.id, file: r.file })), refKind: "contract", coversKey: "contracts" };
+}
+export function configurationKeysSource() {
+    return {
+        items: (tree) => {
+            const file = tree.config.readers?.catalog?.file;
+            return tree.configKnobs().map((k) => ({ id: k.key, ...(file === undefined ? {} : { file }), line: k.line }));
+        },
+        coversKey: "configKeys",
+    };
+}
+const NONE = new Set();
+export function citedByPages(tree, pages) {
+    const feats = new Set();
+    const byRef = new Map();
+    const byCovers = new Map();
+    const add = (m, k, id) => {
+        if (!m.has(k))
+            m.set(k, new Set());
+        m.get(k).add(id);
+    };
+    const citeRef = (r) => {
+        const [kind, ...rest] = r.split(":");
+        add(byRef, kind, rest.join(":"));
+    };
+    for (const p of pages) {
+        const c = citationsOf(p.text);
+        for (const f of c.feats)
+            feats.add(f);
+        for (const r of c.refs)
+            citeRef(r);
+        for (const g of c.gens) {
+            const gen = generatorOf(tree, g.name);
+            if (!gen)
+                continue;
+            try {
+                for (const r of generate(gen, g.args).refs)
+                    citeRef(r);
+                for (const [k, ids] of Object.entries(gen.covers?.(...g.args) ?? {}))
+                    for (const id of ids)
+                        add(byCovers, k, id);
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    const refs = (kind) => byRef.get(kind) ?? NONE;
+    const covers = (key) => byCovers.get(key) ?? NONE;
+    return {
+        feats,
+        refs,
+        covers,
+        isCited: (source, id) => (source.refKind !== undefined && refs(source.refKind).has(id)) || (source.coversKey !== undefined && covers(source.coversKey).has(id)),
+    };
+}
+export function coverageFindings(tree, pages, feats) {
+    const findings = [];
+    const repo = repoOf(tree);
+    const cited = citedByPages(tree, pages);
+    const coveredFeats = cited.feats;
+    const required = [];
+    if (genreRow(tree.genre).requiredFloor.includes(FEATURE_ROWS)) {
+        if ("absent" in feats) {
+            findings.push({ gate: "coverage", page: "(feature rows)", line: 0, message: `the feature-row half of the required set cannot be judged: no comms checkout at ${feats.absent.join(" or ")}` });
+            required.push({ source: FEATURE_ROWS, covered: 0, size: 0, unread: "no comms checkout" });
+        }
+        else if ("error" in feats) {
+            findings.push({ gate: "coverage", page: "(feature rows)", line: 0, message: `a comms checkout without its feature rows: ${feats.error}`, fixed: "fail" });
+            required.push({ source: FEATURE_ROWS, covered: 0, size: 0, unread: feats.error });
+        }
+        else {
+            const due = feats.rows.filter((row) => COVERED_FEAT_STATUSES.includes(row.status));
+            for (const row of due)
+                if (!coveredFeats.has(row.id))
+                    findings.push({ gate: "coverage", page: "(feature rows)", line: 0, message: `${row.id} (status-${repo.word}: ${row.status}) is on no page's \`feats:\`` });
+            required.push({ source: FEATURE_ROWS, covered: due.filter((row) => coveredFeats.has(row.id)).length, size: due.length });
+        }
+    }
+    const report = [];
+    for (const { name, source, required: isRequired } of coverageSourcesOf(tree.config)) {
+        let items;
+        try {
+            items = source.items(tree);
+        }
+        catch (e) {
+            if (!isRequired)
+                throw e;
+            findings.push({ gate: "coverage", page: `(${name})`, line: 0, message: `the required source \`${name}\` cannot be read: ${e.message}`, fixed: "fail" });
+            required.push({ source: name, covered: 0, size: 0, unread: e.message });
+            continue;
+        }
+        const covered = items.filter((it) => cited.isCited(source, it.id));
+        if (!isRequired) {
+            report.push({ source: name, cited: covered.length, size: items.length });
+            continue;
+        }
+        for (const it of items)
+            if (!cited.isCited(source, it.id))
+                findings.push({ gate: "coverage", page: it.file ?? `(${name})`, line: it.line ?? 0, message: `${name}: \`${it.id}\` is covered by no page${source.refKind === undefined ? " (only a generated region covers one)" : ""}` });
+        required.push({ source: name, covered: covered.length, size: items.length });
+    }
+    return { findings, report, required };
+}
+export function requiredSummaryOf(rows) {
+    if (rows.length === 0)
+        return "required: none";
+    return `required: ${rows.map((r) => (r.unread !== undefined ? `${r.source} unread` : `${r.source} ${r.covered}/${r.size}`)).join(", ")}`;
+}

package/dist/generators.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The package's own generators, held by every repository: the index of a genre's pages, grouped by the genre's
+ * readers, the genre table itself, and the table of knob fields. A repository's generators are added beside them,
+ * never under the same name.
+ */
+import { type GenreRow } from "./genre.js";
+import type { Generator, GeneratorReaders } from "./tree.js";
+/** The names of the package's own generators. */
+export declare const BUILT_IN_GENERATORS: readonly string[];
+/** The genre table rendered: one column per genre, one row per column of the table. */
+export declare function genreTableText(rows?: Readonly<Record<string, GenreRow>>): string;
+export declare function builtInGenerators(read: GeneratorReaders): Record<string, Generator>;

package/dist/generators.js

@@ -0,0 +1,45 @@
+import { GENRES, behaviourEvidenceOf } from "./genre.js";
+import { KNOB_FIELDS } from "./knobs.js";
+export const BUILT_IN_GENERATORS = Object.freeze(["page-index", "genre-table", "knob-fields"]);
+const list = (xs, wrap = (x) => x) => (xs.length === 0 ? "—" : xs.map(wrap).join(" · "));
+const code = (x) => `\`${x}\``;
+export function genreTableText(rows = GENRES) {
+    const names = Object.keys(rows);
+    const line = (label, cell) => `| ${label} | ${names.map((n) => cell(rows[n])).join(" | ")} |`;
+    return [
+        `| | ${names.join(" | ")} |`,
+        `|---|${names.map(() => "---").join("|")}|`,
+        line("directory", (r) => code(r.dir)),
+        line("readers", (r) => list(r.audiences)),
+        line("levels", (r) => list(r.levels)),
+        line("behaviour evidence", (r) => list(behaviourEvidenceOf(r), code)),
+        line("required coverage, besides what the repository declares", (r) => list(r.requiredFloor)),
+    ].join("\n");
+}
+function knobFieldsText() {
+    return ["| field | what its column says | required |", "|---|---|---|", ...KNOB_FIELDS.map((f) => `| ${code(f.id)} | ${f.says} | ${f.required ? "yes" : "no"} |`)].join("\n");
+}
+export function builtInGenerators(read) {
+    return {
+        "page-index": {
+            render: () => {
+                const row = read.genre();
+                const pages = read.wikiPages().slice().sort((a, b) => a.fm["page-id"].localeCompare(b.fm["page-id"]));
+                const out = [`Pages: ${pages.length}; stable: ${pages.filter((p) => p.fm.stable === "true").length}.`];
+                for (const reader of row.audiences) {
+                    const mine = pages.filter((p) => (p.fm._list.audience ?? []).includes(reader));
+                    out.push("", `**${reader}** (${mine.length})`, "", "| page | id | kind | owner | stable |", "|---|---|---|---|---|");
+                    for (const p of mine)
+                        out.push(`| [${p.fm.title}](${p.rel}) | \`${p.fm["page-id"]}\` | ${p.fm.kind} | ${p.fm["owner-repo"]} | ${p.fm.stable} |`);
+                }
+                return { text: out.join("\n"), refs: [] };
+            },
+        },
+        "genre-table": {
+            render: () => ({ text: genreTableText(), refs: [] }),
+        },
+        "knob-fields": {
+            render: () => ({ text: knobFieldsText(), refs: [] }),
+        },
+    };
+}

package/dist/genre.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The genres a gate run reads — one frozen table, one row per genre, chosen by the entry configuration's `genre`.
+ *
+ * Both rows are held to one rule set: every rule reads the row of the page's genre, so the two genres differ only
+ * where their rows differ — the page directory, the readers a page may name, the evidence levels a sentence may carry,
+ * and the coverage the genre itself requires besides what the repository declares.
+ */
+/** An evidence level: who re-checks a sentence. */
+export type Level = "G" | "U" | "P" | "V" | "I";
+/** Every evidence level a marker may spell, in the order a page lists them. */
+export declare const LEVELS: readonly Level[];
+/** The levels that vouch for what the code does (a `G` sentence restates a declaration and never vouches for behaviour). */
+export declare const BEHAVIOUR_LEVELS: readonly Level[];
+/** The required coverage source a genre names that no repository declares: its items are the shipped feature rows. */
+export declare const FEATURE_ROWS = "feature rows";
+/**
+ * One genre: the page directory under the repository root, the readers its pages may name in `audience:`, the evidence
+ * levels its sentences may carry, and the coverage sources it requires of every repository (besides what the
+ * repository declares).
+ */
+export interface GenreRow {
+    readonly dir: string;
+    readonly audiences: readonly string[];
+    readonly levels: readonly Level[];
+    readonly requiredFloor: readonly string[];
+}
+export declare const GENRES: Readonly<{
+    wiki: Readonly<{
+        dir: "docs/wiki";
+        audiences: readonly string[];
+        levels: readonly Level[];
+        requiredFloor: readonly string[];
+    }>;
+    manual: Readonly<{
+        dir: "docs/manual";
+        audiences: readonly string[];
+        levels: readonly Level[];
+        requiredFloor: readonly string[];
+    }>;
+}>;
+/** A word of the genre table. */
+export type Genre = keyof typeof GENRES;
+/** The row a configuration's genre names; a word the table does not hold is refused by name, never read as a default. */
+export declare function genreRow(genre: unknown): GenreRow;
+/** A row's levels that vouch for behaviour: the "behaviour evidence" of its genre. */
+export declare function behaviourEvidenceOf(row: GenreRow): readonly Level[];

package/dist/genre.js

@@ -0,0 +1,15 @@
+export const LEVELS = Object.freeze(["G", "U", "P", "V", "I"]);
+export const BEHAVIOUR_LEVELS = Object.freeze(["U", "P"]);
+export const FEATURE_ROWS = "feature rows";
+export const GENRES = Object.freeze({
+    wiki: Object.freeze({ dir: "docs/wiki", audiences: Object.freeze(["embedder", "deployer", "caller"]), levels: Object.freeze(["G", "P", "V", "I"]), requiredFloor: Object.freeze([FEATURE_ROWS]) }),
+    manual: Object.freeze({ dir: "docs/manual", audiences: Object.freeze(["user", "scripter", "admin"]), levels: Object.freeze(["G", "U", "P", "I"]), requiredFloor: Object.freeze([]) }),
+});
+export function genreRow(genre) {
+    if (typeof genre === "string" && Object.hasOwn(GENRES, genre))
+        return GENRES[genre];
+    throw new Error(`unknown genre ${JSON.stringify(genre) ?? String(genre)}: the genres are ${Object.keys(GENRES).join(", ")}`);
+}
+export function behaviourEvidenceOf(row) {
+    return row.levels.filter((l) => BEHAVIOUR_LEVELS.includes(l));
+}

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `@sema-agent/wiki-gate` — the sema wiki gates: one reader module with three gate entries (anchors, freshness,
+ * coverage) and the stamp, over the repository a {@link WikiGateConfig} names.
+ *
+ * The gate holds every page directory it is pointed at — `docs/wiki` and `docs/manual` alike — to one rule set: the
+ * genre, and with it the directory, is chosen by the entry's configuration object, never by a page's own header, and
+ * the package opens no second interface for another genre ({@link GENRES} holds the genres, one row each).
+ *
+ * A repository hands in its profile: its identity, the version its findings fail from per genre, its own readers (its
+ * export surface, its closed-set and contract-sentence registries, its configuration catalog, its literal tables, its
+ * internal work-item name form, its pin reader when its tests are not vitest, the acceptance index and the criterion
+ * text a `U` sentence is vouched by), its generators, its required and reported sources, its own banned forms and its
+ * preflight. The rules — page shape, markers, refs, digests, severities, the stamp — are the package's, and read the
+ * same in every repository.
+ */
+export { V_AGE_MINORS, U_AGE_RELEASES, parseVersion, compareVersions, severityOf, parseRun, vAgeFinding, uAgeFinding, minorReleaseDistance } from "./versions.js";
+export type { Severity, SeverityContext, RunRef, RepoIdentity, ReleaseDistance } from "./versions.js";
+export { declarationOf, pinOf, literalTableReader, literalKeyCatalog } from "./source.js";
+export type { TreeFiles, Resolved, Unresolvable, DeclarationReading, InitializerUnwrap, TableValuesReader, CatalogKnob, CatalogReader } from "./source.js";
+export { splitPage, claimBlocks, citationsOf, correctionLineOf, sectionIdOf } from "./page.js";
+export type { Frontmatter, FrontmatterLine, SplitPage, CutBody, ClaimBlock, GenRegion, Fence, PageUnit, Marker, CorrectionLine } from "./page.js";
+export { GENRES, LEVELS, BEHAVIOUR_LEVELS, FEATURE_ROWS, genreRow, behaviourEvidenceOf } from "./genre.js";
+export type { Genre, GenreRow, Level } from "./genre.js";
+export { ACCEPTANCE_STATES, ACCEPTANCE_INDEX_FILE, parseCritKey, parseAcceptanceIndex, acceptanceIndexAt, cellRefusal } from "./acceptance.js";
+export type { CritKey, AcceptanceCell, AcceptanceIndex, AcceptanceIndexReader } from "./acceptance.js";
+export { CORRECTIONS_DIR, CORRECTION_RECORD, parseCorrectionRecord, correctionRecordAt } from "./corrections.js";
+export type { CorrectionRecord, CorrectionRecordReader, CorrectionRecordSource } from "./corrections.js";
+export { BUILT_IN_GENERATORS, genreTableText } from "./generators.js";
+export { KNOB_FIELDS } from "./knobs.js";
+export type { KnobField } from "./knobs.js";
+export { REF_KINDS, createTree, repoOf, resolveRef, coverageSourcesOf, coversKeysOf } from "./tree.js";
+export type { WikiGateConfig, WikiReaders, WikiTree, TreeOptions, ExportSurface, ClosedSetRow, ContractRow, ContractTag, Generator, Generated, GeneratorFactory, GeneratorReaders, PinReader, CoverageItem, CoverageSource, RequiredSource, RefRefusal } from "./tree.js";
+export { PAGE_KINDS, OWNER_REPOS, FRONTMATTER_KEYS, publicnessBans, checkPage, regenerate, stampPage } from "./check.js";
+export type { Finding, PageCheck } from "./check.js";
+export { COVERED_FEAT_STATUSES, readFeatRows, citedByPages, coverageFindings, requiredSummaryOf, rootExportsSource, stableRootExportsSource, liveClosedSetsSource, contractSentencesSource, configurationKeysSource } from "./coverage.js";
+export type { FeatRows, CitedByPages, CoverageReportRow, RequiredSummaryRow } from "./coverage.js";
+export { verdictOf, wikiAnchors, wikiFreshness, wikiCoverage, runWikiGate } from "./run.js";
+export type { Verdict, JudgedFinding, GateOptions, GateResult, WikiGateCommandLine } from "./run.js";

package/dist/index.js

@@ -0,0 +1,12 @@
+export { V_AGE_MINORS, U_AGE_RELEASES, parseVersion, compareVersions, severityOf, parseRun, vAgeFinding, uAgeFinding, minorReleaseDistance } from "./versions.js";
+export { declarationOf, pinOf, literalTableReader, literalKeyCatalog } from "./source.js";
+export { splitPage, claimBlocks, citationsOf, correctionLineOf, sectionIdOf } from "./page.js";
+export { GENRES, LEVELS, BEHAVIOUR_LEVELS, FEATURE_ROWS, genreRow, behaviourEvidenceOf } from "./genre.js";
+export { ACCEPTANCE_STATES, ACCEPTANCE_INDEX_FILE, parseCritKey, parseAcceptanceIndex, acceptanceIndexAt, cellRefusal } from "./acceptance.js";
+export { CORRECTIONS_DIR, CORRECTION_RECORD, parseCorrectionRecord, correctionRecordAt } from "./corrections.js";
+export { BUILT_IN_GENERATORS, genreTableText } from "./generators.js";
+export { KNOB_FIELDS } from "./knobs.js";
+export { REF_KINDS, createTree, repoOf, resolveRef, coverageSourcesOf, coversKeysOf } from "./tree.js";
+export { PAGE_KINDS, OWNER_REPOS, FRONTMATTER_KEYS, publicnessBans, checkPage, regenerate, stampPage } from "./check.js";
+export { COVERED_FEAT_STATUSES, readFeatRows, citedByPages, coverageFindings, requiredSummaryOf, rootExportsSource, stableRootExportsSource, liveClosedSetsSource, contractSentencesSource, configurationKeysSource } from "./coverage.js";
+export { verdictOf, wikiAnchors, wikiFreshness, wikiCoverage, runWikiGate } from "./run.js";

package/dist/knobs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The knob table: the fields a generated table of configuration knobs may render, one column each, and what the gate
+ * holds such a table to. A generator whose region is a table of knobs names the fields it renders (`rowFields`); the
+ * gate reads that declaration against this table, never the table's prose.
+ */
+/** One field of a knob row: its id, what its column says, and whether every knob table renders it. */
+export interface KnobField {
+    readonly id: string;
+    readonly says: string;
+    readonly required: boolean;
+}
+/** The fields of a knob row, in the order a table lists them. */
+export declare const KNOB_FIELDS: readonly KnobField[];
+/**
+ * What is wrong with the knob table a generator renders, given the fields it names and the text of its region; each
+ * problem is one sentence. A coordinate is read for its shape only: whether the file and the line exist is the anchors
+ * gate's own work and is not read again here.
+ */
+export declare function knobTableProblems(name: string, fields: readonly string[], text: string): string[];

package/dist/knobs.js

@@ -0,0 +1,58 @@
+const field = (id, says, required = false) => Object.freeze({ id, says, required });
+export const KNOB_FIELDS = Object.freeze([
+    field("name", "the knob's name", true),
+    field("domain", "the group of knobs it belongs to"),
+    field("type", "its value type, with the allowed words of an enumeration"),
+    field("default", "the value it takes when unset, as it stands at run time"),
+    field("timing", "when a change takes effect"),
+    field("writers", "who may set it"),
+    field("danger", "the risk axes the catalog names for it"),
+    field("embedderKey", "the option an embedder passes in place of the environment name"),
+    field("startupOnly", "whether it is read once, at start"),
+    field("meaning", "the catalog's own sentence, kept in a column of its own"),
+    field("badValue", "where a bad value surfaces, once the catalog declares it"),
+    field("readPoints", "where the knob is read: one or more `path:line` coordinates the generator computes from its source", true),
+]);
+const FIELD_IDS = KNOB_FIELDS.map((f) => f.id);
+function cellsOf(line) {
+    const inner = line.trim().replace(/^\|/, "").replace(/(?<!\\)\|$/, "");
+    return inner.split(/(?<!\\)\|/).map((c) => c.trim());
+}
+const SEPARATOR = /^\|[\s:|-]+\|\s*$/;
+const COORDINATE = /^\S+:[1-9]\d*$/;
+export function knobTableProblems(name, fields, text) {
+    const out = [];
+    const seen = new Set();
+    for (const id of fields) {
+        if (!FIELD_IDS.includes(id))
+            out.push(`the generator \`${name}\` names the knob field \`${id}\`, which is none of ${FIELD_IDS.join(", ")}`);
+        else if (seen.has(id))
+            out.push(`the generator \`${name}\` names the knob field \`${id}\` twice`);
+        seen.add(id);
+    }
+    for (const f of KNOB_FIELDS)
+        if (f.required && !seen.has(f.id))
+            out.push(`the knob table of the generated region \`${name}\` lacks the required knob field \`${f.id}\` (${f.says})`);
+    const lines = text.split("\n");
+    const header = lines.findIndex((l, i) => /^\|/.test(l) && SEPARATOR.test(lines[i + 1] ?? ""));
+    if (header < 0)
+        return [...out, `the generated region \`${name}\` names knob fields and holds no table`];
+    const columns = cellsOf(lines[header]).length;
+    if (columns !== fields.length)
+        return [...out, `the generator \`${name}\` names ${fields.length} knob fields and the header row of its region has ${columns} columns`];
+    const at = fields.indexOf("readPoints");
+    if (at < 0)
+        return out;
+    const label = fields.indexOf("name");
+    const rows = lines.slice(header + 2);
+    const end = rows.findIndex((l) => /^\s*$/.test(l));
+    for (const row of end < 0 ? rows : rows.slice(0, end)) {
+        const cells = cellsOf(row);
+        const tokens = (cells[at] ?? "").replace(/`/g, "").split(/[\s,]+/).filter(Boolean);
+        if (!tokens.some((t) => COORDINATE.test(t))) {
+            const who = label >= 0 ? (cells[label] ?? "").replace(/`/g, "") : row.slice(0, 40);
+            out.push(`the \`readPoints\` cell of the knob row \`${who}\` holds no \`path:line\` coordinate: ${JSON.stringify((cells[at] ?? "").slice(0, 60))}`);
+        }
+    }
+    return out;
+}

package/dist/page.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Page text as the gates read it: the frontmatter, the claim blocks, the generated regions, the fences, the markers.
+ * One reading for every gate entry and for the stamp.
+ */
+import type { Level } from "./genre.js";
+/**
+ * A page's frontmatter: the first value of each key, and under `_list` every value of each key in order. Keyed by page
+ * text, with no prototype, so a key spelled `constructor` or `__proto__` is a key like any other.
+ */
+export type Frontmatter = Record<string, string | undefined> & {
+    readonly _list: Record<string, string[] | undefined>;
+};
+/** One frontmatter line: its file line, and its key and value when it reads `key: value`. */
+export interface FrontmatterLine {
+    readonly line: number;
+    readonly key: string | undefined;
+    readonly value: string | undefined;
+    readonly raw: string;
+}
+/** A page cut at its frontmatter fences. `bodyLine` is the file line the body starts on. */
+export interface SplitPage {
+    readonly fm: Frontmatter | null;
+    readonly body: string;
+    readonly bodyLine: number;
+    readonly fmLines: readonly FrontmatterLine[];
+}
+/** A claim block: a paragraph, a list item or a table row, with its body-relative first line. */
+export interface ClaimBlock {
+    readonly line: number;
+    readonly text: string;
+}
+/** A generated region: its generator, its arguments, its content, and its span in the body. */
+export interface GenRegion {
+    readonly line: number;
+    readonly name: string;
+    readonly args: string[];
+    readonly content: string;
+    readonly inline: boolean;
+    readonly closed: boolean;
+    readonly span: readonly [number, number];
+}
+/** A code fence: its language, its info string, its lines, and whether it closes. */
+export interface Fence {
+    readonly line: number;
+    readonly lang: string;
+    readonly info: string;
+    readonly body: string[];
+    readonly unclosed?: true;
+}
+/** The page's own text, unit by unit in document order: what the stamp binds. */
+export interface PageUnit {
+    readonly kind: "block" | "fence" | "heading" | "header";
+    readonly text: string;
+}
+/** A marker: its evidence level, its refs, and where it stands in its text. */
+export interface Marker {
+    readonly level: Level;
+    readonly refs: string[];
+    readonly index: number;
+    readonly length: number;
+}
+export declare const GEN_CLOSE = "<!-- /wiki:gen -->";
+/**
+ * A page's frontmatter (`key: value` lines between `---` fences; a key may repeat, so every value is kept in order)
+ * and its body. `bodyLine` is the file line the body starts on, so findings point at file lines.
+ */
+export declare function splitPage(text: string): SplitPage;
+/** What {@link claimBlocks} cuts a body into. */
+export interface CutBody {
+    readonly blocks: ClaimBlock[];
+    readonly gens: GenRegion[];
+    readonly fences: Fence[];
+    readonly units: PageUnit[];
+    /** The headings, each with its body-relative line: the sections a block stands under. */
+    readonly headings: Array<{
+        line: number;
+        text: string;
+    }>;
+    readonly problems: Array<{
+        line: number;
+        message: string;
+    }>;
+}
+/**
+ * The page body cut into what the gates read: claim blocks (a paragraph, a list item or a table row), generated regions,
+ * code fences, and the page's own text as units in document order (headings, table header rows, blocks with their
+ * generated regions folded to a placeholder, fences) — the text the stamp binds. Lines are body-relative (1 = first).
+ */
+export declare function claimBlocks(body: string): CutBody;
+/** The inline generated regions of a text where they stand outside inline code and a correction's quote: each its offset, length and match. */
+export declare function inlineGensOf(text: string): Array<{
+    index: number;
+    length: number;
+    m: RegExpExecArray;
+}>;
+/** A correction line: the quoted sentence it retires, the correction it names, its date and version. */
+export interface CorrectionLine {
+    readonly correction: string;
+    readonly date: string;
+    readonly version: string;
+    /** The retired sentence as quoted: no longer a claim, its markers not judged. */
+    readonly quoted: string;
+    /** Where the quote stands in the block's text (its opening and closing quote marks included). */
+    readonly quoteSpan: readonly [number, number];
+}
+/**
+ * A block that is a correction line — `"<retired sentence>" — corrected by W-<n> on <YYYY-MM-DD> at <X.Y.Z>: <new
+ * sentence> {{…}}` — read; undefined for any other block. The quote ends at the first `" — corrected by `.
+ */
+export declare function correctionLineOf(text: string): CorrectionLine | undefined;
+/** A heading's section id: its words, lowercased, every run of other characters one hyphen (`## The U level` → `the-u-level`). */
+export declare function sectionIdOf(heading: string): string;
+/**
+ * The markers of a text, found on its view with inline code, inline regions and a correction line's quote filled in,
+ * and read from the text itself: a marker inside backticks is an example, one inside a correction's quote belongs to
+ * the sentence it retired, and backticks inside a marker's quoted fragment stay as written. `stripped` is the view,
+ * for what follows the last marker.
+ */
+export declare function markersOf(text: string): {
+    stripped: string;
+    markers: Marker[];
+};
+/** Every ref and generated region a page cites, and its `feats:` — what the coverage gate counts (a region's refs are the generator's, read by the gate). */
+export declare function citationsOf(text: string): {
+    feats: string[];
+    refs: string[];
+    gens: GenRegion[];
+};