@scientific-method/standard-checker 0.1.0 → 0.3.0

package/dist/load/builds.js

@@ -0,0 +1,124 @@
+// Build manifests, which list a build's files, and the lists of the other files of its installation.
+import { existsSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { readText } from "../markdown.js";
+import { locationRule, unlistedFormat } from "../standard.js";
+import { parseYaml } from "../yaml.js";
+/**
+ * Reads and checks the manifest of every build entry, and reports a manifest or list of other files
+ * that belongs to no build. Returns build ID -> the items of its files list that are maps.
+ */
+export function loadBuildFiles({ config, problem }, entries) {
+    const { specDir } = config;
+    // Build manifests: builds/<ID>.files.yaml holds a build's files list and nothing else.
+    const buildFiles = new Map();
+    for (const [id, e] of entries) {
+        if (e.kind !== "BLD")
+            continue;
+        const expected = `${id}.files.yaml`;
+        if ("files" in e.meta)
+            problem(e.file, `the files list belongs in the manifest ${expected}, not in the entry`);
+        if (e.meta.manifest !== expected) {
+            problem(e.file, `manifest must be ${expected}`);
+            continue;
+        }
+        const path = join(dirname(e.file), expected);
+        if (!existsSync(path)) {
+            problem(e.file, `manifest ${expected} does not exist`);
+            continue;
+        }
+        const manifest = parseYaml(readText(path), path, problem);
+        for (const key of Object.keys(manifest))
+            if (key !== "files")
+                problem(path, `a manifest has only the key files, not ${key}`);
+        if (!Array.isArray(manifest.files)) {
+            problem(path, "files must be a list");
+            continue;
+        }
+        // Later checks read f.path, so an item that is not a map is reported and left out.
+        if (manifest.files.some((f) => !f || typeof f !== "object"))
+            problem(path, "every item of files is a map of path, format, size and xxh3");
+        const files = manifest.files.filter((f) => f && typeof f === "object");
+        buildFiles.set(id, files);
+        for (const f of files) {
+            if (!f.path)
+                problem(path, "every file has a path");
+            if (f.format === undefined || f.format === null || f.format === "")
+                problem(path, `${f.path}: every file has a format`);
+            else if (!locationRule(f.format))
+                problem(path, `${f.path}: ${unlistedFormat(f.format)}`);
+            const unpackedFormat = f.unpacked?.format;
+            if (unpackedFormat !== undefined &&
+                unpackedFormat !== null &&
+                unpackedFormat !== "" &&
+                !locationRule(unpackedFormat))
+                problem(path, `${f.path}: unpacked ${unlistedFormat(unpackedFormat)}`);
+            if (!/^[0-9a-f]{32}$/.test(String(f.xxh3)))
+                problem(path, `${f.path}: xxh3 must be 32 lower-case hex digits`);
+            if (typeof f.size !== "number")
+                problem(path, `${f.path}: size must be a number`);
+            if (f.packer && !(f.unpacked && f.unpacked.size && f.unpacked.xxh3 && f.unpacked.format && f.unpacked.tool))
+                problem(path, `${f.path}: a packed file gives the size, xxh3, format and tool of its unpacked form`);
+            if (String(f.path).includes("\\"))
+                problem(path, `${f.path}: paths use forward slashes`);
+        }
+    }
+    if (existsSync(join(specDir, "builds")))
+        for (const name of readdirSync(join(specDir, "builds"))) {
+            const m = /^(.+)\.(?:other-)?files\.yaml$/.exec(name);
+            if (m && entries.get(m[1])?.kind !== "BLD")
+                problem(join(specDir, "builds", name), `belongs to no build entry (${m[1]})`);
+        }
+    return buildFiles;
+}
+/** Checks each build's list of other files against its manifest and its Other files section. */
+export function checkOtherFiles({ problem }, entries, buildFiles) {
+    // Other files: every path of the installation's listing that the manifest leaves out, each with
+    // its reason, in the build entry's Other files section or, for a long list, in
+    // builds/<ID>.other-files.yaml, which that section names.
+    for (const [id, e] of entries) {
+        if (e.kind !== "BLD")
+            continue;
+        const name = `${id}.other-files.yaml`;
+        const path = join(dirname(e.file), name);
+        const named = (e.sections.find((s) => s.title === "Other files")?.text ?? "").includes(name);
+        if (!existsSync(path)) {
+            if (named)
+                problem(e.file, `Other files names ${name}, which does not exist`);
+            continue;
+        }
+        if (!named)
+            problem(e.file, `the Other files section names ${name}, which lists the paths the manifest leaves out`);
+        const list = parseYaml(readText(path), path, problem);
+        for (const key of Object.keys(list))
+            if (key !== "other_files")
+                problem(path, `a list of other files has only the key other_files, not ${key}`);
+        if (!Array.isArray(list.other_files)) {
+            problem(path, "other_files must be a list");
+            continue;
+        }
+        // The front matter reader turns a bare name such as 1990 into a number, so paths compare as text.
+        const inManifest = new Set((buildFiles.get(id) ?? []).map((f) => String(f.path)));
+        const seen = new Set();
+        for (const item of list.other_files) {
+            if (!item || typeof item !== "object" || Object.keys(item).sort().join(",") !== "path,reason") {
+                problem(path, "every item of other_files is a map of path and reason");
+                continue;
+            }
+            if (item.path === null || item.path === undefined || item.path === "") {
+                problem(path, "every other file has a path");
+                continue;
+            }
+            const other = String(item.path);
+            if (item.reason === null || String(item.reason).trim() === "")
+                problem(path, `${other}: every other file gives the reason the manifest leaves it out`);
+            if (other.includes("\\"))
+                problem(path, `${other}: paths use forward slashes`);
+            if (inManifest.has(other))
+                problem(path, `${other} is in the manifest, so it is not one of the other files`);
+            if (seen.has(other))
+                problem(path, `${other} is listed twice`);
+            seen.add(other);
+        }
+    }
+}

package/dist/load/code-ranges.d.ts

@@ -0,0 +1,4 @@
+import type { LoadContext } from "../context.ts";
+import type { CodeRange, Entry, Meta } from "../types.ts";
+/** Reads and checks the Code ranges section of every build entry. Returns build ID -> its ranges. */
+export declare function loadCodeRanges({ problem }: LoadContext, entries: Map<string, Entry>, buildFiles: Map<string, Meta[]>): Map<string, CodeRange[]>;

package/dist/load/code-ranges.js

@@ -0,0 +1,79 @@
+// Code ranges: the half-open ranges of each file that hold code located by offset, each with the
+// finding that shows it. A table File | Range | Overlay | Finding, or None.
+import { asList, idsIn, kindOf } from "../ids.js";
+import { checkOffset, parseOffset } from "../locations.js";
+import { tables } from "../markdown.js";
+import { locationRule } from "../standard.js";
+const CODE_RANGES = ["File", "Range", "Overlay", "Finding"];
+const unticked = (cell) => cell.replace(/^`(.*)`$/, "$1").trim();
+/** Reads and checks the Code ranges section of every build entry. Returns build ID -> its ranges. */
+export function loadCodeRanges({ problem }, entries, buildFiles) {
+    const codeRanges = new Map(); // build ID -> [{ file, start, end }]
+    for (const [id, e] of entries) {
+        if (e.kind !== "BLD")
+            continue;
+        const section = e.sections.find((s) => s.title === "Code ranges");
+        // A missing section is reported with the other sections.
+        if (!section)
+            continue;
+        const ranges = [];
+        if (/^\s*None\.\s*$/.test(section.text)) {
+            codeRanges.set(id, ranges);
+            continue;
+        }
+        const found = tables(section.text);
+        // A malformed section is reported once here; offsets into the build are then not measured
+        // against it, as with a missing section, rather than each failing again.
+        if (found.length !== 1 || found[0].header.join("|") !== CODE_RANGES.join("|") || found[0].rows.length === 0) {
+            problem(e.file, `the Code ranges section is one table with the columns ${CODE_RANGES.join(" | ")}, or None.`);
+            continue;
+        }
+        codeRanges.set(id, ranges);
+        const files = buildFiles.get(id) ?? [];
+        for (const row of found[0].rows) {
+            if (row.length !== CODE_RANGES.length) {
+                problem(e.file, `Code ranges row ${row.join(" | ")}: a row has ${CODE_RANGES.length} cells, not ${row.length}`);
+                continue;
+            }
+            const [path, range, overlay, finding] = row.map(unticked);
+            const at = `Code ranges row ${path} ${range}`;
+            const bf = files.find((f) => f.path === path);
+            if (!bf) {
+                problem(e.file, `${at}: ${path} is not in the manifest`);
+                continue;
+            }
+            // Only overlay code is located by offset, so a row is for a file whose unpacked format takes
+            // both addresses and offsets (MZ). An unlisted format is already reported against its manifest.
+            const format = bf.unpacked?.format ?? bf.format;
+            const rule = locationRule(format);
+            if (rule && !(rule.offset && rule.address))
+                problem(e.file, `${at}: ${path} is a ${format} file, which holds no code located by offset`);
+            // The notation is parseOffset's; a row additionally needs both ends of the range.
+            if (!range.includes("..") || !parseOffset(range)) {
+                problem(e.file, `${at}: the range is one half-open offset range, 0x followed by upper-case hex digits on each side of ..`);
+                continue;
+            }
+            if (!/^(?:-|\d+|0x[0-9A-F]+)$/.test(overlay))
+                problem(e.file, `${at}: the overlay is its number, or - where there is none`);
+            // A finding that does not exist is reported with the other unresolved IDs of the body.
+            const ids = idsIn(finding);
+            const cited = entries.get(ids[0]);
+            if (ids.length !== 1 || kindOf(ids[0]) !== "FND" || finding !== ids[0])
+                problem(e.file, `${at}: the finding column holds the ID of one finding`);
+            else if (cited && !asList(cited.meta.builds).includes(id))
+                problem(e.file, `${at}: ${ids[0]} does not list ${id}`);
+            else if (cited?.meta.status === "superseded")
+                problem(e.file, `${at}: cites ${ids[0]}, which is superseded`, "STATUS-17");
+            // The finding shows code in this file of this build, so it has a location there that is not
+            // file data. One with no locations there, or only file data there, shows no code in the row.
+            else if (cited &&
+                !asList(cited.meta.locations).some((loc) => loc?.build === id && loc?.file === path && loc?.kind !== "file-data")) {
+                problem(e.file, `${at}: ${ids[0]} has no code location in ${path} of ${id}, so it cannot establish a code range there`);
+            }
+            const parsed = checkOffset(problem, e.file, range, bf);
+            if (parsed)
+                ranges.push({ file: path, start: parsed[0], end: parsed[1] });
+        }
+    }
+    return codeRanges;
+}

package/dist/load/entries.d.ts

@@ -0,0 +1,7 @@
+import type { LoadContext } from "../context.ts";
+import type { Entry } from "../types.ts";
+/**
+ * Reads every entry under spec/, by ID, and reports a directory of spec/ the standard does not
+ * define. An entry without an ID or of an unknown kind is reported and left out.
+ */
+export declare function loadEntries({ config, problem }: LoadContext): Map<string, Entry>;

package/dist/load/entries.js

@@ -0,0 +1,57 @@
+// The entries: one Markdown file per ID in the directory of its kind.
+import { readdirSync, statSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { isAlias, kindOf } from "../ids.js";
+import { readEntry } from "../markdown.js";
+import { KINDS } from "../standard.js";
+/**
+ * Reads every entry under spec/, by ID, and reports a directory of spec/ the standard does not
+ * define. An entry without an ID or of an unknown kind is reported and left out.
+ */
+export function loadEntries({ config, problem }) {
+    const { specDir } = config;
+    const entries = new Map();
+    for (const [kind, { dir }] of Object.entries(KINDS)) {
+        const d = join(specDir, dir);
+        if (!existsSync(d))
+            continue;
+        for (const name of readdirSync(d)) {
+            const file = join(d, name);
+            if (statSync(file).isDirectory() || !name.endsWith(".md"))
+                continue;
+            const read = readEntry(file, problem);
+            if (!read)
+                continue;
+            const entry = Object.assign(read, { kind });
+            const id = entry.meta.id;
+            if (typeof id !== "string") {
+                problem(file, "has no id", "IDENTIFIERS-1");
+                continue;
+            }
+            if (name !== `${id}.md`)
+                problem(file, `file name must be ${id}.md`);
+            // Later checks look the kind up in KINDS, so an entry of an unknown kind is reported and dropped.
+            if (!KINDS[kindOf(id)]) {
+                problem(file, `${id} is not an ID of a known kind`, "IDENTIFIERS-1");
+                continue;
+            }
+            if (kindOf(id) !== kind)
+                problem(file, `a ${kindOf(id)} entry does not belong in spec/${dir}/`);
+            // IDENTIFIERS-3 makes a number unique within its kind and area, and IDENTIFIERS-4 an alias.
+            if (entries.has(id))
+                problem(file, `ID ${id} is used twice`, isAlias(id) ? "IDENTIFIERS-4" : "IDENTIFIERS-3");
+            entries.set(id, entry);
+        }
+    }
+    // Stray Markdown anywhere else in spec/ that looks like an entry.
+    for (const dir of readdirSync(specDir)) {
+        const d = join(specDir, dir);
+        if (!statSync(d).isDirectory() ||
+            Object.values(KINDS).some((k) => k.dir === dir) ||
+            dir === "index" ||
+            dir === "glossary")
+            continue;
+        problem(d, "is not a directory the standard defines");
+    }
+    return entries;
+}

package/dist/load/glossary.d.ts

@@ -0,0 +1,12 @@
+import type { LoadContext } from "../context.ts";
+/** The glossary as read from spec/glossary/ and the --glossary drafts. */
+export interface Glossary {
+    /** spec/glossary/. */
+    glossaryDir: string;
+    /** Term -> the text after its heading. */
+    glossary: Map<string, string>;
+    /** Term -> its file in spec/glossary/. */
+    glossaryFiles: Map<string, string>;
+}
+/** Reads and checks spec/glossary/, then adds the terms of the --glossary drafts. */
+export declare function loadGlossary({ config, problem }: LoadContext): Glossary;

package/dist/load/glossary.js

@@ -0,0 +1,70 @@
+// The glossary: one file per term in spec/glossary/, named after the term and opening with it as a
+// # heading. A glossary file is not an entry, so it has no front matter.
+import { existsSync, statSync } from "node:fs";
+import { basename, join } from "node:path";
+import { termFiles } from "../files.js";
+import { readText } from "../markdown.js";
+import { RESERVED_NAMES } from "../standard.js";
+function readTerm(problem, file, report = true) {
+    const text = readText(file);
+    const say = (message) => {
+        if (report)
+            problem(file, message);
+    };
+    if (text.startsWith("---\n"))
+        say("a glossary file has no front matter");
+    const m = /^# (.+)\n?([\s\S]*)$/.exec(text.replace(/^---\n[\s\S]*?\n---\n/, "").replace(/^\s+/, ""));
+    if (!m) {
+        say("opens with the term as a # heading");
+        return null;
+    }
+    const term = m[1].trim().replaceAll("`", "");
+    if (basename(file) !== `${term}.md`)
+        say(`is named after its term, ${term}.md`);
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(term))
+        say(`${term} is not a name the pseudocode can use`);
+    if (RESERVED_NAMES.test(term))
+        say(`${term} is a name Windows reserves for a device, so no file can have it`);
+    return { term, text: m[2] };
+}
+/** Reads and checks spec/glossary/, then adds the terms of the --glossary drafts. */
+export function loadGlossary({ config, problem }) {
+    const { specDir } = config;
+    const glossaryDir = join(specDir, "glossary");
+    const glossary = new Map(); // term -> text after the heading
+    const glossaryFiles = new Map(); // term -> file
+    if (existsSync(join(specDir, "glossary.md")))
+        problem(join(specDir, "glossary.md"), "the glossary is the directory spec/glossary/; move each ## term to spec/glossary/<term>.md with the term as its # heading");
+    if (!existsSync(glossaryDir))
+        problem(null, "spec/glossary/ is missing");
+    else {
+        const folded = new Map();
+        for (const file of termFiles(glossaryDir)) {
+            if (statSync(file).isDirectory() || !file.endsWith(".md")) {
+                problem(file, "is not a glossary file; spec/glossary/ holds one <term>.md per term");
+                continue;
+            }
+            const t = readTerm(problem, file);
+            if (!t)
+                continue;
+            const key = t.term.toLowerCase();
+            if (folded.has(key))
+                problem(file, `${t.term} differs only in case from ${folded.get(key)}`);
+            else
+                folded.set(key, t.term);
+            glossary.set(t.term, t.text);
+            glossaryFiles.set(t.term, file);
+        }
+    }
+    // --glossary <path> adds the terms of a draft term file, or of a directory of them, for checking
+    // entries before their terms are merged into spec/glossary/.
+    for (const draft of config.glossaryDrafts) {
+        const files = statSync(draft).isDirectory() ? termFiles(draft).filter((f) => f.endsWith(".md")) : [draft];
+        for (const file of files) {
+            const t = readTerm(problem, file, false);
+            if (t && !glossary.has(t.term))
+                glossary.set(t.term, t.text);
+        }
+    }
+    return { glossaryDir, glossary, glossaryFiles };
+}

package/dist/load/readme.d.ts

@@ -0,0 +1,3 @@
+import type { LoadContext } from "../context.ts";
+/** Checks spec/README.md and returns its areas, in the order it lists them. */
+export declare function loadAreas({ config, problem }: LoadContext): string[];

package/dist/load/readme.js

@@ -0,0 +1,36 @@
+// spec/README.md: its sections and the area list.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { splitSections, tables } from "../markdown.js";
+/** Checks spec/README.md and returns its areas, in the order it lists them. */
+export function loadAreas({ config, problem }) {
+    const { specDir } = config;
+    const readme = existsSync(join(specDir, "README.md"))
+        ? readFileSync(join(specDir, "README.md"), "utf8").replace(/\r\n/g, "\n")
+        : "";
+    if (!readme)
+        problem(null, "spec/README.md is missing");
+    const areas = [];
+    const readmeSections = splitSections(readme);
+    const titles = readmeSections.map((s) => s.title);
+    const expected = ["Scope", "Standard version", "Areas"];
+    if (titles.join("|") !== expected.join("|"))
+        problem(join(specDir, "README.md"), `sections must be ${expected.join(", ")} in that order, found ${titles.join(", ")}`);
+    const areaSection = readmeSections.find((s) => s.title === "Areas");
+    const areaTable = areaSection && tables(areaSection.text)[0];
+    if (!areaTable || areaTable.header.join("|") !== "Area|Covers")
+        problem(join(specDir, "README.md"), "the area list must be a table with the columns Area | Covers");
+    else
+        for (const row of areaTable.rows) {
+            const a = row[0].replaceAll("`", "");
+            if (!/^[A-Z][A-Z0-9]*$/.test(a))
+                problem(join(specDir, "README.md"), `area ${a} must be upper-case letters and digits starting with a letter`, "IDENTIFIERS-2");
+            if (areas.includes(a))
+                problem(join(specDir, "README.md"), `area ${a} is listed twice`);
+            areas.push(a);
+        }
+    const version = readmeSections.find((s) => s.title === "Standard version");
+    if (version && !/version 1 of the/.test(version.text))
+        problem(join(specDir, "README.md"), "the Standard version section must say which version it follows (version 1)");
+    return areas;
+}

package/dist/load/spec.d.ts

@@ -0,0 +1,6 @@
+import type { LoadContext, Spec } from "../context.ts";
+/**
+ * Reads spec/ and reports what is wrong with its layout, the README, the glossary and the build
+ * manifests. Exits with 1 when there is no spec/ directory.
+ */
+export declare function loadSpec(ctx: LoadContext): Spec;

package/dist/load/spec.js

@@ -0,0 +1,25 @@
+// Reading the spec: the README's areas, the entries, the glossary and what the build entries name.
+import { existsSync } from "node:fs";
+import { checkOtherFiles, loadBuildFiles } from "./builds.js";
+import { loadCodeRanges } from "./code-ranges.js";
+import { loadEntries } from "./entries.js";
+import { loadGlossary } from "./glossary.js";
+import { loadAreas } from "./readme.js";
+/**
+ * Reads spec/ and reports what is wrong with its layout, the README, the glossary and the build
+ * manifests. Exits with 1 when there is no spec/ directory.
+ */
+export function loadSpec(ctx) {
+    const { repoDir, specDir } = ctx.config;
+    if (!existsSync(specDir)) {
+        console.error(`No spec/ directory in ${repoDir}.`);
+        process.exit(1);
+    }
+    const areas = loadAreas(ctx);
+    const entries = loadEntries(ctx);
+    const { glossaryDir, glossary, glossaryFiles } = loadGlossary(ctx);
+    const buildFiles = loadBuildFiles(ctx, entries);
+    checkOtherFiles(ctx, entries, buildFiles);
+    const codeRanges = loadCodeRanges(ctx, entries, buildFiles);
+    return { areas, entries, glossaryDir, glossary, glossaryFiles, buildFiles, codeRanges };
+}

package/dist/locations.d.ts

@@ -0,0 +1,19 @@
+import type { Problem } from "./problems.ts";
+import type { Meta, Yaml } from "./types.ts";
+/**
+ * Reports an address that is not in the notation of format. An unlisted format is already reported
+ * against its manifest, so it is skipped here.
+ */
+export declare function checkAddress(problem: Problem, file: string, value: Yaml, format: Yaml): void;
+/**
+ * An offset names one byte, or a half-open range of two: 0x20..0x3C covers 0x20 up to but not
+ * including 0x3C. Returns [start, end) as BigInts, or null when the notation is wrong.
+ */
+export declare function parseOffset(value: Yaml): [bigint, bigint] | null;
+/**
+ * An offset is into the shipped file bf, so the bytes it covers lie within bf.size. Returns the
+ * parsed range when it is well formed.
+ * `bf` is the file the offset is into, given as { path, size }: the shipped file, or the unpacked
+ * form of a packed one.
+ */
+export declare function checkOffset(problem: Problem, file: string, value: Yaml, bf: Meta, what?: string): [bigint, bigint] | null;

package/dist/locations.js

@@ -0,0 +1,57 @@
+// Addresses and offsets, the two ways a location in a build's file is given.
+import { locationRule } from "./standard.js";
+/**
+ * Reports an address that is not in the notation of format. An unlisted format is already reported
+ * against its manifest, so it is skipped here.
+ */
+export function checkAddress(problem, file, value, format) {
+    const rule = locationRule(format);
+    if (!rule)
+        return;
+    const re = rule.address;
+    if (!re) {
+        problem(file, `an address cannot be given in a file of format ${format}; use offset`);
+        return;
+    }
+    const parts = String(value).split("..");
+    if (parts.length > 2 || parts.some((p) => !re.test(p)))
+        problem(file, `address ${value} is not in the notation for a ${format} file`);
+}
+/**
+ * An offset names one byte, or a half-open range of two: 0x20..0x3C covers 0x20 up to but not
+ * including 0x3C. Returns [start, end) as BigInts, or null when the notation is wrong.
+ */
+export function parseOffset(value) {
+    const parts = String(value).split("..");
+    if (parts.length > 2 || parts.some((p) => !/^0x[0-9A-F]{2,}$/.test(p)))
+        return null;
+    const [start, end] = parts.map((p) => BigInt(p));
+    return [start, end ?? start + 1n];
+}
+/**
+ * An offset is into the shipped file bf, so the bytes it covers lie within bf.size. Returns the
+ * parsed range when it is well formed.
+ * `bf` is the file the offset is into, given as { path, size }: the shipped file, or the unpacked
+ * form of a packed one.
+ */
+export function checkOffset(problem, file, value, bf, what = "shipped file") {
+    const range = parseOffset(value);
+    if (!range) {
+        problem(file, `offset ${value} must be 0x followed by at least two upper-case hex digits, or a range of two`);
+        return null;
+    }
+    const [start, end] = range;
+    if (start > end) {
+        problem(file, "offset range is reversed");
+        return null;
+    }
+    if (start === end) {
+        problem(file, `offset range ${value} is empty; a range is half-open`);
+        return null;
+    }
+    if (Number.isSafeInteger(bf.size) && bf.size >= 0 && end > BigInt(bf.size)) {
+        problem(file, `offset ${value} is outside the ${what} ${bf.path} (${bf.size} bytes)`);
+        return null;
+    }
+    return range;
+}

package/dist/markdown.d.ts

@@ -0,0 +1,27 @@
+import type { Problem } from "./problems.ts";
+import type { Section, Table } from "./types.ts";
+/** The number of lines of text, not counting the empty one after a final newline. */
+export declare const lineCount: (text: string) => number;
+/** Reads a text file with CRLF line ends read as LF. */
+export declare const readText: (file: string) => string;
+/** Reads an entry's front matter, body and sections, or reports why it cannot and returns null. */
+export declare function readEntry(file: string, problem: Problem): {
+    file: string;
+    meta: import("./types.ts").Meta;
+    body: string;
+    sections: Section[];
+} | null;
+/** The `##` sections of a Markdown body, skipping fenced code. */
+export declare function splitSections(body: string): Section[];
+/** Every Markdown table in a section, with the `###` heading above it. */
+export declare function tables(text: string): Table[];
+/** The cells of a table row, with `\|` read as a pipe and pipes inside code spans kept. */
+export declare function cells(line: string): string[];
+/**
+ * A value file: CSV as RFC 4180 defines it, with a header row. Returns { header, rows }, or null
+ * after reporting a problem.
+ */
+export declare function readCsv(file: string, problem: Problem): {
+    header: string[];
+    rows: string[][];
+} | null;