@getrefino/core 0.1.0-rc.5 → 0.1.0

package/dist/documents/frontmatter.js

@@ -0,0 +1,407 @@
+/**
+ * A span parser for YAML frontmatter.
+ *
+ * It does not build a document tree and it cannot serialize one. For each
+ * top-level entry it records where the key is, where its value is, and how
+ * that value is written. Reading a field is a slice; writing one replaces a
+ * single span and leaves every other byte of the file alone.
+ *
+ * That is the whole reason it exists: key order, unknown keys, comments,
+ * indentation, blank lines and quoting style are preserved because they are
+ * never in the code path. Anything this parser cannot represent honestly is
+ * reported as not editable rather than guessed at.
+ *
+ * The YAML subset understood here is the one blog frontmatter actually uses:
+ * top-level scalar entries in plain, single-quoted, double-quoted, literal
+ * (`|`) or folded (`>`) form.
+ */
+export function splitLines(text) {
+    const lines = [];
+    let start = 0;
+    for (;;) {
+        const index = text.indexOf("\n", start);
+        if (index === -1) {
+            if (start < text.length || lines.length === 0) {
+                lines.push({ start, contentEnd: text.length, end: text.length, text: text.slice(start) });
+            }
+            return lines;
+        }
+        const contentEnd = index > start && text[index - 1] === "\r" ? index - 1 : index;
+        lines.push({ start, contentEnd, end: index + 1, text: text.slice(start, contentEnd) });
+        start = index + 1;
+    }
+}
+const FENCE = /^---[ \t]*$/;
+const CLOSING_FENCE = /^(?:---|\.\.\.)[ \t]*$/;
+/** A top-level entry: an unquoted key at column zero followed by a colon. */
+const KEY_LINE = /^([A-Za-z0-9_][A-Za-z0-9_.-]*)[ \t]*:(?=[ \t]|$)/;
+/** A block scalar header we can reproduce byte for byte. `|+` and `|2` are not on the list. */
+const BLOCK_HEADER = /^([|>])(-?)$/;
+const PLAIN_UNSAFE_FIRST = new Set([
+    "-", "?", ":", ",", "[", "]", "{", "}", "#", "&", "*", "!", "|", ">", "'", '"', "%", "@", "`",
+]);
+/** Anything below a space that is not a tab, and DEL. A regex of these is both unreadable and lint-hostile. */
+function hasControlCharacters(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code === 0x09)
+            continue;
+        if (code < 0x20 || code === 0x7f)
+            return true;
+    }
+    return false;
+}
+function isBlank(text) {
+    return text.trim().length === 0;
+}
+function isIndented(text) {
+    return text.length > 0 && (text[0] === " " || text[0] === "\t");
+}
+function indentOf(text) {
+    return /^[ \t]*/.exec(text)[0];
+}
+function plainTrim(value) {
+    return value.replace(/[ \t]+$/, "");
+}
+/**
+ * Where a plain scalar ends on its line: before a ` #` comment, and before
+ * any trailing whitespace. YAML only starts a comment when the `#` is
+ * preceded by whitespace, so `a#b` is one scalar.
+ */
+function plainScalarEnd(text, from, limit) {
+    for (let index = from + 1; index < limit; index += 1) {
+        if (text[index] !== "#")
+            continue;
+        const previous = text[index - 1];
+        if (previous !== " " && previous !== "\t")
+            continue;
+        let end = index - 1;
+        while (end > from && (text[end - 1] === " " || text[end - 1] === "\t"))
+            end -= 1;
+        return end;
+    }
+    let end = limit;
+    while (end > from && (text[end - 1] === " " || text[end - 1] === "\t"))
+        end -= 1;
+    return end;
+}
+/** Read a quoted token starting at `from`. Returns its end offset, or -1 if unterminated. */
+function quotedEnd(text, from, limit) {
+    const quote = text[from];
+    for (let index = from + 1; index < limit; index += 1) {
+        const char = text[index];
+        if (quote === "'") {
+            if (char !== "'")
+                continue;
+            if (text[index + 1] === "'") {
+                index += 1;
+                continue;
+            }
+            return index + 1;
+        }
+        if (char === "\\") {
+            index += 1;
+        }
+        else if (char === '"') {
+            return index + 1;
+        }
+    }
+    return -1;
+}
+function decodeSingle(raw) {
+    return raw.slice(1, -1).replace(/''/g, "'");
+}
+function decodeDouble(raw) {
+    let out = "";
+    const body = raw.slice(1, -1);
+    for (let index = 0; index < body.length; index += 1) {
+        const char = body[index];
+        if (char !== "\\") {
+            out += char;
+            continue;
+        }
+        const next = body[index + 1];
+        index += 1;
+        switch (next) {
+            case "n":
+                out += "\n";
+                break;
+            case "t":
+                out += "\t";
+                break;
+            case "r":
+                out += "\r";
+                break;
+            case '"':
+                out += '"';
+                break;
+            case "\\":
+                out += "\\";
+                break;
+            case "/":
+                out += "/";
+                break;
+            case " ":
+                out += " ";
+                break;
+            case "u": {
+                const hex = body.slice(index + 1, index + 5);
+                if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                    return null;
+                out += String.fromCharCode(Number.parseInt(hex, 16));
+                index += 4;
+                break;
+            }
+            default:
+                return null;
+        }
+    }
+    return out;
+}
+export function encodeDouble(value) {
+    let out = '"';
+    for (const char of value) {
+        const code = char.codePointAt(0);
+        if (char === '"')
+            out += '\\"';
+        else if (char === "\\")
+            out += "\\\\";
+        else if (char === "\n")
+            out += "\\n";
+        else if (char === "\t")
+            out += "\\t";
+        else if (char === "\r")
+            out += "\\r";
+        else if (code < 0x20 || code === 0x7f)
+            out += `\\u${code.toString(16).padStart(4, "0")}`;
+        else
+            out += char;
+    }
+    return `${out}"`;
+}
+export function encodeSingle(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/** Whether a value can be written as a plain scalar without changing what it means. */
+export function isPlainSafe(value) {
+    if (value.length === 0)
+        return false;
+    if (value !== value.trim())
+        return false;
+    if (/[\n\r\t]/.test(value))
+        return false;
+    if (PLAIN_UNSAFE_FIRST.has(value[0]))
+        return false;
+    if (value.includes(": ") || value.endsWith(":"))
+        return false;
+    if (/[ \t]#/.test(value))
+        return false;
+    return !hasControlCharacters(value);
+}
+function unsupported(key, entryStart, entryEnd, valueStart, valueEnd, reason) {
+    return { key, entryStart, entryEnd, valueStart, valueEnd, style: "unsupported", value: null, reason, block: null };
+}
+function readBlockScalar(lines, index, last, key, entryStart, entryEnd, colonEnd, header) {
+    const contentLines = lines.slice(index + 1, last + 1);
+    const headerEnd = lines[index].contentEnd;
+    if (contentLines.length === 0) {
+        return unsupported(key, entryStart, entryEnd, colonEnd, headerEnd, "the block scalar has no content");
+    }
+    const indent = indentOf(contentLines[0].text);
+    const valueEnd = lines[last].contentEnd;
+    if (indent.length === 0) {
+        return unsupported(key, entryStart, entryEnd, colonEnd, valueEnd, "the block scalar is not indented");
+    }
+    const parts = [];
+    for (const line of contentLines) {
+        if (isBlank(line.text)) {
+            parts.push("");
+            continue;
+        }
+        if (!line.text.startsWith(indent)) {
+            return unsupported(key, entryStart, entryEnd, colonEnd, valueEnd, "the block scalar's indentation is uneven");
+        }
+        parts.push(line.text.slice(indent.length));
+    }
+    if (header.startsWith("|")) {
+        return {
+            key, entryStart, entryEnd, valueStart: colonEnd, valueEnd,
+            style: "literal", value: parts.join("\n"), reason: null, block: { header, indent },
+        };
+    }
+    // Folded: lines join with a space, a blank line becomes a newline. A line
+    // indented further than the block keeps its own breaks, which this parser
+    // does not reproduce, so it is refused.
+    if (parts.some((part) => part.length > 0 && (part[0] === " " || part[0] === "\t"))) {
+        return unsupported(key, entryStart, entryEnd, colonEnd, valueEnd, "the folded value contains a more-indented line");
+    }
+    let folded = "";
+    for (const part of parts) {
+        if (part === "") {
+            folded += "\n";
+            continue;
+        }
+        if (folded.length > 0 && !folded.endsWith("\n"))
+            folded += " ";
+        folded += part;
+    }
+    return {
+        key, entryStart, entryEnd, valueStart: colonEnd, valueEnd,
+        style: "folded", value: folded, reason: null, block: { header, indent },
+    };
+}
+function readEntry(text, lines, index, lastLine) {
+    const line = lines[index];
+    const match = KEY_LINE.exec(line.text);
+    const key = match[1];
+    const colonEnd = line.start + match[0].length;
+    // Continuation lines: indented lines, plus blank lines that are followed by
+    // another indented line. A comment at column zero belongs to no entry.
+    let last = index;
+    for (let scan = index + 1; scan <= lastLine; scan += 1) {
+        const candidate = lines[scan];
+        if (isBlank(candidate.text))
+            continue;
+        if (!isIndented(candidate.text))
+            break;
+        last = scan;
+    }
+    const entryStart = line.start;
+    const entryEnd = lines[last].end;
+    const next = last + 1;
+    const inlineRaw = text.slice(colonEnd, line.contentEnd);
+    const leading = indentOf(inlineRaw);
+    const inlineStart = colonEnd + leading.length;
+    const inline = inlineRaw.slice(leading.length);
+    const commentOnly = inline.startsWith("#");
+    const inlineText = commentOnly ? "" : inline;
+    if (BLOCK_HEADER.test(plainTrim(inlineText))) {
+        const header = plainTrim(inlineText);
+        return { entry: readBlockScalar(lines, index, last, key, entryStart, entryEnd, colonEnd, header), next };
+    }
+    if (last !== index) {
+        // Indented lines under something that is not a block scalar: a nested
+        // map, a sequence, or a multi-line scalar. Readable, not writable
+        // through a single span.
+        const reason = inlineText.length === 0
+            ? "the value is a nested map or list, not a single value"
+            : "the value continues across several lines";
+        return { entry: unsupported(key, entryStart, entryEnd, inlineStart, line.contentEnd, reason), next };
+    }
+    if (inlineText.length === 0) {
+        const valueEnd = commentOnly ? inlineStart : line.contentEnd;
+        return {
+            entry: { key, entryStart, entryEnd, valueStart: inlineStart, valueEnd, style: "empty", value: "", reason: null, block: null },
+            next,
+        };
+    }
+    const first = inlineText[0];
+    if (first === "'" || first === '"') {
+        const end = quotedEnd(text, inlineStart, line.contentEnd);
+        if (end === -1) {
+            return { entry: unsupported(key, entryStart, entryEnd, inlineStart, line.contentEnd, "the quoted value is not closed on the same line"), next };
+        }
+        const value = first === "'" ? decodeSingle(text.slice(inlineStart, end)) : decodeDouble(text.slice(inlineStart, end));
+        if (value === null) {
+            return { entry: unsupported(key, entryStart, entryEnd, inlineStart, end, "the quoted value uses an escape Refino does not reproduce"), next };
+        }
+        // Anything after the closing quote other than spaces or a comment is not
+        // something this parser understands.
+        const trailing = text.slice(end, line.contentEnd).trim();
+        if (trailing.length > 0 && !trailing.startsWith("#")) {
+            return { entry: unsupported(key, entryStart, entryEnd, inlineStart, end, "there is more after the quoted value than a comment"), next };
+        }
+        return {
+            entry: {
+                key, entryStart, entryEnd, valueStart: inlineStart, valueEnd: end,
+                style: first === "'" ? "single" : "double", value, reason: null, block: null,
+            },
+            next,
+        };
+    }
+    if (PLAIN_UNSAFE_FIRST.has(first)) {
+        return {
+            entry: unsupported(key, entryStart, entryEnd, inlineStart, line.contentEnd, `the value starts with "${first}", which Refino does not edit`),
+            next,
+        };
+    }
+    const valueEnd = plainScalarEnd(text, inlineStart, line.contentEnd);
+    return {
+        entry: {
+            key, entryStart, entryEnd, valueStart: inlineStart, valueEnd,
+            style: "plain", value: text.slice(inlineStart, valueEnd), reason: null, block: null,
+        },
+        next,
+    };
+}
+/**
+ * Find and parse the leading frontmatter block. Returns null when the file
+ * does not open with one, which is not an error: a Markdown file without
+ * frontmatter simply has no metadata fields.
+ */
+export function parseFrontmatter(text) {
+    const lines = splitLines(text);
+    if (lines.length === 0)
+        return null;
+    const opening = lines[0];
+    if (!FENCE.test(opening.text))
+        return null;
+    let closing = -1;
+    for (let index = 1; index < lines.length; index += 1) {
+        if (CLOSING_FENCE.test(lines[index].text)) {
+            closing = index;
+            break;
+        }
+    }
+    if (closing === -1)
+        return null;
+    const entries = [];
+    let index = 1;
+    while (index < closing) {
+        const line = lines[index];
+        if (isBlank(line.text) || line.text.trimStart().startsWith("#") || !KEY_LINE.test(line.text)) {
+            index += 1;
+            continue;
+        }
+        const read = readEntry(text, lines, index, closing - 1);
+        entries.push(read.entry);
+        index = Math.max(read.next, index + 1);
+    }
+    // A key written twice is ambiguous; neither copy is editable.
+    const counts = new Map();
+    for (const entry of entries)
+        counts.set(entry.key, (counts.get(entry.key) ?? 0) + 1);
+    const resolved = entries.map((entry) => (counts.get(entry.key) ?? 0) > 1
+        ? unsupported(entry.key, entry.entryStart, entry.entryEnd, entry.valueStart, entry.valueEnd, `"${entry.key}" appears more than once in the frontmatter`)
+        : entry);
+    return { start: opening.start, end: lines[closing].end, entries: resolved };
+}
+/** The replacement text for one entry's value span. Throws when the style cannot carry the value. */
+export function renderScalar(text, entry, value) {
+    switch (entry.style) {
+        case "plain":
+        case "empty": {
+            const rendered = isPlainSafe(value) ? value : encodeDouble(value);
+            // `key:` with nothing after it needs a space; `key: x` already has one.
+            return text[entry.valueStart - 1] === ":" ? ` ${rendered}` : rendered;
+        }
+        case "single":
+            return value.includes("\n") ? encodeDouble(value) : encodeSingle(value);
+        case "double":
+            return encodeDouble(value);
+        case "literal": {
+            const { header, indent } = entry.block;
+            const body = value.split("\n").map((line) => (line.length === 0 ? "" : indent + line)).join("\n");
+            return ` ${header}\n${body}`;
+        }
+        case "folded": {
+            const { header, indent } = entry.block;
+            if (value.includes("\n")) {
+                throw new Error(`"${entry.key}" is a folded block scalar and the new value contains a line break`);
+            }
+            return ` ${header}\n${indent}${value}`;
+        }
+        default:
+            throw new Error(`"${entry.key}" is not an editable frontmatter value`);
+    }
+}

package/dist/documents/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Server-side content sources: reading and writing editable fields that live
+ * in the customer's own Markdown and MDX files.
+ *
+ * Imported as `@getrefino/core/documents` so the browser-safe main entry
+ * carries only the identity and wire types. See
+ * `docs/content-editing-architecture.md`.
+ */
+export { EMPTY_CONTENT_CONFIG, MAX_CONTENT_SOURCES, SUPPORTED_EXTENSIONS, documentCandidates, documentIdForPath, parseContentConfig, rebaseContentConfig, sourceTypeForPath, } from "./config.js";
+export type { ContentConfig, ContentSourceConfig, DocumentCandidate, SupportedExtension, } from "./config.js";
+export { METADATA_ALIASES, METADATA_FIELDS, METADATA_LABELS, matchMetadataFields, normalizeKey, } from "./fields.js";
+export type { MetadataFieldName, MetadataMatch, MetadataMatchResult } from "./fields.js";
+export { encodeDouble, encodeSingle, isPlainSafe, parseFrontmatter, renderScalar, } from "./frontmatter.js";
+export type { FrontmatterBlock, FrontmatterEntry, ScalarStyle } from "./frontmatter.js";
+export { MarkdownEditError, applyMarkdownEdits, findEntry, parseMarkdownSource, } from "./markdown.js";
+export type { AppliedMarkdownEdits, Eol, MarkdownEdits, MarkdownSource } from "./markdown.js";
+export { buildDocumentCommitMessage, createDocumentService } from "./service.js";
+export type { DocumentService, DocumentServiceOptions } from "./service.js";
+export type { SourceFile, SourceFileStore, SourceFileWrite, SourceFileWriteResult, } from "./file-store.js";

package/dist/documents/index.js

@@ -0,0 +1,13 @@
+/**
+ * Server-side content sources: reading and writing editable fields that live
+ * in the customer's own Markdown and MDX files.
+ *
+ * Imported as `@getrefino/core/documents` so the browser-safe main entry
+ * carries only the identity and wire types. See
+ * `docs/content-editing-architecture.md`.
+ */
+export { EMPTY_CONTENT_CONFIG, MAX_CONTENT_SOURCES, SUPPORTED_EXTENSIONS, documentCandidates, documentIdForPath, parseContentConfig, rebaseContentConfig, sourceTypeForPath, } from "./config.js";
+export { METADATA_ALIASES, METADATA_FIELDS, METADATA_LABELS, matchMetadataFields, normalizeKey, } from "./fields.js";
+export { encodeDouble, encodeSingle, isPlainSafe, parseFrontmatter, renderScalar, } from "./frontmatter.js";
+export { MarkdownEditError, applyMarkdownEdits, findEntry, parseMarkdownSource, } from "./markdown.js";
+export { buildDocumentCommitMessage, createDocumentService } from "./service.js";

package/dist/documents/markdown.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Markdown and MDX source handling.
+ *
+ * A source file is two spans: an optional leading frontmatter block, and
+ * everything after it. Refino reads fields by slicing those spans and writes
+ * them by replacing one span at a time, so a save touches exactly the bytes
+ * the owner changed.
+ *
+ * Nothing here parses Markdown or MDX. The body is a string that goes out to
+ * the editor and comes back; JSX, imports, exports, expressions, fenced
+ * code, tables, links and raw HTML survive because they are never
+ * interpreted. That is the whole MDX safety strategy, and it is why it does
+ * not decay as MDX grows.
+ *
+ * Every write is re-parsed and checked against what was intended before it
+ * is returned. A file Refino cannot round-trip is refused, never rewritten.
+ */
+import type { FrontmatterBlock, FrontmatterEntry } from "./frontmatter.js";
+export type Eol = "\n" | "\r\n";
+export interface MarkdownSource {
+    /** The file exactly as it is on disk. */
+    readonly text: string;
+    readonly eol: Eol;
+    readonly frontmatter: FrontmatterBlock | null;
+    /** The body span, with line endings normalized to `\n` for the editor. */
+    readonly body: string;
+    readonly bodyStart: number;
+    readonly bodyEnd: number;
+    /** Null when the body can be written back safely; a reason when it cannot. */
+    readonly bodyUneditableReason: string | null;
+}
+export interface MarkdownEdits {
+    /** Frontmatter values by key, already resolved from field ids. */
+    readonly frontmatter?: Readonly<Record<string, string>>;
+    /** The whole body, with `\n` line endings. */
+    readonly body?: string;
+}
+export interface AppliedMarkdownEdits {
+    readonly text: string;
+    /** What the file now holds for each edited field, after normalization. */
+    readonly frontmatter: Readonly<Record<string, string>>;
+    readonly body: string | null;
+}
+export declare class MarkdownEditError extends Error {
+    readonly key: string | null;
+    constructor(message: string, key?: string | null);
+}
+export declare function parseMarkdownSource(text: string): MarkdownSource;
+export declare function findEntry(source: MarkdownSource, key: string): FrontmatterEntry | null;
+/**
+ * Apply field edits to the source text and prove the result reads back as
+ * intended. The proof, not the parser, is what makes this safe:
+ *
+ * - the frontmatter keys are the same, in the same order;
+ * - every entry that was not edited is byte-identical;
+ * - every entry that was edited reads back exactly the value that was sent;
+ * - the body reads back exactly the body that was sent.
+ */
+export declare function applyMarkdownEdits(text: string, edits: MarkdownEdits): AppliedMarkdownEdits;

package/dist/documents/markdown.js

@@ -0,0 +1,162 @@
+import { parseFrontmatter, renderScalar } from "./frontmatter.js";
+export class MarkdownEditError extends Error {
+    key;
+    constructor(message, key = null) {
+        super(message);
+        this.name = "MarkdownEditError";
+        this.key = key;
+    }
+}
+const BOM = "";
+function detectEol(text) {
+    const index = text.indexOf("\n");
+    return index > 0 && text[index - 1] === "\r" ? "\r\n" : "\n";
+}
+/**
+ * Line endings Refino will not touch: a file that mixes them, or uses a lone
+ * carriage return, cannot have its body rewritten without also rewriting
+ * lines nobody edited.
+ */
+function bodyEolProblem(body, eol) {
+    if (/\r(?!\n)/.test(body))
+        return "the file uses carriage returns on their own";
+    const newlines = (body.match(/\n/g) ?? []).length;
+    const crlf = (body.match(/\r\n/g) ?? []).length;
+    if (crlf > 0 && crlf < newlines)
+        return "the file mixes Windows and Unix line endings";
+    if (eol === "\r\n" && crlf === 0 && newlines > 0)
+        return "the file mixes Windows and Unix line endings";
+    return null;
+}
+export function parseMarkdownSource(text) {
+    const eol = detectEol(text);
+    if (text.startsWith(BOM)) {
+        return {
+            text,
+            eol,
+            frontmatter: null,
+            body: text,
+            bodyStart: 0,
+            bodyEnd: text.length,
+            bodyUneditableReason: "the file begins with a byte order mark",
+        };
+    }
+    const frontmatter = parseFrontmatter(text);
+    const bodyStart = frontmatter ? frontmatter.end : 0;
+    const raw = text.slice(bodyStart);
+    const problem = bodyEolProblem(raw, eol);
+    return {
+        text,
+        eol,
+        frontmatter,
+        body: problem === null && eol === "\r\n" ? raw.replace(/\r\n/g, "\n") : raw,
+        bodyStart,
+        bodyEnd: text.length,
+        bodyUneditableReason: problem,
+    };
+}
+export function findEntry(source, key) {
+    return source.frontmatter?.entries.find((entry) => entry.key === key) ?? null;
+}
+function splice(text, replacements) {
+    const ordered = [...replacements].sort((a, b) => a.start - b.start);
+    let out = "";
+    let cursor = 0;
+    for (const replacement of ordered) {
+        if (replacement.start < cursor) {
+            throw new MarkdownEditError("Two edits in this article overlap in the source file.");
+        }
+        out += text.slice(cursor, replacement.start) + replacement.text;
+        cursor = replacement.end;
+    }
+    return out + text.slice(cursor);
+}
+/**
+ * Apply field edits to the source text and prove the result reads back as
+ * intended. The proof, not the parser, is what makes this safe:
+ *
+ * - the frontmatter keys are the same, in the same order;
+ * - every entry that was not edited is byte-identical;
+ * - every entry that was edited reads back exactly the value that was sent;
+ * - the body reads back exactly the body that was sent.
+ */
+export function applyMarkdownEdits(text, edits) {
+    const source = parseMarkdownSource(text);
+    const replacements = [];
+    const intendedFrontmatter = {};
+    for (const [key, value] of Object.entries(edits.frontmatter ?? {})) {
+        const entry = findEntry(source, key);
+        if (!entry) {
+            throw new MarkdownEditError(`The article has no frontmatter field "${key}".`, key);
+        }
+        if (entry.style === "unsupported") {
+            throw new MarkdownEditError(`Refino cannot edit "${key}" in this article: ${entry.reason}.`, key);
+        }
+        let rendered;
+        try {
+            rendered = renderScalar(text, entry, value);
+        }
+        catch (error) {
+            throw new MarkdownEditError(`Refino cannot write "${key}" in this article: ${error instanceof Error ? error.message : String(error)}.`, key);
+        }
+        replacements.push({ start: entry.valueStart, end: entry.valueEnd, text: rendered });
+        intendedFrontmatter[key] = value;
+    }
+    let intendedBody = null;
+    if (edits.body !== undefined) {
+        if (source.bodyUneditableReason !== null) {
+            throw new MarkdownEditError(`Refino cannot edit this article's body: ${source.bodyUneditableReason}.`);
+        }
+        let body = edits.body;
+        // Keep the file's own habit about a final newline rather than letting a
+        // textarea decide it.
+        const hadTrailingNewline = source.body.endsWith("\n");
+        if (hadTrailingNewline && body.length > 0 && !body.endsWith("\n"))
+            body += "\n";
+        if (!source.frontmatter && /^---[ \t]*\n/.test(body)) {
+            throw new MarkdownEditError("The body cannot start with a `---` line in an article that has no frontmatter: it would become frontmatter.");
+        }
+        intendedBody = body;
+        replacements.push({
+            start: source.bodyStart,
+            end: source.bodyEnd,
+            text: source.eol === "\r\n" ? body.replace(/\n/g, "\r\n") : body,
+        });
+    }
+    const next = splice(text, replacements);
+    verify(source, next, intendedFrontmatter, intendedBody);
+    return { text: next, frontmatter: intendedFrontmatter, body: intendedBody };
+}
+function verify(source, next, intendedFrontmatter, intendedBody) {
+    const reparsed = parseMarkdownSource(next);
+    const before = source.frontmatter?.entries ?? [];
+    const after = reparsed.frontmatter?.entries ?? [];
+    if (before.length !== after.length || before.some((entry, index) => entry.key !== after[index].key)) {
+        throw new MarkdownEditError("Saving would have changed this article's frontmatter structure, so nothing was written.");
+    }
+    for (let index = 0; index < before.length; index += 1) {
+        const original = before[index];
+        const written = after[index];
+        const intended = intendedFrontmatter[original.key];
+        if (intended === undefined) {
+            const originalText = source.text.slice(original.entryStart, original.entryEnd);
+            const writtenText = next.slice(written.entryStart, written.entryEnd);
+            if (originalText !== writtenText) {
+                throw new MarkdownEditError(`Saving would have rewritten the untouched frontmatter field "${original.key}", so nothing was written.`, original.key);
+            }
+            continue;
+        }
+        if (written.value !== intended) {
+            throw new MarkdownEditError(`Saving "${original.key}" would not have read back as it was written, so nothing was written.`, original.key);
+        }
+    }
+    if (intendedBody === null) {
+        if (reparsed.body !== source.body) {
+            throw new MarkdownEditError("Saving would have changed this article's body, so nothing was written.");
+        }
+        return;
+    }
+    if (reparsed.bodyUneditableReason !== null || reparsed.body !== intendedBody) {
+        throw new MarkdownEditError("Saving the body would not have read back as it was written, so nothing was written.");
+    }
+}